public override object VisitCastExpression(CastExpression castExpression, object data)
            {
                //This was the hardest achievement to write ever :p
                UnlockWith(castExpression);

                return base.VisitCastExpression(castExpression, data);
            }

 public override object TrackedVisitInvocationExpression(InvocationExpression invocationExpression, object data)
 {
     if (invocationExpression.TargetObject is FieldReferenceExpression)
     {
         FieldReferenceExpression targetObject = (FieldReferenceExpression) invocationExpression.TargetObject;
         string methodName = targetObject.FieldName;
         TypeDeclaration typeDeclaration = GetEnclosingTypeDeclaration(invocationExpression);
         TypeDeclaration thisTypeDeclaration = (TypeDeclaration) AstUtil.GetParentOfType(invocationExpression, typeof(TypeDeclaration));
         if (typeDeclaration != null && IsTestFixture(thisTypeDeclaration))
         {
             IList methods = AstUtil.GetChildrenWithType(typeDeclaration, typeof(MethodDeclaration));
             IList specialMethods = GetMethods(methods, methodName);
             if (ContainsInternalMethod(specialMethods))
             {
                 Expression replacedExpression;
                 MethodDeclaration method = (MethodDeclaration) specialMethods[0];
                 bool staticMethod = AstUtil.ContainsModifier(method, Modifiers.Static);
                 replacedExpression = CreateReflectionInvocation(invocationExpression, staticMethod);
                 if (invocationExpression.Parent is Expression || invocationExpression.Parent is VariableDeclaration)
                 {
                     TypeReference returnType = GetInternalMethodReturnType(specialMethods);
                     CastExpression castExpression = new CastExpression(returnType, replacedExpression, CastType.Cast);
                     replacedExpression = castExpression;
                 }
                 ReplaceCurrentNode(replacedExpression);
             }
         }
     }
     return base.TrackedVisitInvocationExpression(invocationExpression, data);
 }

 public override object VisitCastExpression(CastExpression castExpression, object data)
 {
     if (GetPrecedence(castExpression.Expression) > GetPrecedence(castExpression)) {
         castExpression.Expression = Deparenthesize(castExpression.Expression);
     }
     return base.VisitCastExpression(castExpression, data);
 }

        private CastExpression GetCastExpression(BinaryOperatorExpression binaryOperatorExpression)
        {
            TypeReference leftType = GetExpressionType(binaryOperatorExpression.Left);

            CastExpression castedUnsignedShift = new CastExpression(new TypeReference("u" + leftType.Type), binaryOperatorExpression, CastType.Cast);
            ParenthesizedExpression parenthesizedCastedUnsignedShift = new ParenthesizedExpression(castedUnsignedShift);
            return new CastExpression(new TypeReference(leftType.Type), parenthesizedCastedUnsignedShift, CastType.Cast);
        }

		/// <summary>
		/// Creates an expression which, when evaluated, creates a List&lt;T&gt; in the debugee
		/// filled with contents of IEnumerable&lt;T&gt; from the debugee.
		/// </summary>
		/// <param name="iEnumerableVariable">Expression for IEnumerable variable in the debugee.</param>
		/// <param name="itemType">
		/// The generic argument of IEnumerable&lt;T&gt; that <paramref name="iEnumerableVariable"/> implements.</param>
		public static Expression CreateDebugListExpression(Expression iEnumerableVariable, DebugType itemType, out DebugType listType)
		{
			// is using itemType.AppDomain ok?
			listType = DebugType.CreateFromType(itemType.AppDomain, typeof(System.Collections.Generic.List<>), itemType);
			var iEnumerableType = DebugType.CreateFromType(itemType.AppDomain, typeof(IEnumerable<>), itemType);
			// explicitely cast the variable to IEnumerable<T>, where T is itemType
			Expression iEnumerableVariableExplicitCast = new CastExpression(iEnumerableType.GetTypeReference() , iEnumerableVariable, CastType.Cast);
			return new ObjectCreateExpression(listType.GetTypeReference(), iEnumerableVariableExplicitCast.ToList());
		}

 public override object VisitCastExpression(CastExpression castExpression, object data)
 {
     if (castExpression.CastTo.Type == "int" &&
         castExpression.Expression is MemberReferenceExpression &&
         (castExpression.Expression as MemberReferenceExpression).MemberName == "Length") {
         ReplaceCurrentNode(castExpression.Expression);
         return null;
     }
     return base.VisitCastExpression(castExpression, data);
 }

        /// <summary>
        /// Creates an expression which, when evaluated, creates a List&lt;T&gt; in the debugee
        /// filled with contents of IEnumerable&lt;T&gt; from the debugee.
        /// </summary>
        /// <param name="iEnumerableVariable">Expression for IEnumerable variable in the debugee.</param>
        /// <param name="itemType">
        /// The generic argument of IEnumerable&lt;T&gt; that <paramref name="iEnumerableVariable"/> implements.</param>
        public static Expression CreateDebugListExpression(Expression iEnumerableVariable, DebugType itemType, out DebugType listType)
        {
            // is using itemType.AppDomain ok?
            listType = DebugType.CreateFromType(itemType.AppDomain, typeof(System.Collections.Generic.List<>), itemType);
            var iEnumerableType = DebugType.CreateFromType(itemType.AppDomain, typeof(IEnumerable<>), itemType);
            // explicitely cast the variable to IEnumerable<T>, where T is itemType
            Expression iEnumerableVariableExplicitCast = new CastExpression { Expression = iEnumerableVariable.Clone() , Type = iEnumerableType.GetTypeReference() };

            var obj = new ObjectCreateExpression() { Type = listType.GetTypeReference() };
            obj.Arguments.Add(iEnumerableVariableExplicitCast);

            return obj;
        }

		public override object VisitLambdaExpression(ICSharpCode.NRefactory.Ast.LambdaExpression lambdaExpression, object data)
		{
			var invocationExpression = lambdaExpression.Parent as InvocationExpression;
			if (invocationExpression == null)
				return base.VisitLambdaExpression(lambdaExpression, data);

			var target = invocationExpression.TargetObject as MemberReferenceExpression;
			if(target == null)
				return base.VisitLambdaExpression(lambdaExpression, data);

			INode node = lambdaExpression;
			var parenthesizedlambdaExpression = new ParenthesizedExpression(lambdaExpression);
			switch (target.MemberName)
			{
				case "Sum":
				case "Average":
					node = ModifyLambdaForNumerics(lambdaExpression, parenthesizedlambdaExpression);
					break;
				case "Max":
				case "Min":
					node = ModifyLambdaForMinMax(lambdaExpression, parenthesizedlambdaExpression);
					break;
				case "OrderBy":
				case "OrderByDescending":
				case "GroupBy":
				case "Recurse":
				case "Select":
					node = ModifyLambdaForSelect(parenthesizedlambdaExpression, target);
					break;
				case "SelectMany":
					node = ModifyLambdaForSelectMany(lambdaExpression, parenthesizedlambdaExpression, invocationExpression);
					break;
				case "Any":
				case "all":
				case "First":
				case "FirstOrDefault":
				case "Last":
				case "LastOfDefault":
				case "Single":
				case "Where":
				case "Count":
				case "SingleOrDefault":
					node = new CastExpression(new TypeReference("Func<dynamic, bool>"), parenthesizedlambdaExpression, CastType.Cast);
				break;
			}
			ReplaceCurrentNode(node);

			return base.VisitLambdaExpression(lambdaExpression, data);
		}

 public override object VisitCastExpression(CastExpression castExpression, object data)
 {
     if (castExpression.CastType == CastType.Cast) {
         // Casts to value types are marked as conversions
         // this code only supports primitive types, user-defined value types are handled by
         // the DOM-aware CSharpToVBNetConvertVisitor
         string type;
         if (TypeReference.PrimitiveTypesCSharpReverse.TryGetValue(castExpression.CastTo.Type, out type)) {
             if (type != "object" && type != "string") {
                 // type is value type
                 castExpression.CastType = CastType.Conversion;
             }
         }
     }
     return base.VisitCastExpression(castExpression, data);
 }

 public override object VisitCastExpression(CastExpression castExpression, object data)
 {
     base.VisitCastExpression(castExpression, data);
     if (castExpression.CastType == CastType.Conversion || castExpression.CastType == CastType.PrimitiveConversion) {
         switch (castExpression.CastTo.Type) {
             case "System.Boolean":
                 return ReplacePrimitiveCastWithConvertMethodCall(castExpression, "ToBoolean");
             case "System.Byte":
                 return ReplacePrimitiveCastWithConvertMethodCall(castExpression, "ToByte");
             case "System.Char":
                 return ReplacePrimitiveCastWithConvertMethodCall(castExpression, "ToChar");
             case "System.DateTime":
                 return ReplacePrimitiveCastWithConvertMethodCall(castExpression, "ToDateTime");
             case "System.Decimal":
                 return ReplacePrimitiveCastWithConvertMethodCall(castExpression, "ToDecimal");
             case "System.Double":
                 return ReplacePrimitiveCastWithConvertMethodCall(castExpression, "ToDouble");
             case "System.Int16":
                 return ReplacePrimitiveCastWithConvertMethodCall(castExpression, "ToInt16");
             case "System.Int32":
                 return ReplacePrimitiveCastWithConvertMethodCall(castExpression, "ToInt32");
             case "System.Int64":
                 return ReplacePrimitiveCastWithConvertMethodCall(castExpression, "ToInt64");
             case "System.SByte":
                 return ReplacePrimitiveCastWithConvertMethodCall(castExpression, "ToSByte");
             case "System.Single":
                 return ReplacePrimitiveCastWithConvertMethodCall(castExpression, "ToSingle");
             case "System.String":
                 return ReplacePrimitiveCastWithConvertMethodCall(castExpression, "ToString");
             case "System.UInt16":
                 return ReplacePrimitiveCastWithConvertMethodCall(castExpression, "ToUInt16");
             case "System.UInt32":
                 return ReplacePrimitiveCastWithConvertMethodCall(castExpression, "ToUInt32");
             case "System.UInt64":
                 return ReplacePrimitiveCastWithConvertMethodCall(castExpression, "ToUInt64");
         }
     }
     return null;
 }

		public sealed override object VisitCastExpression(CastExpression castExpression, object data) {
			this.BeginVisit(castExpression);
			object result = this.TrackedVisitCastExpression(castExpression, data);
			this.EndVisit(castExpression);
			return result;
		}

		public virtual object VisitCastExpression(CastExpression castExpression, object data) {
			throw new global::System.NotImplementedException("CastExpression");
		}

