public void LiftReferenceExpression()
		{
			var referenceExpression = new ReferenceExpression("foo");
			var parameter = ParameterDeclaration.Lift(referenceExpression);
			Assert.AreEqual(referenceExpression.Name, parameter.Name);
			Assert.IsNull(parameter.Type);
		}

		/// <summary>
		/// This turn a call to TryGetParemeter('item') where item is a local variable
		/// into a WrapIfNull(item) method call.
		/// </summary>
		/// <param name="node">The node.</param>
		public override void OnMethodInvocationExpression(MethodInvocationExpression node)
		{
			var expression = node.Target as ReferenceExpression;
			if (expression == null || expression.Name != "TryGetParameter")
			{
				base.OnMethodInvocationExpression(node);
				return;
			}
			var name = ((StringLiteralExpression)node.Arguments[0]).Value;
			var entity = NameResolutionService.Resolve(name);
			if (entity == null)
			{
				base.OnMethodInvocationExpression(node);
				return;
			}
			var parentNode = node.ParentNode;
			var mie = CodeBuilder.CreateMethodInvocation(
				CodeBuilder.CreateSelfReference(_currentMethod.DeclaringType),
				wrapNullValue);

			var item = new ReferenceExpression(node.LexicalInfo, name);
			TypeSystemServices.Bind(item, entity);
			mie.Arguments.Add(item);
			parentNode.Replace(node, mie);
		}

 public override void OnReferenceExpression(ReferenceExpression node)
 {
     if (LookingFor(node))
     {
         Found(node);
     }
 }

 public GeneratorExpressionTrees(string parameter, ReferenceExpression parameterRef, NameResolutionService nameResolutionService, BooCodeBuilder codeBuilder)
 {
     _parameter = parameter;
     _parameterRef = parameterRef;
     _nameResolutionService = nameResolutionService;
     _codeBuilder = codeBuilder;
 }

		public static Expression my(ReferenceExpression typeReference)
		{
			var myReference = new GenericReferenceExpression(typeReference.LexicalInfo);
			myReference.Target = AstUtil.CreateReferenceExpression(typeReference.LexicalInfo, "Boo.Lang.Environments.My");
			myReference.GenericArguments.Add(TypeReference.Lift(typeReference));
			return new MemberReferenceExpression(typeReference.LexicalInfo, myReference, "Instance");
		}

        public override void OnReferenceExpression(ReferenceExpression node)
        {
            var entity = NameResolutionService.Resolve(node.Name);
            if (entity != null)
            {
                base.OnReferenceExpression(node);
                return;
            }
            if (node.Name.StartsWith("@"))
            {
                ReplaceWithComponentReference(node, node.Name);
                return;
            }
            else if (node.ParentNode is ExpressionPair)
            {
                var pair = (ExpressionPair) node.ParentNode;
                var literal = CodeBuilder.CreateStringLiteral(node.Name);
                pair.Replace(node, literal);
                return;
            }
            else if (
                //search for the left side of a key in a hash literal expression
                node.ParentNode is ExpressionPair
                && ((ExpressionPair) node.ParentNode).First == node
                && node.ParentNode.ParentNode is HashLiteralExpression)
            {
                var parent = (ExpressionPair) node.ParentNode;
                var literal = CodeBuilder.CreateStringLiteral(node.Name);
                parent.First = literal;
                parent.Replace(node, literal);
                return;
            }

            base.OnReferenceExpression(node);
        }

        /// <summary>
        /// Sets the node name to pascal case.
        /// </summary>
        /// <param name="node">The node.</param>
        protected virtual void TransformNodeName(ReferenceExpression node)
        {
            var nameCharacters = node.Name.ToCharArray();

            nameCharacters[0] = char.ToUpperInvariant(nameCharacters[0]);

            node.Name = new string(nameCharacters);
        }

        public override void OnReferenceExpression(ReferenceExpression node)
        {
            IAccessibleMember member = node.Entity as IAccessibleMember;
            if (null == member) return;

            if (_checker.IsAccessible(member)) return;
            Error(CompilerErrorFactory.UnaccessibleMember(node, member.FullName));
        }

 public static CompilerError AmbiguousReference(ReferenceExpression reference, System.Reflection.MemberInfo[] members)
 {
     return new CompilerError("BCE0004",
                               SafeLexicalInfo(reference),
                               reference.Name,
                               ToNameList(members)
                               );
 }

		B.ReferenceExpression MakeReferenceExpression(string fullName)
		{
			string[] parts = fullName.Split('.');
			B.ReferenceExpression r = new B.ReferenceExpression(lastLexicalInfo, parts[0]);
			for (int i = 1; i < parts.Length; i++)
				r = new B.MemberReferenceExpression(lastLexicalInfo, r, parts[i]);
			return r;
		}

        public override void OnMethodInvocationExpression(MethodInvocationExpression node)
        {
            if (node is MethodInvocationExpression && node.Target is GenericReferenceExpression)
            {
                var genericReferenceExpression = (GenericReferenceExpression)node.Target;
                if (genericReferenceExpression.Target is MemberReferenceExpression)
                {
                    var memberReferenceExpression = (MemberReferenceExpression)genericReferenceExpression.Target;
                    if (memberReferenceExpression.Target is MemberReferenceExpression)
                    {
                        var memberReferenceExpression2 = (MemberReferenceExpression)memberReferenceExpression.Target;
                        if (memberReferenceExpression2.Target is MemberReferenceExpression)
                        {
                            var memberReferenceExpression3 = (MemberReferenceExpression)memberReferenceExpression2.Target;
                            if (memberReferenceExpression3.Target is ReferenceExpression)
                            {
                                var referenceExpression = (ReferenceExpression)memberReferenceExpression3.Target;
                                if (referenceExpression.Name == "Boo" && memberReferenceExpression3.Name == "Lang" && memberReferenceExpression2.Name == "Builtins" && memberReferenceExpression.Name == "array" && 1 == ((ICollection)genericReferenceExpression.GenericArguments).Count)
                                {
                                    TypeReference node2 = genericReferenceExpression.GenericArguments[0];
                                    if (1 == ((ICollection)node.Arguments).Count && node.Arguments[0] is CastExpression)
                                    {
                                        var castExpression = (CastExpression)node.Arguments[0];
                                        Expression target = castExpression.Target;
                                        if (castExpression.Type is SimpleTypeReference)
                                        {
                                            var simpleTypeReference = (SimpleTypeReference)castExpression.Type;
                                            if (simpleTypeReference.Name == "int")
                                            {
                                                var methodInvocationExpression = new MethodInvocationExpression(LexicalInfo.Empty);
                                                var arg_255_0 = methodInvocationExpression;
                                                var genericReferenceExpression2 = new GenericReferenceExpression(LexicalInfo.Empty);
                                                GenericReferenceExpression arg_226_0 = genericReferenceExpression2;
                                                var referenceExpression2 = new ReferenceExpression(LexicalInfo.Empty);
                                                string text = referenceExpression2.Name = "array";
                                                Expression expression = arg_226_0.Target = referenceExpression2;
                                                TypeReferenceCollection typeReferenceCollection = genericReferenceExpression2.GenericArguments = TypeReferenceCollection.FromArray(new TypeReference[]
                                            {
                                                TypeReference.Lift(node2)
                                            });
                                                Expression expression2 = arg_255_0.Target = genericReferenceExpression2;
                                                ExpressionCollection expressionCollection = methodInvocationExpression.Arguments = ExpressionCollection.FromArray(new Expression[]
                                            {
                                                Expression.Lift(target)
                                            });
                                                ReplaceCurrentNode(methodInvocationExpression);
                                            }
                                        }

                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Called when we encounter a reference expression
        /// </summary>
        /// <param name="node">The node.</param>
        public override void OnReferenceExpression(ReferenceExpression node)
        {
            if (this.ShouldTransformNodeName(node))
            {
                this.TransformNodeName(node);
            }

            base.OnReferenceExpression(node);
        }

 public WithExpander(ReferenceExpression instance)
 {
     this.instance = instance;
     /*
     foreach (var method in members.Where(m => m.EntityType == EntityType.Method))
     {
         keywords.Add(method.Name);
     }*/
 }

 public override void OnReferenceExpression(ReferenceExpression node) {
     if (node.Name[0] == '_')
     {
         var result = new MemberReferenceExpression(node.LexicalInfo);
         result.Name = node.Name.Substring(1);
         result.Target = instance.CloneNode();
         ReplaceCurrentNode(result);
     }
 }

 public override void OnReferenceExpression(ReferenceExpression node)
 {
     if (TypeInference.IsTypeLiteral(node))
     {
         TypeofExpression typeofExpression = new TypeofExpression(LexicalInfo.Empty);
         TypeReference typeReference = typeofExpression.Type = TypeReference.Lift(node);
         this.ReplaceCurrentNode(typeofExpression);
     }
 }

        public static Expression build_with(ReferenceExpression builder, MethodInvocationExpression build, ReferenceExpression frameWorkVersion)
        {
            var targetName = builder.Name;

            return new MethodInvocationExpression(
                    new ReferenceExpression(targetName),
                    build.Arguments[0],
                    new StringLiteralExpression(frameWorkVersion.Name)
                );
        }

		public void LiftCastExpression()
		{
			var referenceExpression = new ReferenceExpression("foo");
			var typeReference = new SimpleTypeReference("T");
			Expression cast = new TryCastExpression(referenceExpression, typeReference);
			var parameter = ParameterDeclaration.Lift(cast);
			Assert.AreEqual(referenceExpression.Name, parameter.Name);
			Assert.IsTrue(typeReference.Matches(parameter.Type));
			Assert.AreNotSame(typeReference, parameter.Type);
		}

 /// <summary>
 /// Sets the node name to pascal case.
 /// </summary>
 /// <param name="node">The node.</param>
 protected virtual void TransformNodeName(ReferenceExpression node)
 {
     string[] parts = node.Name.Split(new char[] { '_' },StringSplitOptions.RemoveEmptyEntries);
     StringBuilder name = new StringBuilder();
     foreach (string part in parts)
     {
         name.Append(char.ToUpperInvariant(part[0]))
             .Append(part.Substring(1));
     }
     node.Name = name.ToString();
 }

 public static ReferenceExpression CreateReferenceExpression(string fullname)
 {
     string[] parts = fullname.Split('.');
     ReferenceExpression expression = new ReferenceExpression(parts[0]);
     expression.IsSynthetic = true;
     for (int i=1; i<parts.Length; ++i)
     {
         expression = new MemberReferenceExpression(expression, parts[i]);
         expression.IsSynthetic = true;
     }
     return expression;
 }

        public override void OnReferenceExpression(ReferenceExpression node){
            if(checkAll(node)){
                return;
            }
            
            if(checkSubstitution(node)){
                return;
            }

            //else{
                base.OnReferenceExpression(node);
            //}
        }