Introduce statement continuations following the specification

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;
 
 import '../log.dart';
 export '../log.dart';
@@ skipping 12 matching lines @@
 
   Interpreter(this.program);
 
   void run() {
     assert(program.libraries.isEmpty);
     Procedure mainMethod = program.mainMethod;
 
     if (mainMethod == null) return;
 
     Statement statementBlock = mainMethod.function.body;
-    ExecConfiguration configuration =
-        new ExecConfiguration(statementBlock, new State.initial());
+    ExecConfiguration configuration = new ExecConfiguration(
+        statementBlock, new Environment.empty(), const State.initial());
     visitor.trampolinedExecution(configuration);
   }
 }
 
 class Location {
   Value value;
 
   Location(this.value);
 }
 
 class Binding {
   final VariableDeclaration variable;
   final Location location;
 
   Binding(this.variable, this.location);
 }
 
 class Environment {
   final List<Binding> bindings = <Binding>[];
   final Environment parent;
 
-  Value get thisInstance => (parent != null)
-      ? parent.thisInstance
-      : throw "Invalid reference to 'this' expression";
-
   Environment.empty() : parent = null;
   Environment(this.parent);
 
   bool contains(VariableDeclaration variable) {
     for (Binding b in bindings.reversed) {
       if (identical(b.variable, variable)) return true;
     }
     return parent?.contains(variable) ?? false;
   }
 
   Binding lookupBinding(VariableDeclaration variable) {
     assert(contains(variable));
     for (Binding b in bindings) {
       if (identical(b.variable, variable)) return b;
     }
     return parent.lookupBinding(variable);
   }
 
   Value lookup(VariableDeclaration variable) {
     return lookupBinding(variable).location.value;
   }
 
   void assign(VariableDeclaration variable, Value value) {
     assert(contains(variable));
     lookupBinding(variable).location.value = value;
   }
 
-  void expand(VariableDeclaration variable, Value value) {
+  Environment extend(VariableDeclaration variable, Value value) {
     assert(!contains(variable));
-    bindings.add(new Binding(variable, new Location(value)));
+    return new Environment(this)
+      ..bindings.add(new Binding(variable, new Location(value)));
   }
 }
 
-class InstanceEnvironment extends Environment {
-  final ObjectValue _thisInstance;
-  Value get thisInstance => _thisInstance;
-
-  InstanceEnvironment(this._thisInstance, Environment env) : super(env);
-}
-
 /// Evaluate expressions.
 class Evaluator extends ExpressionVisitor1<Configuration, EvalConfiguration> {
   Configuration eval(Expression expr, EvalConfiguration config) =>
       expr.accept1(this, config);
 
   Configuration evalList(List<InterpreterExpression> list, Environment env,
       ApplicationContinuation cont) {
     if (list.isNotEmpty) {
       return new EvalConfiguration(list.first.expression, env,
           new ExpressionListEK(list.first, list.skip(1), env, cont));
@@ skipping 35 matching lines @@
 
   Configuration visitStaticGet(StaticGet node, EvalConfiguration config) =>
       defaultExpression(node, config);
   Configuration visitStaticSet(StaticSet node, EvalConfiguration config) =>
       defaultExpression(node, config);
 
   Configuration visitStaticInvocation(
       StaticInvocation node, EvalConfiguration config) {
     if ('print' == node.name.toString()) {
       var cont = new PrintEK(config.continuation);
-
       return new EvalConfiguration(
           node.arguments.positional.first, config.environment, cont);
     } else {
       log.info('static-invocation-${node.target.name.toString()}\n');
 
       List<InterpreterExpression> args =
           _createArgumentExpressionList(node.arguments, node.target.function);
       ApplicationContinuation cont =
           new StaticInvocationA(node.target.function, config.continuation);
-
       return new EvalListConfiguration(args, config.environment, cont);
     }
   }
 
   Configuration visitMethodInvocation(
       MethodInvocation node, EvalConfiguration config) {
     // Currently supports only method invocation with <2 arguments and is used
     // to evaluate implemented operators for int, double and String values.
     var cont = new MethodInvocationEK(
         node.arguments, node.name, config.environment, config.continuation);
 
     return new EvalConfiguration(node.receiver, config.environment, cont);
   }
 
   Configuration visitConstructorInvocation(
-      ConstructorInvocation node, EvalConfiguration config) {
-    ApplicationContinuation cont =
-        new ConstructorInvocationA(node.target, config.continuation);
-    var args =
-        _createArgumentExpressionList(node.arguments, node.target.function);
-
-    return new EvalListConfiguration(args, config.environment, cont);
-  }
+          ConstructorInvocation node, EvalConfiguration config) =>
+      defaultExpression(node, config);
 
   Configuration visitNot(Not node, EvalConfiguration config) {
     return new EvalConfiguration(
         node.operand, config.environment, new NotEK(config.continuation));
   }
 
   Configuration visitLogicalExpression(
       LogicalExpression node, EvalConfiguration config) {
     if ('||' == node.operator) {
       var cont = new OrEK(node.right, config.environment, config.continuation);
@@ skipping 15 matching lines @@
   Configuration visitStringConcatenation(
       StringConcatenation node, EvalConfiguration config) {
     var cont = new StringConcatenationA(config.continuation);
     var expressions = node.expressions
         .map((Expression e) => new PositionalExpression(e))
         .toList();
     return new EvalListConfiguration(expressions, config.environment, cont);
   }
 
   Configuration visitThisExpression(
-      ThisExpression node, EvalConfiguration config) {
-    return new ValuePassingConfiguration(
-        config.continuation, config.environment.thisInstance);
-  }
+          ThisExpression node, EvalConfiguration config) =>
+      defaultExpression(node, config);
 
   // Evaluation of BasicLiterals.
   Configuration visitStringLiteral(
       StringLiteral node, EvalConfiguration config) {
     return new ValuePassingConfiguration(
         config.continuation, new StringValue(node.value));
   }
 
   Configuration visitIntLiteral(IntLiteral node, EvalConfiguration config) {
     return new ValuePassingConfiguration(
@@ skipping 19 matching lines @@
   Configuration visitLet(Let node, EvalConfiguration config) {
     var letCont = new LetEK(
         node.variable, node.body, config.environment, config.continuation);
     return new EvalConfiguration(
         node.variable.initializer, config.environment, letCont);
   }
 }
 
 /// Represents a state for statement execution.
 class State {
-  final Environment environment;
   final Label labels;
-  final ExecConfiguration statementConfiguration;
+  // TODO: Add switch labels.
+  // TODO: Add component for exception support.
+  final ExpressionContinuation returnContinuation;
+  final StatementContinuation continuation;
 
-  final ExpressionContinuation returnContinuation;
+  State(this.labels, this.returnContinuation, this.continuation);
 
-  State(this.environment, this.labels, this.statementConfiguration,
-      this.returnContinuation);
+  const State.initial()
+      : labels = null,
+        returnContinuation = null,
+        continuation = null;
 
-  State.initial() : this(new Environment.empty(), null, null, null);
-
-  State withEnvironment(Environment env) {
-    return new State(env, labels, statementConfiguration, returnContinuation);
+  State withBreak(Statement stmt, Environment env) {
+    Label breakLabels = new Label(stmt, env, continuation, labels);
+    return new State(breakLabels, returnContinuation, continuation);
   }
 
-  State withBreak(Statement stmt) {
-    Label breakLabels = new Label(stmt, statementConfiguration, labels);
-    return new State(
-        environment, breakLabels, statementConfiguration, returnContinuation);
+  State withReturnContinuation(ExpressionContinuation returnCont) {
+    return new State(labels, returnCont, continuation);
   }
 
-  State withConfiguration(Configuration config) {
-    return new State(environment, labels, config, returnContinuation);
-  }
-
-  State withExpressionContinuation(ExpressionContinuation cont) {
-    return new State(environment, labels, statementConfiguration, cont);
+  State withContinuation(StatementContinuation cont) {
+    return new State(labels, returnContinuation, cont);
   }
 
   Label lookupLabel(LabeledStatement s) {
     assert(labels != null);
     return labels.lookupLabel(s);
   }
 }
 
 /// Represents a labeled statement, the corresponding continuation and the
 /// enclosing label.
 class Label {
   final LabeledStatement statement;
-  final ExecConfiguration configuration;
+  final Environment environment;
+  final StatementContinuation continuation;
   final Label enclosingLabel;
 
-  Label(this.statement, this.configuration, this.enclosingLabel);
+  Label(
+      this.statement, this.environment, this.continuation, this.enclosingLabel);
 
   Label lookupLabel(LabeledStatement s) {
     if (identical(s, statement)) return this;
     assert(enclosingLabel != null);
     return enclosingLabel.lookupLabel(s);
   }
 }
 
 // ------------------------------------------------------------------------
 //                           Configurations
 // ------------------------------------------------------------------------
 
 abstract class Configuration {
   /// Executes the current and returns the next configuration.
   Configuration step(StatementExecuter executer);
 }
 
-/// Represents the configuration for evaluating an [Expression].
+/// Configuration for evaluating an [Expression].
 class EvalConfiguration extends Configuration {
   final Expression expression;
 
   /// Environment in which the expression is evaluated.
   final Environment environment;
 
   /// Next continuation to be applied.
   final Continuation continuation;
 
   EvalConfiguration(this.expression, this.environment, this.continuation);
 
   Configuration step(StatementExecuter executer) =>
       executer.eval(expression, this);
 }
 
-/// Represents the configuration for evaluating a list of expressions.
+/// Configuration for evaluating a `List<InterpreterExpression>`.
 class EvalListConfiguration extends Configuration {
   final List<InterpreterExpression> expressions;
   final Environment environment;
-  final Continuation continuation;
+  final ApplicationContinuation continuation;
 
   EvalListConfiguration(this.expressions, this.environment, this.continuation);
 
   Configuration step(StatementExecuter executer) =>
       executer.evalList(expressions, environment, continuation);
 }
 
-/// Represents the configuration for execution of statement.
+/// Configuration for execution of a [Statement].
 class ExecConfiguration extends Configuration {
-  final Statement statement;
+  final Statement currentStatement;
+  final Environment environment;
   final State state;
 
-  ExecConfiguration(this.statement, this.state);
+  ExecConfiguration(this.currentStatement, this.environment, this.state);
 
   Configuration step(StatementExecuter executer) =>
-      executer.exec(statement, state);
+      executer.exec(currentStatement, this);
 }
 
-class ExitConfiguration extends ExecConfiguration {
-  final ExpressionContinuation returnContinuation;
+/// Configuration for applying a [StatementContinuation] to an [Environment].
+class ForwardConfiguration extends Configuration {
+  final StatementContinuation continuation;
+  final Environment environment;
 
-  ExitConfiguration(this.returnContinuation) : super(null, null);
+  ForwardConfiguration(this.continuation, this.environment);
 
-  Configuration step(StatementExecuter _) {
-    return returnContinuation(Value.nullInstance);
-  }
+  Configuration step(StatementExecuter _) => continuation?.call(environment);
 }
 
-class NewInstanceConfiguration extends ExecConfiguration {
-  final ExpressionContinuation continuation;
-  final ObjectValue newObject;
-
-  NewInstanceConfiguration(this.continuation, this.newObject)
-      : super(null, new State.initial());
-
-  Configuration step(StatementExecuter _) {
-    return continuation(newObject);
-  }
-}
-
-/// Represents the configuration for applying an [ExpressionContinuation].
+/// Configuration for applying [ExpressionContinuation] to a [Value].
 class ValuePassingConfiguration extends Configuration {
   final ExpressionContinuation continuation;
   final Value value;
 
   ValuePassingConfiguration(this.continuation, this.value);
 
   Configuration step(StatementExecuter _) => continuation(value);
 }
 
-/// Represents the configuration for applying an [ApplicationContinuation].
+/// Configuration for applying an [ApplicationContinuation] to a
+/// `List<InterpreterValue>`.
 class ApplicationConfiguration extends Configuration {
   final ApplicationContinuation continuation;
   final List<InterpreterValue> values;
 
   ApplicationConfiguration(this.continuation, this.values);
 
   Configuration step(StatementExecuter _) => continuation(values);
 }
 
 // ------------------------------------------------------------------------
 //            Interpreter Expressions and Values
 // ------------------------------------------------------------------------
+
 abstract class InterpreterExpression {
   Expression get expression;
 
   InterpreterValue assignValue(Value v);
 }
 
 class PositionalExpression extends InterpreterExpression {
   final Expression expression;
 
   PositionalExpression(this.expression);
 
   InterpreterValue assignValue(Value v) => new PositionalValue(v);
 }
 
 class NamedExpression extends InterpreterExpression {
   final String name;
   final Expression expression;
 
   NamedExpression(this.name, this.expression);
   InterpreterValue assignValue(Value v) => new NamedValue(name, v);
 }
 
-class LocalInitializerExpression extends InterpreterExpression {
-  final VariableDeclaration variable;
-
-  Expression get expression => variable.initializer;
-
-  LocalInitializerExpression(this.variable);
-
-  InterpreterValue assignValue(Value v) =>
-      new LocalInitializerValue(variable, v);
-}
-
 class FieldInitializerExpression extends InterpreterExpression {
   final Field field;
   final Expression expression;
 
   FieldInitializerExpression(this.field, this.expression);
 
   InterpreterValue assignValue(Value v) => new FieldInitializerValue(field, v);
 }
 
 abstract class InterpreterValue {
   Value get value;
 }
 
 class PositionalValue extends InterpreterValue {
   final Value value;
 
   PositionalValue(this.value);
 }
 
 class NamedValue extends InterpreterValue {
   final String name;
   final Value value;
 
   NamedValue(this.name, this.value);
 }
 
-class LocalInitializerValue extends InterpreterValue {
-  final VariableDeclaration variable;
-  final Value value;
-
-  LocalInitializerValue(this.variable, this.value);
-}
-
 class FieldInitializerValue extends InterpreterValue {
   final Field field;
   final Value value;
 
   FieldInitializerValue(this.field, this.value);
 }
 
 abstract class Continuation {}
 
+// ------------------------------------------------------------------------
+//                        Statement Continuations
+// ------------------------------------------------------------------------
+
+/// Represents a the continuation for the execution of the next statement of
+/// the program.
+///
+/// There are various kinds of [StatementContinuation]s and their names are
+/// suffixed with "SK".
+abstract class StatementContinuation extends Continuation {
+  Configuration call(Environment env);
+}
+
+/// Applies the expression continuation to the provided value.
+class ExitSK extends StatementContinuation {
+  final ExpressionContinuation continuation;
+  final Value value;
+
+  ExitSK(this.continuation, this.value);
+
+  Configuration call(Environment _) =>
+      new ValuePassingConfiguration(continuation, value);
+}
+
+/// Executes the next statement from a block with the corresponding environment
+/// or proceeds with next statement continuation.
+class BlockSK extends StatementContinuation {
+  final List<Statement> statements;
+  final Environment enclosingEnv;
+  final State state;
+
+  BlockSK(this.statements, this.enclosingEnv, this.state);
+
+  BlockSK.fromConfig(this.statements, ExecConfiguration conf)
+      : enclosingEnv = conf.environment,
+        state = conf.state;
+
+  Configuration call(Environment env) {
+    if (statements.isEmpty) {
+      return new ForwardConfiguration(state.continuation, enclosingEnv);
+    }
+    // Proceed with the execution statement when there are some remaining to
+    // be executed.
+    var cont = new BlockSK(statements.skip(1).toList(), enclosingEnv, state);
+    return new ExecConfiguration(
+        statements.first, env, state.withContinuation(cont));
+  }
+}
+
+class NewSK extends StatementContinuation {
+  final ExpressionContinuation continuation;
+  final Location location;
+
+  NewSK(this.continuation, this.location);
+
+  Configuration call(Environment _) =>
+      new ValuePassingConfiguration(continuation, location.value);
+}
+
+class WhileConditionSK extends StatementContinuation {
+  final Expression condition;
+  final Statement body;
+  final Environment enclosingEnv;
+  final State state;
+
+  WhileConditionSK(this.condition, this.body, this.enclosingEnv, this.state);
+
+  Configuration call(Environment _) {
+    // Evaluate the condition for the while loop execution.
+    var cont = new WhileConditionEK(condition, body, enclosingEnv, state);
+    return new EvalConfiguration(condition, enclosingEnv, cont);
+  }
+}
+
+// ------------------------------------------------------------------------
+//                       Application Continuations
+// ------------------------------------------------------------------------
+
 /// Represents the continuation called after the evaluation of argument
 /// expressions.
 ///
 /// There are various kinds of [ApplicationContinuation] and their names are
 /// suffixed with "A".
 abstract class ApplicationContinuation extends Continuation {
   Configuration call(List<InterpreterValue> values);
 
   /// Binds actual argument values to formal parameters of the function in a
   /// new environment or in the provided initial environment.
   /// TODO: Add checks for validation of arguments according to spec.
   static Environment createEnvironment(
       FunctionNode function, List<InterpreterValue> args,
       [Environment parentEnv]) {
-    Environment newEnv = new Environment(parentEnv);
+    Environment newEnv = new Environment(parentEnv ?? new Environment.empty());
+
     List<PositionalValue> positional = args.reversed
         .where((InterpreterValue av) => av is PositionalValue)
         .toList();
 
     // Add positional parameters.
     for (int i = 0; i < positional.length; ++i) {
-      newEnv.expand(function.positionalParameters[i], positional[i].value);
+      newEnv =
+          newEnv.extend(function.positionalParameters[i], positional[i].value);
     }
 
     Map<String, Value> named = new Map.fromIterable(
         args.where((InterpreterValue av) => av is NamedValue),
         key: (NamedValue av) => av.name,
         value: (NamedValue av) => av.value);
 
     // Add named parameters.
     for (VariableDeclaration v in function.namedParameters) {
-      newEnv.expand(v, named[v.name.toString()]);
+      newEnv = newEnv.extend(v, named[v.name.toString()]);
     }
 
     return newEnv;
   }
 }
 
+/// Represents the application continuation called after the evaluation of all
+/// argument expressions for an invocation.
+class ValueA extends ApplicationContinuation {
+  final InterpreterValue value;
+  final ApplicationContinuation applicationContinuation;
+
+  ValueA(this.value, this.applicationContinuation);
+
+  Configuration call(List<InterpreterValue> args) {
+    args.add(value);
+    return new ApplicationConfiguration(applicationContinuation, args);
+  }
+}
+
 class StringConcatenationA extends ApplicationContinuation {
   final ExpressionContinuation continuation;
 
   StringConcatenationA(this.continuation);
 
   Configuration call(List<InterpreterValue> values) {
     StringBuffer result = new StringBuffer();
     for (InterpreterValue v in values.reversed) {
       result.write(v.value.value);
     }
     return new ValuePassingConfiguration(
         continuation, new StringValue(result.toString()));
   }
 }
 
 /// Represents the application continuation for static invocation.
 class StaticInvocationA extends ApplicationContinuation {
   final FunctionNode function;
   final ExpressionContinuation continuation;
 
   StaticInvocationA(this.function, this.continuation);
 
   Configuration call(List<InterpreterValue> argValues) {
     Environment functionEnv =
         ApplicationContinuation.createEnvironment(function, argValues);
+    State bodyState = new State(
+        null, continuation, new ExitSK(continuation, Value.nullInstance));
 
-    State bodyState = new State.initial()
-        .withExpressionContinuation(continuation)
-        .withConfiguration(new ExitConfiguration(continuation))
-        .withEnvironment(functionEnv);
-    return new ExecConfiguration(function.body, bodyState);
-  }
-}
-
-/// Represents the application continuation for constructor invocation applied
-/// on the list of evaluated arguments.
-class ConstructorInvocationA extends ApplicationContinuation {
-  final Constructor constructor;
-  final ExpressionContinuation continuation;
-
-  ConstructorInvocationA(this.constructor, this.continuation);
-
-  Configuration call(List<InterpreterValue> argValues) {
-    Environment ctrEnv = ApplicationContinuation.createEnvironment(
-        constructor.function, argValues);
-
-    var class_ = new Class(constructor.enclosingClass.reference);
-    var newObject =
-        new ObjectValue(class_, new List<Value>(class_.instanceSize));
-
-    return new ObjectInitializationConfiguration(
-        constructor,
-        new InstanceEnvironment(newObject, ctrEnv),
-        new NewInstanceConfiguration(continuation, newObject));
-  }
-}
-
-/// Represents the application continuation for redirecting constructor
-/// invocation applied on the list of evaluated arguments.
-class RedirectingConstructorA extends ApplicationContinuation {
-  final Constructor constructor;
-  final Environment environment;
-  final ExecConfiguration configuration;
-
-  RedirectingConstructorA(
-      this.constructor, this.environment, this.configuration);
-
-  Configuration call(List<InterpreterValue> argValues) {
-    Value object = environment.thisInstance;
-    Environment ctrEnv = ApplicationContinuation.createEnvironment(
-        constructor.function,
-        argValues,
-        new InstanceEnvironment(object, new Environment.empty()));
-
-    return new ObjectInitializationConfiguration(
-        constructor, ctrEnv, configuration);
-  }
-}
-
-/// Represents the application continuation for super constructor
-/// invocation applied on the list of evaluated arguments.
-class SuperConstructorA extends ApplicationContinuation {
-  final Constructor constructor;
-  final Environment environment;
-  final ExecConfiguration configuration;
-
-  SuperConstructorA(this.constructor, this.environment, this.configuration);
-
-  Configuration call(List<InterpreterValue> argValues) {
-    Value object = environment.thisInstance;
-
-    Environment superEnv = ApplicationContinuation.createEnvironment(
-        constructor.function,
-        argValues,
-        new InstanceEnvironment(object, new Environment.empty()));
-
-    return new ObjectInitializationConfiguration(
-        constructor, superEnv, configuration);
-  }
-}
-
-/// Represents the configuration for execution of initializer and
-/// constructor body statements for initialization of a newly allocated object.
-class ObjectInitializationConfiguration extends Configuration {
-  final Constructor constructor;
-  final Environment environment;
-  final ExecConfiguration configuration;
-
-  ObjectInitializationConfiguration(
-      this.constructor, this.environment, this.configuration);
-
-  Configuration step(StatementExecuter _) {
-    if (constructor.initializers.isNotEmpty &&
-        constructor.initializers.last is RedirectingInitializer) {
-      // Constructor is redirecting.
-      Initializer initializer = constructor.initializers.first;
-      if (initializer is RedirectingInitializer) {
-        var app = new RedirectingConstructorA(
-            initializer.target, environment, configuration);
-        var args = _createArgumentExpressionList(
-            initializer.arguments, initializer.target.function);
-
-        return new EvalListConfiguration(args, environment, app);
-      }
-      // Redirecting initializer is not the only initializer.
-      for (Initializer i in constructor.initializers.reversed.skip(1)) {
-        assert(i is LocalInitializer);
-      }
-      var class_ = new Class(constructor.enclosingClass.reference);
-      var initEnv = new Environment(environment);
-      var cont = new InitializerEK(
-          class_, initEnv, constructor.initializers, configuration);
-      return new EvalConfiguration(
-          (initializer as LocalInitializer).variable.initializer,
-          initEnv,
-          cont);
-    }
-
-    // Set head of configurations to be executed to configuration for current
-    // constructor body.
-    var state = new State.initial()
-        .withEnvironment(environment)
-        .withConfiguration(configuration);
-    var bodyConfig = new ExecConfiguration(constructor.function.body, state);
-
-    // Initialize fields in immediately enclosing class.
-    var cont = new InstanceFieldsA(constructor, environment, bodyConfig);
-    var fieldExpressions = _createInstanceInitializers(constructor);
-
-    return new EvalListConfiguration(
-        fieldExpressions, new Environment.empty(), cont);
-  }
-
-  /// Creates a list of expressions for instance field initializers in
-  /// immediately enclosing class.
-  static List<InterpreterExpression> _createInstanceInitializers(
-      Constructor ctr) {
-    Class currentClass = new Class(ctr.enclosingClass.reference);
-    List<InterpreterExpression> es = <InterpreterExpression>[];
-
-    for (int i = currentClass.superclass?.instanceSize ?? 0;
-        i < currentClass.instanceSize;
-        i++) {
-      Field current = currentClass.instanceFields[i];
-      if (current.initializer != null) {
-        es.add(new FieldInitializerExpression(current, current.initializer));
-      }
-    }
-
-    return es;
-  }
-}
-
-/// Represents the application continuation applied on the list of evaluated
-/// field initializer expressions.
-class InstanceFieldsA extends ApplicationContinuation {
-  final Constructor constructor;
-  final Environment environment;
-  final ExecConfiguration configuration;
-
-  final Class _currentClass;
-  final ObjectValue _newObject;
-
-  InstanceFieldsA(this.constructor, this.environment, this.configuration)
-      : _currentClass = new Class(constructor.enclosingClass.reference),
-        _newObject = environment.thisInstance;
-
-  Configuration call(List<InterpreterValue> fieldValues) {
-    for (FieldInitializerValue current in fieldValues.reversed) {
-      _currentClass.setProperty(_newObject, current.field, current.value);
-    }
-
-    if (constructor.initializers.isEmpty) {
-      _initializeNullFields(_currentClass, _newObject);
-      return configuration;
-    }
-
-    // Produce next configuration.
-    if (constructor.initializers.first is SuperInitializer) {
-      // SuperInitializer appears last in the initializer list.
-      assert(constructor.initializers.length == 1);
-      SuperInitializer current = constructor.initializers.first;
-      var args = _createArgumentExpressionList(
-          current.arguments, current.target.function);
-
-      var superApp =
-          new SuperConstructorA(current.target, environment, configuration);
-      _initializeNullFields(_currentClass, _newObject);
-      return new EvalListConfiguration(args, environment, superApp);
-    }
-
-    Class class_ = new Class(constructor.enclosingClass.reference);
-    Environment initEnv = new Environment(environment);
-
-    var cont = new InitializerEK(
-        class_, initEnv, constructor.initializers, configuration);
-    return new EvalConfiguration(
-        _getExpression(constructor.initializers.first), initEnv, cont);
-  }
-}
-
-/// Represents the expression continuation applied on the list of evaluated
-/// initializer expressions preceding a super call in the list.
-class InitializerEK extends ExpressionContinuation {
-  final Class currentClass;
-  final Environment initializerEnvironment;
-  final List<Initializer> initializers;
-  final ExecConfiguration configuration;
-
-  InitializerEK(this.currentClass, this.initializerEnvironment,
-      this.initializers, this.configuration);
-
-  Configuration call(Value v) {
-    ObjectValue newObject = initializerEnvironment.thisInstance;
-    Initializer current = initializers.first;
-    if (current is FieldInitializer) {
-      currentClass.setProperty(newObject, current.field, v);
-    } else if (current is LocalInitializer) {
-      initializerEnvironment.expand(current.variable, v);
-    } else {
-      throw 'Assigning value $v to ${current.runtimeType}';
-    }
-
-    if (initializers.length <= 1) {
-      _initializeNullFields(currentClass, newObject);
-      return configuration;
-    }
-
-    Initializer next = initializers[1];
-
-    if (next is RedirectingInitializer) {
-      // RedirectingInitializer appears last in the initializer list.
-      assert(initializers.length == 2);
-      var app = new RedirectingConstructorA(
-          next.target, initializerEnvironment, configuration);
-      var args =
-          _createArgumentExpressionList(next.arguments, next.target.function);
-      return new EvalListConfiguration(args, initializerEnvironment, app);
-    }
-
-    if (next is SuperInitializer) {
-      // SuperInitializer appears last in the initializer list.
-      assert(initializers.length == 2);
-      var args =
-          _createArgumentExpressionList(next.arguments, next.target.function);
-      var superApp = new SuperConstructorA(
-          next.target, initializerEnvironment, configuration);
-      _initializeNullFields(currentClass, newObject);
-      return new EvalListConfiguration(args, initializerEnvironment, superApp);
-    }
-
-    var cont = new InitializerEK(currentClass, initializerEnvironment,
-        initializers.skip(1).toList(), configuration);
-    return new EvalConfiguration(
-        _getExpression(next), initializerEnvironment, cont);
-  }
-}
-
-/// Represents the application continuation called after the evaluation of all
-/// argument expressions for an invocation.
-class ValueA extends ApplicationContinuation {
-  final InterpreterValue value;
-  final ApplicationContinuation applicationContinuation;
-
-  ValueA(this.value, this.applicationContinuation);
-
-  Configuration call(List<InterpreterValue> args) {
-    args.add(value);
-    return new ApplicationConfiguration(applicationContinuation, args);
+    return new ExecConfiguration(function.body, functionEnv, bodyState);
   }
 }
 
 // ------------------------------------------------------------------------
 //                           Expression Continuations
 // ------------------------------------------------------------------------
+
 /// Represents an expression continuation.
 ///
 /// There are various kinds of [ExpressionContinuation]s and their names are
 /// suffixed with "EK".
 abstract class ExpressionContinuation extends Continuation {
   Configuration call(Value v);
 }
 
 /// Represents a continuation that returns the next [ExecConfiguration]
 /// to be executed.
 class ExpressionEK extends ExpressionContinuation {
-  final ExecConfiguration configuration;
+  final StatementContinuation continuation;
+  final Environment environment;
 
-  ExpressionEK(this.configuration);
+  ExpressionEK(this.continuation, this.environment);
 
   Configuration call(Value _) {
-    return configuration;
+    return new ForwardConfiguration(continuation, environment);
   }
 }
 
 class PrintEK extends ExpressionContinuation {
   final ExpressionContinuation continuation;
 
   PrintEK(this.continuation);
 
   Configuration call(Value v) {
     log.info('print(${v.value.runtimeType}: ${v.value})\n');
@@ skipping 173 matching lines @@
 class LetEK extends ExpressionContinuation {
   final VariableDeclaration variable;
   final Expression letBody;
   final Environment environment;
   final ExpressionContinuation continuation;
 
   LetEK(this.variable, this.letBody, this.environment, this.continuation);
 
   Configuration call(Value value) {
     var letEnv = new Environment(environment);
-    letEnv.expand(variable, value);
+    letEnv.extend(variable, value);
     return new EvalConfiguration(letBody, letEnv, continuation);
   }
 }
 
 /// Represents the continuation for the condition expression in [WhileStatement].
 class WhileConditionEK extends ExpressionContinuation {
-  final WhileStatement node;
+  final Expression condition;
+  final Statement body;
+  final Environment enclosingEnv;
   final State state;
 
-  WhileConditionEK(this.node, this.state);
+  WhileConditionEK(this.condition, this.body, this.enclosingEnv, this.state);
 
-  ExecConfiguration call(Value v) {
-    if (identical(v, Value.trueInstance)) {
-      // Add configuration for the While statement to the linked list.
-      ExecConfiguration config = new ExecConfiguration(node, state);
-      // Configuration for the body of the loop.
-      return new ExecConfiguration(node.body, state.withConfiguration(config));
+  Configuration call(Value v) {
+    if (identical(v, Value.falseInstance)) {
+      return new ForwardConfiguration(state.continuation, enclosingEnv);
     }
-
-    return state.statementConfiguration;
+    var cont = new WhileConditionSK(condition, body, enclosingEnv, state);
+    return new ExecConfiguration(
+        body, enclosingEnv, state.withContinuation(cont));
   }
 }
 
 /// Represents the continuation for the condition expression in [IfStatement].
 class IfConditionEK extends ExpressionContinuation {
   final Statement then;
   final Statement otherwise;
+  final Environment environment;
   final State state;
 
-  IfConditionEK(this.then, this.otherwise, this.state);
+  IfConditionEK(this.then, this.otherwise, this.environment, this.state);
 
-  ExecConfiguration call(Value v) {
+  Configuration call(Value v) {
     if (identical(v, Value.trueInstance)) {
       log.info("if-then\n");
-      return new ExecConfiguration(then, state);
+      return new ExecConfiguration(then, environment, state);
     } else if (otherwise != null) {
       log.info("if-otherwise\n");
-      return new ExecConfiguration(otherwise, state);
+      return new ExecConfiguration(otherwise, environment, state);
     }
-    return state.statementConfiguration;
+    return new ForwardConfiguration(state.continuation, environment);
   }
 }
 
 /// Represents the continuation for the initializer expression in
 /// [VariableDeclaration].
 class VariableInitializerEK extends ExpressionContinuation {
   final VariableDeclaration variable;
   final Environment environment;
-  final ExecConfiguration nextConfiguration;
+  final StatementContinuation continuation;
 
-  VariableInitializerEK(
-      this.variable, this.environment, this.nextConfiguration);
+  VariableInitializerEK(this.variable, this.environment, this.continuation);
 
-  ExecConfiguration call(Value v) {
-    environment.expand(variable, v);
-    return nextConfiguration;
+  Configuration call(Value v) {
+    return new ForwardConfiguration(
+        continuation, environment.extend(variable, v));
   }
 }
 
 /// 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, State> {
+/// - 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, in which case the return continuation is
+/// returned and applied accordingly.
+/// - It throws, in which case the handler is returned and applied accordingly.
+class StatementExecuter
+    extends StatementVisitor1<Configuration, ExecConfiguration> {
   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 exec(Statement statement, ExecConfiguration conf) =>
+      statement.accept1(this, conf);
   Configuration eval(Expression expression, EvalConfiguration config) =>
       evaluator.eval(expression, config);
   Configuration evalList(
           List<InterpreterExpression> es, Environment env, Continuation cont) =>
       evaluator.evalList(es, env, cont);
 
-  Configuration defaultStatement(Statement node, State state) {
+  Configuration defaultStatement(Statement node, ExecConfiguration conf) {
     throw notImplemented(
         m: "Execution is not implemented for statement:\n$node ");
   }
 
-  Configuration visitInvalidStatement(InvalidStatement node, State state) {
+  Configuration visitInvalidStatement(
+      InvalidStatement node, ExecConfiguration conf) {
     throw "Invalid statement at ${node.location}";
   }
 
   Configuration visitExpressionStatement(
-      ExpressionStatement node, State state) {
-    var cont = new ExpressionEK(state.statementConfiguration);
-    return new EvalConfiguration(node.expression, state.environment, cont);
+      ExpressionStatement node, ExecConfiguration conf) {
+    var cont = new ExpressionEK(conf.state.continuation, conf.environment);
+    return new EvalConfiguration(node.expression, conf.environment, cont);
   }
 
-  Configuration visitBlock(Block node, State state) {
+  Configuration visitBlock(Block node, ExecConfiguration conf) {
     if (node.statements.isEmpty) {
-      return state.statementConfiguration;
+      return new ForwardConfiguration(
+          conf.state.continuation, conf.environment);
     }
-    State blockState =
-        state.withEnvironment(new Environment(state.environment));
-    ExecConfiguration configuration = state.statementConfiguration;
-    for (Statement s in node.statements.reversed) {
-      configuration =
-          new ExecConfiguration(s, blockState.withConfiguration(configuration));
-    }
-    return configuration;
+
+    var env = new Environment(conf.environment);
+    var cont = new BlockSK.fromConfig(node.statements.skip(1).toList(), conf);
+    return new ExecConfiguration(
+        node.statements.first, env, conf.state.withContinuation(cont));
   }
 
-  Configuration visitEmptyStatement(EmptyStatement node, State state) {
-    return state.statementConfiguration;
+  Configuration visitEmptyStatement(
+      EmptyStatement node, ExecConfiguration conf) {
+    return new ForwardConfiguration(conf.state.continuation, conf.environment);
   }
 
-  Configuration visitIfStatement(IfStatement node, State state) {
-    var cont = new IfConditionEK(node.then, node.otherwise, state);
+  Configuration visitIfStatement(IfStatement node, ExecConfiguration conf) {
+    var cont = new IfConditionEK(
+        node.then, node.otherwise, conf.environment, conf.state);
 
-    return new EvalConfiguration(node.condition, state.environment, cont);
+    return new EvalConfiguration(node.condition, conf.environment, cont);
   }
 
-  Configuration visitLabeledStatement(LabeledStatement node, State state) {
-    return new ExecConfiguration(node.body, state.withBreak(node));
+  Configuration visitLabeledStatement(
+      LabeledStatement node, ExecConfiguration conf) {
+    return new ExecConfiguration(node.body, conf.environment,
+        conf.state.withBreak(node, conf.environment));
   }
 
-  Configuration visitBreakStatement(BreakStatement node, State state) {
-    return state.lookupLabel(node.target).configuration;
+  Configuration visitBreakStatement(
+      BreakStatement node, ExecConfiguration conf) {
+    Label l = conf.state.lookupLabel(node.target);
+    return new ForwardConfiguration(l.continuation, l.environment);
   }
 
-  Configuration visitWhileStatement(WhileStatement node, State state) {
-    var cont = new WhileConditionEK(node, state);
+  Configuration visitWhileStatement(
+      WhileStatement node, ExecConfiguration conf) {
+    var cont = new WhileConditionEK(
+        node.condition, node.body, conf.environment, conf.state);
 
-    return new EvalConfiguration(node.condition, state.environment, cont);
+    return new EvalConfiguration(node.condition, conf.environment, cont);
   }
 
-  Configuration visitDoStatement(DoStatement node, State state) {
-    WhileStatement whileStatement =
-        new WhileStatement(node.condition, node.body);
-    ExecConfiguration configuration =
-        new ExecConfiguration(whileStatement, state);
+  Configuration visitDoStatement(DoStatement node, ExecConfiguration conf) {
+    var cont = new WhileConditionSK(
+        node.condition, node.body, conf.environment, conf.state);
 
     return new ExecConfiguration(
-        node.body, state.withConfiguration(configuration));
+        node.body, conf.environment, conf.state.withContinuation(cont));
   }
 
-  Configuration visitReturnStatement(ReturnStatement node, State state) {
-    assert(state.returnContinuation != null);
+  Configuration visitReturnStatement(
+      ReturnStatement node, ExecConfiguration conf) {
+    assert(conf.state.returnContinuation != null);
     log.info('return\n');
     if (node.expression == null) {
       return new ValuePassingConfiguration(
-          state.returnContinuation, Value.nullInstance);
+          conf.state.returnContinuation, Value.nullInstance);
     }
 
     return new EvalConfiguration(
-        node.expression, state.environment, state.returnContinuation);
+        node.expression, conf.environment, conf.state.returnContinuation);
   }
 
   Configuration visitVariableDeclaration(
-      VariableDeclaration node, State state) {
+      VariableDeclaration node, ExecConfiguration conf) {
     if (node.initializer != null) {
       var cont = new VariableInitializerEK(
-          node, state.environment, state.statementConfiguration);
-      return new EvalConfiguration(node.initializer, state.environment, cont);
+          node, conf.environment, conf.state.continuation);
+      return new EvalConfiguration(node.initializer, conf.environment, cont);
     }
-    state.environment.expand(node, Value.nullInstance);
-    return state.statementConfiguration;
+    return new ForwardConfiguration(conf.state.continuation,
+        conf.environment.extend(node, Value.nullInstance));
   }
 }
 
 // ------------------------------------------------------------------------
 //                                VALUES
 // ------------------------------------------------------------------------
 
 typedef Value Getter(Value receiver);
 typedef void Setter(Value receiver, Value value);
 
@@ skipping 277 matching lines @@
 void _initializeNullFields(Class class_, ObjectValue newObject) {
   int superClassSize = class_.superclass?.instanceSize ?? 0;
   for (int i = superClassSize; i < class_.instanceSize; i++) {
     Field field = class_.instanceFields[i];
     if (class_.getProperty(newObject, field) == null) {
       assert(field.initializer == null);
       class_.setProperty(newObject, field, Value.nullInstance);
     }
   }
 }