Support mixins when loading from .dill

pkg/compiler/lib/src/kernel/element_map.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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
@@ skipping 35 matching lines @@
   CallStructure getCallStructure(ir.Arguments arguments);
 
   /// Returns the [Selector] corresponding to the invocation or getter/setter
   /// access of [node].
   Selector getSelector(ir.Expression node);
 
   /// Returns the [ConstructorEntity] corresponding to the generative or factory
   /// constructor [node].
   ConstructorEntity getConstructor(ir.Member node);
 
+  /// Returns the [ConstructorEntity] corresponding to a super initializer
+  /// in [constructor] targeting [target].

[Siggi Cherem (dart-lang), 2017/05/17 16:50:32]

nit: consider rephrasing this a bit and include below a bit more details on what
the result is (in addition to what the "target" is).

In particular, I was a bit confused by "targeting [target]": IIUC, the result
matches [target] when [target] corresponds to the immediate superclass, but in
dart2js we need the entity for the mixin application instead. Correct?

Here is a possible tweak/suggestion:
 
Returns the [ConstructorEntity] corresponding to a super initializer in
[constructor].

The IR resolves super initializers to a [target] up in the type hierarchy. Most
of the time, the result of this function will be the entity corresponding to
that target. In the presence of unnamed mixins, this function returns an entity
for an intermediate synthetic constructor that kernel doesn't explicitly
represent. 

For example:
     class M {}
     class C extends Object with M {}

Kernel will say that C()'s super initializer resolves to Object(), but this
function will return an entity representing the unnamed mixin application
"Object+M"'s constructor.

[Johnni Winther, 2017/05/18 08:57:03]

Done.

+  ///
+  /// Depending on IR encoding of mixins, [target] might be the constructor of
+  /// the first non-mixin-application superclass of the class of [constructor].
+  ///
+  /// For instance
+  ///
+  ///     class M {}
+  ///     class C extends Object with M {}
+  ///
+  /// The default constructor of `C` might have the no-name constructor of
+  /// `Object` as target instead of the no-name constructor of the unnamed
+  /// mixin application `Object+M`.
+  ConstructorEntity getSuperConstructor(
+      ir.Constructor constructor, ir.Member target);
+
   /// Returns the [MemberEntity] corresponding to the member [node].
   MemberEntity getMember(ir.Member node);
 
   /// Returns the [FunctionEntity] corresponding to the procedure [node].
   FunctionEntity getMethod(ir.Procedure node);
 
   /// Returns the [FieldEntity] corresponding to the field [node].
   FieldEntity getField(ir.Field node);
 
   /// Returns the [ClassEntity] corresponding to the class [node].
@@ skipping 748 matching lines @@
     }
     if (isRedirecting) {
       return new RedirectingGenerativeConstantConstructor(
           defaultValues, superConstructorInvocation);
     } else {
       return new GenerativeConstantConstructor(
           type, defaultValues, fieldMap, superConstructorInvocation);
     }
   }
 }