Add support for running constructors with new

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 21 matching lines @@
     Statement statementBlock = mainMethod.function.body;
     ExecConfiguration configuration = new ExecConfiguration(
         statementBlock, new Environment.empty(), const State.initial());
     visitor.trampolinedExecution(configuration);
   }
 }
 
 class Location {
   Value value;
 
+  Location.empty();
   Location(this.value);
 }
 
 class Binding {
   final VariableDeclaration variable;
   final Location location;
 
   Binding(this.variable, this.location);
 }
 
@@ skipping 115 matching lines @@
   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);
+          _getArgumentExpressions(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) =>
-      defaultExpression(node, config);
+      ConstructorInvocation node, EvalConfiguration config) {
+    ApplicationContinuation cont =
+        new ConstructorInvocationA(node.target, config.continuation);
+    var args = _getArgumentExpressions(node.arguments, node.target.function);
+
+    return new EvalListConfiguration(args, config.environment, cont);
+  }
 
   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) =>
-      defaultExpression(node, config);
+      ThisExpression node, EvalConfiguration config) {
+    return new ValuePassingConfiguration(
+        config.continuation, config.environment.thisInstance);
+  }
 
   // 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 259 matching lines @@
       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);
   }
 }
 
+/// Applies the expression continuation to the provided value.
+class NewSK extends StatementContinuation {
+  final ExpressionContinuation continuation;
+  final Value value;
+
+  NewSK(this.continuation, this.value);
+
+  Configuration call(Environment _) =>
+      new ValuePassingConfiguration(continuation, value.value);
+}
+
+class ConstructorBodySK extends StatementContinuation {
+  final Statement body;
+  final Environment environment;
+  // todo: Add component for exception handler.
+  final StatementContinuation continuation;
+
+  ConstructorBodySK(this.body, this.environment, this.continuation);
+
+  Configuration call(Environment _) {
+    return new ExecConfiguration(
+        body, environment, new State(null, null, continuation));
+  }
+}
+
 // ------------------------------------------------------------------------
 //                       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 {
@@ skipping 70 matching lines @@
   Configuration call(List<InterpreterValue> argValues) {
     Environment functionEnv =
         ApplicationContinuation.createEnvironment(function, argValues);
     State bodyState = new State(
         null, continuation, new ExitSK(continuation, Value.nullInstance));
 
     return new ExecConfiguration(function.body, functionEnv, bodyState);
   }
 }
 
+/// Represents the application continuation for constructor invocation applied
+/// on the list of evaluated arguments when a constructor is invoked with new.
+///
+/// It creates the newly allocated object instance.
+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 newObject = new ObjectValue(constructor.enclosingClass);
+    var cont = new InitializationEK(
+        constructor, ctrEnv, new NewSK(continuation, newObject));

[Dmitry Stefantsov, 2017/07/25 11:45:07]

From the specification I get it that the second argument to [NewSK] constructor
should be a label, not a value.  Is it so?

[zhivkag, 2017/07/25 13:17:02]

Done.

+
+    return new ValuePassingConfiguration(cont, newObject);
+  }
+}
+
 // ------------------------------------------------------------------------
 //                           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);
@@ skipping 24 matching lines @@
   }
 }
 
 class PropertyGetEK extends ExpressionContinuation {
   final Name name;
   final ExpressionContinuation continuation;
 
   PropertyGetEK(this.name, this.continuation);
 
   Configuration call(Value receiver) {
-    // TODO: CPS the invocation of the getter.
     Value propertyValue = receiver.class_.lookupImplicitGetter(name)(receiver);
     return new ValuePassingConfiguration(continuation, propertyValue);
   }
 }
 
 class PropertySetEK extends ExpressionContinuation {
   final Expression value;
   final Name setterName;
   final Environment environment;
   final ExpressionContinuation continuation;
@@ skipping 201 matching lines @@
     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 StatementContinuation continuation;
-
   VariableInitializerEK(this.variable, this.environment, this.continuation);
 
   Configuration call(Value v) {
     return new ForwardConfiguration(
         continuation, environment.extend(variable, v));
   }
 }
 
