fixes #27586, prefer context type in generic inference

pkg/analyzer/test/src/task/strong/checker_test.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.
 
 library analyzer.test.src.task.strong.checker_test;
 
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'strong_test_helper.dart';
 
@@ skipping 369 matching lines @@
     await checkFile('''
 abstract class Equality<Q> {}
 abstract class EqualityBase<R> implements Equality<R> {
   final C<R> c = /*info:INFERRED_TYPE_ALLOCATION*/const C();
   const EqualityBase();
 }
 class DefaultEquality<S> extends EqualityBase<S> {
   const DefaultEquality();
 }
 class SetEquality<T> implements Equality<T> {
-  final Equality<T> field = const DefaultEquality();
-  const SetEquality([Equality<T> inner = const DefaultEquality()]);
+  final Equality<T> field = /*info:INFERRED_TYPE_ALLOCATION*/const DefaultEquality();
+  const SetEquality([Equality<T> inner = /*info:INFERRED_TYPE_ALLOCATION*/const DefaultEquality()]);
 }
 class C<Q> {
   final List<Q> list = /*info:INFERRED_TYPE_LITERAL*/const [];
   final Map<Q, Iterable<Q>> m =  /*info:INFERRED_TYPE_LITERAL*/const {};
   const C();
 }
 main() {
   const SetEquality<String>();
 }
     ''');
