Support mixins when loading from .dill

pkg/compiler/lib/src/kernel/element_map_impl.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 dart2js.kernel.element_map;
 
 import 'package:kernel/ast.dart' as ir;
+import 'package:kernel/clone.dart';
+import 'package:kernel/type_algebra.dart';
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
 import '../common/resolution.dart';
 import '../compile_time_constants.dart';
 import '../constants/constant_system.dart';
 import '../constants/constructors.dart';
 import '../constants/evaluation.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
@@ skipping 594 matching lines @@
       if (node.kind == ir.ProcedureKind.Factory) {
         return _getConstructor(node);
       } else {
         return _getMethod(node);
       }
     }
     throw new UnsupportedError("Unexpected member: $node");
   }
 
   @override
-  FunctionEntity getConstructor(ir.Member node) => _getConstructor(node);
+  ConstructorEntity getConstructor(ir.Member node) => _getConstructor(node);
+
+  @override
+  ConstructorEntity getSuperConstructor(
+      ir.Constructor sourceNode, ir.Member targetNode) {
+    KConstructor source = getConstructor(sourceNode);
+    KClass sourceClass = source.enclosingClass;
+    KConstructor target = getConstructor(targetNode);
+    KClass targetClass = target.enclosingClass;
+    KClass superClass = _getSuperType(sourceClass)?.element;
+    if (superClass == targetClass) {
+      return target;
+    }
+    _KClassEnv env = _classEnvs[superClass.classIndex];
+    ir.Member member = env.lookupConstructor(target.name);
+    if (member != null) {
+      return getConstructor(member);
+    }
+    throw new SpannableAssertionFailure(
+        source, "Super constructor for $source not found.");
+  }
 
   ConstantConstructor _getConstructorConstant(KConstructor constructor) {
     _ConstructorData data = _memberList[constructor.memberIndex];
     return data.getConstructorConstant(this, constructor);
   }
 
   ConstantExpression _getFieldConstant(KField field) {
     _FieldData data = _memberList[field.memberIndex];
     return data.getFieldConstant(this, field);
   }
@@ skipping 146 matching lines @@
 
   Map<String, ir.Member> _constructorMap;
   Map<String, ir.Member> _memberMap;
   Map<String, ir.Member> _setterMap;
 
   Iterable<ConstantValue> _metadata;
 
   _KClassEnv(this.cls)
       // TODO(johnniwinther): Change this to use a property on [cls] when such
       // is added to kernel.
-      : isUnnamedMixinApplication = cls.name.contains('+');
+      : isUnnamedMixinApplication =
+            cls.name.contains('+') || cls.name.contains('&');
+
+  /// Copied from 'package:kernel/transformations/mixin_full_resolution.dart'.
+  ir.Constructor _buildForwardingConstructor(
+      CloneVisitor cloner, ir.Constructor superclassConstructor) {
+    var superFunction = superclassConstructor.function;
+
+    // We keep types and default values for the parameters but always mark the
+    // parameters as final (since we just forward them to the super
+    // constructor).
+    ir.VariableDeclaration cloneVariable(ir.VariableDeclaration variable) {
+      ir.VariableDeclaration clone = cloner.clone(variable);
+      clone.isFinal = true;
+      return clone;
+    }
+
+    // Build a [FunctionNode] which has the same parameters as the one in the
+    // superclass constructor.
+    var positionalParameters =
+        superFunction.positionalParameters.map(cloneVariable).toList();
+    var namedParameters =
+        superFunction.namedParameters.map(cloneVariable).toList();
+    var function = new ir.FunctionNode(new ir.EmptyStatement(),
+        positionalParameters: positionalParameters,
+        namedParameters: namedParameters,
+        requiredParameterCount: superFunction.requiredParameterCount,
+        returnType: const ir.VoidType());
+
+    // Build a [SuperInitializer] which takes all positional/named parameters
+    // and forward them to the super class constructor.
+    var positionalArguments = <ir.Expression>[];
+    for (var variable in positionalParameters) {
+      positionalArguments.add(new ir.VariableGet(variable));
+    }
+    var namedArguments = <ir.NamedExpression>[];
+    for (var variable in namedParameters) {
+      namedArguments.add(
+          new ir.NamedExpression(variable.name, new ir.VariableGet(variable)));
+    }
+    var superInitializer = new ir.SuperInitializer(superclassConstructor,
+        new ir.Arguments(positionalArguments, named: namedArguments));
+
+    // Assemble the constructor.
+    return new ir.Constructor(function,
+        name: superclassConstructor.name,
+        initializers: <ir.Initializer>[superInitializer]);
+  }
 
   void _ensureMaps() {
     if (_memberMap == null) {
       _memberMap = <String, ir.Member>{};
       _setterMap = <String, ir.Member>{};
       _constructorMap = <String, ir.Member>{};
 
       void addMembers(ir.Class c, {bool includeStatic}) {
         for (ir.Member member in c.members) {
           if (member is ir.Constructor ||
@@ skipping 19 matching lines @@
             throw new SpannableAssertionFailure(
                 NO_LOCATION_SPANNABLE, "Unexpected class member node: $member");
           }
         }
       }
 
       if (cls.mixedInClass != null) {
         addMembers(cls.mixedInClass, includeStatic: false);
       }
       addMembers(cls, includeStatic: true);
+
+      if (isUnnamedMixinApplication && _constructorMap.isEmpty) {
+        // Unnamed mixin applications have no constructors when read from .dill.
+        // For each generative constructor in the superclass we make a
+        // corresponding forwarding constructor in the subclass.
+        //
+        // This code is copied from
+        // 'package:kernel/transformations/mixin_full_resolution.dart'
+        var superclassSubstitution = getSubstitutionMap(cls.supertype);
+        var superclassCloner =
+            new CloneVisitor(typeSubstitution: superclassSubstitution);
+        for (var superclassConstructor in cls.superclass.constructors) {
+          var forwardingConstructor = _buildForwardingConstructor(
+              superclassCloner, superclassConstructor);
+          cls.addMember(forwardingConstructor);
+          _constructorMap[forwardingConstructor.name.name] =
+              forwardingConstructor;
+        }
+      }
     }
   }
 
   /// Return the [ir.Member] for the member [name] in [library].
   ir.Member lookupMember(String name, {bool setter: false}) {
     _ensureMaps();
     return setter ? _setterMap[name] : _memberMap[name];
   }
 
   /// Return the [ir.Member] for the member [name] in [library].
@@ skipping 557 matching lines @@
     return node.isExternal &&
         !elementMap.isForeignLibrary(node.enclosingLibrary);
   }
 
   @override
   bool isJsInteropMember(MemberEntity element) {
     // TODO(johnniwinther): Compute this.
     return false;
   }
 }