//.........这里部分代码省略.........

#line  1688 "VBNET.ATG" 
				pexpr = expr; 
				break;
			}
			case 81: case 93: case 204: {

#line  1690 "VBNET.ATG" 
				CastType castType = CastType.Cast; 
				if (la.kind == 93) {
					lexer.NextToken();
				} else if (la.kind == 81) {
					lexer.NextToken();

#line  1692 "VBNET.ATG" 
					castType = CastType.Conversion; 
				} else if (la.kind == 204) {
					lexer.NextToken();

#line  1693 "VBNET.ATG" 
					castType = CastType.TryCast; 
				} else SynErr(259);
				Expect(25);
				Expr(
#line  1695 "VBNET.ATG" 
out expr);
				Expect(12);
				TypeName(
#line  1695 "VBNET.ATG" 
out type);
				Expect(26);

#line  1696 "VBNET.ATG" 
				pexpr = new CastExpression(type, expr, castType); 
				break;
			}
			case 63: case 64: case 65: case 66: case 67: case 68: case 70: case 72: case 73: case 77: case 78: case 79: case 80: case 82: case 83: case 84: {
				CastTarget(
#line  1697 "VBNET.ATG" 
out type);
				Expect(25);
				Expr(
#line  1697 "VBNET.ATG" 
out expr);
				Expect(26);

#line  1697 "VBNET.ATG" 
				pexpr = new CastExpression(type, expr, CastType.PrimitiveConversion); 
				break;
			}
			case 44: {
				lexer.NextToken();
				Expr(
#line  1698 "VBNET.ATG" 
out expr);

#line  1698 "VBNET.ATG" 
				pexpr = new AddressOfExpression(expr); 
				break;
			}
			case 116: {
				lexer.NextToken();
				Expect(25);
				GetTypeTypeName(
#line  1699 "VBNET.ATG" 
out type);

			public override object VisitCastExpression (CastExpression expression, object data)
			{
				//				Console.WriteLine ("CastExpression");
				IntegrateTemporaryVariableVisitorOptions options = (IntegrateTemporaryVariableVisitorOptions)data;
				if (IsExpressionToReplace (expression.Expression, (IntegrateTemporaryVariableVisitorOptions)data)) {
					if (IsPrimary (options.Initializer))
						options.Changes.Add (ReplaceExpression (expression.Expression, options.Initializer, options));
					else
						options.Changes.Add (ReplaceExpression (expression.Expression, new ParenthesizedExpression (options.Initializer), options));
					return null;
				} else {
					return base.VisitCastExpression (expression, data);
				}
			}

	void RelationalExpr(
#line  2251 "cs.ATG" 
ref Expression outExpr) {

#line  2253 "cs.ATG" 
		TypeReference type;
		Expression expr;
		BinaryOperatorType op = BinaryOperatorType.None;
		Location startLocation = la.Location;
		
		ShiftExpr(
#line  2259 "cs.ATG" 
ref outExpr);
		while (StartOf(37)) {
			if (StartOf(38)) {
				if (la.kind == 23) {
					lexer.NextToken();

#line  2261 "cs.ATG" 
					op = BinaryOperatorType.LessThan; 
				} else if (la.kind == 22) {
					lexer.NextToken();

#line  2262 "cs.ATG" 
					op = BinaryOperatorType.GreaterThan; 
				} else if (la.kind == 36) {
					lexer.NextToken();

#line  2263 "cs.ATG" 
					op = BinaryOperatorType.LessThanOrEqual; 
				} else if (la.kind == 35) {
					lexer.NextToken();

#line  2264 "cs.ATG" 
					op = BinaryOperatorType.GreaterThanOrEqual; 
				} else SynErr(215);
				UnaryExpr(
#line  2266 "cs.ATG" 
out expr);
				ShiftExpr(
#line  2267 "cs.ATG" 
ref expr);

#line  2268 "cs.ATG" 
				outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
			} else {
				if (la.kind == 85) {
					lexer.NextToken();
					TypeWithRestriction(
#line  2271 "cs.ATG" 
out type, false, false);
					if (
#line  2272 "cs.ATG" 
la.kind == Tokens.Question && !IsPossibleExpressionStart(Peek(1).kind)) {
						NullableQuestionMark(
#line  2273 "cs.ATG" 
ref type);
					}

#line  2274 "cs.ATG" 
					outExpr = new TypeOfIsExpression(outExpr, type)  { StartLocation = startLocation, EndLocation = t.EndLocation }; 
				} else if (la.kind == 50) {
					lexer.NextToken();
					TypeWithRestriction(
#line  2276 "cs.ATG" 
out type, false, false);
					if (
#line  2277 "cs.ATG" 
la.kind == Tokens.Question && !IsPossibleExpressionStart(Peek(1).kind)) {
						NullableQuestionMark(
#line  2278 "cs.ATG" 
ref type);
					}

#line  2279 "cs.ATG" 
					outExpr = new CastExpression(type, outExpr, CastType.TryCast) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
				} else SynErr(216);
			}
		}
	}

//.........这里部分代码省略.........

#line  1776 "VBNET.ATG" 
				pexpr = cie; 
				break;
			}
			case 96: case 108: case 222: {

#line  1778 "VBNET.ATG" 
				CastType castType = CastType.Cast; 
				if (la.kind == 108) {
					lexer.NextToken();
				} else if (la.kind == 96) {
					lexer.NextToken();

#line  1780 "VBNET.ATG" 
					castType = CastType.Conversion; 
				} else if (la.kind == 222) {
					lexer.NextToken();

#line  1781 "VBNET.ATG" 
					castType = CastType.TryCast; 
				} else SynErr(286);
				Expect(37);
				Expr(
#line  1783 "VBNET.ATG" 
out expr);
				Expect(22);
				TypeName(
#line  1783 "VBNET.ATG" 
out type);
				Expect(38);

#line  1784 "VBNET.ATG" 
				pexpr = new CastExpression(type, expr, castType); 
				break;
			}
			case 78: case 79: case 80: case 81: case 82: case 83: case 85: case 87: case 88: case 92: case 93: case 94: case 95: case 97: case 98: case 99: {
				CastTarget(
#line  1785 "VBNET.ATG" 
out type);
				Expect(37);
				Expr(
#line  1785 "VBNET.ATG" 
out expr);
				Expect(38);

#line  1785 "VBNET.ATG" 
				pexpr = new CastExpression(type, expr, CastType.PrimitiveConversion); 
				break;
			}
			case 57: {
				lexer.NextToken();
				Expr(
#line  1786 "VBNET.ATG" 
out expr);

#line  1786 "VBNET.ATG" 
				pexpr = new AddressOfExpression(expr); 
				break;
			}
			case 131: {
				lexer.NextToken();
				Expect(37);
				GetTypeTypeName(
#line  1787 "VBNET.ATG" 
out type);

		private static INode ModifyLambdaForSelectMany(LambdaExpression lambdaExpression,
		                                               ParenthesizedExpression parenthesizedlambdaExpression,
		                                               InvocationExpression invocationExpression)
		{
			INode node = lambdaExpression;
			var argPos = invocationExpression.Arguments.IndexOf(lambdaExpression);
			switch (argPos)
			{
				case 0: // first one, select the collection
					// need to enter a cast for (IEnumerable<dynamic>) on the end of the lambda body
					var selectManyExpression = new LambdaExpression
					{
						ExpressionBody =
							new CastExpression(new TypeReference("IEnumerable<dynamic>"),
							                   new ParenthesizedExpression(lambdaExpression.ExpressionBody), CastType.Cast),
						Parameters = lambdaExpression.Parameters,
					};
					node = new CastExpression(new TypeReference("Func<dynamic, IEnumerable<dynamic>>"),
					                          new ParenthesizedExpression(selectManyExpression), CastType.Cast);
					break;
				case 1: // the transformation func
					node = new CastExpression(new TypeReference("Func<dynamic, dynamic, dynamic>"), parenthesizedlambdaExpression,
					                          CastType.Cast);
					break;
			}
			return node;
		}

		public override object VisitCastExpression (CastExpression castExpression, object data) 
		{
			return CreateResult (castExpression.CastTo);
		}

		public static IEnumerable<TreeNode> LazyGetItemsOfIList(Expression targetObject)
		{
			// This is needed for expanding IEnumerable<T>
			
			var type = new SimpleType() { Identifier = typeof(IList).FullName };
			type.AddAnnotation(typeof(IList));
			
			targetObject = new CastExpression() { Expression = targetObject.Clone(), Type = type };

			int count = 0;
			GetValueException error = null;
			try {
				count = GetIListCount(targetObject);
			} catch (GetValueException e) {
				// Cannot yield a value in the body of a catch clause (CS1631)
				error = e;
			}
			if (error != null) {
				yield return new TreeNode(null, "(error)", error.Message, null, null);
			} else if (count == 0) {
				yield return new TreeNode(null, "(empty)", null, null, null);
			} else {
				for(int i = 0; i < count; i++) {
					string imageName;
					var image = ExpressionNode.GetImageForArrayIndexer(out imageName);
					var expression = new ExpressionNode(image, "[" + i + "]", targetObject.AppendIndexer(i));
					expression.ImageName = imageName;
					yield return expression;
				}
			}
		}

 public override object TrackedVisitCastExpression(CastExpression castExpression, object data)
 {
     return castExpression.Expression.AcceptVisitor(this, data);
 }