Initial implementation of interpreter for Kernel

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 35 matching lines @@
 /// relatively few nodes.  Or use whichever is more convenient.
 ///
 /// The AST can also be mutated by direct field manipulation, but the user then
 /// has to update parent pointers manually.
 ///
 library kernel.ast;
 
 import 'visitor.dart';
 export 'visitor.dart';
 
+import 'interpreter/interpreter_visitor.dart';
+export 'interpreter/interpreter_visitor.dart';
+
 import 'type_propagation/type_propagation.dart';
 export 'type_propagation/type_propagation.dart';
 
 import 'canonical_name.dart' show CanonicalName;
 export 'canonical_name.dart' show CanonicalName;
 
 import 'transformations/flags.dart';
 import 'text/ast_to_text.dart';
 import 'type_algebra.dart';
 import 'type_environment.dart';
@@ skipping 1333 matching lines @@
       var upcastType = types.hierarchy.getTypeAsInstanceOf(type, superclass);
       if (upcastType != null) return upcastType;
     } else if (type is BottomType) {
       return superclass.bottomType;
     }
     types.typeError(this, '$type is not a subtype of $superclass');
     return superclass.rawType;
   }
 
   accept(ExpressionVisitor v);
+  accept1(ExpressionVisitor1 v, State s);

[Kevin Millikin (Google), 2017/03/02 10:30:29]

I'd change this to:

