Add support for super initialziers in constructor initializer list

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 643 matching lines @@
 /// 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 class_ = new Class(constructor.enclosingClass.reference);
+    var newObject = new ObjectValue(class_);
     var cont = new InitializationEK(
         constructor, ctrEnv, new NewSK(continuation, new Location(newObject)));
 
     return new ValuePassingConfiguration(cont, newObject);
   }
 }
 
+/// Represents the application continuation for constructor invocation applied
+/// on the list of evaluated arguments when a constructor is invoked in a
+/// constructor initializer list with a [RedirectingInitializer] or
+/// [SuperInitializer].
+class ConstructorInitializerA extends ApplicationContinuation {
+  final Constructor constructor;
+  final Location location;
+  final ConstructorBodySK continuation;
+
+  ConstructorInitializerA(this.constructor, this.location, this.continuation);
+
+  Configuration call(List<InterpreterValue> vs) {
+    Environment ctrEnv =
+        ApplicationContinuation.createEnvironment(constructor.function, vs);
+    var cont = new InitializationEK(constructor, ctrEnv, continuation);
+
+    return new ValuePassingConfiguration(cont, location.value);
+  }
+}
+
 /// Represents the application continuation applied on the list of evaluated
 /// field initializer expressions.
 class InstanceFieldsA extends ApplicationContinuation {
   final Constructor constructor;
   final Location location;
   final Environment environment;
   final ConstructorBodySK continuation;
 
   final Class _currentClass;
 
   InstanceFieldsA(
       this.constructor, this.location, this.environment, this.continuation)
       : _currentClass = new Class(constructor.enclosingClass.reference);
 
   Configuration call(List<InterpreterValue> fieldValues) {
     for (FieldInitializerValue f in fieldValues) {
       // Directly set the field with the corresponding implicit setter.
       _currentClass.implicitSetters[f.field.name](location.value, f.value);
     }
 
+    if (constructor.initializers.length == 0) {
+      return new ForwardConfiguration(continuation, environment);
+    }
+
     // The first initializer is either an initializer with expression
     // (i.e., Field or Local initializer) or a Super initializer.

[Dmitry Stefantsov, 2017/08/02 15:05:49]

Please, see if the changes from the previous updated CL persist after landing
this one.  I remember leaving notes about this comment and some lines below.

[zhivkag, 2017/08/02 15:25:39]

Done.

-    if (constructor.initializers.length == 0 ||
-        constructor.initializers.first is SuperInitializer) {
-      _initializeNullFields(_currentClass, location.value);
-      // TODO(zhivkag): Produce the configuration for executing the super
-      // initializer.
-      return new ForwardConfiguration(continuation, environment);
+    if (constructor.initializers.first is SuperInitializer) {
+      // Target constructor is from the superclass `object`.
+      if (_currentClass.superclass.superclass == null) {
+        // TODO(zhivkag): Execute the constructor when support for
+        // native/external functions is added.
+        _initializeNullFields(_currentClass, location.value);
+        return new ForwardConfiguration(continuation, environment);
+      }
+
+      return _createEvalListConfig(constructor.initializers.first);
     }
+
     // Otherwise, the next expression from Field or Local initializers will be
     // evaluated.
-    Expression expr = (constructor.initializers.first is FieldInitializer)
-        ? (constructor.initializers.first as FieldInitializer).value
-        : (constructor.initializers.first as LocalInitializer)
-            .variable
-            .initializer;
+    return _createEvalConfig(constructor.initializers.first);
+  }
+
+  Configuration _createEvalListConfig(SuperInitializer initializer) {
+    List<InterpreterExpression> args = _getArgumentExpressions(
+        initializer.arguments, initializer.target.function);
+    var cont =
+        new ConstructorInitializerA(initializer.target, location, continuation);
+
+    return new EvalListConfiguration(args, environment, cont);
+  }
+
+  EvalConfiguration _createEvalConfig(Initializer initializer) {
+    Expression expr = (initializer is FieldInitializer)
+        ? initializer.value
+        : (initializer as LocalInitializer).variable.initializer;
 
     var cont = new InitializerListEK(constructor, 0 /* initializerIndex*/,

[Dmitry Stefantsov, 2017/08/02 15:05:49]

How about putting this in-line comment to its own line above with an
explanation, why the index is 0 here?

[zhivkag, 2017/08/02 15:25:39]

Done.

         location, environment, continuation);
     return new EvalConfiguration(expr, environment, cont);
   }
 }
-
 // ------------------------------------------------------------------------
 //                           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 264 matching lines @@
 /// instance with running the constructor.
 class InitializationEK extends ExpressionContinuation {
   final Constructor constructor;
   final Environment environment;
   // TODO(zhivkag): 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 initializers is not implemented.';
+        constructor.initializers.last is RedirectingInitializer) {
+      throw 'Support for redirecting initializers 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);
     var initializers = _getFieldInitializers(constructor.enclosingClass);
     var fieldsCont =
         new InstanceFieldsA(constructor, new Location(value), ctrEnv, bodyCont);
@@ skipping 39 matching lines @@
   Configuration _createNextConfiguration(Environment env) {
     assert(initializerIndex + 1 < constructor.initializers.length);
     Initializer next = constructor.initializers[initializerIndex + 1];
     if (next is SuperInitializer) {
       // TODO(zhivkag): Execute `object` constructor when support for
       // native/external functions is added.
       if (_currentClass.superclass.superclass == null) {
         _initializeNullFields(_currentClass, location.value);
         return new ForwardConfiguration(continuation, environment);
       }
-      // TODO(zhivkag): Produce the configuration according to
-      // specification.
-      throw 'Support for SuperInitializers in not implemented.';
+      return _createEvalListConfig(next);
     }
 
     if (next is RedirectingInitializer) {
       // TODO(zhivkag): Produce the configuration according to
       // specification.
       throw 'Support for RedirectingInitializers is not implemented.';
     }
 
     Expression nextExpr = (next is FieldInitializer)
         ? next.value
         : (next as LocalInitializer).variable.initializer;
 
     var cont = withInitializerIndex(initializerIndex + 1);
     return new EvalConfiguration(nextExpr, env, cont);
   }
+
+  Configuration _createEvalListConfig(SuperInitializer initializer) {
+    List<InterpreterExpression> args = _getArgumentExpressions(
+        initializer.arguments, initializer.target.function);
+    var cont =
+        new ConstructorInitializerA(initializer.target, location, continuation);
+
+    return new EvalListConfiguration(args, environment, cont);
+  }
 }
 
 /// 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
@@ skipping 228 matching lines @@
     if (name.toString() == "==") return equals(arg);
     throw notImplemented(obj: name);
   }
 }
 
 class ObjectValue extends Value {
   final Class class_;
   final List<Location> fields;
   Object get value => this;
 
-  ObjectValue(ast.Class classDeclaration)
-      : class_ = new Class(classDeclaration.reference),
-        fields = new List<Location>(classDeclaration.fields.length) {
+  ObjectValue(this.class_) : fields = new List<Location>(class_.instanceSize) {
     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.");
@@ skipping 153 matching lines @@
 /// Initializes all non initialized fields from the provided class to
 /// `Value.nullInstance` in the provided value.
 void _initializeNullFields(Class class_, Value value) {
   int startIndex = class_.superclass?.instanceSize ?? 0;
   for (int i = startIndex; i < class_.instanceSize; i++) {
     if (value.fields[i].value == null) {
       value.fields[i].value = Value.nullInstance;
     }
   }
 }