New instance allocation

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 158 matching lines @@
 
   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 newObject =
-        new ObjectValue(class_, new List<Value>(class_.instanceSize));
-
-    ApplicationContinuation cont = new ConstructorInvocationApplication(
-        newObject, node.target, config.continuation);
+    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 323 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 Constructor constructor;
-  final ExpressionContinuation expressionContinuation;
+  final ExpressionContinuation continuation;
 
-  ConstructorInvocationApplication(
-      this.newObject, this.constructor, this.expressionContinuation);
+  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);
+  }
+}
+
+/// 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;
+
+  RedirectingConstructorApplication(
+      this.newObject, this.constructor, this.continuation);
+
+  Configuration call(List<InterpreterValue> argValues) {
+    Environment ctrEnv = ApplicationContinuation.createEnvironment(
+        constructor.function, argValues);
+    var cont =
+        new ObjectInitializationContinuation(constructor, ctrEnv, continuation);
+    return new ContinuationConfiguration(cont, newObject);
+  }
+}
+
+/// 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;
+
+  SuperConstructorApplication(
+      this.newObject, this.constructor, this.continuation);
+
+  Configuration call(List<InterpreterValue> argValues) {
+    Environment ctrEnv = ApplicationContinuation.createEnvironment(
+        constructor.function, argValues);
+    var cont =
+        new ObjectInitializationContinuation(constructor, ctrEnv, continuation);
+    return new ContinuationConfiguration(cont, newObject);
+  }
+}
+
+class ObjectInitializationContinuation extends ExpressionContinuation {
+  final Constructor constructor;
+  final Environment environment;
+  final ExpressionContinuation continuation;
+
+  ObjectInitializationContinuation(
+      this.constructor, this.environment, this.continuation);
+
+  Configuration call(Value v) {
     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);
+        var app = new RedirectingConstructorApplication(
+            v, initializer.target, continuation);
         var args = _createArgumentExpressionList(
             initializer.arguments, initializer.target.function);
 
-        return new ExpressionListConfiguration(args, ctrEnv, app);
+        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 cont = new InitializerContinuation(newObject, class_, ctrEnv,
-          constructor.initializers, expressionContinuation);
+      var cont = new InitializerContinuation(
+          v, class_, environment, constructor.initializers, continuation);
       return new ExpressionConfiguration(
-          (initializer as LocalInitializer).variable.initializer, ctrEnv, cont);
+          (initializer as LocalInitializer).variable.initializer,
+          environment,
+          cont);
     }
 
     // Initialize fields in immediately enclosing class.
     var cont = new InstanceFieldsApplication(
-        newObject, constructor, ctrEnv, expressionContinuation);
+        v, constructor, environment, continuation);
     var fieldExpressions = _createInstanceInitializers(constructor);
 
-    return new ExpressionListConfiguration(fieldExpressions, ctrEnv, cont);
+    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;
@@ skipping 32 matching lines @@
       _initializeNullFields(_currentClass, newObject);
       return new ContinuationConfiguration(expressionContinuation, newObject);
     }
 
     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(
+      var superApp = new SuperConstructorApplication(
           newObject, current.target, expressionContinuation);
       _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);
@@ skipping 28 matching lines @@
       // todo: return configuration for body of ctr.
       _initializeNullFields(currentClass, newObject);
       return new ContinuationConfiguration(continuation, newObject);
     }
 
     Initializer next = initializers[1];
 
     if (next is RedirectingInitializer) {
       // RedirectingInitializer appears last in the initializer list.
       assert(initializers.length == 2);
-      var cont = new ConstructorInvocationApplication(
+      var cont = new RedirectingConstructorApplication(
           newObject, next.target, continuation);
       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);
+      var superApp =
+          new SuperConstructorApplication(newObject, next.target, continuation);
       _initializeNullFields(currentClass, newObject);
       return new ExpressionListConfiguration(
           args, initializerEnvironment, superApp);
     }
 
     var cont = new InitializerContinuation(newObject, currentClass,
         initializerEnvironment, initializers.skip(1).toList(), continuation);
     return new ExpressionConfiguration(
         _getExpression(next), initializerEnvironment, cont);
   }
@@ skipping 703 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);
     }
   }
 }