Use "Object" as the reified type of covariant override parameters.

pkg/dev_compiler/lib/src/compiler/code_generator.dart

 // Copyright (c) 2015, 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 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 170 matching lines @@
 
   /// The main entry point to JavaScript code generation.
   ///
   /// Takes the metadata for the build unit, as well as resolved trees and
   /// errors, and computes the output module code and optionally the source map.
   JSModuleFile compile(BuildUnit unit, List<CompilationUnit> compilationUnits,
       List<String> errors) {
     _buildUnit = unit;
     _libraryRoot = _buildUnit.libraryRoot;
     if (!_libraryRoot.endsWith(separator)) {
-      _libraryRoot = '$_libraryRoot${separator}';
+      _libraryRoot += separator;
     }
 
     var module = _emitModule(compilationUnits);
     var dartApiSummary = _summarizeModule(compilationUnits);
 
     return new JSModuleFile(unit.name, errors, options, module, dartApiSummary);
   }
 
   List<int> _summarizeModule(List<CompilationUnit> units) {
     if (!options.summarizeApi) return null;
@@ skipping 1597 matching lines @@
     for (MethodDeclaration node in methods) {
       var name = node.name.name;
       var element = resolutionMap.elementDeclaredByMethodDeclaration(node);
       // TODO(vsm): Clean up all the nasty duplication.
       if (node.isAbstract) {
         continue;
       }
 
       Function lookup;
       List<JS.Property> tMember;
-      JS.Expression type;
       if (node.isGetter) {
         lookup = classElem.lookUpInheritedConcreteGetter;
         tMember = node.isStatic ? tStaticGetters : tInstanceGetters;
       } else if (node.isSetter) {
         lookup = classElem.lookUpInheritedConcreteSetter;
         tMember = node.isStatic ? tStaticSetters : tInstanceSetters;
       } else {
         // Method
         lookup = classElem.lookUpInheritedConcreteMethod;
         tMember = node.isStatic ? tStaticMethods : tInstanceMethods;
       }
 
-      type = _emitAnnotatedFunctionType(element.type, node.metadata,
+      // Swap in "Object" over parameter types that are covariant overrides.
+      var objectType = context.typeProvider.objectType;
+      var reifiedType = element is MethodElement
+          ? element.getReifiedType(objectType)
+          : element.type;
+      var type = _emitAnnotatedFunctionType(reifiedType, node.metadata,
           parameters: node.parameters?.parameters,
           nameType: options.hoistSignatureTypes,
           hoistType: options.hoistSignatureTypes,
           definite: true);
 
+      // Don't add redundant signatures for inherited unchanged methods.
       var inheritedElement = lookup(name, currentLibrary);
-      if (inheritedElement != null && inheritedElement.type == element.type) {
+      if (inheritedElement != null &&
+          (inheritedElement is! MethodElement ||

[Leaf, 2017/01/18 01:51:45]

Is this right?  You're not checking that the type is the same for getters and
setters any more, right?

[Bob Nystrom, 2017/01/18 21:42:52]

Oops, fixed. Sorry.

+              inheritedElement.getReifiedType(objectType) == reifiedType)) {
         continue;
       }
+
       var memberName = _declareMemberName(element);
       var property = new JS.Property(memberName, type);
       tMember.add(property);
       // TODO(vsm): Why do we need this?
       if (node.isStatic && !node.isGetter && !node.isSetter) {
         sNames.add(memberName);
       }
     }
 
     var tInstanceFields = <JS.Property>[];
@@ skipping 1059 matching lines @@
       {List<FormalParameter> parameters,
       bool lowerTypedef: false,
       bool nameType: true,
       bool hoistType: true,
       definite: false}) {
     var parts = _emitFunctionTypeParts(type,
         parameters: parameters,
         lowerTypedef: lowerTypedef,
         nameType: nameType,
         hoistType: hoistType);
-    var helper = (definite) ? 'definiteFunctionType' : 'functionType';
+    var helper = definite ? 'definiteFunctionType' : 'functionType';
     var fullType = _callHelper('${helper}(#)', [parts]);
     if (!nameType) return fullType;
     return _typeTable.nameType(type, fullType,
         hoistType: hoistType, definite: definite);
   }
 
   JS.Expression _emitAnnotatedFunctionType(
       FunctionType type, List<Annotation> metadata,
       {List<FormalParameter> parameters,
       bool lowerTypedef: false,
@@ skipping 14 matching lines @@
   List<JS.Expression> _emitFunctionTypeParts(FunctionType type,
       {List<FormalParameter> parameters,
       bool lowerTypedef: false,
       bool nameType: true,
       bool hoistType: true}) {
     var parameterTypes = type.normalParameterTypes;
     var optionalTypes = type.optionalParameterTypes;
     var namedTypes = type.namedParameterTypes;
     var rt =
         _emitType(type.returnType, nameType: nameType, hoistType: hoistType);
+
     var ra = _emitTypeNames(parameterTypes, parameters,
         nameType: nameType, hoistType: hoistType);
 
     List<JS.Expression> typeParts;
     if (namedTypes.isNotEmpty) {
       assert(optionalTypes.isEmpty);
       // TODO(vsm): Pass in annotations here as well.
       var na = _emitTypeProperties(namedTypes);
       typeParts = [rt, ra, na];
     } else if (optionalTypes.isNotEmpty) {
@@ skipping 2875 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }