Handle forwarding constructors to unnamed mixin applications

pkg/compiler/lib/src/kernel/env.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.env;
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/clone.dart';
 import 'package:kernel/type_algebra.dart';
 
@@ skipping 240 matching lines @@
     }
     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() {
+  void _ensureMaps(KernelToElementMapBase elementMap) {
     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.name.name.contains('#')) {
             // Skip synthetic .dill members.
             continue;
@@ skipping 23 matching lines @@
           }
         }
       }
 
       if (cls.mixedInClass != null) {
         addMembers(cls.mixedInClass, includeStatic: false);
       }
       addMembers(cls, includeStatic: true);
 
       if (isUnnamedMixinApplication && _constructorMap.isEmpty) {
+        // Ensure that constructors are created for the superclass in case it
+        // is also an unnamed mixin application.
+        ClassEntity superclass = elementMap.getClass(cls.superclass);
+        elementMap.elementEnvironment.lookupConstructor(superclass, '');
+
         // 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 [MemberEntity] for the member [name] in [cls]. If [setter] is
   /// `true`, the setter or assignable field corresponding to [name] is
   /// returned.
   MemberEntity lookupMember(KernelToElementMap elementMap, String name,
       {bool setter: false}) {
-    _ensureMaps();
+    _ensureMaps(elementMap);
     ir.Member member = setter ? _setterMap[name] : _memberMap[name];
     return member != null ? elementMap.getMember(member) : null;
   }
 
   /// Calls [f] for each member of [cls].
   void forEachMember(
       KernelToElementMap elementMap, void f(MemberEntity member)) {
-    _ensureMaps();
+    _ensureMaps(elementMap);
     _memberMap.values.forEach((ir.Member member) {
       f(elementMap.getMember(member));
     });
     for (ir.Member member in _setterMap.values) {
       if (member is ir.Procedure) {
         f(elementMap.getMember(member));
       } else {
         // Skip fields; these are also in _memberMap.
       }
     }
   }
 
   /// Return the [ConstructorEntity] for the constructor [name] in [cls].
   ConstructorEntity lookupConstructor(
       KernelToElementMap elementMap, String name) {
-    _ensureMaps();
+    _ensureMaps(elementMap);
     ir.Member constructor = _constructorMap[name];
     return constructor != null ? elementMap.getConstructor(constructor) : null;
   }
 
   /// Calls [f] for each constructor of [cls].
   void forEachConstructor(
       KernelToElementMap elementMap, void f(ConstructorEntity constructor)) {
-    _ensureMaps();
+    _ensureMaps(elementMap);
     _constructorMap.values.forEach((ir.Member constructor) {
       f(elementMap.getConstructor(constructor));
     });
   }
 
   void addConstructorBody(ConstructorBodyEntity constructorBody) {
     _constructorBodyList ??= <ConstructorBodyEntity>[];
     _constructorBodyList.add(constructorBody);
   }
 
@@ skipping 276 matching lines @@
   }
 }
 
 class TypedefData {
   final ir.Typedef node;
   final TypedefEntity element;
   final TypedefType rawType;
 
   TypedefData(this.node, this.element, this.rawType);
 }