accept1(ExpressionVisitor1 v, arg);

 }
 
 /// An expression containing compile-time errors.
 ///
 /// Should throw a runtime error when evaluated.
 class InvalidExpression extends Expression {
   DartType getStaticType(TypeEnvironment types) => const BottomType();
 
   accept(ExpressionVisitor v) => v.visitInvalidExpression(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitInvalidExpression1(this, s);
 
   visitChildren(Visitor v) {}
   transformChildren(Transformer v) {}
 }
 
 /// Read a local variable, a local function, or a function parameter.
 class VariableGet extends Expression {
   VariableDeclaration variable;
   DartType promotedType; // Null if not promoted.
 
   VariableGet(this.variable, [this.promotedType]);
 
   DartType getStaticType(TypeEnvironment types) {
     return promotedType ?? variable.type;
   }
 
   accept(ExpressionVisitor v) => v.visitVariableGet(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitVariableGet1(this, s);
 
   visitChildren(Visitor v) {
     promotedType?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (promotedType != null) {
       promotedType = v.visitDartType(promotedType);
     }
   }
 }
 
 /// Assign a local variable or function parameter.
 ///
 /// Evaluates to the value of [value].
 class VariableSet extends Expression {
   VariableDeclaration variable;
   Expression value;
 
   VariableSet(this.variable, this.value) {
     value?.parent = this;
   }
 
   DartType getStaticType(TypeEnvironment types) => value.getStaticType(types);
 
   accept(ExpressionVisitor v) => v.visitVariableSet(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitVariableSet1(this, s);
 
   visitChildren(Visitor v) {
     value?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (value != null) {
       value = value.accept(v);
       value?.parent = this;
     }
@@ skipping 36 matching lines @@
     String nameString = name.name;
     if (nameString == 'hashCode') {
       return types.intType;
     } else if (nameString == 'runtimeType') {
       return types.typeType;
     }
     return const DynamicType();
   }
 
   accept(ExpressionVisitor v) => v.visitPropertyGet(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitPropertyGet1(this, s);
 
   visitChildren(Visitor v) {
     receiver?.accept(v);
     name?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (receiver != null) {
       receiver = receiver.accept(v);
       receiver?.parent = this;
@@ skipping 26 matching lines @@
 
   Member get interfaceTarget => interfaceTargetReference?.asMember;
 
   void set interfaceTarget(Member member) {
     interfaceTargetReference = getMemberReference(member);
   }
 
   DartType getStaticType(TypeEnvironment types) => value.getStaticType(types);
 
   accept(ExpressionVisitor v) => v.visitPropertySet(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitPropertySet1(this, s);
 
   visitChildren(Visitor v) {
     receiver?.accept(v);
     name?.accept(v);
     value?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (receiver != null) {
       receiver = receiver.accept(v);
@@ skipping 30 matching lines @@
   }
 
   transformChildren(Transformer v) {
     if (receiver != null) {
       receiver = receiver.accept(v);
       receiver?.parent = this;
     }
   }
 
   accept(ExpressionVisitor v) => v.visitDirectPropertyGet(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitDirectPropertyGet1(this, s);
 
   DartType getStaticType(TypeEnvironment types) {
     Class superclass = target.enclosingClass;
     var receiverType = receiver.getStaticTypeAsInstanceOf(superclass, types);
     return Substitution
         .fromInterfaceType(receiverType)
         .substituteType(target.getterType);
   }
 }
 
@@ skipping 31 matching lines @@
       receiver = receiver.accept(v);
       receiver?.parent = this;
     }
     if (value != null) {
       value = value.accept(v);
       value?.parent = this;
     }
   }
 
   accept(ExpressionVisitor v) => v.visitDirectPropertySet(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitDirectPropertySet1(this, s);
 
   DartType getStaticType(TypeEnvironment types) => value.getStaticType(types);
 }
 
 /// Directly call an instance method, bypassing ordinary dispatch.
 class DirectMethodInvocation extends InvocationExpression {
   Expression receiver;
   Reference targetReference;
   Arguments arguments;
 
@@ skipping 26 matching lines @@
       receiver = receiver.accept(v);
       receiver?.parent = this;
     }
     if (arguments != null) {
       arguments = arguments.accept(v);
       arguments?.parent = this;
     }
   }
 
   accept(ExpressionVisitor v) => v.visitDirectMethodInvocation(this);
+  accept1(ExpressionVisitor1 v, State s) =>
+      v.visitDirectMethodInvocation1(this, s);
 
   DartType getStaticType(TypeEnvironment types) {
     if (types.isOverloadedArithmeticOperator(target)) {
       return types.getTypeOfOverloadedArithmetic(receiver.getStaticType(types),
           arguments.positional[0].getStaticType(types));
     }
     Class superclass = target.enclosingClass;
     var receiverType = receiver.getStaticTypeAsInstanceOf(superclass, types);
     var returnType = Substitution
         .fromInterfaceType(receiverType)
@@ skipping 28 matching lines @@
       return interfaceTarget.getterType;
     }
     var receiver =
         types.hierarchy.getTypeAsInstanceOf(types.thisType, declaringClass);
     return Substitution
         .fromInterfaceType(receiver)
         .substituteType(interfaceTarget.getterType);
   }
 
   accept(ExpressionVisitor v) => v.visitSuperPropertyGet(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitSuperPropertyGet1(this, s);
 
   visitChildren(Visitor v) {
     name?.accept(v);
   }
 
   transformChildren(Transformer v) {}
 }
 
 /// Expression of form `super.field = value`.
 ///
@@ skipping 15 matching lines @@
 
   Member get interfaceTarget => interfaceTargetReference?.asMember;
 
   void set interfaceTarget(Member member) {
     interfaceTargetReference = getMemberReference(member);
   }
 
   DartType getStaticType(TypeEnvironment types) => value.getStaticType(types);
 
   accept(ExpressionVisitor v) => v.visitSuperPropertySet(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitSuperPropertySet1(this, s);
 
   visitChildren(Visitor v) {
     name?.accept(v);
     value?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (value != null) {
       value = value.accept(v);
       value?.parent = this;
@@ skipping 12 matching lines @@
 
   Member get target => targetReference?.asMember;
 
   void set target(Member target) {
     targetReference = getMemberReference(target);
   }
 
   DartType getStaticType(TypeEnvironment types) => target.getterType;
 
   accept(ExpressionVisitor v) => v.visitStaticGet(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitStaticGet1(this, s);
 
   visitChildren(Visitor v) {
     target?.acceptReference(v);
   }
 
   transformChildren(Transformer v) {}
 }
 
 /// Assign a static field or call a static setter.
 ///
@@ skipping 12 matching lines @@
 
   Member get target => targetReference?.asMember;
 
   void set target(Member target) {
     targetReference = getMemberReference(target);
   }
 
   DartType getStaticType(TypeEnvironment types) => value.getStaticType(types);
 
   accept(ExpressionVisitor v) => v.visitStaticSet(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitStaticSet1(this, s);
 
   visitChildren(Visitor v) {
     target?.acceptReference(v);
     value?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (value != null) {
       value = value.accept(v);
       value?.parent = this;
@@ skipping 124 matching lines @@
       }
     }
     if (name.name == '==') {
       // We use this special case to simplify generation of '==' checks.
       return types.boolType;
     }
     return const DynamicType();
   }
 
   accept(ExpressionVisitor v) => v.visitMethodInvocation(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitMethodInvocation1(this, s);
 
   visitChildren(Visitor v) {
     receiver?.accept(v);
     name?.accept(v);
     arguments?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (receiver != null) {
       receiver = receiver.accept(v);
@@ skipping 37 matching lines @@
         types.hierarchy.getTypeAsInstanceOf(types.thisType, superclass);
     var returnType = Substitution
         .fromInterfaceType(receiverType)
         .substituteType(interfaceTarget.function.returnType);
     return Substitution
         .fromPairs(interfaceTarget.function.typeParameters, arguments.types)
         .substituteType(returnType);
   }
 
   accept(ExpressionVisitor v) => v.visitSuperMethodInvocation(this);
+  accept1(ExpressionVisitor1 v, State s) =>
+      v.visitSuperMethodInvocation1(this, s);
 
   visitChildren(Visitor v) {
     name?.accept(v);
     arguments?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (arguments != null) {
       arguments = arguments.accept(v);
       arguments?.parent = this;
@@ skipping 29 matching lines @@
     targetReference = getMemberReference(target);
   }
 
   DartType getStaticType(TypeEnvironment types) {
     return Substitution
         .fromPairs(target.function.typeParameters, arguments.types)
         .substituteType(target.function.returnType);
   }
 
   accept(ExpressionVisitor v) => v.visitStaticInvocation(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitStaticInvocation1(this, s);
 
   visitChildren(Visitor v) {
     target?.acceptReference(v);
     arguments?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (arguments != null) {
       arguments = arguments.accept(v);
       arguments?.parent = this;
@@ skipping 31 matching lines @@
     targetReference = getMemberReference(target);
   }
 
   DartType getStaticType(TypeEnvironment types) {
     return arguments.types.isEmpty
         ? target.enclosingClass.rawType
         : new InterfaceType(target.enclosingClass, arguments.types);
   }
 
   accept(ExpressionVisitor v) => v.visitConstructorInvocation(this);
+  accept1(ExpressionVisitor1 v, State s) =>
+      v.visitConstructorInvocation1(this, s);
 
   visitChildren(Visitor v) {
     target?.acceptReference(v);
     arguments?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (arguments != null) {
       arguments = arguments.accept(v);
       arguments?.parent = this;
@@ skipping 14 matching lines @@
 class Not extends Expression {
   Expression operand;
 
   Not(this.operand) {
     operand?.parent = this;
   }
 
   DartType getStaticType(TypeEnvironment types) => types.boolType;
 
   accept(ExpressionVisitor v) => v.visitNot(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitNot1(this, s);
 
   visitChildren(Visitor v) {
     operand?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (operand != null) {
       operand = operand.accept(v);
       operand?.parent = this;
     }
   }
 }
 
 /// Expression of form `x && y` or `x || y`
 class LogicalExpression extends Expression {
   Expression left;
   String operator; // && or || or ??
   Expression right;
 
   LogicalExpression(this.left, this.operator, this.right) {
     left?.parent = this;
     right?.parent = this;
   }
 
   DartType getStaticType(TypeEnvironment types) => types.boolType;
 
   accept(ExpressionVisitor v) => v.visitLogicalExpression(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitLogicalExpression1(this, s);
 
   visitChildren(Visitor v) {
     left?.accept(v);
     right?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (left != null) {
       left = left.accept(v);
       left?.parent = this;
@@ skipping 17 matching lines @@
   ConditionalExpression(
       this.condition, this.then, this.otherwise, this.staticType) {
     condition?.parent = this;
     then?.parent = this;
     otherwise?.parent = this;
   }
 
   DartType getStaticType(TypeEnvironment types) => staticType;
 
   accept(ExpressionVisitor v) => v.visitConditionalExpression(this);
+  accept1(ExpressionVisitor1 v, State s) =>
+      v.visitConditionalExpression1(this, s);
 
   visitChildren(Visitor v) {
     condition?.accept(v);
     then?.accept(v);
     otherwise?.accept(v);
     staticType?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (condition != null) {
@@ skipping 24 matching lines @@
 class StringConcatenation extends Expression {
   final List<Expression> expressions;
 
   StringConcatenation(this.expressions) {
     setParents(expressions, this);
   }
 
   DartType getStaticType(TypeEnvironment types) => types.stringType;
 
   accept(ExpressionVisitor v) => v.visitStringConcatenation(this);
+  accept1(ExpressionVisitor1 v, State s) =>
+      v.visitStringConcatenation1(this, s);
 
   visitChildren(Visitor v) {
     visitList(expressions, v);
   }
 
   transformChildren(Transformer v) {
     transformList(expressions, v, this);
   }
 }
 
 /// Expression of form `x is T`.
 class IsExpression extends Expression {
   Expression operand;
   DartType type;
 
   IsExpression(this.operand, this.type) {
     operand?.parent = this;
   }
 
   DartType getStaticType(TypeEnvironment types) => types.boolType;
 
   accept(ExpressionVisitor v) => v.visitIsExpression(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitIsExpression1(this, s);
 
   visitChildren(Visitor v) {
     operand?.accept(v);
     type?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (operand != null) {
       operand = operand.accept(v);
       operand?.parent = this;
     }
     type = v.visitDartType(type);
   }
 }
 
 /// Expression of form `x as T`.
 class AsExpression extends Expression {
   Expression operand;
   DartType type;
 
   AsExpression(this.operand, this.type) {
     operand?.parent = this;
   }
 
   DartType getStaticType(TypeEnvironment types) => type;
 
   accept(ExpressionVisitor v) => v.visitAsExpression(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitAsExpression1(this, s);
 
   visitChildren(Visitor v) {
     operand?.accept(v);
     type?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (operand != null) {
       operand = operand.accept(v);
       operand?.parent = this;
@@ skipping 11 matching lines @@
 }
 
 class StringLiteral extends BasicLiteral {
   String value;
 
   StringLiteral(this.value);
 
   DartType getStaticType(TypeEnvironment types) => types.stringType;
 
   accept(ExpressionVisitor v) => v.visitStringLiteral(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitStringLiteral1(this, s);
 }
 
 class IntLiteral extends BasicLiteral {
   int value;
 
   IntLiteral(this.value);
 
   DartType getStaticType(TypeEnvironment types) => types.intType;
 
   accept(ExpressionVisitor v) => v.visitIntLiteral(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitIntLiteral1(this, s);
 }
 
 class DoubleLiteral extends BasicLiteral {
   double value;
 
   DoubleLiteral(this.value);
 
   DartType getStaticType(TypeEnvironment types) => types.doubleType;
 
   accept(ExpressionVisitor v) => v.visitDoubleLiteral(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitDoubleLiteral1(this, s);
 }
 
 class BoolLiteral extends BasicLiteral {
   bool value;
 
   BoolLiteral(this.value);
 
   DartType getStaticType(TypeEnvironment types) => types.boolType;
 
   accept(ExpressionVisitor v) => v.visitBoolLiteral(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitBoolLiteral1(this, s);
 }
 
 class NullLiteral extends BasicLiteral {
   Object get value => null;
 
   DartType getStaticType(TypeEnvironment types) => const BottomType();
 
   accept(ExpressionVisitor v) => v.visitNullLiteral(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitNullLiteral1(this, s);
 }
 
 class SymbolLiteral extends Expression {
   String value; // Everything strictly after the '#'.
 
   SymbolLiteral(this.value);
 
   DartType getStaticType(TypeEnvironment types) => types.symbolType;
 
   accept(ExpressionVisitor v) => v.visitSymbolLiteral(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitSymbolLiteral1(this, s);
 
   visitChildren(Visitor v) {}
   transformChildren(Transformer v) {}
 }
 
 class TypeLiteral extends Expression {
   DartType type;
 
   TypeLiteral(this.type);
 
   DartType getStaticType(TypeEnvironment types) => types.typeType;
 
   accept(ExpressionVisitor v) => v.visitTypeLiteral(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitTypeLiteral1(this, s);
 
   visitChildren(Visitor v) {
     type?.accept(v);
   }
 
   transformChildren(Transformer v) {
     type = v.visitDartType(type);
   }
 }
 
 class ThisExpression extends Expression {
   DartType getStaticType(TypeEnvironment types) => types.thisType;
 
   accept(ExpressionVisitor v) => v.visitThisExpression(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitThisExpression1(this, s);
 
   visitChildren(Visitor v) {}
   transformChildren(Transformer v) {}
 }
 
 class Rethrow extends Expression {
   DartType getStaticType(TypeEnvironment types) => const BottomType();
 
   accept(ExpressionVisitor v) => v.visitRethrow(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitRethrow1(this, s);
 
   visitChildren(Visitor v) {}
   transformChildren(Transformer v) {}
 }
 
 class Throw extends Expression {
   Expression expression;
 
   Throw(this.expression) {
     expression?.parent = this;
   }
 
   DartType getStaticType(TypeEnvironment types) => const BottomType();
 
   accept(ExpressionVisitor v) => v.visitThrow(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitThrow1(this, s);
 
   visitChildren(Visitor v) {
     expression?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (expression != null) {
       expression = expression.accept(v);
       expression?.parent = this;
     }
   }
 }
 
 class ListLiteral extends Expression {
   bool isConst;
   DartType typeArgument; // Not null, defaults to DynamicType.
   final List<Expression> expressions;
 
   ListLiteral(this.expressions,
       {this.typeArgument: const DynamicType(), this.isConst: false}) {
     assert(typeArgument != null);
     setParents(expressions, this);
   }
 
   DartType getStaticType(TypeEnvironment types) {
     return types.literalListType(typeArgument);
   }
 
   accept(ExpressionVisitor v) => v.visitListLiteral(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitListLiteral1(this, s);
 
   visitChildren(Visitor v) {
     typeArgument?.accept(v);
     visitList(expressions, v);
   }
 
   transformChildren(Transformer v) {
     typeArgument = v.visitDartType(typeArgument);
     transformList(expressions, v, this);
   }
@@ skipping 12 matching lines @@
     assert(keyType != null);
     assert(valueType != null);
     setParents(entries, this);
   }
 
   DartType getStaticType(TypeEnvironment types) {
     return types.literalMapType(keyType, valueType);
   }
 
   accept(ExpressionVisitor v) => v.visitMapLiteral(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitMapLiteral1(this, s);
 
   visitChildren(Visitor v) {
     keyType?.accept(v);
     valueType?.accept(v);
     visitList(entries, v);
   }
 
   transformChildren(Transformer v) {
     keyType = v.visitDartType(keyType);
     valueType = v.visitDartType(valueType);
@@ skipping 35 matching lines @@
 
   AwaitExpression(this.operand) {
     operand?.parent = this;
   }
 
   DartType getStaticType(TypeEnvironment types) {
     return types.unfutureType(operand.getStaticType(types));
   }
 
   accept(ExpressionVisitor v) => v.visitAwaitExpression(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitAwaitExpression1(this, s);
 
   visitChildren(Visitor v) {
     operand?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (operand != null) {
       operand = operand.accept(v);
       operand?.parent = this;
     }
   }
 }
 
 /// Expression of form `(x,y) => ...` or `(x,y) { ... }`
 ///
 /// The arrow-body form `=> e` is desugared into `return e;`.
 class FunctionExpression extends Expression {
   FunctionNode function;
 
   FunctionExpression(this.function) {
     function?.parent = this;
   }
 
   DartType getStaticType(TypeEnvironment types) => function.functionType;
 
   accept(ExpressionVisitor v) => v.visitFunctionExpression(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitFunctionExpression1(this, s);
 
   visitChildren(Visitor v) {
     function?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (function != null) {
       function = function.accept(v);
       function?.parent = this;
     }
   }
 }
 
 /// Synthetic expression of form `let v = x in y`
 class Let extends Expression {
   VariableDeclaration variable; // Must have an initializer.
   Expression body;
 
   Let(this.variable, this.body) {
     variable?.parent = this;
     body?.parent = this;
   }
 
   DartType getStaticType(TypeEnvironment types) => body.getStaticType(types);
 
   accept(ExpressionVisitor v) => v.visitLet(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitLet1(this, s);
 
   visitChildren(Visitor v) {
     variable?.accept(v);
     body?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (variable != null) {
       variable = variable.accept(v);
       variable?.parent = this;
@@ skipping 21 matching lines @@
   /// Reference to a deferred import in the enclosing library.
   DeferredImport import;
 
   LoadLibrary(this.import);
 
   DartType getStaticType(TypeEnvironment types) {
     return types.futureType(const DynamicType());
   }
 
   accept(ExpressionVisitor v) => v.visitLoadLibrary(this);
+  accept1(ExpressionVisitor1 v, State s) => v.visitLoadLibrary1(this, s);
 
   visitChildren(Visitor v) {}
   transformChildren(Transformer v) {}
 }
 
 /// Checks that the given deferred import has been marked as 'loaded'.
 class CheckLibraryIsLoaded extends Expression {
   /// Reference to a deferred import in the enclosing library.
   DeferredImport import;
 
   CheckLibraryIsLoaded(this.import);
 
   DartType getStaticType(TypeEnvironment types) {
     return types.objectType;
   }
 
   accept(ExpressionVisitor v) => v.visitCheckLibraryIsLoaded(this);
+  accept1(ExpressionVisitor1 v, State s) =>
+      v.visitCheckLibraryIsLoaded1(this, s);
 
   visitChildren(Visitor v) {}
   transformChildren(Transformer v) {}
 }
 
 // ------------------------------------------------------------------------
 //                              STATEMENTS
 // ------------------------------------------------------------------------
 
 abstract class Statement extends TreeNode {
@@ skipping 1309 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;
 }