Use correct types on cloned constructors in mixin applications.

pkg/front_end/lib/src/fasta/kernel/kernel_target.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.
 
 library fasta.kernel_target;
 
 import 'dart:async' show Future;
 
 import 'dart:io' show File, IOSink;
 
 import 'package:kernel/ast.dart'
     show
         Arguments,
         AsyncMarker,
         Class,
         Constructor,
+        DartType,
         EmptyStatement,
         Expression,
         ExpressionStatement,
         Field,
         FieldInitializer,
         FunctionNode,
         Initializer,
         InvalidInitializer,
         Library,
         Name,
         NamedExpression,
         NullLiteral,
         ProcedureKind,
         Program,
         RedirectingInitializer,
         Source,
         StringLiteral,
         SuperInitializer,
         Throw,
+        TypeParameter,
         VariableDeclaration,
         VariableGet,
         VoidType;
 
 import 'package:kernel/binary/ast_to_binary.dart' show BinaryPrinter;
 
 import 'package:kernel/text/ast_to_text.dart' show Printer;
 
 import 'package:kernel/transformations/erasure.dart' show Erasure;
 
 import 'package:kernel/transformations/continuation.dart' as transformAsync;
 
 import 'package:kernel/transformations/mixin_full_resolution.dart'
     show MixinFullResolution;
 
 import 'package:kernel/transformations/setup_builtin_library.dart'
     as setup_builtin_library;
 
+import 'package:kernel/type_algebra.dart' show substitute;
+
 import '../source/source_loader.dart' show SourceLoader;
 
 import '../source/source_class_builder.dart' show SourceClassBuilder;
 
 import '../target_implementation.dart' show TargetImplementation;
 
 import '../translate_uri.dart' show TranslateUri;
 
 import '../dill/dill_target.dart' show DillTarget;
 
 import '../errors.dart'
     show InputError, internalError, reportCrash, resetCrashReporting;
 
 import '../util/relativize.dart' show relativizeUri;
 
 import '../compiler_context.dart' show CompilerContext;
 
 import 'kernel_builder.dart'
     show
         Builder,
         ClassBuilder,
         KernelClassBuilder,
         KernelLibraryBuilder,
         KernelNamedTypeBuilder,
         KernelProcedureBuilder,
         LibraryBuilder,
         MixinApplicationBuilder,
         NamedMixinApplicationBuilder,
         NamedTypeBuilder,