+/// Expression continuation that further initializes the newly allocated object
+/// instance with running the constructor.
+class InitializationEK extends ExpressionContinuation {
+  final Constructor constructor;
+  final Environment environment;
+  // todo: Add components for exception handling support
+  final StatementContinuation continuation;
+
+  InitializationEK(this.constructor, this.environment, this.continuation);
+
+  Configuration call(Value value) {
+    if (constructor.enclosingClass.superclass.superclass != null) {
+      throw 'Support for super constructors in not implemented.';
+    }
+
+    if (constructor.initializers.isNotEmpty &&
+        !(constructor.initializers.last is SuperInitializer)) {
+      throw 'Support for initializer is not implemented.';
+    }
+
+    // The statement body is captured by the next statement continuation and
+    // expressions for field initialization are evaluated.
+    var ctrEnv = environment.extendWithThis(value);
+    var bodyCont =
+        new ConstructorBodySK(constructor.function.body, ctrEnv, continuation);
+    // todo: Add support for initialization of fields with initializers.
+    return new ForwardConfiguration(bodyCont, ctrEnv);

[Dmitry Stefantsov, 2017/07/25 11:45:07]

Shouldn't we initialize fields first?

[zhivkag, 2017/07/25 13:17:02]

Indeed, we should initialize the fields first (hence the todo remark above the
return). I was planning to do this in a separate CL just to keep the reviews
smaller. Would you prefer to have the change in this CL instead? 

[Dmitry Stefantsov, 2017/07/25 13:21:09]

No, another CL is fine.

As a side note, it would be nice to have TODOs in their usual form: in caps and
with an assignee.

[zhivkag, 2017/07/25 15:23:54]

That's a good point, I have updated the TODOs in the code to follow the
mentioned convention.

+  }
+}
+
 /// 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, in which case the return continuation is
 /// returned and applied accordingly.
 /// - It throws, in which case the handler is returned and applied accordingly.
@@ skipping 175 matching lines @@
       if (f.isStatic) continue;
       assert(f.hasImplicitGetter);
 
       int currentFieldIndex = implicitGetters.length;
       // Shadowing an inherited getter with the same name.
       implicitGetters[f.name] =
           (Value receiver) => receiver.fields[currentFieldIndex].value;
       if (f.hasImplicitSetter) {
         // Shadowing an inherited setter with the same name.
         implicitSetters[f.name] = (Value receiver, Value value) =>
-            receiver.fields[currentFieldIndex] = new Location(value);
+            receiver.fields[currentFieldIndex].value = value;
       }
     }
   }
 
   /// Populates instance methods, getters and setters for the current class and
   /// its super class recursively.
   _populateInstanceMethods(ast.Class class_) {
     if (class_.superclass != null) {
       _populateInstanceMethods(class_.superclass);
     }
 
-    for (Procedure p in class_.members) {
-      if (p.isStatic) continue;
-      // Shadowing an inherited method, getter or setter with the same name.
-      methods[p.name] = p;
+    for (Member m in class_.members) {
+      if (m is Procedure) {
+        // Shadowing an inherited method, getter or setter with the same name.
+        methods[m.name] = m;
+      }
     }
   }
 }
 
 abstract class Value {
   Class get class_;
   List<Location> get fields;
   Object get value;
 
   static final NullValue nullInstance = const NullValue();
@@ skipping 11 matching lines @@
   BoolValue equals(Value other) =>
       value == other?.value ? Value.trueInstance : Value.falseInstance;
 
   Value invokeMethod(Name name, [Value arg]) {
     if (name.toString() == "==") return equals(arg);
     throw notImplemented(obj: name);
   }
 }
 
 class ObjectValue extends Value {
-  Class class_;
-  List<Location> fields;
+  final Class class_;
+  final List<Location> fields;
   Object get value => this;
 
-  ObjectValue(this.class_, this.fields);
+  ObjectValue(ast.Class classDeclaration)
+      : class_ = new Class(classDeclaration.reference),
+        fields = new List<Location>(classDeclaration.fields.length) {
+    for (int i = 0; i < fields.length; i++) {
+      // Create fresh locations for each field.
+      fields[i] = new Location.empty();
+    }
+  }
 }
 
 abstract class LiteralValue extends Value {
   Class get class_ =>
       notImplemented(m: "Loading class for literal is not implemented.");
   List<Location> get fields =>
       notImplemented(m: "Literal value does not have fields");
 
   const LiteralValue();
 }
@@ skipping 85 matching lines @@
   const NullValue();
 }
 
 notImplemented({String m, Object obj}) {
   throw new NotImplemented(m ?? 'Evaluation for $obj is not implemented');
 }
 
 // ------------------------------------------------------------------------
 //                             INTERNAL FUNCTIONS
 // ------------------------------------------------------------------------
+
 /// Creates a list of all argument expressions to be evaluated for the
 /// invocation of the provided [FunctionNode] containing the actual arguments
 /// and the optional argument initializers.
-List<InterpreterExpression> _createArgumentExpressionList(
+List<InterpreterExpression> _getArgumentExpressions(
     Arguments providedArgs, FunctionNode fun) {
   List<InterpreterExpression> args = <InterpreterExpression>[];
   // Add positional arguments expressions.
   args.addAll(providedArgs.positional
       .map((Expression e) => new PositionalExpression(e)));
 
   // Add optional positional argument initializers.
   for (int i = providedArgs.positional.length;
       i < fun.positionalParameters.length;
       i++) {
@@ skipping 11 matching lines @@
     var current = providedArgs.named[i];
     args.add(new NamedExpression(current.name, current.value));
     namedFormals.remove(current.name);
   }
 
   // Add missing optional named initializers.
   args.addAll(namedFormals.values);
 
   return args;
 }