fix #30423, covariant parameter tearoff type should be Object

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';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/ast/token.dart' show StringToken;
-import 'package:analyzer/src/dart/element/element.dart'
-    show FieldElementImpl, LocalVariableElementImpl;
-import 'package:analyzer/src/dart/element/type.dart' show DynamicTypeImpl;
+import 'package:analyzer/src/dart/element/element.dart';
+import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/resolver.dart'
     show TypeProvider, NamespaceBuilder;
 import 'package:analyzer/src/generated/type_system.dart'
     show StrongTypeSystemImpl;
 import 'package:analyzer/src/summary/idl.dart' show UnlinkedUnit;
 import 'package:analyzer/src/summary/link.dart' as summary_link;
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/summary/summarize_ast.dart'
@@ skipping 1984 matching lines @@
         elementToType = (ExecutableElement element) => element.type;
         getOverride = classElem.lookUpInheritedConcreteGetter;
         lookup = classElem.type.lookUpInheritedGetter;
         tMember = node.isStatic ? tStaticGetters : tInstanceGetters;
       } else if (node.isSetter) {
         elementToType = (ExecutableElement element) => element.type;
         getOverride = classElem.lookUpInheritedConcreteSetter;
         lookup = classElem.type.lookUpInheritedSetter;
         tMember = node.isStatic ? tStaticSetters : tInstanceSetters;
       } else {
-        // Method
-        // Swap in "Object" for parameter types that are covariant overrides.
-        var objectType = context.typeProvider.objectType;
-        elementToType =
-            (MethodElement element) => element.getReifiedType(objectType);
+        // Swap in "Object" for parameter types that are covariant, either via
+        // the `covariant` keyword or because of covariant generics.
+        elementToType = _getMemberRuntimeType;
         getOverride = classElem.lookUpInheritedConcreteMethod;
         lookup = classElem.type.lookUpInheritedMethod;
         tMember = node.isStatic ? tStaticMethods : tInstanceMethods;
       }
 
       DartType reifiedType = elementToType(element);
       // Don't add redundant signatures for inherited methods whose signature
       // did not change.  If we are not overriding, or if the thing we are
       // overriding has a different reified type from ourselves, we must
       // emit a signature on this class.  Otherwise we will inherit the
@@ skipping 145 matching lines @@
               return self.call.apply(self, args);
             }
             self.__proto__ = this.__proto__;
             callableClass.call(self, #);
             return self;
           }
           #
         }''', [params, params, body]);
   }
 
+  FunctionType _getMemberRuntimeType(ExecutableElement element) {
+    // Check whether we have any covariant parameters.
+    // Usually we don't, so we can use the same type.
+    if (!element.parameters.any(_isCovariant)) return element.type;
+
+    var parameters = element.parameters
+        .map((p) => new ParameterElementImpl.synthetic(p.name,
+            _isCovariant(p) ? objectClass.type : p.type, p.parameterKind))
+        .toList();
+
+    var function = new FunctionElementImpl("", -1)
+      ..isSynthetic = true
+      ..returnType = element.returnType
+      ..shareTypeParameters(element.typeParameters)
+      ..parameters = parameters;
+    return function.type = new FunctionTypeImpl(function);
+  }
+
   JS.Expression _constructorName(ConstructorElement ctor) {
     var name = ctor.name;
     if (name == '') {
       // Default constructors (factory or not) use `new` as their name.
       return _propertyName('new');
     }
     return _emitMemberName(name, isStatic: true);
   }
 
   JS.Block _emitConstructorBody(ConstructorDeclaration node,
@@ skipping 175 matching lines @@
   /// Emits argument initializers, which handles optional/named args, as well
   /// as generic type checks needed due to our covariance.
   JS.Statement _emitArgumentInitializers(node, {bool constructor: false}) {
     // Constructor argument initializers are emitted earlier in the code, rather
     // than always when we visit the function body, so we control it explicitly.
     if (node is ConstructorDeclaration != constructor) return null;
 
     var parameters = _parametersOf(node);
     if (parameters == null) return null;
 
-    var covariantParams = _classProperties?.covariantParameters;
-
     var body = <JS.Statement>[];
     for (var param in parameters.parameters) {
       var jsParam = _emitSimpleIdentifier(param.identifier);
 
       if (!options.destructureNamedParams) {
         if (param.kind == ParameterKind.NAMED) {
           // Parameters will be passed using their real names, not the (possibly
           // renamed) local variable.
           var paramName = js.string(param.identifier.name, "'");
 
           // TODO(ochafik): Fix `'prop' in obj` to please Closure's renaming.
           body.add(js.statement('let # = # && # in # ? #.# : #;', [
             jsParam,
             namedArgumentTemp,
             paramName,
             namedArgumentTemp,
             namedArgumentTemp,
             paramName,
             _defaultParamValue(param),
           ]));
         } else if (param.kind == ParameterKind.POSITIONAL) {
           body.add(js.statement('if (# === void 0) # = #;',
               [jsParam, jsParam, _defaultParamValue(param)]));
         }
       }
 
       var paramElement = resolutionMap.elementDeclaredByFormalParameter(param);
-      if (paramElement.isCovariant ||
-          covariantParams != null && covariantParams.contains(paramElement)) {
+      if (_isCovariant(paramElement)) {
         var castType = _emitType(paramElement.type);
         body.add(js.statement('#._check(#);', [castType, jsParam]));
       }
     }
     return body.isEmpty ? null : _statement(body);
   }
 
+  bool _isCovariant(ParameterElement p) {
+    if (p.isCovariant) return true;
+    var covariantParams = _classProperties?.covariantParameters;
+    return covariantParams != null && covariantParams.contains(p);
+  }
+
   JS.Expression _defaultParamValue(FormalParameter param) {
     if (param is DefaultFormalParameter && param.defaultValue != null) {
       return _visit(param.defaultValue);
     } else {
       return new JS.LiteralNull();
     }
   }
 
   JS.Fun _emitNativeFunctionBody(MethodDeclaration node) {
     String name =
@@ skipping 3537 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;
 }