-        TypeBuilder;
+        TypeBuilder,
+        TypeVariableBuilder;
 
 class KernelTarget extends TargetImplementation {
   final DillTarget dillTarget;
 
   /// Shared with [CompilerContext].
   final Map<String, Source> uriToSource;
 
   SourceLoader<Library> loader;
   Program program;
 
   final List errors = [];
 
+  final TypeBuilder dynamicType =
+      new KernelNamedTypeBuilder("dynamic", null, -1, null);
+
   KernelTarget(DillTarget dillTarget, TranslateUri uriTranslator,
       [Map<String, Source> uriToSource])
       : dillTarget = dillTarget,
         uriToSource = uriToSource ?? CompilerContext.current.uriToSource,
         super(dillTarget.ticker, uriTranslator) {
     resetCrashReporting();
     loader = createLoader();
   }
 
   SourceLoader<Library> createLoader() => new SourceLoader<Library>(this);
@@ skipping 276 matching lines @@
     return loader.coreLibrary.exports["Object"];
   }
 
   Class get objectClass => objectClassBuilder.cls;
 
   /// If [builder] doesn't have a constructors, install the defaults.
   void installDefaultConstructor(SourceClassBuilder builder) {
     if (builder.isMixinApplication || builder.constructors.isNotEmpty) return;
 
     /// Quotes below are from [Dart Programming Language Specification, 4th
-    /// Edition](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-408.pdf):
+    /// Edition](
+    /// http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-408.pdf):
     if (builder is NamedMixinApplicationBuilder) {
       /// >A mixin application of the form S with M; defines a class C with
       /// >superclass S.
       /// >...
 
       /// >Let LM be the library in which M is declared. For each generative
       /// >constructor named qi(Ti1 ai1, . . . , Tiki aiki), i in 1..n of S
       /// >that is accessible to LM , C has an implicitly declared constructor
       /// >named q'i = [C/S]qi of the form q'i(ai1,...,aiki) :
       /// >super(ai1,...,aiki);.
       Builder supertype = builder;
       while (supertype is NamedMixinApplicationBuilder) {
         NamedMixinApplicationBuilder named = supertype;
         TypeBuilder type = named.mixinApplication;
         if (type is MixinApplicationBuilder) {
           MixinApplicationBuilder t = type;
           type = t.supertype;
         }
         if (type is NamedTypeBuilder) {
           supertype = type.builder;
         } else {
           internalError("Unhandled: ${type.runtimeType}");
         }
       }
       if (supertype is KernelClassBuilder) {
+        Map<TypeParameter, DartType> substitutionMap =
+            computeKernelSubstitutionMap(
+                builder.getSubstitutionMap(supertype, builder.fileUri,
+                    builder.charOffset, dynamicType),
+                builder.parent);
         for (Constructor constructor in supertype.cls.constructors) {
-          builder.addSyntheticConstructor(
-              makeMixinApplicationConstructor(builder.cls.mixin, constructor));
+          builder.addSyntheticConstructor(makeMixinApplicationConstructor(
+              builder.cls.mixin, constructor, substitutionMap));
         }
       } else {
         internalError("Unhandled: ${supertype.runtimeType}");
       }
     } else {
       /// >Iff no constructor is specified for a class C, it implicitly has a
       /// >default constructor C() : super() {}, unless C is class Object.
       // The superinitializer is installed below in [finishConstructors].
       builder.addSyntheticConstructor(makeDefaultConstructor());
     }
   }
 
-  Constructor makeMixinApplicationConstructor(
-      Class mixin, Constructor constructor) {
+  Map<TypeParameter, DartType> computeKernelSubstitutionMap(
+      Map<TypeVariableBuilder, TypeBuilder> substitutionMap,
+      LibraryBuilder library) {
+    if (substitutionMap == null) return const <TypeParameter, DartType>{};
+    Map<TypeParameter, DartType> result = <TypeParameter, DartType>{};
+    substitutionMap
+        .forEach((TypeVariableBuilder variable, TypeBuilder argument) {
+      result[variable.target] = argument.build(library);
+    });
+    return result;
+  }
+
+  Constructor makeMixinApplicationConstructor(Class mixin,
+      Constructor constructor, Map<TypeParameter, DartType> substitutionMap) {
     VariableDeclaration copyFormal(VariableDeclaration formal) {
       // TODO(ahe): Handle initializers.
       return new VariableDeclaration(formal.name,
-          type: formal.type, isFinal: formal.isFinal, isConst: formal.isConst);
+          type: substitute(formal.type, substitutionMap),
+          isFinal: formal.isFinal,
+          isConst: formal.isConst);
     }
 
     List<VariableDeclaration> positionalParameters = <VariableDeclaration>[];
     List<VariableDeclaration> namedParameters = <VariableDeclaration>[];
     List<Expression> positional = <Expression>[];
     List<NamedExpression> named = <NamedExpression>[];
     for (VariableDeclaration formal
         in constructor.function.positionalParameters) {
       positionalParameters.add(copyFormal(formal));
       positional.add(new VariableGet(positionalParameters.last));
@@ skipping 155 matching lines @@
   }
   for (Constructor constructor in superclass.constructors) {
     if (constructor.name.name.isEmpty) {
       return constructor.function.requiredParameterCount == 0
           ? constructor
           : null;
     }
   }
   return null;
 }