fix #30427, casting tearoffs to the wrong type

pkg/analyzer/lib/src/task/strong/checker.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.
 
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.checker;
 
 import 'dart:collection';
 import 'package:analyzer/analyzer.dart';
@@ skipping 892 matching lines @@
       }
 
       // Get the lower bound of the declared return type (e.g. `F<Null>`) and
       // see if it can be assigned to the expected type (e.g. `F<Object>`).
       //
       // That way we can tell if any lower `T` will work or not.
       var classType = targetType.element.type;
       var classLowerBound = classType.instantiate(new List.filled(
           classType.typeParameters.length, typeProvider.nullType));
       var memberLowerBound = _lookUpMember(classLowerBound, member).type;
       var expectedType = member.returnType;

[Jennifer Messerly, 2017/08/11 22:06:07]

If we wanted to fix other covariant tearoffs by casting at tearoff point, we
could do it here.

instead of using ".returnType" on both sides, just evaluate the full type:


var worstCaseType = _lookUpMember(classLowerBound, member).type;
var expectedType = member.type

var isMethod = member is MethodElement;
var isCall = node is MethodInvocation;
var isTearOff = isMethod && !isCall;
if (!isTearOff) {
  // For non-tearoff, we're only interested in the return type.
  expectedType = expectedType.returnType;
  worstCaseType = worstCaseType.returnType;
}

... rest of code as normal & revert the changes I'm making below, because
tearoffs won't be special anymore and "expectedType" will mean the right thing
:)

 
       if (!rules.isSubtypeOf(memberLowerBound.returnType, expectedType)) {
-        if (node is MethodInvocation && member is! MethodElement) {
-          // If `o.m` is not a method, we need to cast `o.m` before the call:
-          // `(o.m as expectedType)(args)`.
+        var isMethod = member is MethodElement;
+        var isCall = node is MethodInvocation;
+
+        if (isMethod && !isCall) {
+          // If `o.m` is a method tearoff, cast to the method type.
+          setImplicitCast(node, member.type);
+        } else if (!isMethod && isCall) {
+          // If `o.g()` is calling a field/getter `g`, we need to cast `o.g`
+          // before the call: `(o.g as expectedType)(args)`.
           // This cannot be represented by an `as` node without changing the
           // Dart AST structure, so we record it as a special cast.
           setImplicitOperationCast(node, expectedType);
         } else {
+          // For method calls `o.m()` or getters `o.g`, simply cast the result.
           setImplicitCast(node, expectedType);
         }
         _hasImplicitCasts = true;
       }
     }
   }
 
   /// Returns true if we can safely skip the covariance checks because [target]
   /// has known type arguments, such as `this` `super` or a non-factory `new`.
   ///
@@ skipping 1041 matching lines @@
   }
 
   /// If node is a [ClassDeclaration] returns its members, otherwise if node is
   /// a [ClassTypeAlias] this returns an empty list.
   WithClause _withClause(Declaration node) {
     return node is ClassDeclaration
         ? node.withClause
         : (node as ClassTypeAlias).withClause;
   }
 }