@@ skipping 2021 matching lines @@
     addFile(r'''
 class C<T> {}
 class M1<T extends /*error:IMPLICIT_DYNAMIC_TYPE*/List> {}
 class M2<T> {}
 class I<T> {}
 class D<T, S> extends /*error:IMPLICIT_DYNAMIC_TYPE*/C
     with M1, /*error:IMPLICIT_DYNAMIC_TYPE*/M2
     implements /*error:IMPLICIT_DYNAMIC_TYPE*/I {}
 
 C f(D d) {
-  D x = new /*error:IMPLICIT_DYNAMIC_TYPE*/D();
+  D x = /*info:INFERRED_TYPE_ALLOCATION*/new /*error:IMPLICIT_DYNAMIC_TYPE*/D();
   D<int, dynamic> y = /*info:INFERRED_TYPE_ALLOCATION*/new /*error:IMPLICIT_DYNAMIC_TYPE*/D();
   D<dynamic, int> z = /*info:INFERRED_TYPE_ALLOCATION*/new /*error:IMPLICIT_DYNAMIC_TYPE*/D();
-  return new /*error:IMPLICIT_DYNAMIC_TYPE*/C();
+  return /*info:INFERRED_TYPE_ALLOCATION*/new /*error:IMPLICIT_DYNAMIC_TYPE*/C();
 }
 
 class A<T extends num> {}
 class N1<T extends List<int>> {}
 class N2<T extends Object> {}
 class J<T extends Object> {}
 class B<T extends Object> extends A with N1, N2 implements J {}
 A g(B b) {
   B y = /*info:INFERRED_TYPE_ALLOCATION*/new B();
   return /*info:INFERRED_TYPE_ALLOCATION*/new A();
@@ skipping 935 matching lines @@
   M<Object> mOfOs;
   M<A> mOfAs;
 
   {
     lOfDs = mOfDs;
     lOfDs = mOfOs;
     lOfDs = mOfAs;
     lOfDs = lOfDs;
     lOfDs = lOfOs;
     lOfDs = lOfAs;
-    lOfDs = new L(); // Reset type propagation.
+    lOfDs = /*info:INFERRED_TYPE_ALLOCATION*/new L(); // Reset type propagation.
   }
   {
     lOfOs = mOfDs;
     lOfOs = mOfOs;
     lOfOs = mOfAs;
     lOfOs = lOfDs;
     lOfOs = lOfOs;
     lOfOs = lOfAs;
     lOfOs = new L<Object>(); // Reset type propagation.
   }
   {
     lOfAs = /*error:INVALID_ASSIGNMENT*/mOfDs;
     lOfAs = /*error:INVALID_ASSIGNMENT*/mOfOs;
     lOfAs = mOfAs;
     lOfAs = /*info:DOWN_CAST_COMPOSITE*/lOfDs;
     lOfAs = /*info:DOWN_CAST_IMPLICIT*/lOfOs;
     lOfAs = lOfAs;
     lOfAs = new L<A>(); // Reset type propagation.
   }
   {
     mOfDs = mOfDs;
     mOfDs = mOfOs;
     mOfDs = mOfAs;
     mOfDs = /*info:DOWN_CAST_IMPLICIT*/lOfDs;
     mOfDs = /*info:DOWN_CAST_IMPLICIT*/lOfOs;
     mOfDs = /*error:INVALID_ASSIGNMENT*/lOfAs;
-    mOfDs = new M(); // Reset type propagation.
+    mOfDs = /*info:INFERRED_TYPE_ALLOCATION*/new M(); // Reset type propagation.
   }
   {
     mOfOs = mOfDs;
     mOfOs = mOfOs;
     mOfOs = mOfAs;
     mOfOs = /*info:DOWN_CAST_IMPLICIT*/lOfDs;
     mOfOs = /*info:DOWN_CAST_IMPLICIT*/lOfOs;
     mOfOs = /*error:INVALID_ASSIGNMENT*/lOfAs;
     mOfOs = new M<Object>(); // Reset type propagation.
   }
@@ skipping 334 matching lines @@
   num n = 3;
   int i = 3;
   String s = "hello";
   {
      List<int> l = <int>[i];
      l = <int>[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/s];
      l = <int>[/*info:DOWN_CAST_IMPLICIT*/n];
      l = <int>[i, /*info:DOWN_CAST_IMPLICIT*/n, /*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/s];
   }
   {
-     List l = /*info:INFERRED_TYPE_LITERAL*/[i];
-     l = /*info:INFERRED_TYPE_LITERAL*/[s];
-     l = /*info:INFERRED_TYPE_LITERAL*/[n];
-     l = /*info:INFERRED_TYPE_LITERAL*/[i, n, s];
+     List l = [i];
+     l = [s];
+     l = [n];
+     l = [i, n, s];
   }
   {
      Map<String, int> m = <String, int>{s: i};
      m = <String, int>{s: /*error:MAP_VALUE_TYPE_NOT_ASSIGNABLE*/s};
      m = <String, int>{s: /*info:DOWN_CAST_IMPLICIT*/n};
      m = <String, int>{s: i,
                        s: /*info:DOWN_CAST_IMPLICIT*/n,
                        s: /*error:MAP_VALUE_TYPE_NOT_ASSIGNABLE*/s};
   }
  // TODO(leafp): We can't currently test for key errors since the
  // error marker binds to the entire entry.
   {
-     Map m = /*info:INFERRED_TYPE_LITERAL*/{s: i};
-     m = /*info:INFERRED_TYPE_LITERAL*/{s: s};
-     m = /*info:INFERRED_TYPE_LITERAL*/{s: n};
-     m = /*info:INFERRED_TYPE_LITERAL*/
-         {s: i,
+     Map m = {s: i};
+     m = {s: s};
+     m = {s: n};
+     m = {s: i,
           s: n,
           s: s};
-     m = /*info:INFERRED_TYPE_LITERAL*/
-         {i: s,
+     m = {i: s,
           n: s,
           s: s};
   }
 }
 ''');
   }
 
   test_typePromotionFromDynamic() async {
     await checkFile(r'''
 f() {
@@ skipping 50 matching lines @@
 void f/*<T extends num>*/(T x, T y) {
   var z = x;
   var f = () => x;
   f = () => y;
   if (x is int) {
     /*info:DYNAMIC_INVOKE*/z./*error:UNDEFINED_GETTER*/isEven;
     var q = x;
     q = /*info:DOWN_CAST_COMPOSITE*/z;
     /*info:DYNAMIC_INVOKE*/f()./*error:UNDEFINED_GETTER*/isEven;
 
-    // This does not capture the type `T extends int`. Instead the return type
-    // is `T extends num`. What happens is we substitute {T/T} on the function
-    // type, and the way it is implemented, this leads back to `T extends num`.
-    // See https://github.com/dart-lang/sdk/issues/27725
+    // This captures the type `T extends int`.
     var g = () => x;
-    g = f;
-    /*info:DYNAMIC_INVOKE*/g()./*error:UNDEFINED_GETTER*/isEven;
-    q = /*info:DOWN_CAST_COMPOSITE*/g();
+    g = /*info:DOWN_CAST_COMPOSITE*/f;
+    g().isEven;
+    q = g();
     int r = x;
   }
 }
     ''');
   }
 
   test_typeSubtyping_assigningClass() async {
     await checkFile('''
 class A {}
 class B extends A {}
@@ skipping 256 matching lines @@
 class CheckerTest_Driver extends CheckerTest {
   @override
   bool get enableNewAnalysisDriver => true;
 
   @failingTest
   @override
   test_covariantOverride_fields() async {
     await super.test_covariantOverride_fields();
   }
 }