Add suport for initializer list execution 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 525 matching lines @@
     if (constructor.initializers.isNotEmpty &&
         constructor.initializers.last is RedirectingInitializer) {
       var cont = new RedirectingConstructorInvocationApplication(newObject,
           constructor.initializers.last, ctrEnv, expressionContinuation);
       var es = _createLocalInitializerExpressionList(
           constructor.initializers.take(constructor.initializers.length - 1));
       return new ExpressionListConfiguration(es, ctrEnv, cont);
     }
 
     var cont = new InstanceFieldsApplication(
-        newObject, constructor, expressionContinuation);
+        newObject, constructor, ctrEnv, expressionContinuation);
     var fieldExpressions = _createInstanceInitializers(constructor);
 
     return new ExpressionListConfiguration(fieldExpressions, ctrEnv, cont);
   }
 
   /// Creates a list of expressions for local initializers.
   static List<InterpreterExpression> _createLocalInitializerExpressionList(
       List<LocalInitializer> initializers) {
     List<InterpreterExpression> es = <InterpreterExpression>[];
 
@@ skipping 47 matching lines @@
 
     return new ExpressionListConfiguration(args, environment, cont);
   }
 }
 
 /// Represents the application continuation applied on the list of evaluated
 /// field initializer expressions.
 class InstanceFieldsApplication extends ApplicationContinuation {
   final ObjectValue newObject;
   final Constructor constructor;
+  final Environment environment;
   final ExpressionContinuation expressionContinuation;
 
   final Class _currentClass;
 
-  InstanceFieldsApplication(
-      this.newObject, this.constructor, this.expressionContinuation)
+  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);
     }
 
+    var es = _createInitializerListExpressions(constructor.initializers);
+    List<Initializer> initializers = constructor.initializers.skip(es.length);
+
+    ApplicationContinuation cont = new InitializerListApplication(newObject,
+        constructor, environment, initializers, expressionContinuation);
+
+    return new ExpressionListConfiguration(es, environment, cont);
+  }
+}
+
+/// Represents the application continuation applied on the list of evaluated
+/// initializer expressions preceding a super call in the list.
+class InitializerListApplication extends ApplicationContinuation {
+  final ObjectValue newObject;
+  final Constructor constructor;
+  final Environment environment;
+  final List<Initializer> remainingInitializers;
+  final ExpressionContinuation expressionContinuation;
+
+  final Class _currentClass;
+
+  InitializerListApplication(this.newObject, this.constructor, this.environment,
+      this.remainingInitializers, this.expressionContinuation)
+      : _currentClass = new Class(constructor.enclosingClass.reference);
+
+  Configuration call(List<InterpreterValue> values) {
+    var initEnv = new Environment(environment);
+
+    // Apply values from evaluation to object or/and initializer environment.
+    for (InterpreterValue current in values.reversed) {
+      if (current is LocalInitializerValue) {
+        initEnv.expand(current.variable, current.value);
+      } else if (current is FieldInitializerValue) {
+        _currentClass.setProperty(newObject, current.field, current.value);
+      } else {
+        throw '${current.runtimeType} in InitializerListApplication';
+      }
+    }
+
+    if (remainingInitializers.isNotEmpty) {
+      assert(remainingInitializers.first is SuperInitializer);
+      // todo: Evaluate arguments for super invocation.
+    }
+
     return new ContinuationConfiguration(expressionContinuation, newObject);
   }
 }
 
 /// Represents the application continuation called after the evaluation of all
 /// argument expressions for an invocation.
 class ValueApplication extends ApplicationContinuation {
   final InterpreterValue value;
   final ApplicationContinuation applicationContinuation;
 
@@ skipping 685 matching lines @@
     var current = providedArgs.named[i];
     args.add(new NamedArgumentExpression(current.name, current.value));
     namedFormals.remove(current.name);
   }
 
   // Add missing optional named initializers.
   args.addAll(namedFormals.values);
 
   return args;
 }
+
+List<InterpreterExpression> _createInitializerListExpressions(
+    List<Initializer> initializers) {
+  List<InterpreterExpression> es = <InterpreterExpression>[];
+
+  for (Initializer current in initializers) {
+    if (current is FieldInitializer) {
+      es.add(new FieldInitializerExpression(current.field, current.value));
+    } else if (current is LocalInitializer) {
+      es.add(new LocalInitializerExpression(current.variable));
+    } else {
+      assert(current is SuperInitializer);
+      return es;
+    }
+  }
+
+  return es;
+}