Update elements, nodes and visitors for serialization.

pkg/compiler/lib/src/tree/nodes.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:collection' show IterableMixin;
 
 import '../common.dart';
 import '../tokens/precedence_constants.dart' as Precedence show FUNCTION_INFO;
 import '../tokens/token.dart' show BeginGroupToken, Token;
 import '../tokens/token_constants.dart' as Tokens
     show IDENTIFIER_TOKEN, KEYWORD_TOKEN, PLUS_TOKEN;
 import '../util/util.dart';
 import '../util/characters.dart';
 import '../resolution/secret_tree_element.dart'
     show NullTreeElementMixin, StoredTreeElementMixin;
 import '../elements/elements.dart' show MetadataAnnotation;
 import 'dartstring.dart';
 import 'prettyprint.dart';
 import 'unparser.dart';
 
 abstract class Visitor<R> {
   const Visitor();
 
   R visitNode(Node node);
 
   R visitAssert(Assert node) => visitStatement(node);
-  R visitAsyncForIn(AsyncForIn node) => visitLoop(node);
+  R visitAsyncForIn(AsyncForIn node) => visitForIn(node);
   R visitAsyncModifier(AsyncModifier node) => visitNode(node);
   R visitAwait(Await node) => visitExpression(node);
   R visitBlock(Block node) => visitStatement(node);
   R visitBreakStatement(BreakStatement node) => visitGotoStatement(node);
   R visitCascade(Cascade node) => visitExpression(node);
   R visitCascadeReceiver(CascadeReceiver node) => visitExpression(node);
   R visitCaseMatch(CaseMatch node) => visitNode(node);
   R visitCatchBlock(CatchBlock node) => visitNode(node);
   R visitClassNode(ClassNode node) => visitNode(node);
   R visitCombinator(Combinator node) => visitNode(node);
   R visitConditional(Conditional node) => visitExpression(node);
   R visitConditionalUri(ConditionalUri node) => visitNode(node);
   R visitContinueStatement(ContinueStatement node) => visitGotoStatement(node);
   R visitDottedName(DottedName node) => visitExpression(node);
   R visitDoWhile(DoWhile node) => visitLoop(node);
   R visitEmptyStatement(EmptyStatement node) => visitStatement(node);
   R visitEnum(Enum node) => visitNode(node);
   R visitExport(Export node) => visitLibraryDependency(node);
   R visitExpression(Expression node) => visitNode(node);
   R visitExpressionStatement(ExpressionStatement node) => visitStatement(node);
   R visitFor(For node) => visitLoop(node);
+  R visitForIn(ForIn node) => visitLoop(node);
   R visitFunctionDeclaration(FunctionDeclaration node) => visitStatement(node);
   R visitFunctionExpression(FunctionExpression node) => visitExpression(node);
   R visitGotoStatement(GotoStatement node) => visitStatement(node);
   R visitIdentifier(Identifier node) => visitExpression(node);
   R visitImport(Import node) => visitLibraryDependency(node);
   R visitIf(If node) => visitStatement(node);
   R visitLabel(Label node) => visitNode(node);
   R visitLabeledStatement(LabeledStatement node) => visitStatement(node);
   R visitLibraryDependency(LibraryDependency node) => visitLibraryTag(node);
   R visitLibraryName(LibraryName node) => visitLibraryTag(node);
   R visitLibraryTag(LibraryTag node) => visitNode(node);
   R visitLiteral(Literal node) => visitExpression(node);
   R visitLiteralBool(LiteralBool node) => visitLiteral(node);
   R visitLiteralDouble(LiteralDouble node) => visitLiteral(node);
   R visitLiteralInt(LiteralInt node) => visitLiteral(node);
   R visitLiteralList(LiteralList node) => visitExpression(node);
   R visitLiteralMap(LiteralMap node) => visitExpression(node);
   R visitLiteralMapEntry(LiteralMapEntry node) => visitNode(node);
   R visitLiteralNull(LiteralNull node) => visitLiteral(node);
   R visitLiteralString(LiteralString node) => visitStringNode(node);
   R visitStringJuxtaposition(StringJuxtaposition node) => visitStringNode(node);
-  R visitSyncForIn(SyncForIn node) => visitLoop(node);
+  R visitSyncForIn(SyncForIn node) => visitForIn(node);
   R visitLoop(Loop node) => visitStatement(node);
   R visitMetadata(Metadata node) => visitNode(node);
   R visitMixinApplication(MixinApplication node) => visitNode(node);
   R visitModifiers(Modifiers node) => visitNode(node);
   R visitNamedArgument(NamedArgument node) => visitExpression(node);
   R visitNamedMixinApplication(NamedMixinApplication node) {
     return visitMixinApplication(node);
   }
 
   R visitNewExpression(NewExpression node) => visitExpression(node);
@@ skipping 36 matching lines @@
 }
 
 /// Visitor for [Node]s that take an additional argument of type [A] and returns
 /// a value of type [R].
 abstract class Visitor1<R, A> {
   const Visitor1();
 
   R visitNode(Node node, A arg);
 
   R visitAssert(Assert node, A arg) => visitStatement(node, arg);
-  R visitAsyncForIn(AsyncForIn node, A arg) => visitLoop(node, arg);
+  R visitAsyncForIn(AsyncForIn node, A arg) => visitForIn(node, arg);
   R visitAsyncModifier(AsyncModifier node, A arg) => visitNode(node, arg);
   R visitAwait(Await node, A arg) => visitExpression(node, arg);
   R visitBlock(Block node, A arg) => visitStatement(node, arg);
   R visitBreakStatement(BreakStatement node, A arg) {
     return visitGotoStatement(node, arg);
   }
 
   R visitCascade(Cascade node, A arg) => visitExpression(node, arg);
   R visitCascadeReceiver(CascadeReceiver node, A arg) {
     return visitExpression(node, arg);
@@ skipping 22 matching lines @@
   }
 
   R visitEnum(Enum node, A arg) => visitNode(node, arg);
   R visitExport(Export node, A arg) => visitLibraryDependency(node, arg);
   R visitExpression(Expression node, A arg) => visitNode(node, arg);
   R visitExpressionStatement(ExpressionStatement node, A arg) {
     return visitStatement(node, arg);
   }
 
   R visitFor(For node, A arg) => visitLoop(node, arg);
+  R visitForIn(ForIn node, A arg) => visitLoop(node, arg);
   R visitFunctionDeclaration(FunctionDeclaration node, A arg) {
     return visitStatement(node, arg);
   }
 
   R visitFunctionExpression(FunctionExpression node, A arg) {
     return visitExpression(node, arg);
   }
 
   R visitGotoStatement(GotoStatement node, A arg) {
     return visitStatement(node, arg);
@@ skipping 25 matching lines @@
   R visitLiteralInt(LiteralInt node, A arg) => visitLiteral(node, arg);
   R visitLiteralList(LiteralList node, A arg) => visitExpression(node, arg);
   R visitLiteralMap(LiteralMap node, A arg) => visitExpression(node, arg);
   R visitLiteralMapEntry(LiteralMapEntry node, A arg) => visitNode(node, arg);
   R visitLiteralNull(LiteralNull node, A arg) => visitLiteral(node, arg);
   R visitLiteralString(LiteralString node, A arg) => visitStringNode(node, arg);
   R visitStringJuxtaposition(StringJuxtaposition node, A arg) {
     return visitStringNode(node, arg);
   }
 
-  R visitSyncForIn(SyncForIn node, A arg) => visitLoop(node, arg);
+  R visitSyncForIn(SyncForIn node, A arg) => visitForIn(node, arg);
   R visitLoop(Loop node, A arg) => visitStatement(node, arg);
   R visitMetadata(Metadata node, A arg) => visitNode(node, arg);
   R visitMixinApplication(MixinApplication node, A arg) => visitNode(node, arg);
   R visitModifiers(Modifiers node, A arg) => visitNode(node, arg);
   R visitNamedArgument(NamedArgument node, A arg) => visitExpression(node, arg);
   R visitNamedMixinApplication(NamedMixinApplication node, A arg) {
     return visitMixinApplication(node, arg);
   }
 
   R visitNewExpression(NewExpression node, A arg) => visitExpression(node, arg);
@@ skipping 2886 matching lines @@
 
   // VariableDefinitions.
   get metadata => null;
   get type => null;
 
   // Typedef.
   get typeParameters => null;
   get formals => null;
   get typedefKeyword => null;
 }