Add support for execution of constructor body

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 29 matching lines @@
   final VariableDeclaration variable;
   Value value;
 
   Binding(this.variable, this.value);
 }
 
 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;
   }
 
@@ skipping 13 matching lines @@
     assert(contains(variable));
     lookupBinding(variable).value = value;
   }
 
   void expand(VariableDeclaration variable, Value value) {
     assert(!contains(variable));
     bindings.add(new Binding(variable, 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, ExpressionConfiguration> {
   Configuration eval(Expression expr, ExpressionConfiguration config) =>
       expr.accept1(this, config);
 
   Configuration evalList(List<InterpreterExpression> list, Environment env,
       ApplicationContinuation cont) {
     if (list.isNotEmpty) {
       return new ExpressionConfiguration(list.first.expression, env,
@@ skipping 69 matching lines @@
     // 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, config.environment, config.continuation);
 
     return new ExpressionConfiguration(node.receiver, config.environment, cont);
   }
 
   Configuration visitConstructorInvocation(
       ConstructorInvocation node, ExpressionConfiguration config) {
-    // Currently, the bodies of the constructors are not executed.
-    // Currently initializer list is executed only for redirecting
-    // constructors.
-    if (node.target.function.body is! EmptyStatement) {
-      throw 'Execution for body of constructor is not implemented.';
-    }
-
     ApplicationContinuation cont =
         new ConstructorInvocationApplication(node.target, config.continuation);
-
     var args =
         _createArgumentExpressionList(node.arguments, node.target.function);
 
     return new ExpressionListConfiguration(args, config.environment, cont);
   }
 
   Configuration visitNot(Not node, ExpressionConfiguration config) {
     return new ExpressionConfiguration(node.operand, config.environment,
         new NotContinuation(config.continuation));
   }
@@ skipping 23 matching lines @@
   Configuration visitStringConcatenation(
       StringConcatenation node, ExpressionConfiguration config) {
     var cont = new StringConcatenationContinuation(config.continuation);
     var expressions = node.expressions
         .map((Expression e) => new PositionalExpression(e))
         .toList();
     return new ExpressionListConfiguration(
         expressions, config.environment, cont);
   }
 
+  Configuration visitThisExpression(
+      ThisExpression node, ExpressionConfiguration config) {
+    return new ContinuationConfiguration(
+        config.continuation, config.environment.thisInstance);
+  }
+
   // Evaluation of BasicLiterals.
   Configuration visitStringLiteral(
       StringLiteral node, ExpressionConfiguration config) {
     return new ContinuationConfiguration(
         config.continuation, new StringValue(node.value));
   }
 
   Configuration visitIntLiteral(
       IntLiteral node, ExpressionConfiguration config) {
     return new ContinuationConfiguration(
@@ skipping 93 matching lines @@
 
   Configuration step(StatementExecuter executer) =>
       executer.exec(statement, state);
 }
 
 class ExitConfiguration extends StatementConfiguration {
   final ExpressionContinuation returnContinuation;
 
   ExitConfiguration(this.returnContinuation) : super(null, null);
 
-  Configuration step(StatementExecuter executer) {
+  Configuration step(StatementExecuter _) {
     return returnContinuation(Value.nullInstance);
   }
 }
 
+class NewInstanceConfiguration extends StatementConfiguration {
+  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].
 class ContinuationConfiguration extends Configuration {
   final ExpressionContinuation continuation;
   final Value value;
 
   ContinuationConfiguration(this.continuation, this.value);
 
   Configuration step(StatementExecuter _) => continuation(value);
 }
 
@@ skipping 109 matching lines @@
   FieldInitializerValue(this.field, this.value);
 }
 
 abstract class Continuation {}
 
 /// Represents the continuation called after the evaluation of argument
 /// expressions.
 abstract class ApplicationContinuation extends Continuation {
   Configuration call(List<InterpreterValue> values);
 
-  /// Creates an environment binding actual argument values to formal parameters
-  /// of the function in a new environment, which is used to execute the
-  /// body od the function.
+  /// 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 newEnv = new Environment.empty();
+      FunctionNode function, List<InterpreterValue> args,
+      [Environment parentEnv]) {
+    Environment newEnv = new Environment(parentEnv);
     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);
     }
 
     Map<String, Value> named = new Map.fromIterable(
@@ skipping 38 matching lines @@
   ConstructorInvocationApplication(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));
 
-    var cont =
-        new ObjectInitializationContinuation(constructor, ctrEnv, continuation);
-
-    return new ContinuationConfiguration(cont, newObject);
+    return new ObjectInitializationConfiguration(
+        constructor,
+        new InstanceEnvironment(newObject, ctrEnv),
+        new NewInstanceConfiguration(continuation, newObject));

[Dmitry Stefantsov, 2017/05/18 12:56:51]

I think this statement would be hard to translate to a CEK machine transition.
The reason is that here we assume that 'newObject' is mutable. We pass the
reference to 'NewInstanceConfiguration', and it will return an object that is
referenced by 'newObject', and it will be initialized at that point.

My plan of how we may avoid it is not to create 'NewInstanceConfiguration' here,
but rather delay it until the moment when 'newObject' is fully initialized. Here
we may just pass the necessary part, i.e. 'continuation'.

   }
 }
 
 /// Represents the application continuation for redirecting constructor
 /// invocation applied on the list of evaluated arguments.
 class RedirectingConstructorApplication extends ApplicationContinuation {
-  final ObjectValue newObject;
   final Constructor constructor;
-  final ExpressionContinuation continuation;
+  final Environment environment;
+  final StatementConfiguration configuration;
 
   RedirectingConstructorApplication(
-      this.newObject, this.constructor, this.continuation);
+      this.constructor, this.environment, this.configuration);
 
   Configuration call(List<InterpreterValue> argValues) {
+    Value object = environment.thisInstance;
     Environment ctrEnv = ApplicationContinuation.createEnvironment(
-        constructor.function, argValues);
-    var cont =
-        new ObjectInitializationContinuation(constructor, ctrEnv, continuation);
-    return new ContinuationConfiguration(cont, newObject);
+        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 SuperConstructorApplication extends ApplicationContinuation {
-  final ObjectValue newObject;
   final Constructor constructor;
-  // TODO: remember to execute body of previous ctr.
-  final ExpressionContinuation continuation;
+  final Environment environment;
+  final StatementConfiguration configuration;
 
   SuperConstructorApplication(
-      this.newObject, this.constructor, this.continuation);
+      this.constructor, this.environment, this.configuration);
 
   Configuration call(List<InterpreterValue> argValues) {
-    Environment ctrEnv = ApplicationContinuation.createEnvironment(
-        constructor.function, argValues);
-    var cont =
-        new ObjectInitializationContinuation(constructor, ctrEnv, continuation);
-    return new ContinuationConfiguration(cont, newObject);
+    Value object = environment.thisInstance;
+
+    Environment superEnv = ApplicationContinuation.createEnvironment(
+        constructor.function,
+        argValues,
+        new InstanceEnvironment(object, new Environment.empty()));
+
+    return new ObjectInitializationConfiguration(
+        constructor, superEnv, configuration);
   }
 }
 
-class ObjectInitializationContinuation extends ExpressionContinuation {
+/// 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 ExpressionContinuation continuation;
+  final StatementConfiguration configuration;
 
-  ObjectInitializationContinuation(
-      this.constructor, this.environment, this.continuation);
+  ObjectInitializationConfiguration(
+      this.constructor, this.environment, this.configuration);
 
-  Configuration call(Value v) {
+  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 RedirectingConstructorApplication(
-            v, initializer.target, continuation);
+            initializer.target, environment, configuration);
         var args = _createArgumentExpressionList(
             initializer.arguments, initializer.target.function);
 
         return new ExpressionListConfiguration(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 InitializerContinuation(
-          v, class_, environment, constructor.initializers, continuation);
+          class_, initEnv, constructor.initializers, configuration);
       return new ExpressionConfiguration(
           (initializer as LocalInitializer).variable.initializer,
-          environment,
+          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 StatementConfiguration(constructor.function.body, state);
+
     // Initialize fields in immediately enclosing class.
-    var cont = new InstanceFieldsApplication(
-        v, constructor, environment, continuation);
+    var cont =
+        new InstanceFieldsApplication(constructor, environment, bodyConfig);
     var fieldExpressions = _createInstanceInitializers(constructor);
 
     return new ExpressionListConfiguration(
         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 InstanceFieldsApplication extends ApplicationContinuation {
-  final ObjectValue newObject;
   final Constructor constructor;
   final Environment environment;
-  final ExpressionContinuation expressionContinuation;
+  final StatementConfiguration configuration;
 
   final Class _currentClass;
+  final ObjectValue _newObject;
 
-  InstanceFieldsApplication(this.newObject, this.constructor, this.environment,
-      this.expressionContinuation)
-      : _currentClass = new Class(constructor.enclosingClass.reference);
+  InstanceFieldsApplication(
+      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);
+      _currentClass.setProperty(_newObject, current.field, current.value);
     }
 
     if (constructor.initializers.isEmpty) {
-      _initializeNullFields(_currentClass, newObject);
-      return new ContinuationConfiguration(expressionContinuation, newObject);
+      _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 SuperConstructorApplication(
-          newObject, current.target, expressionContinuation);
-      _initializeNullFields(_currentClass, newObject);
+          current.target, environment, configuration);
+      _initializeNullFields(_currentClass, _newObject);
       return new ExpressionListConfiguration(args, environment, superApp);
     }
 
     Class class_ = new Class(constructor.enclosingClass.reference);
     Environment initEnv = new Environment(environment);
 
-    var cont = new InitializerContinuation(newObject, class_, initEnv,
-        constructor.initializers, expressionContinuation);
+    var cont = new InitializerContinuation(
+        class_, initEnv, constructor.initializers, configuration);
     return new ExpressionConfiguration(
         _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 InitializerContinuation extends ExpressionContinuation {
-  final ObjectValue newObject;
   final Class currentClass;
   final Environment initializerEnvironment;
   final List<Initializer> initializers;
-  final ExpressionContinuation continuation;
+  final StatementConfiguration configuration;
 
-  InitializerContinuation(this.newObject, this.currentClass,
-      this.initializerEnvironment, this.initializers, this.continuation);
+  InitializerContinuation(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) {
-      // todo: return configuration for body of ctr.
       _initializeNullFields(currentClass, newObject);
-      return new ContinuationConfiguration(continuation, newObject);
+      return configuration;
     }
 
     Initializer next = initializers[1];
 
     if (next is RedirectingInitializer) {
       // RedirectingInitializer appears last in the initializer list.
       assert(initializers.length == 2);
-      var cont = new RedirectingConstructorApplication(
-          newObject, next.target, continuation);
+      var app = new RedirectingConstructorApplication(
+          next.target, initializerEnvironment, configuration);
       var args =
           _createArgumentExpressionList(next.arguments, next.target.function);
-      return new ExpressionListConfiguration(
-          args, initializerEnvironment, cont);
+      return new ExpressionListConfiguration(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 SuperConstructorApplication(newObject, next.target, continuation);
+      var superApp = new SuperConstructorApplication(
+          next.target, initializerEnvironment, configuration);
       _initializeNullFields(currentClass, newObject);
       return new ExpressionListConfiguration(
           args, initializerEnvironment, superApp);
     }
 
-    var cont = new InitializerContinuation(newObject, currentClass,
-        initializerEnvironment, initializers.skip(1).toList(), continuation);
+    var cont = new InitializerContinuation(currentClass, initializerEnvironment,
+        initializers.skip(1).toList(), configuration);
     return new ExpressionConfiguration(
         _getExpression(next), initializerEnvironment, cont);
   }
 }
 
 /// Represents the application continuation called after the evaluation of all
 /// argument expressions for an invocation.
 class ValueApplication extends ApplicationContinuation {
   final InterpreterValue value;
   final ApplicationContinuation applicationContinuation;
@@ skipping 696 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);
     }
   }
 }