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.';
-    }
+    var class_ = new Class(node.target.enclosingClass.reference);
 
-    var class_ = new Class(node.target.enclosingClass.reference);
-    var newObject =
-        new ObjectValue(class_, new List<Value>(class_.instanceSize));
-
-    ApplicationContinuation cont = new ConstructorInvocationApplication(
-        newObject, node.target, config.continuation);
-
+    var env = new InstanceEnvironment(
+        new ObjectValue(class_, new List<Value>(class_.instanceSize)),
+        new Environment.empty());
+    var nextConfig = new NewInstanceConfiguration(config.continuation, env);
+    ApplicationContinuation cont =
+        new ConstructorInvocationApplication(env, node.target, nextConfig);
     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 21 matching lines @@
   }
 
   Configuration visitStringConcatenation(
       StringConcatenation node, ExpressionConfiguration config) {
     var cont = new StringConcatenationContinuation(
         node.expressions, config.environment, config.continuation);
     return new ExpressionConfiguration(
         node.expressions.first, 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 Environment environment;
+
+  NewInstanceConfiguration(this.continuation, this.environment)
+      : super(null, new State.initial());
+
+  Configuration step(StatementExecuter _) {
+    return continuation(environment.thisInstance);
+  }
+}
+
 /// 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,
+      [parentEnv]) {
+    Environment newEnv = new Environment(parentEnv);
     List<PositionalArgumentValue> positional = args.reversed
         .where((InterpreterValue av) => av is PositionalArgumentValue)
         .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 25 matching lines @@
         .withExpressionContinuation(continuation)
         .withConfiguration(new ExitConfiguration(continuation))
         .withEnvironment(functionEnv);
     return new StatementConfiguration(function.body, bodyState);
   }
 }
 
 /// Represents the application continuation for constructor invocation applied
 /// on the list of evaluated arguments.
 class ConstructorInvocationApplication extends ApplicationContinuation {
-  final ObjectValue newObject;
+  final InstanceEnvironment instanceEnvironment;
   final Constructor constructor;
-  final ExpressionContinuation expressionContinuation;
+  final StatementConfiguration configuration;
 
   ConstructorInvocationApplication(
-      this.newObject, this.constructor, this.expressionContinuation);
+      this.instanceEnvironment, this.constructor, this.configuration);
 
   Configuration call(List<InterpreterValue> argValues) {
     Environment ctrEnv = ApplicationContinuation.createEnvironment(
-        constructor.function, argValues);
+        constructor.function, argValues, instanceEnvironment);
 
     if (constructor.initializers.isNotEmpty &&
         constructor.initializers.last is RedirectingInitializer) {
       // Constructor is redirecting.
       Initializer initializer = constructor.initializers.first;
       if (initializer is RedirectingInitializer) {
         var app = new ConstructorInvocationApplication(
-            newObject, initializer.target, expressionContinuation);
+            instanceEnvironment, initializer.target, configuration);
         var args = _createArgumentExpressionList(
             initializer.arguments, initializer.target.function);
 
         return new ExpressionListConfiguration(args, ctrEnv, 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 cont = new InitializerContinuation(newObject, class_, ctrEnv,
-          constructor.initializers, expressionContinuation);
+      var cont = new InitializerContinuation(instanceEnvironment, class_,
+          ctrEnv, constructor.initializers, configuration);
       return new ExpressionConfiguration(
           (initializer as LocalInitializer).variable.initializer, ctrEnv, cont);
     }
 
+    var newState = configuration.state
+        .withEnvironment(ctrEnv)
+        .withConfiguration(configuration);
+
+    // Set head of configurations to be executed to configuration for current
+    // constructor body.
+    var nextConfiguration =
+        new StatementConfiguration(constructor.function.body, newState);
+
     // Initialize fields in immediately enclosing class.
     var cont = new InstanceFieldsApplication(
-        newObject, constructor, ctrEnv, expressionContinuation);
+        instanceEnvironment, constructor, ctrEnv, nextConfiguration);
     var fieldExpressions = _createInstanceInitializers(constructor);
 
     return new ExpressionListConfiguration(fieldExpressions, ctrEnv, 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 InstanceEnvironment instanceEnvironment;
   final Constructor constructor;
   final Environment environment;
-  final ExpressionContinuation expressionContinuation;
+  final StatementConfiguration configuration;
 
   final Class _currentClass;
 
-  InstanceFieldsApplication(this.newObject, this.constructor, this.environment,
-      this.expressionContinuation)
+  InstanceFieldsApplication(this.instanceEnvironment, this.constructor,
+      this.environment, this.configuration)
       : _currentClass = new Class(constructor.enclosingClass.reference);
 
   Configuration call(List<InterpreterValue> fieldValues) {
+    Value newObject = instanceEnvironment.thisInstance;
     for (FieldInitializerValue current in fieldValues.reversed) {
       _currentClass.setProperty(newObject, current.field, current.value);
     }
 
     if (constructor.initializers.isEmpty) {
       _initializeNullFields(_currentClass, newObject);
-      return new ContinuationConfiguration(expressionContinuation, newObject);
+      return 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 ConstructorInvocationApplication(
-          newObject, current.target, expressionContinuation);
+          instanceEnvironment, current.target, 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(instanceEnvironment, 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 InstanceEnvironment instanceEnvironment;
   final Class currentClass;
   final Environment initializerEnvironment;

[Dmitry Stefantsov, 2017/05/16 11:06:52]

Having two environments in the same continuation really feels wrong. I think it
should be rewritten.

   final List<Initializer> initializers;
-  final ExpressionContinuation continuation;
+  final StatementConfiguration configuration;
 
-  InitializerContinuation(this.newObject, this.currentClass,
-      this.initializerEnvironment, this.initializers, this.continuation);
+  InitializerContinuation(this.instanceEnvironment, this.currentClass,
+      this.initializerEnvironment, this.initializers, this.configuration);
 
   Configuration call(Value v) {
+    Value newObject = instanceEnvironment.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 ConstructorInvocationApplication(
-          newObject, next.target, continuation);
+          instanceEnvironment, next.target, configuration);
       var args =
           _createArgumentExpressionList(next.arguments, next.target.function);
       return new ExpressionListConfiguration(
           args, initializerEnvironment, cont);
     }
 
     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 ConstructorInvocationApplication(
-          newObject, next.target, continuation);
+          instanceEnvironment, next.target, 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(instanceEnvironment, 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 710 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);
     }
   }
 }