Add support for redirecting constructors

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 693 matching lines @@
       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) {
+      // This can happen when initializing fields of a constructor with an empty
+      // initializer list.
       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);
@@ skipping 305 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) {
+    Location location = new Location(value);
+
     if (constructor.initializers.isNotEmpty &&
         constructor.initializers.last is RedirectingInitializer) {
-      throw 'Support for redirecting initializers is not implemented.';
+      return _createRedirectingInitializerConfig(
+          constructor.initializers.first, location);
     }
-
     // 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);
+        new InstanceFieldsA(constructor, location, ctrEnv, bodyCont);
     return new EvalListConfiguration(
         initializers, new Environment.empty(), fieldsCont);
   }
+
+  /// Creates the next configuration to further initializer the value for
+  /// redirecting constructors.
+  Configuration _createRedirectingInitializerConfig(
+      Initializer initializer, Location location) {
+    Initializer current = constructor.initializers.first;
+    if (current is RedirectingInitializer) {
+      // Evaluate the list of arguments for invoking the target constructor in
+      // the current environment.
+      List<InterpreterExpression> exprs =
+          _getArgumentExpressions(current.arguments, current.target.function);
+      var cont =
+          new ConstructorInitializerA(current.target, location, continuation);
+      return new EvalListConfiguration(exprs, environment, cont);
+    }
+    Expression expr = (current is FieldInitializer)
+        ? current.value
+        : (current as LocalInitializer).variable.initializer;
+
+    // The index is set to 0 since we are evaluating the expression for the
+    // first initializer in the initializer list.
+    var cont = new InitializerListEK(
+        constructor, 0, location, environment, continuation);
+    return new EvalConfiguration(expr, environment, cont);
+  }
 }
 
 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;
@@ skipping 26 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 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);
       }
-      return _createEvalListConfig(next);
+      return _createEvalListConfig(next.arguments, next.target, env);
     }
 
     if (next is RedirectingInitializer) {
-      // TODO(zhivkag): Produce the configuration according to
-      // specification.
-      throw 'Support for RedirectingInitializers is not implemented.';
+      return _createEvalListConfig(next.arguments, next.target, env);
     }
 
     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);
+  Configuration _createEvalListConfig(
+      Arguments args, Constructor ctr, Environment env) {
+    List<InterpreterExpression> exprs =
+        _getArgumentExpressions(args, ctr.function);
+    var cont = new ConstructorInitializerA(ctr, location, continuation);
+    return new EvalListConfiguration(exprs, 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.
@@ skipping 403 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;
     }
   }
 }