Add support for initializers in 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 672 matching lines @@
   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);
     }
 
-    // TODO(zhivkag): Execute constructor initializer list before initializing
-    // fields in immediately enclosing class to null.
-    _initializeNullFields(_currentClass, location.value);
-    return new ForwardConfiguration(continuation, environment);
+    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);
+    }
+    // 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;
+
+    var cont = new InitializerListEK(constructor, 0 /* initializerIndex*/,
+        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
@@ skipping 289 matching lines @@
     var bodyCont =
         new ConstructorBodySK(constructor.function.body, ctrEnv, continuation);
     var initializers = _getFieldInitializers(constructor.enclosingClass);
     var fieldsCont =
         new InstanceFieldsA(constructor, new Location(value), ctrEnv, bodyCont);
     return new EvalListConfiguration(
         initializers, new Environment.empty(), fieldsCont);
   }
 }
 
+class InitializerListEK extends ExpressionContinuation {
+  final Constructor constructor;
+  final int initializerIndex;
+  final Location location;
+  final Environment environment;
+  // TODO(zhivkag): Add componnents for exception handling.
+  final ConstructorBodySK continuation;
+  final Class _currentClass;
+
+  InitializerListEK(this.constructor, this.initializerIndex, this.location,
+      this.environment, this.continuation)
+      : _currentClass = new Class(constructor.enclosingClass.reference);
+
+  /// Creates a continuation for the evaluation of the initializer at position
+  /// [index].
+  InitializerListEK withInitializerIndex(int index) {
+    return new InitializerListEK(
+        constructor, index, location, environment, continuation);
+  }
+
+  Configuration call(Value value) {
+    Initializer current = constructor.initializers[initializerIndex];
+    if (current is FieldInitializer) {
+      _currentClass.lookupImplicitSetter(current.field.name)(
+          location.value, value);
+      return _createNextConfiguration(environment);
+    }
+    if (current is LocalInitializer) {
+      Environment newEnv = environment.extend(current.variable, value);
+      return _createNextConfiguration(newEnv);
+    }
+    throw "Value can't be applied to initalizer of type ${current.runtimeType}";
+  }
+
+  Configuration _createNextConfiguration(Environment env) {
+    assert(initializerIndex + 1 < constructor.initializers.length);
+    Initializer next = constructor.initializers[initializerIndex + 1];
+    if (next is SuperInitializer) {
+      // TODO(zhivkag): Execute constructor of "object" class 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.';
+    }
+
+    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);
+  }
+}
+
 /// 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.
 class StatementExecuter
     extends StatementVisitor1<Configuration, ExecConfiguration> {
   Evaluator evaluator = new Evaluator();
 
   void trampolinedExecution(Configuration configuration) {
     while (configuration != null) {
       configuration = configuration.step(this);
     }
-    ;
   }
 
   Configuration exec(Statement statement, ExecConfiguration conf) =>
       statement.accept1(this, conf);
   Configuration eval(Expression expression, EvalConfiguration config) =>
       evaluator.eval(expression, config);
   Configuration evalList(
           List<InterpreterExpression> es, Environment env, Continuation cont) =>
       evaluator.evalList(es, env, cont);
 
@@ skipping 384 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;
     }
   }
 }