public ForExpression(Position pos, VariableDeclaration varDec, Expression high, Expression body)
 {
     Pos = pos;
     VarDec = varDec;
     High = high;
     Body = body;
 }

		public override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
		{
			if (nameComparer.Equals(from, variableDeclaration.Name)) {
				variableDeclaration.Name = to;
			}
			return base.VisitVariableDeclaration(variableDeclaration, data);
		}

        public LocalVariablesDeclaration(Expression type, VariableDeclaration variables,
		                                  TokenPosition position)
            : base(position)
        {
            this.type = type;
            this.variables = variables;
        }

 public void visit(VariableDeclaration node)
 {
     if (symboltable.resolve(node.Name) != null)
         throw new SemanticError("Variable " + node.Name +
             " is already defined (row " + node.Row + ").");
     Symbol symbol = new Symbol(node.Name, node.Type);
     symboltable.define(symbol);
 }

 public override object Walk(VariableDeclaration node)
 {
     var value = node.Initializer == null
         ? null
         : node.Initializer.Accept(this);
     Context.CurrentFrame.Define(node.Identifier.Value, value);
     return value;
 }

 public virtual object Walk(VariableDeclaration node)
 {
     if (Enter(node))
     {
         node.Identifier.Accept(this);
         if (node.Initializer != null)
             node.Initializer.Accept(this);
     }
     Exit(node);
     return null;
 }

        public void InvalidRange()
        {
            var stringlit = new StringLiteral("foo", 0);
            var range = new Range(stringlit, stringlit, 0);
            var variabledecl = new VariableDeclaration("foo", "int", 0);
            var variable = new VariableReference("foo", 0);
            var loop = new Loop(variable, range, new List<Statement>(), 0);
            statementlist.Add(variabledecl);
            statementlist.Add(loop);
            var parsetree = new Program(statementlist);

            Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree));
        }

        public void NonIntegerLoopVariable(string type)
        {
            var variabledecl = new VariableDeclaration("foo", type, 0);
            statementlist.Add(variabledecl);
            var variable = new VariableReference("foo", 0);
            var integer = new IntegerLiteral("5", 0);
            var range = new Range(integer, integer, 0);
            var variabledecl2 = new VariableDeclaration("bar", "int", 0);
            var loopbody = new List<Statement>();
            loopbody.Add(variabledecl2);
            var loop = new Loop(variable, range, loopbody, 0);
            statementlist.Add(loop);
            var parsetree = new Program(statementlist);

            Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree));
        }

        public void FalseAnd()
        {
            var falseboolean = new LogicalOp("=", new IntegerLiteral("4", 0), new IntegerLiteral("5", 0), 0);
            var trueboolean = new LogicalOp("=", new IntegerLiteral("4", 0), new IntegerLiteral("5", 0), 0);
            var and1 = new LogicalOp("&", falseboolean, trueboolean, 0);
            var and2 = new LogicalOp("&", falseboolean, falseboolean, 0);
            var assignment1 = new Assignment(result, and1, 0);
            program.Add(assignment1);
            var result2 = new VariableDeclaration("result2", "bool", 0);
            symboltable.define(new Symbol("result2", "bool"));
            var assignment2 = new Assignment(result2, and2, 0);
            program.Add(assignment2);

            interpreter.Run(new Program(program));
            Assert.That(interpreter.Valuetable[symboltable.resolve("result")], Is.EqualTo(false));
            Assert.That(interpreter.Valuetable[symboltable.resolve("result2")], Is.EqualTo(false));
        }

        private static bool MatchesLocalVariable(SrcMLDataContext db, VariableDeclaration def, XElement use)
        {
            if (def.IsGlobal ?? false)
                return false;

            if (def.DeclarationName != use.Value)
                return false;
            
            var useXPath = use.GetXPath(false);
            var validScopes = from scope in db.ValidScopes
                              where scope.DefinitionId == def.Id
                              select scope;
            foreach (var scope in validScopes)
            {
                if (useXPath.StartsWith(scope.XPath))
                    return true;
            }

            var method = (from ancestor in use.Ancestors()
                          where ContainerNames.MethodDefinitions.Any(mn => mn == ancestor.Name)
                          select ancestor).FirstOrDefault();
            var classNameFromMethod = SrcMLHelper.GetClassNameForMethod(method);

            if (null == classNameFromMethod)
            {
                return false;
            }

            var classDef = from scope in def.ValidScopes.OfType<TypeDefinition>()
                           where scope.TypeName == classNameFromMethod.Value
                           select scope;
            if (classDef.Any())
            {
                return true;
            }

            return false;
        }

 public override void Exit(VariableDeclaration node)
 {
     level--;
 }

 public virtual void Exit(VariableDeclaration node)
 {
 }

 public virtual bool Enter(VariableDeclaration node)
 {
     return true;
 }

		public Using (Expression expr, Statement stmt, Location loc)
			: base (stmt, loc)
		{
			this.decl = new VariableDeclaration (expr);
		}

    public virtual Differences VisitVariableDeclaration(VariableDeclaration variableDeclaration1, VariableDeclaration variableDeclaration2){
      Differences differences = new Differences(variableDeclaration1, variableDeclaration2);
      if (variableDeclaration1 == null || variableDeclaration2 == null){
        if (variableDeclaration1 != variableDeclaration2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
        return differences;
      }
      VariableDeclaration changes = (VariableDeclaration)variableDeclaration2.Clone();
      VariableDeclaration deletions = (VariableDeclaration)variableDeclaration2.Clone();
      VariableDeclaration insertions = (VariableDeclaration)variableDeclaration2.Clone();

      //      variableDeclaration1.Field;
      //      variableDeclaration1.Initializer;
      //      variableDeclaration1.Name;
      //      variableDeclaration1.Type;

      if (differences.NumberOfDifferences == 0){
        differences.Changes = null;
        differences.Deletions = null;
        differences.Insertions = null;
      }else{
        differences.Changes = changes;
        differences.Deletions = deletions;
        differences.Insertions = insertions;
      }
      return differences;
    }

			public Statement RewriteForDeclarators (BlockContext bc, Statement stmt)
			{
				for (int i = declarators.Count - 1; i >= 0; --i) {
					var d = declarators [i];
					var vd = new VariableDeclaration (d.Variable, type_expr.Location);
					vd.Initializer = d.Initializer;
					vd.IsNested = true;
					vd.dispose_call = CreateDisposeCall (bc, d.Variable);
					vd.dispose_call.Resolve (bc);

					stmt = new Using (vd, stmt, d.Variable.Location);
				}

				declarators = null;
				return stmt;
			}

            public override void Visit(VariableDeclaration node)
            {
                if (node.EnclosingScope is GlobalScope && node.Identifier == varName)
                {
                    found = true;
                }

                base.Visit(node);
            }

		public Fixed (VariableDeclaration decl, Statement stmt, Location l)
		{
			this.decl = decl;
			statement = stmt;
			loc = l;
		}

        private static int RelocateVar(Block block, int insertAt, Var varStatement)
        {
            // if the var statement is at the next position to insert, then we don't need
            // to do anything.
            if (block[insertAt] != varStatement && !InsideConditionalComment(varStatement))
            {
                // check to see if the current position is a var and we are the NEXT statement.
                // if that's the case, we don't need to break out the initializer, just append all the
                // vardecls as-is to the current position.
                var existingVar = block[insertAt] as Var;
                if (existingVar != null && block[insertAt + 1] == varStatement)
                {
                    // just append our vardecls to the insertion point, then delete our statement
                    existingVar.Append(varStatement);
                    block.RemoveAt(insertAt + 1);
                }
                else
                {
                    // iterate through the decls and count how many have initializers
                    var initializerCount = 0;
                    for (var ndx = 0; ndx < varStatement.Count; ++ndx)
                    {
                        if (varStatement[ndx].Initializer != null)
                        {
                            ++initializerCount;
                        }
                    }

                    // if there are more than two decls with initializers, then we won't actually
                    // be gaining anything by moving the var to the top. We'll get rid of the four
                    // bytes for the "var ", but we'll be adding two bytes for the name and comma
                    // because name=init will still need to remain behind.
                    if (initializerCount <= 2)
                    {
                        // first iterate through all the declarations in the var statement,
                        // constructing an expression statement that is made up of assignment
                        // operators for each of the declarations that have initializers (if any)
                        // and removing all the initializers
                        var assignments = new List<AstNode>();
                        for (var ndx = 0; ndx < varStatement.Count; ++ndx)
                        {
                            var varDecl = varStatement[ndx];
                            if (varDecl.Initializer != null)
                            {
                                if (varDecl.IsCCSpecialCase)
                                {
                                    // create a vardecl with the same name and no initializer
                                    var copyDecl = new VariableDeclaration(
                                        varDecl.Context,
                                        varDecl.Parser,
                                        varDecl.Identifier,
                                        varDecl.Field.OriginalContext,
                                        null,
                                        0,
                                        true);

                                    // replace the special vardecl with the copy
                                    varStatement.ReplaceChild(varDecl, copyDecl);

                                    // add the original vardecl to the list of "assignments"
                                    assignments.Add(varDecl);
                                }
                                else
                                {
                                    // hold on to the object so we don't lose it to the GC
                                    var initializer = varDecl.Initializer;

                                    // remove it from the vardecl
                                    varDecl.ReplaceChild(initializer, null);

                                    // create an assignment operator for a lookup to the name
                                    // as the left, and the initializer as the right, and add it to the list
                                    assignments.Add(new BinaryOperator(
                                        varDecl.Context,
                                        varDecl.Parser,
                                        new Lookup(varDecl.Identifier, varDecl.Field.OriginalContext, varDecl.Parser),
                                        initializer,
                                        JSToken.Assign));
                                }
                            }
                        }

                        // now if there were any initializers...
                        if (assignments.Count > 0)
                        {
                            // we want to create one big expression from all the assignments and replace the
                            // var statement with the assignment(s) expression. Start at position n=1 and create
                            // a binary operator of n-1 as the left, n as the right, and using a comma operator.
                            var expression = assignments[0];
                            for (var ndx = 1; ndx < assignments.Count; ++ndx)
                            {
                                expression = new BinaryOperator(
                                    null,
                                    expression.Parser,
                                    expression,
                                    assignments[ndx],
                                    JSToken.Comma);
                            }

                            // replace the var with the expression.
//.........这里部分代码省略.........

 public virtual Statement VisitVariableDeclaration(VariableDeclaration variableDeclaration){
   if (variableDeclaration == null) return null;
   variableDeclaration.Type = this.VisitTypeReference(variableDeclaration.Type);
   variableDeclaration.Initializer = this.VisitExpression(variableDeclaration.Initializer);
   return variableDeclaration;
 }