Add visitor with additional argument for Statement nodes

pkg/kernel/lib/ast.dart

 // Copyright (c) 2016, 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.
 
 /// -----------------------------------------------------------------------
 ///                           ERROR HANDLING
 /// -----------------------------------------------------------------------
 ///
 /// As a rule of thumb, errors that can be detected statically are handled by
 /// the frontend, typically by translating the erroneous code into a 'throw' or
@@ skipping 2737 matching lines @@
   visitChildren(Visitor v) {}
   transformChildren(Transformer v) {}
 }
 
 // ------------------------------------------------------------------------
 //                              STATEMENTS
 // ------------------------------------------------------------------------
 
 abstract class Statement extends TreeNode {
   accept(StatementVisitor v);
+  accept1(StatementVisitor1 v, arg);
 }
 
 /// A statement with a compile-time error.
 ///
 /// Should throw an exception at runtime.
 class InvalidStatement extends Statement {
   accept(StatementVisitor v) => v.visitInvalidStatement(this);
+  accept1(StatementVisitor1 v, arg) => v.visitInvalidStatement(this, arg);
 
   visitChildren(Visitor v) {}
   transformChildren(Transformer v) {}
 }
 
 class ExpressionStatement extends Statement {
   Expression expression;
 
   ExpressionStatement(this.expression) {
     expression?.parent = this;
   }
 
   accept(StatementVisitor v) => v.visitExpressionStatement(this);
+  accept1(StatementVisitor1 v, arg) => v.visitExpressionStatement(this, arg);
 
   visitChildren(Visitor v) {
     expression?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (expression != null) {
       expression = expression.accept(v);
       expression?.parent = this;
     }
   }
 }
 
 class Block extends Statement {
   final List<Statement> statements;
 
   Block(this.statements) {
     setParents(statements, this);
   }
 
   accept(StatementVisitor v) => v.visitBlock(this);
+  accept1(StatementVisitor1 v, arg) => v.visitBlock(this, arg);
 
   visitChildren(Visitor v) {
     visitList(statements, v);
   }
 
   transformChildren(Transformer v) {
     transformList(statements, v, this);
   }
 
   void addStatement(Statement node) {
     statements.add(node);
     node.parent = this;
   }
 }
 
 class EmptyStatement extends Statement {
   accept(StatementVisitor v) => v.visitEmptyStatement(this);
+  accept1(StatementVisitor1 v, arg) => v.visitEmptyStatement(this, arg);
 
   visitChildren(Visitor v) {}
   transformChildren(Transformer v) {}
 }
 
 class AssertStatement extends Statement {
   Expression condition;
   Expression message; // May be null.
 
   AssertStatement(this.condition, [this.message]) {
     condition?.parent = this;
     message?.parent = this;
   }
 
   accept(StatementVisitor v) => v.visitAssertStatement(this);
+  accept1(StatementVisitor1 v, arg) => v.visitAssertStatement(this, arg);
 
   visitChildren(Visitor v) {
     condition?.accept(v);
     message?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (condition != null) {
       condition = condition.accept(v);
       condition?.parent = this;
@@ skipping 11 matching lines @@
 ///
 /// The frontend does not generate labeled statements without uses.
 class LabeledStatement extends Statement {
   Statement body;
 
   LabeledStatement(this.body) {
     body?.parent = this;
   }
 
   accept(StatementVisitor v) => v.visitLabeledStatement(this);
+  accept1(StatementVisitor1 v, arg) => v.visitLabeledStatement(this, arg);
 
   visitChildren(Visitor v) {
     body?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (body != null) {
       body = body.accept(v);
       body?.parent = this;
     }
@@ skipping 19 matching lines @@
 ///         BODY'
 ///       }
 ///     }
 //
 class BreakStatement extends Statement {
   LabeledStatement target;
 
   BreakStatement(this.target);
 
   accept(StatementVisitor v) => v.visitBreakStatement(this);
+  accept1(StatementVisitor1 v, arg) => v.visitBreakStatement(this, arg);
 
   visitChildren(Visitor v) {}
   transformChildren(Transformer v) {}
 }
 
 class WhileStatement extends Statement {
   Expression condition;
   Statement body;
 
   WhileStatement(this.condition, this.body) {
     condition?.parent = this;
     body?.parent = this;
   }
 
   accept(StatementVisitor v) => v.visitWhileStatement(this);
+  accept1(StatementVisitor1 v, arg) => v.visitWhileStatement(this, arg);
 
   visitChildren(Visitor v) {
     condition?.accept(v);
     body?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (condition != null) {
       condition = condition.accept(v);
       condition?.parent = this;
     }
     if (body != null) {
       body = body.accept(v);
       body?.parent = this;
     }
   }
 }
 
 class DoStatement extends Statement {
   Statement body;
   Expression condition;
 
   DoStatement(this.body, this.condition) {
     body?.parent = this;
     condition?.parent = this;
   }
 
   accept(StatementVisitor v) => v.visitDoStatement(this);
+  accept1(StatementVisitor1 v, arg) => v.visitDoStatement(this, arg);
 
   visitChildren(Visitor v) {
     body?.accept(v);
     condition?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (body != null) {
       body = body.accept(v);
       body?.parent = this;
@@ skipping 12 matching lines @@
   Statement body;
 
   ForStatement(this.variables, this.condition, this.updates, this.body) {
     setParents(variables, this);
     condition?.parent = this;
     setParents(updates, this);
     body?.parent = this;
   }
 
   accept(StatementVisitor v) => v.visitForStatement(this);
+  accept1(StatementVisitor1 v, arg) => v.visitForStatement(this, arg);
 
   visitChildren(Visitor v) {
     visitList(variables, v);
     condition?.accept(v);
     visitList(updates, v);
     body?.accept(v);
   }
 
   transformChildren(Transformer v) {
     transformList(variables, v, this);
@@ skipping 16 matching lines @@
   bool isAsync; // True if this is an 'await for' loop.
 
   ForInStatement(this.variable, this.iterable, this.body,
       {this.isAsync: false}) {
     variable?.parent = this;
     iterable?.parent = this;
     body?.parent = this;
   }
 
   accept(StatementVisitor v) => v.visitForInStatement(this);
+  accept1(StatementVisitor1 v, arg) => v.visitForInStatement(this, arg);
 
   visitChildren(Visitor v) {
     variable?.accept(v);
     iterable?.accept(v);
     body?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (variable != null) {
       variable = variable.accept(v);
@@ skipping 17 matching lines @@
 class SwitchStatement extends Statement {
   Expression expression;
   final List<SwitchCase> cases;
 
   SwitchStatement(this.expression, this.cases) {
     expression?.parent = this;
     setParents(cases, this);
   }
 
   accept(StatementVisitor v) => v.visitSwitchStatement(this);
+  accept1(StatementVisitor1 v, arg) => v.visitSwitchStatement(this, arg);
 
   visitChildren(Visitor v) {
     expression?.accept(v);
     visitList(cases, v);
   }
 
   transformChildren(Transformer v) {
     if (expression != null) {
       expression = expression.accept(v);
       expression?.parent = this;
@@ skipping 42 matching lines @@
   }
 }
 
 /// Jump to a case in an enclosing switch.
 class ContinueSwitchStatement extends Statement {
   SwitchCase target;
 
   ContinueSwitchStatement(this.target);
 
   accept(StatementVisitor v) => v.visitContinueSwitchStatement(this);
+  accept1(StatementVisitor1 v, arg) =>
+      v.visitContinueSwitchStatement(this, arg);
 
   visitChildren(Visitor v) {}
   transformChildren(Transformer v) {}
 }
 
 class IfStatement extends Statement {
   Expression condition;
   Statement then;
   Statement otherwise;
 
   IfStatement(this.condition, this.then, this.otherwise) {
     condition?.parent = this;
     then?.parent = this;
     otherwise?.parent = this;
   }
 
   accept(StatementVisitor v) => v.visitIfStatement(this);
+  accept1(StatementVisitor1 v, arg) => v.visitIfStatement(this, arg);
 
   visitChildren(Visitor v) {
     condition?.accept(v);
     then?.accept(v);
     otherwise?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (condition != null) {
       condition = condition.accept(v);
@@ skipping 11 matching lines @@
 }
 
 class ReturnStatement extends Statement {
   Expression expression; // May be null.
 
   ReturnStatement([this.expression]) {
     expression?.parent = this;
   }
 
   accept(StatementVisitor v) => v.visitReturnStatement(this);
+  accept1(StatementVisitor1 v, arg) => v.visitReturnStatement(this, arg);
 
   visitChildren(Visitor v) {
     expression?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (expression != null) {
       expression = expression.accept(v);
       expression?.parent = this;
     }
   }
 }
 
 class TryCatch extends Statement {
   Statement body;
   List<Catch> catches;
 
   TryCatch(this.body, this.catches) {
     body?.parent = this;
     setParents(catches, this);
   }
 
   accept(StatementVisitor v) => v.visitTryCatch(this);
+  accept1(StatementVisitor1 v, arg) => v.visitTryCatch(this, arg);
 
   visitChildren(Visitor v) {
     body?.accept(v);
     visitList(catches, v);
   }
 
   transformChildren(Transformer v) {
     if (body != null) {
       body = body.accept(v);
       body?.parent = this;
@@ skipping 45 matching lines @@
 class TryFinally extends Statement {
   Statement body;
   Statement finalizer;
 
   TryFinally(this.body, this.finalizer) {
     body?.parent = this;
     finalizer?.parent = this;
   }
 
   accept(StatementVisitor v) => v.visitTryFinally(this);
+  accept1(StatementVisitor1 v, arg) => v.visitTryFinally(this, arg);
 
   visitChildren(Visitor v) {
     body?.accept(v);
     finalizer?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (body != null) {
       body = body.accept(v);
       body?.parent = this;
@@ skipping 27 matching lines @@
 
   void set isYieldStar(bool value) {
     flags = value ? (flags | FlagYieldStar) : (flags & ~FlagYieldStar);
   }
 
   void set isNative(bool value) {
     flags = value ? (flags | FlagNative) : (flags & ~FlagNative);
   }
 
   accept(StatementVisitor v) => v.visitYieldStatement(this);
+  accept1(StatementVisitor1 v, arg) => v.visitYieldStatement(this, arg);
 
   visitChildren(Visitor v) {
     expression?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (expression != null) {
       expression = expression.accept(v);
       expression?.parent = this;
     }
@@ skipping 57 matching lines @@
 
   void set isFinal(bool value) {
     flags = value ? (flags | FlagFinal) : (flags & ~FlagFinal);
   }
 
   void set isConst(bool value) {
     flags = value ? (flags | FlagConst) : (flags & ~FlagConst);
   }
 
   accept(StatementVisitor v) => v.visitVariableDeclaration(this);
+  accept1(StatementVisitor1 v, arg) => v.visitVariableDeclaration(this, arg);
 
   visitChildren(Visitor v) {
     type?.accept(v);
     inferredValue?.accept(v);
     initializer?.accept(v);
   }
 
   transformChildren(Transformer v) {
     type = v.visitDartType(type);
     if (initializer != null) {
@@ skipping 13 matching lines @@
 class FunctionDeclaration extends Statement {
   VariableDeclaration variable; // Is final and has no initializer.
   FunctionNode function;
 
   FunctionDeclaration(this.variable, this.function) {
     variable?.parent = this;
     function?.parent = this;
   }
 
   accept(StatementVisitor v) => v.visitFunctionDeclaration(this);
+  accept1(StatementVisitor1 v, arg) => v.visitFunctionDeclaration(this, arg);
 
   visitChildren(Visitor v) {
     variable?.accept(v);
     function?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (variable != null) {
       variable = variable.accept(v);
       variable?.parent = this;
@@ skipping 652 matching lines @@
 /// library has not been assigned a canonical name yet.
 ///
 /// Returns `null` if the library is `null`.
 CanonicalName getCanonicalNameOfLibrary(Library library) {
   if (library == null) return null;
   if (library.canonicalName == null) {
     throw '$library has no canonical name';
   }
   return library.canonicalName;
 }