public GridValuesProvider(Expression targetObject, DebugType itemType)
		{
			this.targetObject = targetObject;
			this.itemType = itemType;
			
			this.memberFromNameMap = this.GetItemTypeMembers().MakeDictionary(memberInfo => memberInfo.Name);
		}

		private string GenerateExpression(Expression expression)
		{
			var sb = new StringBuilder();
			var memberReferenceExpression = expression as MemberReferenceExpression;
			while (memberReferenceExpression != null)
			{
				if (sb.Length != 0)
					sb.Insert(0, ".");

				sb.Insert(0, memberReferenceExpression.MemberName);

				expression = memberReferenceExpression.TargetObject;
				memberReferenceExpression = expression as MemberReferenceExpression;
			}

			var identifierExpression = expression as IdentifierExpression;
			if(identifierExpression != null && sb.Length != 0)
			{
				string path;
				if (aliasToName.TryGetValue(identifierExpression.Identifier, out path))
				{
					sb.Insert(0, path);
				}
			}
			if (sb.Length == 0)
				return null;

			return sb.ToString();
		}

		private void ProcessQuery(Expression queryExpressionSelectClause)
		{
			var objectCreateExpression = QueryParsingUtils.GetAnonymousCreateExpression(queryExpressionSelectClause) as ObjectCreateExpression;
			if (objectCreateExpression == null ||
				objectCreateExpression.IsAnonymousType == false)
				return;

			foreach (
				var expression in
					objectCreateExpression.ObjectInitializer.CreateExpressions.OfType<NamedArgumentExpression>())
			{
				var generateExpression = GenerateExpression(expression.Expression);
				if (generateExpression != null)
					QueryParameters.Add(generateExpression);
			}

			foreach (
				var expression in
					objectCreateExpression.ObjectInitializer.CreateExpressions.OfType<MemberReferenceExpression>())
			{
				var generateExpression = GenerateExpression(expression);
				if (generateExpression != null)
					QueryParameters.Add(generateExpression);
			}
		}

		public ResolveResult Resolve (Expression expression)
		{
			ResolveResult result = expression.AcceptVisitor (this, null) as ResolveResult;
			if (result == null)
				result = CreateResult ("");
			return result;
		}

 public static VariableDeclaration add_Variable(this BlockStatement blockDeclaration, string name, Expression expression, TypeReference typeReference)
 {
     var variableDeclaration = new VariableDeclaration(name, expression) {TypeReference = typeReference};
     var localVariableDeclaration = new LocalVariableDeclaration(variableDeclaration);
     blockDeclaration.append(localVariableDeclaration);
     return variableDeclaration;
 }

		public static IEnumerable<TreeNode> LazyGetChildNodesOfArray(TreeNode parent, Expression expression, ArrayDimensions dimensions)
		{
			if (dimensions.TotalElementCount == 0)
				return new TreeNode[] { new TreeNode(null, "(empty)", null, null, parent, null) };
			
			return new ArrayRangeNode(parent, expression, dimensions, dimensions).ChildNodes;
		}

		/// <summary>
		/// Gets "a.b" from "a.b.c"
		/// </summary>
		Expression GetTarget(Expression memberReferenceExpr)
		{
			if (memberReferenceExpr is MemberReferenceExpression) {
				return ((MemberReferenceExpression)memberReferenceExpr).TargetObject;
			}
			return null;
		}

		private void ProcessQuery(Expression queryExpressionSelectClause)
		{
			var objectCreateExpression = queryExpressionSelectClause as ObjectCreateExpression;
			if (objectCreateExpression == null ||
				objectCreateExpression.IsAnonymousType == false)
				return;

			// we only want the outer most value
			if (queryProcessed)
				return;

			queryProcessed = true;

			foreach (
				var expression in
					objectCreateExpression.ObjectInitializer.CreateExpressions.OfType<NamedArgumentExpression>())
			{
				FieldNames.Add(expression.Name);
			}

			foreach (
				var expression in
					objectCreateExpression.ObjectInitializer.CreateExpressions.OfType<MemberReferenceExpression>())
			{
				FieldNames.Add(expression.MemberName);
			}

			foreach (
			  var expression in
				  objectCreateExpression.ObjectInitializer.CreateExpressions.OfType<IdentifierExpression>())
			{
				FieldNames.Add(expression.Identifier);
			}
		}

		public IReturnType ResolveType(Expression expression)
		{
			ResolveResult rr = Resolve(expression);
			if (rr != null)
				return rr.ResolvedType;
			else
				return null;
		}

		internal InferredReturnType(Expression expression, NRefactoryResolver resolver)
		{
			if (resolver == null)
				throw new ArgumentNullException("resolver");
			
			_expression = expression;
			_resolver = resolver;
		}

 public static void Assign(this BlockStatement block, Expression left, Expression right)
 {
     if (left == null)
         throw new ArgumentNullException("left");
     if (right == null)
         throw new ArgumentNullException("right");
     AddStatement(block, new AssignmentExpression(left, AssignmentOperatorType.Assign, right));
 }

		public IListNode(Expression targetObject)
		{
			this.targetObject = targetObject;
			
			this.Name = "IList";
			this.count = Utils.GetIListCount(this.targetObject);
			this.ChildNodes = Utils.LazyGetItemsOfIList(this.targetObject);
		}

 private bool IsMethodInvocation(Expression expression)
 {
     if (expression.Parent is InvocationExpression)
     {
         InvocationExpression invocation = (InvocationExpression) expression.Parent;
         return expression.GetHashCode() == invocation.TargetObject.GetHashCode();
     }
     return false;
 }

		public static IEnumerable<TreeNode> LazyGetMembersOfObject(Expression expression, MemberInfo[] members)
		{
			List<TreeNode> nodes = new List<TreeNode>();
			foreach(MemberInfo memberInfo in members) {
				nodes.Add(new ExpressionNode(ExpressionNode.GetImageForMember((IDebugMemberInfo)memberInfo), memberInfo.Name, expression.AppendMemberReference((IDebugMemberInfo)memberInfo)));
			}
			nodes.Sort();
			return nodes;
		}

		public ArrayRangeNode(Expression arrayTarget, ArrayDimensions bounds, ArrayDimensions originalBounds)
		{
			this.arrayTarget = arrayTarget;
			this.bounds = bounds;
			this.originalBounds = originalBounds;
			
			this.Name = GetName();
			this.ChildNodes = LazyGetChildren();
		}

		public IListNode(TreeNode parent, Expression targetListObject)
			: base(parent)
		{
			this.targetList = targetListObject;
			
			this.Name = "IList";
			this.listCount = this.targetList.GetIListCount();
			this.childNodes = Utils.LazyGetItemsOfIList(this, this.targetList);
		}

		private Expression SimplifyLetExpression(Expression expression)
		{
			var castExpression = expression as CastExpression;
			if (castExpression != null)
				return SimplifyLetExpression(castExpression.Expression);
			var parenthesizedExpression = expression as ParenthesizedExpression;
			if (parenthesizedExpression != null)
				return SimplifyLetExpression(parenthesizedExpression.Expression);
			return expression;
		}

 public LocalLookupVariable(string name, TypeReference typeRef, Location startPos, Location endPos, bool isConst, bool isLoopVariable, Expression initializer)
 {
     this.Name = name;
     this.TypeRef = typeRef;
     this.StartPos = startPos;
     this.EndPos = endPos;
     this.IsConst = isConst;
     this.IsLoopVariable = isLoopVariable;
     this.Initializer = initializer;
 }

		public IEnumerableNode(Expression targetObject, DebugType itemType)
		{
			this.targetObject = targetObject;
			
			this.Name = "IEnumerable";
			this.Text = "Expanding will enumerate the IEnumerable";
			DebugType debugListType;
			this.debugListExpression = DebuggerHelpers.CreateDebugListExpression(targetObject, itemType, out debugListType);
			this.ChildNodes = Utils.LazyGetItemsOfIList(this.debugListExpression);
		}

		public ResolveResult Resolve(Expression expression)
		{
			ResolveResult rr;
			if (!cachedResults.TryGetValue(expression, out rr)) {
				rr = (ResolveResult)expression.AcceptVisitor(this, null);
				if (rr != null)
					rr.Freeze();
				cachedResults[expression] = rr;
			}
			return rr;
		}