Add Visitor1<R, A>

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

Index: pkg/compiler/lib/src/tree/nodes.dart
diff --git a/pkg/compiler/lib/src/tree/nodes.dart b/pkg/compiler/lib/src/tree/nodes.dart
index 46c54245bcb9c8fb4f4910b41f308826cfb2d89a..d0a57bb31d1fb37d8c3d5dd1f30ad7a5383c402a 100644
--- a/pkg/compiler/lib/src/tree/nodes.dart
+++ b/pkg/compiler/lib/src/tree/nodes.dart
@@ -110,6 +110,137 @@ abstract class Visitor<R> {
   R visitYield(Yield node) => visitStatement(node);
 }
 
+abstract class Visitor1<R, A> {

[sigurdm, 2016/04/07 09:12:59]

Add dart-doc

[Johnni Winther, 2016/04/07 09:15:46]

Done.

+  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 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);
+  }
+  R visitCaseMatch(CaseMatch node, A arg) => visitNode(node, arg);
+  R visitCatchBlock(CatchBlock node, A arg) => visitNode(node, arg);
+  R visitClassNode(ClassNode node, A arg) => visitNode(node, arg);
+  R visitCombinator(Combinator node, A arg) => visitNode(node, arg);
+  R visitConditional(Conditional node, A arg) => visitExpression(node, arg);
+  R visitConditionalUri(ConditionalUri node, A arg) {
+    return visitNode(node, arg);
+  }
+  R visitContinueStatement(ContinueStatement node, A arg) {
+    return visitGotoStatement(node, arg);
+  }
+  R visitDottedName(DottedName node, A arg) {
+    return visitExpression(node, arg);
+  }
+  R visitDoWhile(DoWhile node, A arg) => visitLoop(node, arg);
+  R visitEmptyStatement(EmptyStatement node, A arg) {
+    return visitStatement(node, arg);
+  }
+  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 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);
+  }
+  R visitIdentifier(Identifier node, A arg) {
+    return visitExpression(node, arg);
+  }
+  R visitImport(Import node, A arg) {
+    return visitLibraryDependency(node, arg);
+  }
+  R visitIf(If node, A arg) => visitStatement(node, arg);
+  R visitLabel(Label node, A arg) => visitNode(node, arg);
+  R visitLabeledStatement(LabeledStatement node, A arg) {
+    return visitStatement(node, arg);
+  }
+  R visitLibraryDependency(LibraryDependency node, A arg) {
+    return visitLibraryTag(node, arg);
+  }
+  R visitLibraryName(LibraryName node, A arg) => visitLibraryTag(node, arg);
+  R visitLibraryTag(LibraryTag node, A arg) => visitNode(node, arg);
+  R visitLiteral(Literal node, A arg) => visitExpression(node, arg);
+  R visitLiteralBool(LiteralBool node, A arg) => visitLiteral(node, arg);
+  R visitLiteralDouble(LiteralDouble node, A arg) => visitLiteral(node, arg);
+  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 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);
+  R visitNodeList(NodeList node, A arg) => visitNode(node, arg);
+  R visitOperator(Operator node, A arg) => visitIdentifier(node, arg);
+  R visitParenthesizedExpression(ParenthesizedExpression node, A arg) {
+    return visitExpression(node, arg);
+  }
+  R visitPart(Part node, A arg) => visitLibraryTag(node, arg);
+  R visitPartOf(PartOf node, A arg) => visitNode(node, arg);
+  R visitPostfix(Postfix node, A arg) => visitNodeList(node, arg);
+  R visitPrefix(Prefix node, A arg) => visitNodeList(node, arg);
+  R visitRedirectingFactoryBody(RedirectingFactoryBody node, A arg) {
+    return visitStatement(node, arg);
+  }
+  R visitRethrow(Rethrow node, A arg) => visitStatement(node, arg);
+  R visitReturn(Return node, A arg) => visitStatement(node, arg);
+  R visitSend(Send node, A arg) => visitExpression(node, arg);
+  R visitSendSet(SendSet node, A arg) => visitSend(node, arg);
+  R visitStatement(Statement node, A arg) => visitNode(node, arg);
+  R visitStringNode(StringNode node, A arg) => visitExpression(node, arg);
+  R visitStringInterpolation(StringInterpolation node, A arg) {
+    return visitStringNode(node, arg);
+  }
+  R visitStringInterpolationPart(StringInterpolationPart node, A arg) {
+    return visitNode(node, arg);
+  }
+  R visitSwitchCase(SwitchCase node, A arg) => visitNode(node, arg);
+  R visitSwitchStatement(SwitchStatement node, A arg) {
+    return visitStatement(node, arg);
+  }
+  R visitLiteralSymbol(LiteralSymbol node, A arg) => visitExpression(node, arg);
+  R visitThrow(Throw node, A arg) => visitExpression(node, arg);
+  R visitTryStatement(TryStatement node, A arg) => visitStatement(node, arg);
+  R visitTypeAnnotation(TypeAnnotation node, A arg) => visitNode(node, arg);
+  R visitTypedef(Typedef node, A arg) => visitNode(node, arg);
+  R visitTypeVariable(TypeVariable node, A arg) => visitNode(node, arg);
+  R visitVariableDefinitions(VariableDefinitions node, A arg) {
+    return visitStatement(node, arg);
+  }
+  R visitWhile(While node, A arg) => visitLoop(node, arg);
+  R visitYield(Yield node, A arg) => visitStatement(node, arg);
+}
+
+
 Token firstBeginToken(Node first, Node second) {
   Token token = null;
   if (first != null) {
@@ -141,8 +272,12 @@ abstract class Node extends NullTreeElementMixin implements Spannable {
 
   accept(Visitor visitor);
 
+  accept1(Visitor1 visitor, arg);
+
   visitChildren(Visitor visitor);
 
+  visitChildren1(Visitor1 visitor, arg);
+
   /**
    * Returns this node unparsed to Dart source string.
    */
@@ -271,6 +406,8 @@ class ClassNode extends Node {
 
   accept(Visitor visitor) => visitor.visitClassNode(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitClassNode(this, arg);
+
   visitChildren(Visitor visitor) {
     if (name != null) name.accept(visitor);
     if (typeParameters != null) typeParameters.accept(visitor);
@@ -279,6 +416,14 @@ class ClassNode extends Node {
     if (body != null) body.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (name != null) name.accept1(visitor, arg);
+    if (typeParameters != null) typeParameters.accept1(visitor, arg);
+    if (superclass != null) superclass.accept1(visitor, arg);
+    if (interfaces != null) interfaces.accept1(visitor, arg);
+    if (body != null) body.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => beginToken;
 
   @override
@@ -313,11 +458,18 @@ class MixinApplication extends Node {
 
   accept(Visitor visitor) => visitor.visitMixinApplication(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitMixinApplication(this, arg);
+
   visitChildren(Visitor visitor) {
     if (superclass != null) superclass.accept(visitor);
     if (mixins != null) mixins.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (superclass != null) superclass.accept1(visitor, arg);
+    if (mixins != null) mixins.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => superclass.getBeginToken();
   Token getEndToken() => mixins.getEndToken();
 }
@@ -347,6 +499,10 @@ class NamedMixinApplication extends Node implements MixinApplication {
 
   accept(Visitor visitor) => visitor.visitNamedMixinApplication(this);
 
+  accept1(Visitor1 visitor, arg) {
+    return visitor.visitNamedMixinApplication(this, arg);
+  }
+
   visitChildren(Visitor visitor) {
     name.accept(visitor);
     if (typeParameters != null) typeParameters.accept(visitor);
@@ -355,6 +511,14 @@ class NamedMixinApplication extends Node implements MixinApplication {
     mixinApplication.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    name.accept1(visitor, arg);
+    if (typeParameters != null) typeParameters.accept1(visitor, arg);
+    if (modifiers != null) modifiers.accept1(visitor, arg);
+    if (interfaces != null) interfaces.accept1(visitor, arg);
+    mixinApplication.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => classKeyword;
   Token getEndToken() => endToken;
 }
@@ -363,9 +527,6 @@ abstract class Expression extends Node {
   Expression();
 
   Expression asExpression() => this;
-
-  // TODO(ahe): make class abstract instead of adding an abstract method.
-  accept(Visitor visitor);
 }
 
 abstract class Statement extends Node {
@@ -373,9 +534,6 @@ abstract class Statement extends Node {
 
   Statement asStatement() => this;
 
-  // TODO(ahe): make class abstract instead of adding an abstract method.
-  accept(Visitor visitor);
-
   bool isValidBreakTarget() => true;
 }
 
@@ -423,12 +581,20 @@ class Send extends Expression with StoredTreeElementMixin {
 
   accept(Visitor visitor) => visitor.visitSend(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitSend(this, arg);
+
   visitChildren(Visitor visitor) {
     if (receiver != null) receiver.accept(visitor);
     if (selector != null) selector.accept(visitor);
     if (argumentsNode != null) argumentsNode.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (receiver != null) receiver.accept1(visitor, arg);
+    if (selector != null) selector.accept1(visitor, arg);
+    if (argumentsNode != null) argumentsNode.accept1(visitor, arg);
+  }
+
   int argumentCount() {
     return (argumentsNode == null) ? -1 : argumentsNode.slowLength();
   }
@@ -529,6 +695,18 @@ class SendSet extends Send {
 
   accept(Visitor visitor) => visitor.visitSendSet(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitSendSet(this, arg);
+
+  visitChildren(Visitor visitor) {
+    super.visitChildren(visitor);
+    if (assignmentOperator != null) assignmentOperator.accept(visitor);
+  }
+
+  visitChildren1(Visitor1 visitor, arg) {
+    super.visitChildren1(visitor, arg);
+    if (assignmentOperator != null) assignmentOperator.accept1(visitor, arg);
+  }
+
   /// `true` if this send is not a simple assignment.
   bool get isComplex => !identical(assignmentOperator.source, '=');
 
@@ -536,11 +714,6 @@ class SendSet extends Send {
   bool get isIfNullAssignment =>
       identical(assignmentOperator.source, '??=');
 
-  visitChildren(Visitor visitor) {
-    super.visitChildren(visitor);
-    if (assignmentOperator != null) assignmentOperator.accept(visitor);
-  }
-
   Send copyWithReceiver(Node newReceiver, bool isConditional) {
     assert(receiver == null);
     return new SendSet(newReceiver, selector, assignmentOperator,
@@ -571,10 +744,16 @@ class NewExpression extends Expression {
 
   accept(Visitor visitor) => visitor.visitNewExpression(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitNewExpression(this, arg);
+
   visitChildren(Visitor visitor) {
     if (send != null) send.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (send != null) send.accept1(visitor, arg);
+  }
+
   bool get isConst {
     return newToken == null || identical(newToken.stringValue, 'const');
   }
@@ -617,6 +796,8 @@ class NodeList extends Node with IterableMixin<Node> {
 
   accept(Visitor visitor) => visitor.visitNodeList(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitNodeList(this, arg);
+
   visitChildren(Visitor visitor) {
     if (nodes == null) return;
     for (Link<Node> link = nodes; !link.isEmpty; link = link.tail) {
@@ -624,6 +805,13 @@ class NodeList extends Node with IterableMixin<Node> {
     }
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (nodes == null) return;
+    for (Link<Node> link = nodes; !link.isEmpty; link = link.tail) {
+      if (link.head != null) link.head.accept1(visitor, arg);
+    }
+  }
+
   Token getBeginToken() {
     if (beginToken != null) return beginToken;
      if (nodes != null) {
@@ -664,10 +852,16 @@ class Block extends Statement {
 
   accept(Visitor visitor) => visitor.visitBlock(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitBlock(this, arg);
+
   visitChildren(Visitor visitor) {
     if (statements != null) statements.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (statements != null) statements.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => statements.getBeginToken();
 
   Token getEndToken() => statements.getEndToken();
@@ -690,12 +884,20 @@ class If extends Statement {
 
   accept(Visitor visitor) => visitor.visitIf(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitIf(this, arg);
+
   visitChildren(Visitor visitor) {
     if (condition != null) condition.accept(visitor);
     if (thenPart != null) thenPart.accept(visitor);
     if (elsePart != null) elsePart.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (condition != null) condition.accept1(visitor, arg);
+    if (thenPart != null) thenPart.accept1(visitor, arg);
+    if (elsePart != null) elsePart.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => ifToken;
 
   Token getEndToken() {
@@ -719,12 +921,20 @@ class Conditional extends Expression {
 
   accept(Visitor visitor) => visitor.visitConditional(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitConditional(this, arg);
+
   visitChildren(Visitor visitor) {
     condition.accept(visitor);
     thenExpression.accept(visitor);
     elseExpression.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    condition.accept1(visitor, arg);
+    thenExpression.accept1(visitor, arg);
+    elseExpression.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => condition.getBeginToken();
 
   Token getEndToken() => elseExpression.getEndToken();
@@ -756,6 +966,8 @@ class For extends Loop {
 
   accept(Visitor visitor) => visitor.visitFor(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitFor(this, arg);
+
   visitChildren(Visitor visitor) {
     if (initializer != null) initializer.accept(visitor);
     if (conditionStatement != null) conditionStatement.accept(visitor);
@@ -763,6 +975,13 @@ class For extends Loop {
     if (body != null) body.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (initializer != null) initializer.accept1(visitor, arg);
+    if (conditionStatement != null) conditionStatement.accept1(visitor, arg);
+    if (update != null) update.accept1(visitor, arg);
+    if (body != null) body.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => forToken;
 
   Token getEndToken() {
@@ -779,8 +998,12 @@ class FunctionDeclaration extends Statement {
 
   accept(Visitor visitor) => visitor.visitFunctionDeclaration(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitFunctionDeclaration(this, arg);
+
   visitChildren(Visitor visitor) => function.accept(visitor);
 
+  visitChildren1(Visitor1 visitor, arg) => function.accept1(visitor, arg);
+
   Token getBeginToken() => function.getBeginToken();
 
   @override
@@ -804,8 +1027,12 @@ class AsyncModifier extends Node {
 
   accept(Visitor visitor) => visitor.visitAsyncModifier(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitAsyncModifier(this, arg);
+
   visitChildren(Visitor visitor) {}
 
+  visitChildren1(Visitor1 visitor, arg) {}
+
   Token getBeginToken() => asyncToken;
 
   Token getEndToken() => starToken != null ? starToken : asyncToken;
@@ -845,6 +1072,8 @@ class FunctionExpression extends Expression with StoredTreeElementMixin {
 
   accept(Visitor visitor) => visitor.visitFunctionExpression(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitFunctionExpression(this, arg);
+
   bool get isRedirectingFactory {
     return body != null && body.asRedirectingFactoryBody() != null;
   }
@@ -859,6 +1088,16 @@ class FunctionExpression extends Expression with StoredTreeElementMixin {
     if (body != null) body.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (modifiers != null) modifiers.accept1(visitor, arg);
+    if (returnType != null) returnType.accept1(visitor, arg);
+    if (name != null) name.accept1(visitor, arg);
+    if (parameters != null) parameters.accept1(visitor, arg);
+    if (initializers != null) initializers.accept1(visitor, arg);
+    if (asyncModifier != null) asyncModifier.accept1(visitor, arg);
+    if (body != null) body.accept1(visitor, arg);
+  }
+
   bool get hasBody => body.asEmptyStatement() == null;
 
   bool get hasEmptyBody {
@@ -898,6 +1137,8 @@ abstract class Literal<T> extends Expression {
 
   visitChildren(Visitor visitor) {}
 
+  visitChildren1(Visitor1 visitor, arg) {}
+
   Token getBeginToken() => token;
 
   Token getEndToken() => token;
@@ -921,6 +1162,8 @@ class LiteralInt extends Literal<int> {
   }
 
   accept(Visitor visitor) => visitor.visitLiteralInt(this);
+
+  accept1(Visitor1 visitor, arg) => visitor.visitLiteralInt(this, arg);
 }
 
 class LiteralDouble extends Literal<double> {
@@ -942,6 +1185,8 @@ class LiteralDouble extends Literal<double> {
   }
 
   accept(Visitor visitor) => visitor.visitLiteralDouble(this);
+
+  accept1(Visitor1 visitor, arg) => visitor.visitLiteralDouble(this, arg);
 }
 
 class LiteralBool extends Literal<bool> {
@@ -957,6 +1202,8 @@ class LiteralBool extends Literal<bool> {
   }
 
   accept(Visitor visitor) => visitor.visitLiteralBool(this);
+
+  accept1(Visitor1 visitor, arg) => visitor.visitLiteralBool(this, arg);
 }
 
 
@@ -1031,14 +1278,18 @@ class LiteralString extends StringNode {
 
   LiteralString asLiteralString() => this;
 
-  void visitChildren(Visitor visitor) {}
-
   bool get isInterpolation => false;
 
   Token getBeginToken() => token;
   Token getEndToken() => token;
 
   accept(Visitor visitor) => visitor.visitLiteralString(this);
+
+  accept1(Visitor1 visitor, arg) => visitor.visitLiteralString(this, arg);
+
+  void visitChildren(Visitor visitor) {}
+
+  void visitChildren1(Visitor1 visitor, arg) {}
 }
 
 class LiteralNull extends Literal<String> {
@@ -1049,6 +1300,8 @@ class LiteralNull extends Literal<String> {
   String get value => null;
 
   accept(Visitor visitor) => visitor.visitLiteralNull(this);
+
+  accept1(Visitor1 visitor, arg) => visitor.visitLiteralNull(this, arg);
 }
 
 class LiteralList extends Expression {
@@ -1064,11 +1317,18 @@ class LiteralList extends Expression {
   LiteralList asLiteralList() => this;
   accept(Visitor visitor) => visitor.visitLiteralList(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitLiteralList(this, arg);
+
   visitChildren(Visitor visitor) {
     if (typeArguments != null) typeArguments.accept(visitor);
     elements.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (typeArguments != null) typeArguments.accept1(visitor, arg);
+    elements.accept1(visitor, arg);
+  }
+
   Token getBeginToken() {
     if (constKeyword != null) return constKeyword;
     return firstBeginToken(typeArguments, elements);
@@ -1086,11 +1346,17 @@ class LiteralSymbol extends Expression {
 
   LiteralSymbol asLiteralSymbol() => this;
 
+  accept(Visitor visitor) => visitor.visitLiteralSymbol(this);
+
+  accept1(Visitor1 visitor, arg) => visitor.visitLiteralSymbol(this, arg);
+
   void visitChildren(Visitor visitor) {
     if (identifiers != null) identifiers.accept(visitor);
   }
 
-  accept(Visitor visitor) => visitor.visitLiteralSymbol(this);
+  void visitChildren1(Visitor1 visitor, arg) {
+    if (identifiers != null) identifiers.accept1(visitor, arg);
+  }
 
   Token getBeginToken() => hashToken;
 
@@ -1118,8 +1384,12 @@ class Identifier extends Expression with StoredTreeElementMixin {
 
   accept(Visitor visitor) => visitor.visitIdentifier(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitIdentifier(this, arg);
+
   visitChildren(Visitor visitor) {}
 
+  visitChildren1(Visitor1 visitor, arg) {}
+
   Token getBeginToken() => token;
 
   Token getEndToken() => token;
@@ -1135,11 +1405,17 @@ class DottedName extends Expression {
 
   DottedName asDottedName() => this;
 
+  accept(Visitor visitor) => visitor.visitDottedName(this);
+
+  accept1(Visitor1 visitor, arg) => visitor.visitDottedName(this, arg);
+
   void visitChildren(Visitor visitor) {
     identifiers.accept(visitor);
   }
 
-  accept(Visitor visitor) => visitor.visitDottedName(this);
+  void visitChildren1(Visitor1 visitor, arg) {
+    identifiers.accept1(visitor, arg);
+  }
 
   Token getBeginToken() => token;
   Token getEndToken() => identifiers.getEndToken();
@@ -1163,6 +1439,8 @@ class Operator extends Identifier {
   Operator asOperator() => this;
 
   accept(Visitor visitor) => visitor.visitOperator(this);
+
+  accept1(Visitor1 visitor, arg) => visitor.visitOperator(this, arg);
 }
 
 class Return extends Statement {
@@ -1181,10 +1459,16 @@ class Return extends Statement {
 
   accept(Visitor visitor) => visitor.visitReturn(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitReturn(this, arg);
+
   visitChildren(Visitor visitor) {
     if (expression != null) expression.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (expression != null) expression.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => beginToken;
 
   Token getEndToken() {
@@ -1207,10 +1491,16 @@ class Yield extends Statement {
 
   accept(Visitor visitor) => visitor.visitYield(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitYield(this, arg);
+
   visitChildren(Visitor visitor) {
     expression.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    expression.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => yieldToken;
 
   Token getEndToken() => endToken;
@@ -1228,10 +1518,16 @@ class RedirectingFactoryBody extends Statement with StoredTreeElementMixin {
 
   accept(Visitor visitor) => visitor.visitRedirectingFactoryBody(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitRedirectingFactoryBody(this, arg);

[sigurdm, 2016/04/07 09:13:00]

LL

[Johnni Winther, 2016/04/07 09:15:46]

Done.

+
   visitChildren(Visitor visitor) {
     constructorReference.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    constructorReference.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => beginToken;
 
   Token getEndToken() => endToken;
@@ -1247,10 +1543,16 @@ class ExpressionStatement extends Statement {
 
   accept(Visitor visitor) => visitor.visitExpressionStatement(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitExpressionStatement(this, arg);
+
   visitChildren(Visitor visitor) {
     if (expression != null) expression.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (expression != null) expression.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => expression.getBeginToken();
 
   Token getEndToken() => endToken;
@@ -1268,10 +1570,16 @@ class Throw extends Expression {
 
   accept(Visitor visitor) => visitor.visitThrow(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitThrow(this, arg);
+
   visitChildren(Visitor visitor) {
     expression.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    expression.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => throwToken;
 
   Token getEndToken() => endToken;
@@ -1288,10 +1596,16 @@ class Await extends Expression {
 
   accept(Visitor visitor) => visitor.visitAwait(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitAwait(this, arg);
+
   visitChildren(Visitor visitor) {
     expression.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    expression.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => awaitToken;
 
   Token getEndToken() => expression.getEndToken();
@@ -1312,11 +1626,18 @@ class Assert extends Statement {
 
   accept(Visitor visitor) => visitor.visitAssert(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitAssert(this, arg);
+
   visitChildren(Visitor visitor) {
     condition.accept(visitor);
     if (message != null) message.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    condition.accept1(visitor, arg);
+    if (message != null) message.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => assertToken;
   Token getEndToken() => semicolonToken;
 }
@@ -1330,8 +1651,13 @@ class Rethrow extends Statement {
   Rethrow asRethrow() => this;
 
   accept(Visitor visitor) => visitor.visitRethrow(this);
+
+  accept1(Visitor1 visitor, arg) => visitor.visitRethrow(this, arg);
+
   visitChildren(Visitor visitor) { }
 
+  visitChildren1(Visitor1 visitor, arg) { }
+
   Token getBeginToken() => throwToken;
   Token getEndToken() => endToken;
 }
@@ -1346,11 +1672,18 @@ class TypeAnnotation extends Node {
 
   accept(Visitor visitor) => visitor.visitTypeAnnotation(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitTypeAnnotation(this, arg);
+
   visitChildren(Visitor visitor) {
     typeName.accept(visitor);
     if (typeArguments != null) typeArguments.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    typeName.accept1(visitor, arg);
+    if (typeArguments != null) typeArguments.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => typeName.getBeginToken();
 
   Token getEndToken() {
@@ -1366,6 +1699,8 @@ class TypeVariable extends Node {
 
   accept(Visitor visitor) => visitor.visitTypeVariable(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitTypeVariable(this, arg);
+
   visitChildren(Visitor visitor) {
     name.accept(visitor);
     if (bound != null) {
@@ -1373,6 +1708,13 @@ class TypeVariable extends Node {
     }
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    name.accept1(visitor, arg);
+    if (bound != null) {
+      bound.accept1(visitor, arg);
+    }
+  }
+
   TypeVariable asTypeVariable() => this;
 
   Token getBeginToken() => name.getBeginToken();
@@ -1407,12 +1749,20 @@ class VariableDefinitions extends Statement {
 
   accept(Visitor visitor) => visitor.visitVariableDefinitions(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitVariableDefinitions(this, arg);
+
   visitChildren(Visitor visitor) {
     if (metadata != null) metadata.accept(visitor);
     if (type != null) type.accept(visitor);
     if (definitions != null) definitions.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (metadata != null) metadata.accept1(visitor, arg);
+    if (type != null) type.accept1(visitor, arg);
+    if (definitions != null) definitions.accept1(visitor, arg);
+  }
+
   Token getBeginToken() {
     var token = firstBeginToken(modifiers, type);
     if (token == null) {
@@ -1448,11 +1798,18 @@ class DoWhile extends Loop {
 
   accept(Visitor visitor) => visitor.visitDoWhile(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitDoWhile(this, arg);
+
   visitChildren(Visitor visitor) {
     if (condition != null) condition.accept(visitor);
     if (body != null) body.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (condition != null) condition.accept1(visitor, arg);
+    if (body != null) body.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => doKeyword;
 
   Token getEndToken() => endToken;
@@ -1469,11 +1826,18 @@ class While extends Loop {
 
   accept(Visitor visitor) => visitor.visitWhile(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitWhile(this, arg);
+
   visitChildren(Visitor visitor) {
     if (condition != null) condition.accept(visitor);
     if (body != null) body.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (condition != null) condition.accept1(visitor, arg);
+    if (body != null) body.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => whileKeyword;
 
   Token getEndToken() => body.getEndToken();
@@ -1490,10 +1854,16 @@ class ParenthesizedExpression extends Expression {
 
   accept(Visitor visitor) => visitor.visitParenthesizedExpression(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitParenthesizedExpression(this, arg);

[sigurdm, 2016/04/07 09:12:59]

LL

[Johnni Winther, 2016/04/07 09:15:46]

Done.

+
   visitChildren(Visitor visitor) {
     if (expression != null) expression.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (expression != null) expression.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => beginToken;
 
   Token getEndToken() => beginToken.endGroup;
@@ -1559,9 +1929,15 @@ class Modifiers extends Node {
   Modifiers asModifiers() => this;
   Token getBeginToken() => nodes.getBeginToken();
   Token getEndToken() => nodes.getEndToken();
+
   accept(Visitor visitor) => visitor.visitModifiers(this);
+
+  accept1(Visitor1 visitor, arg) => visitor.visitModifiers(this, arg);
+
   visitChildren(Visitor visitor) => nodes.accept(visitor);
 
+  visitChildren1(Visitor1 visitor, arg) => nodes.accept1(visitor, arg);
+
   bool get isStatic => (flags & FLAG_STATIC) != 0;
   bool get isAbstract => (flags & FLAG_ABSTRACT) != 0;
   bool get isFinal => (flags & FLAG_FINAL) != 0;
@@ -1602,11 +1978,18 @@ class StringInterpolation extends StringNode {
 
   accept(Visitor visitor) => visitor.visitStringInterpolation(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitStringInterpolation(this, arg);
+
   visitChildren(Visitor visitor) {
     string.accept(visitor);
     parts.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    string.accept1(visitor, arg);
+    parts.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => string.getBeginToken();
   Token getEndToken() => parts.getEndToken();
 }
@@ -1621,11 +2004,18 @@ class StringInterpolationPart extends Node {
 
   accept(Visitor visitor) => visitor.visitStringInterpolationPart(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitStringInterpolationPart(this, arg);

[sigurdm, 2016/04/07 09:12:59]

LL

[Johnni Winther, 2016/04/07 09:15:45]

Done.

+
   visitChildren(Visitor visitor) {
     expression.accept(visitor);
     string.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    expression.accept1(visitor, arg);
+    string.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => expression.getBeginToken();
 
   Token getEndToken() => string.getEndToken();
@@ -1687,11 +2077,18 @@ class StringJuxtaposition extends StringNode {
 
   accept(Visitor visitor) => visitor.visitStringJuxtaposition(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitStringJuxtaposition(this, arg);
+
   void visitChildren(Visitor visitor) {
     first.accept(visitor);
     second.accept(visitor);
   }
 
+  void visitChildren1(Visitor1 visitor, arg) {
+    first.accept1(visitor, arg);
+    second.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => first.getBeginToken();
 
   Token getEndToken() => second.getEndToken();
@@ -1706,8 +2103,12 @@ class EmptyStatement extends Statement {
 
   accept(Visitor visitor) => visitor.visitEmptyStatement(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitEmptyStatement(this, arg);
+
   visitChildren(Visitor visitor) {}
 
+  visitChildren1(Visitor1 visitor, arg) {}
+
   Token getBeginToken() => semicolonToken;
 
   Token getEndToken() => semicolonToken;
@@ -1727,11 +2128,18 @@ class LiteralMap extends Expression {
 
   accept(Visitor visitor) => visitor.visitLiteralMap(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitLiteralMap(this, arg);
+
   visitChildren(Visitor visitor) {
     if (typeArguments != null) typeArguments.accept(visitor);
     entries.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (typeArguments != null) typeArguments.accept1(visitor, arg);
+    entries.accept1(visitor, arg);
+  }
+
   Token getBeginToken() {
     if (constKeyword != null) return constKeyword;
     return firstBeginToken(typeArguments, entries);
@@ -1752,11 +2160,18 @@ class LiteralMapEntry extends Node {
 
   accept(Visitor visitor) => visitor.visitLiteralMapEntry(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitLiteralMapEntry(this, arg);
+
   visitChildren(Visitor visitor) {
     key.accept(visitor);
     value.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    key.accept1(visitor, arg);
+    value.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => key.getBeginToken();
 
   Token getEndToken() => value.getEndToken();
@@ -1774,11 +2189,18 @@ class NamedArgument extends Expression {
 
   accept(Visitor visitor) => visitor.visitNamedArgument(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitNamedArgument(this, arg);
+
   visitChildren(Visitor visitor) {
     name.accept(visitor);
     expression.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    name.accept1(visitor, arg);
+    expression.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => name.getBeginToken();
 
   Token getEndToken() => expression.getEndToken();
@@ -1799,11 +2221,18 @@ class SwitchStatement extends Statement {
 
   accept(Visitor visitor) => visitor.visitSwitchStatement(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitSwitchStatement(this, arg);
+
   visitChildren(Visitor visitor) {
     parenthesizedExpression.accept(visitor);
     cases.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    parenthesizedExpression.accept1(visitor, arg);
+    cases.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => switchKeyword;
 
   Token getEndToken() => cases.getEndToken();
@@ -1818,8 +2247,14 @@ class CaseMatch extends Node {
   CaseMatch asCaseMatch() => this;
   Token getBeginToken() => caseKeyword;
   Token getEndToken() => colonToken;
+
   accept(Visitor visitor) => visitor.visitCaseMatch(this);
+
+  accept1(Visitor1 visitor, arg) => visitor.visitCaseMatch(this, arg);
+
   visitChildren(Visitor visitor) => expression.accept(visitor);
+
+  visitChildren1(Visitor1 visitor, arg) => expression.accept1(visitor, arg);
 }
 
 class SwitchCase extends Node {
@@ -1851,11 +2286,18 @@ class SwitchCase extends Node {
 
   accept(Visitor visitor) => visitor.visitSwitchCase(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitSwitchCase(this, arg);
+
   visitChildren(Visitor visitor) {
     labelsAndCases.accept(visitor);
     statements.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    labelsAndCases.accept1(visitor, arg);
+    statements.accept1(visitor, arg);
+  }
+
   Token getBeginToken() {
     return startToken;
   }
@@ -1886,6 +2328,10 @@ abstract class GotoStatement extends Statement {
     if (target != null) target.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (target != null) target.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => keywordToken;
 
   Token getEndToken() => semicolonToken;
@@ -1901,6 +2347,8 @@ class BreakStatement extends GotoStatement {
   BreakStatement asBreakStatement() => this;
 
   accept(Visitor visitor) => visitor.visitBreakStatement(this);
+
+  accept1(Visitor1 visitor, arg) => visitor.visitBreakStatement(this, arg);
 }
 
 class ContinueStatement extends GotoStatement {
@@ -1910,6 +2358,8 @@ class ContinueStatement extends GotoStatement {
   ContinueStatement asContinueStatement() => this;
 
   accept(Visitor visitor) => visitor.visitContinueStatement(this);
+
+  accept1(Visitor1 visitor, arg) => visitor.visitContinueStatement(this, arg);
 }
 
 abstract class ForIn extends Loop {
@@ -1938,12 +2388,20 @@ class SyncForIn extends ForIn with StoredTreeElementMixin {
 
   accept(Visitor visitor) => visitor.visitSyncForIn(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitSyncForIn(this, arg);
+
   visitChildren(Visitor visitor) {
     declaredIdentifier.accept(visitor);
     expression.accept(visitor);
     body.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    declaredIdentifier.accept1(visitor, arg);
+    expression.accept1(visitor, arg);
+    body.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => forToken;
 }
 
@@ -1958,12 +2416,20 @@ class AsyncForIn extends ForIn with StoredTreeElementMixin {
 
   accept(Visitor visitor) => visitor.visitAsyncForIn(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitAsyncForIn(this, arg);
+
   visitChildren(Visitor visitor) {
     declaredIdentifier.accept(visitor);
     expression.accept(visitor);
     body.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    declaredIdentifier.accept1(visitor, arg);
+    expression.accept1(visitor, arg);
+    body.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => awaitToken;
 }
 
@@ -1979,10 +2445,16 @@ class Label extends Node {
 
   accept(Visitor visitor) => visitor.visitLabel(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitLabel(this, arg);
+
   void visitChildren(Visitor visitor) {
     identifier.accept(visitor);
   }
 
+  void visitChildren1(Visitor1 visitor, arg) {
+    identifier.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => identifier.token;
   Token getEndToken() => colonToken;
 }
@@ -1997,11 +2469,18 @@ class LabeledStatement extends Statement {
 
   accept(Visitor visitor) => visitor.visitLabeledStatement(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitLabeledStatement(this, arg);
+
   visitChildren(Visitor visitor) {
     labels.accept(visitor);
     statement.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    labels.accept1(visitor, arg);
+    statement.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => labels.getBeginToken();
 
   Token getEndToken() => statement.getEndToken();
@@ -2037,8 +2516,12 @@ class LibraryName extends LibraryTag {
 
   accept(Visitor visitor) => visitor.visitLibraryName(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitLibraryName(this, arg);
+
   visitChildren(Visitor visitor) => name.accept(visitor);
 
+  visitChildren1(Visitor1 visitor, arg) => name.accept1(visitor, arg);
+
   Token getBeginToken() => libraryKeyword;
 
   Token getEndToken() => name.getEndToken().next;
@@ -2089,12 +2572,20 @@ class Import extends LibraryDependency {
 
   accept(Visitor visitor) => visitor.visitImport(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitImport(this, arg);
+
   visitChildren(Visitor visitor) {
     uri.accept(visitor);
     if (prefix != null) prefix.accept(visitor);
     if (combinators != null) combinators.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    uri.accept1(visitor, arg);
+    if (prefix != null) prefix.accept1(visitor, arg);
+    if (combinators != null) combinators.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => importKeyword;
 
   Token getEndToken() {
@@ -2127,12 +2618,20 @@ class ConditionalUri extends Node {
 
   accept(Visitor visitor) => visitor.visitConditionalUri(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitConditionalUri(this, arg);
+
   visitChildren(Visitor visitor) {
     key.accept(visitor);
     if (value != null) value.accept(visitor);
     uri.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    key.accept1(visitor, arg);
+    if (value != null) value.accept1(visitor, arg);
+    uri.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => ifToken;
 
   Token getEndToken() => uri.getEndToken();
@@ -2156,11 +2655,18 @@ class Enum extends Node {
 
   accept(Visitor visitor) => visitor.visitEnum(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitEnum(this, arg);
+
   visitChildren(Visitor visitor) {
     name.accept(visitor);
     if (names != null) names.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    name.accept1(visitor, arg);
+    if (names != null) names.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => enumToken;
   Token getEndToken() => names.getEndToken();
 }
@@ -2188,11 +2694,18 @@ class Export extends LibraryDependency {
 
   accept(Visitor visitor) => visitor.visitExport(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitExport(this, arg);
+
   visitChildren(Visitor visitor) {
     uri.accept(visitor);
     if (combinators != null) combinators.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    uri.accept1(visitor, arg);
+    if (combinators != null) combinators.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => exportKeyword;
 
   Token getEndToken() {
@@ -2216,8 +2729,12 @@ class Part extends LibraryTag {
 
   accept(Visitor visitor) => visitor.visitPart(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitPart(this, arg);
+
   visitChildren(Visitor visitor) => uri.accept(visitor);
 
+  visitChildren1(Visitor1 visitor, arg) => uri.accept1(visitor, arg);
+
   Token getBeginToken() => partKeyword;
 
   Token getEndToken() => uri.getEndToken().next;
@@ -2240,8 +2757,12 @@ class PartOf extends Node {
 
   accept(Visitor visitor) => visitor.visitPartOf(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitPartOf(this, arg);
+
   visitChildren(Visitor visitor) => name.accept(visitor);
 
+  visitChildren1(Visitor1 visitor, arg) => name.accept1(visitor, arg);
+
   Token getBeginToken() => partKeyword;
 
   Token getEndToken() => name.getEndToken().next;
@@ -2262,8 +2783,12 @@ class Combinator extends Node {
 
   accept(Visitor visitor) => visitor.visitCombinator(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitCombinator(this, arg);
+
   visitChildren(Visitor visitor) => identifiers.accept(visitor);
 
+  visitChildren1(Visitor1 visitor, arg) => identifiers.accept1(visitor, arg);
+
   Token getBeginToken() => keywordToken;
 
   Token getEndToken() => identifiers.getEndToken();
@@ -2285,6 +2810,8 @@ class Typedef extends Node {
 
   accept(Visitor visitor) => visitor.visitTypedef(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitTypedef(this, arg);
+
   visitChildren(Visitor visitor) {
     if (returnType != null) returnType.accept(visitor);
     name.accept(visitor);
@@ -2292,6 +2819,13 @@ class Typedef extends Node {
     formals.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (returnType != null) returnType.accept1(visitor, arg);
+    name.accept1(visitor, arg);
+    if (typeParameters != null) typeParameters.accept1(visitor, arg);
+    formals.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => typedefKeyword;
 
   Token getEndToken() => endToken;
@@ -2312,12 +2846,20 @@ class TryStatement extends Statement {
 
   accept(Visitor visitor) => visitor.visitTryStatement(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitTryStatement(this, arg);
+
   visitChildren(Visitor visitor) {
     tryBlock.accept(visitor);
     catchBlocks.accept(visitor);
     if (finallyBlock != null) finallyBlock.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    tryBlock.accept1(visitor, arg);
+    catchBlocks.accept1(visitor, arg);
+    if (finallyBlock != null) finallyBlock.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => tryKeyword;
 
   Token getEndToken() {
@@ -2334,10 +2876,16 @@ class Cascade extends Expression {
   Cascade asCascade() => this;
   accept(Visitor visitor) => visitor.visitCascade(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitCascade(this, arg);
+
   void visitChildren(Visitor visitor) {
     expression.accept(visitor);
   }
 
+  void visitChildren1(Visitor1 visitor, arg) {
+    expression.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => expression.getBeginToken();
 
   Token getEndToken() => expression.getEndToken();
@@ -2351,10 +2899,16 @@ class CascadeReceiver extends Expression {
   CascadeReceiver asCascadeReceiver() => this;
   accept(Visitor visitor) => visitor.visitCascadeReceiver(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitCascadeReceiver(this, arg);
+
   void visitChildren(Visitor visitor) {
     expression.accept(visitor);
   }
 
+  void visitChildren1(Visitor1 visitor, arg) {
+    expression.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => expression.getBeginToken();
 
   Token getEndToken() => expression.getEndToken();
@@ -2375,6 +2929,8 @@ class CatchBlock extends Node {
 
   accept(Visitor visitor) => visitor.visitCatchBlock(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitCatchBlock(this, arg);
+
   Node get exception {
     if (formals == null || formals.nodes.isEmpty) return null;
     VariableDefinitions declarations = formals.nodes.head;
@@ -2395,6 +2951,12 @@ class CatchBlock extends Node {
     block.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    if (type != null) type.accept1(visitor, arg);
+    if (formals != null) formals.accept1(visitor, arg);
+    block.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => onKeyword != null ? onKeyword : catchKeyword;
 
   Token getEndToken() => block.getEndToken();
@@ -2410,10 +2972,16 @@ class Metadata extends Node {
 
   accept(Visitor visitor) => visitor.visitMetadata(this);
 
+  accept1(Visitor1 visitor, arg) => visitor.visitMetadata(this, arg);
+
   visitChildren(Visitor visitor) {
     expression.accept(visitor);
   }
 
+  visitChildren1(Visitor1 visitor, arg) {
+    expression.accept1(visitor, arg);
+  }
+
   Token getBeginToken() => token;
 
   Token getEndToken() => expression.getEndToken();
@@ -2482,8 +3050,12 @@ class ErrorNode
 
   accept(Visitor visitor) {}
 
+  accept1(Visitor1 visitor, arg) {}
+
   visitChildren(Visitor visitor) {}
 
+  visitChildren1(Visitor1 visitor, arg) {}
+
   bool get isErroneous => true;
 
   // FunctionExpression.