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);
+            superOrRedirectConstructor.function, initializer.arguments);
         _buildInlinedSuperInitializers(

[Siggi Cherem (dart-lang), 2016/12/29 23:28:33]

I wonder if we should rename this function. Some ideas:
 - _buildInlinedSuperOrRedirectInitializers (yikes!), or
 - _buildInlinedXYZInitializer where XYZ can be "direct", "special", "known", or
simply
 - _buildInlinedInitializer
?

[Emily Fortuna, 2016/12/29 23:42:44]

good point. I changed to _buildInlinedInitializer

-            superConstructor, arguments, fieldValues);
+            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) {
+    if (!foundSuperOrRedirectCall) {

[Siggi Cherem (dart-lang), 2016/12/29 23:28:32]

consider updating the comment above this?

I believe that the redirect will handle injecting a default super call
transitively as well, but just wanted to double check. For example, in a code
like:

class A {
  final x;
  @NoInline()
  A() : x = 1;
}

class B extends A {
  final y;

  @NoInline()
  B.a(v) : y = v;

  @NoInline()
  B.b() : this.a(2);
}


I expect that the code for `B.b()` should include the x = 1 initializer,
correct?

[Emily Fortuna, 2016/12/29 23:42:44]

Correct. and good catch on the comment. updated!

       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(
             defaultConstructor, <HInstruction>[], fieldValues);
       }
     }
   }
 
@@ skipping 847 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);
   }
 }