Add support for super constructor invocation

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 161 matching lines @@
     // 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);
 
     var args =
         _createArgumentExpressionList(node.arguments, node.target.function);
 
     return new ExpressionListConfiguration(args, config.environment, cont);
   }
 
   Configuration visitNot(Not node, ExpressionConfiguration config) {
@@ skipping 404 matching lines @@
 
   InstanceFieldsApplication(this.newObject, this.constructor, this.environment,
       this.expressionContinuation)
       : _currentClass = new Class(constructor.enclosingClass.reference);
 
   Configuration call(List<InterpreterValue> fieldValues) {
     for (FieldInitializerValue current in fieldValues.reversed) {
       _currentClass.setProperty(newObject, current.field, current.value);
     }
 
-    if (constructor.initializers.isEmpty ||
-        constructor.initializers.first is SuperInitializer) {
-      // todo: eval super args or constructor body configuration.
+    if (constructor.initializers.isEmpty) {
       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(
+          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);
     return new ExpressionConfiguration(
         _getExpression(constructor.initializers.first), initEnv, cont);
   }
 }
 
@@ skipping 14 matching lines @@
     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.
       return new ContinuationConfiguration(continuation, newObject);

[Dmitry Stefantsov, 2017/05/15 11:48:23]

Should we call "_initializeNullFields" here before returning?

[zhivkag, 2017/05/15 11:58:14]

Yes, thanks! Done.

     }
 
     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);
       var args =
           _createArgumentExpressionList(next.arguments, next.target.function);
       return new ExpressionListConfiguration(
           args, initializerEnvironment, cont);
     }
 
     if (next is SuperInitializer) {
-      // todo: eval args for super.
-      if (currentClass.superclass.superclass != null) {
-        throw 'Super initializer invocation is not supported.';
-      }
-      return new ContinuationConfiguration(continuation, newObject);
+      // 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);
+      _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);
   }
 }
 
 /// Represents the application continuation called after the evaluation of all
@@ skipping 701 matching lines @@
 Expression _getExpression(Initializer initializer) {
   if (initializer is FieldInitializer) {
     return initializer.value;
   }
   if (initializer is LocalInitializer) {
     return initializer.variable.initializer;
   }
 
   throw '${initializer.runtimeType} has no epxression.';
 }
+
+/// Initializes all non initialized fields in given class with
+/// [Value.nullInstance].
+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);
+    }
+  }
+}