Some constructor fixes: implement redirecting constructors, work with finding default constructors …

pkg/compiler/lib/src/ssa/builder_kernel.dart

 // Copyright (c) 2016, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
@@ skipping 290 matching lines @@
         fieldValues[field] = pop();
       }
     }
 
     return fieldValues;
   }
 
   /// Collects field initializers all the way up the inheritance chain.
   void _buildInitializers(
       ir.Constructor constructor, Map<ir.Field, HInstruction> fieldValues) {
-    var foundSuperCall = false;
+    var foundSuperOrRedirectCall = false;
     for (var initializer in constructor.initializers) {
-      if (initializer is ir.SuperInitializer) {
-        foundSuperCall = true;
-        var superConstructor = initializer.target;
+      if (initializer is ir.SuperInitializer ||
+          initializer is ir.RedirectingInitializer) {
+        foundSuperOrRedirectCall = true;
+        var superOrRedirectConstructor = initializer.target;
         var arguments = _normalizeAndBuildArguments(
-            superConstructor.function, initializer.arguments);
-        _buildInlinedSuperInitializers(
-            superConstructor, arguments, fieldValues);
+            superOrRedirectConstructor.function, initializer.arguments);
+        _buildInlinedInitializers(
+            superOrRedirectConstructor, arguments, fieldValues);
       } else if (initializer is ir.FieldInitializer) {
         initializer.value.accept(this);
         fieldValues[initializer.field] = pop();
       }
     }
 
-    // TODO(het): does kernel always set the super initializer at the end?
-    // If there was no super-call initializer, then call the default constructor
-    // in the superclass.
-    if (!foundSuperCall) {
+    // Kernel always set the super initializer at the end, so if there was no
+    // super-call initializer, then the default constructor is called in the
+    // superclass.
+    if (!foundSuperOrRedirectCall) {
       if (constructor.enclosingClass != astAdapter.objectClass) {
         var superclass = constructor.enclosingClass.superclass;
         var defaultConstructor = superclass.constructors
-            .firstWhere((c) => c.name == '', orElse: () => null);
+            .firstWhere((c) => c.name.name == '', orElse: () => null);
         if (defaultConstructor == null) {
           compiler.reporter.internalError(
               NO_LOCATION_SPANNABLE, 'Could not find default constructor.');
         }
-        _buildInlinedSuperInitializers(
+        _buildInlinedInitializers(
             defaultConstructor, <HInstruction>[], fieldValues);
       }
     }
   }
 
   List<HInstruction> _normalizeAndBuildArguments(
       ir.FunctionNode function, ir.Arguments arguments) {
     var signature = astAdapter.getFunctionSignature(function);
     var builtArguments = <HInstruction>[];
     var positionalIndex = 0;
@@ skipping 31 matching lines @@
         }
       });
     }
 
     return builtArguments;
   }
 
   /// Inlines the given super [constructor]'s initializers by collecting it's
   /// field values and building its constructor initializers. We visit super
   /// constructors all the way up to the [Object] constructor.
-  void _buildInlinedSuperInitializers(ir.Constructor constructor,
+  void _buildInlinedInitializers(ir.Constructor constructor,
       List<HInstruction> arguments, Map<ir.Field, HInstruction> fieldValues) {
     // TODO(het): Handle RTI if class needs it
     fieldValues.addAll(_collectFieldValues(constructor.enclosingClass));
 
     var signature = astAdapter.getFunctionSignature(constructor.function);
     var index = 0;
     signature.orderedForEachParameter((ParameterElement parameter) {
       HInstruction argument = arguments[index++];
       // Because we are inlining the initializer, we must update
       // what was given as parameter. This will be used in case
@@ skipping 790 matching lines @@
           constructor = astAdapter.mapLiteralUntypedMaker;
         }
       } else {
         inputs.addAll(typeInputs);
       }
     }
 
     // If runtime type information is needed and the map literal has no type
     // parameters, 'constructor' is a static function that forwards the call to
     // the factory constructor without type parameters.
-    assert(constructor.kind == ir.ProcedureKind.Factory);
+    assert(constructor.kind == ir.ProcedureKind.Method
+        || constructor.kind == ir.ProcedureKind.Factory);
 
     // The instruction type will always be a subtype of the mapLiteralClass, but
     // type inference might discover a more specific type, or find nothing (in
     // dart2js unit tests).
     TypeMask mapType = new TypeMask.nonNullSubtype(
         astAdapter.getElement(astAdapter.mapLiteralClass), closedWorld);
     TypeMask returnTypeMask = TypeMaskFactory.inferredReturnTypeForElement(
         astAdapter.getElement(constructor), globalInferenceResults);
     TypeMask instructionType =
         mapType.intersection(returnTypeMask, closedWorld);
@@ skipping 1265 matching lines @@
     kernelBuilder.open(exitBlock);
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
   }
 }