Parametrize over the additional agrument type for StatementVisitor1 and ExpressionVisitor1

pkg/kernel/lib/interpreter/interpreter.dart

 // Copyright (c) 2017, 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.
 library kernel.interpreter;
 
 import '../ast.dart';
 import '../ast.dart' as ast show Class;
 
 class NotImplemented {
   String message;
@@ skipping 57 matching lines @@
     lookupBinding(variable).value = value;
   }
 
   void expand(VariableDeclaration variable, Value value) {
     assert(!contains(variable));
     bindings.add(new Binding(variable, value));
   }
 }
 
 /// Evaluate expressions.
-class Evaluator extends ExpressionVisitor1<Configuration> {
+class Evaluator extends ExpressionVisitor1<Configuration, ExpressionState> {
   Configuration eval(Expression expr, ExpressionState state) =>
       expr.accept1(this, state);
 
-  Configuration defaultExpression(Expression node, state) {
+  Configuration defaultExpression(Expression node, ExpressionState state) {
     throw new NotImplemented('Evaluation for expressions of type '
         '${node.runtimeType} is not implemented.');
   }
 
-  Configuration visitInvalidExpression1(InvalidExpression node, state) {
+  Configuration visitInvalidExpression1(
+      InvalidExpression node, ExpressionState state) {
     throw 'Invalid expression at ${node.location.toString()}';
   }
 
-  Configuration visitVariableGet(VariableGet node, state) {
+  Configuration visitVariableGet(VariableGet node, ExpressionState state) {
     Value value = state.environment.lookup(node.variable);
     return new ContinuationConfiguration(state.continuation, value);
   }
 
-  Configuration visitVariableSet(VariableSet node, state) {
+  Configuration visitVariableSet(VariableSet node, ExpressionState state) {
     var cont = new VariableSetContinuation(state, node.variable);
     return new ExpressionConfiguration(
         node.value, state.withContinuation(cont));
   }
 
-  Configuration visitPropertyGet(PropertyGet node, state) {
+  Configuration visitPropertyGet(PropertyGet node, ExpressionState state) {
     var cont = new PropertyGetContinuation(node.name, state);
     return new ExpressionConfiguration(
         node.receiver, state.withContinuation(cont));
   }
 
-  Configuration visitPropertySet(PropertySet node, state) {
+  Configuration visitPropertySet(PropertySet node, ExpressionState state) {
     var cont = new PropertySetContinuation(node.value, node.name, state);
     return new ExpressionConfiguration(
         node.receiver, state.withContinuation(cont));
   }
 
   Configuration visitStaticGet(StaticGet node, state) =>

[Dmitry Stefantsov, 2017/04/20 15:48:15]

What about this method and the next one?

[zhivkag, 2017/04/20 16:02:52]

I have missed them, thanks for noticing! 

       defaultExpression(node, state);
   Configuration visitStaticSet(StaticSet node, state) =>
       defaultExpression(node, state);
 
-  Configuration visitStaticInvocation(StaticInvocation node, state) {
+  Configuration visitStaticInvocation(
+      StaticInvocation node, ExpressionState state) {
     if ('print' == node.name.toString()) {
       return new ExpressionConfiguration(node.arguments.positional.first,
           state.withContinuation(new PrintContinuation(state)));
     } else {
       // Currently supports only static invocations with no arguments.
       if (node.arguments.positional.isEmpty && node.arguments.named.isEmpty) {
         State statementState = new State.initial()
             .withExpressionContinuation(state.continuation)
             .withConfiguration(new ExitConfiguration(state.continuation));
 
         return new StatementConfiguration(
             node.target.function.body, statementState);
       }
       throw new NotImplemented(
           'Support for static invocation with arguments is not implemented');
     }
   }
 
-  Configuration visitMethodInvocation(MethodInvocation node, state) {
+  Configuration visitMethodInvocation(
+      MethodInvocation node, ExpressionState state) {
     // Currently supports only method invocation with <2 arguments and is used
     // to evaluate implemented operators for int, double and String values.
     var cont =
         new MethodInvocationContinuation(node.arguments, node.name, state);
 
     return new ExpressionConfiguration(
         node.receiver, state.withContinuation(cont));
   }
 
-  Configuration visitConstructorInvocation(ConstructorInvocation node, state) {
+  Configuration visitConstructorInvocation(
+      ConstructorInvocation node, ExpressionState state) {
     Class class_ = new Class(node.target.enclosingClass.reference);
 
     // Currently we don't support initializers.
     // TODO: Modify to respect dart semantics for initialization.
     //  1. Init fields and eval initializers, repeat the same with super.
     //  2. Eval the Function body of the constructor.
     List<Value> fields = <Value>[];
 
     return new ContinuationConfiguration(
         state.continuation, new ObjectValue(class_, fields));
   }
 
-  Configuration visitNot(Not node, state) {
+  Configuration visitNot(Not node, ExpressionState state) {
     return new ExpressionConfiguration(
         node.operand, state.withContinuation(new NotContinuation(state)));
   }
 
-  Configuration visitLogicalExpression(LogicalExpression node, state) {
+  Configuration visitLogicalExpression(
+      LogicalExpression node, ExpressionState state) {
     if ('||' == node.operator) {
       var cont = new OrContinuation(node.right, state);
       return new ExpressionConfiguration(
           node.left, state.withContinuation(cont));
     } else {
       assert('&&' == node.operator);
       var cont = new AndContinuation(node.right, state);
       return new ExpressionConfiguration(
           node.left, state.withContinuation(cont));
     }
   }
 
-  Configuration visitConditionalExpression(ConditionalExpression node, state) {
+  Configuration visitConditionalExpression(
+      ConditionalExpression node, ExpressionState state) {
     var cont = new ConditionalContinuation(node.then, node.otherwise, state);
     return new ExpressionConfiguration(
         node.condition, state.withContinuation(cont));
   }
 
-  Configuration visitStringConcatenation(StringConcatenation node, state) {
+  Configuration visitStringConcatenation(
+      StringConcatenation node, ExpressionState state) {
     var cont = new StringConcatenationContinuation(node.expressions, state);
     return new ExpressionConfiguration(
         node.expressions.first, state.withContinuation(cont));
   }
 
   // Evaluation of BasicLiterals.
-  Configuration visitStringLiteral(StringLiteral node, state) {
+  Configuration visitStringLiteral(StringLiteral node, ExpressionState state) {
     return new ContinuationConfiguration(
         state.continuation, new StringValue(node.value));
   }
 
-  Configuration visitIntLiteral(IntLiteral node, state) {
+  Configuration visitIntLiteral(IntLiteral node, ExpressionState state) {
     return new ContinuationConfiguration(
         state.continuation, new IntValue(node.value));
   }
 
-  Configuration visitDoubleLiteral(DoubleLiteral node, state) {
+  Configuration visitDoubleLiteral(DoubleLiteral node, ExpressionState state) {
     return new ContinuationConfiguration(
         state.continuation, new DoubleValue(node.value));
   }
 
-  Configuration visitBoolLiteral(BoolLiteral node, state) {
+  Configuration visitBoolLiteral(BoolLiteral node, ExpressionState state) {
     Value value = node.value ? Value.trueInstance : Value.falseInstance;
     return new ContinuationConfiguration(state.continuation, value);
   }
 
-  Configuration visitNullLiteral(NullLiteral node, state) {
+  Configuration visitNullLiteral(NullLiteral node, ExpressionState state) {
     return new ContinuationConfiguration(
         state.continuation, Value.nullInstance);
   }
 
-  Configuration visitLet(Let node, state) {
+  Configuration visitLet(Let node, ExpressionState state) {
     var letCont = new LetContinuation(node.variable, node.body, state);
     return new ExpressionConfiguration(
         node.variable.initializer, state.withContinuation(letCont));
   }
 }
 
 /// Represents a state for statement execution.
 class State {
   final Environment environment;
   final Label labels;
@@ skipping 393 matching lines @@
 
 /// Executes statements.
 ///
 /// Execution of a statement completes in one of the following ways:
 /// - it completes normally, in which case the execution proceeds to applying
 /// the next continuation
 /// - it breaks with a label, in which case the corresponding continuation is
 /// returned and applied
 /// - it returns with or without value, TBD
 /// - it throws, TBD
-class StatementExecuter extends StatementVisitor1<Configuration> {
+class StatementExecuter extends StatementVisitor1<Configuration, State> {
   Evaluator evaluator = new Evaluator();
 
   void trampolinedExecution(Configuration configuration) {
     while (configuration != null) {
       configuration = configuration.step(this);
     }
   }
 
   Configuration exec(Statement statement, State state) =>
       statement.accept1(this, state);
   Configuration eval(Expression expression, ExpressionState state) =>
       evaluator.eval(expression, state);
 
-  Configuration defaultStatement(Statement node, state) {
+  Configuration defaultStatement(Statement node, State state) {
     throw notImplemented(
         m: "Execution is not implemented for statement:\n$node ");
   }
 
-  Configuration visitInvalidStatement(InvalidStatement node, state) {
+  Configuration visitInvalidStatement(InvalidStatement node, State state) {
     throw "Invalid statement at ${node.location}";
   }
 
-  Configuration visitExpressionStatement(ExpressionStatement node, state) {
+  Configuration visitExpressionStatement(
+      ExpressionStatement node, State state) {
     return new ExpressionConfiguration(
         node.expression, new ExpressionState.fromStatementState(state));
   }
 
-  Configuration visitBlock(Block node, state) {
+  Configuration visitBlock(Block node, State state) {
     if (node.statements.isEmpty) {
       return state.statementConfiguration;
     }
     State blockState =
         state.withEnvironment(new Environment(state.environment));
     StatementConfiguration configuration = state.statementConfiguration;
     for (Statement s in node.statements.reversed) {
       configuration = new StatementConfiguration(
           s, blockState.withConfiguration(configuration));
     }
     return configuration;
   }
 
-  Configuration visitEmptyStatement(EmptyStatement node, state) {
+  Configuration visitEmptyStatement(EmptyStatement node, State state) {
     return state.statementConfiguration;
   }
 
-  Configuration visitIfStatement(IfStatement node, state) {
+  Configuration visitIfStatement(IfStatement node, State state) {
     var expState = new ExpressionState.fromStatementState(state);
     var cont = new IfConditionContinuation(node.then, node.otherwise, state);
     return new ExpressionConfiguration(
         node.condition, expState.withContinuation(cont));
   }
 
-  Configuration visitLabeledStatement(LabeledStatement node, state) {
+  Configuration visitLabeledStatement(LabeledStatement node, State state) {
     return new StatementConfiguration(node.body, state.withBreak(node));
   }
 
-  Configuration visitBreakStatement(BreakStatement node, state) {
+  Configuration visitBreakStatement(BreakStatement node, State state) {
     return state.lookupLabel(node.target).configuration;
   }
 
-  Configuration visitWhileStatement(WhileStatement node, state) {
+  Configuration visitWhileStatement(WhileStatement node, State state) {
     var expState = new ExpressionState.fromStatementState(state);
     var cont = new WhileConditionContinuation(node, state);
 
     return new ExpressionConfiguration(
         node.condition, expState.withContinuation(cont));
   }
 
-  Configuration visitDoStatement(DoStatement node, state) {
+  Configuration visitDoStatement(DoStatement node, State state) {
     WhileStatement whileStatement =
         new WhileStatement(node.condition, node.body);
     StatementConfiguration configuration =
         new StatementConfiguration(whileStatement, state);
 
     return new StatementConfiguration(
         node.body, state.withConfiguration(configuration));
   }
 
-  Configuration visitReturnStatement(ReturnStatement node, state) {
+  Configuration visitReturnStatement(ReturnStatement node, State state) {
     assert(state.returnContinuation != null);
     // The new ExpressionState contains the next expression continuation.
     var expState = new ExpressionState.fromStatementState(state)
         .withContinuation(state.returnContinuation);
     return new ExpressionConfiguration(
         node.expression ?? new NullLiteral(), expState);
   }
 
-  Configuration visitVariableDeclaration(VariableDeclaration node, state) {
+  Configuration visitVariableDeclaration(
+      VariableDeclaration node, State state) {
     if (node.initializer != null) {
       var expState = new ExpressionState.fromStatementState(state);
       var cont = new VariableInitializerContinuation(
           node, state.environment, state.statementConfiguration);
       return new ExpressionConfiguration(
           node.initializer, expState.withContinuation(cont));
     }
     state.environment.expand(node, Value.nullInstance);
     return state.statementConfiguration;
   }
@@ skipping 222 matching lines @@
 
 class NullValue extends LiteralValue {
   Object get value => null;
 
   const NullValue();
 }
 
 notImplemented({String m, Object obj}) {
   throw new NotImplemented(m ?? 'Evaluation for $obj is not implemented');
 }