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 389 matching lines @@
     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 940 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 = /*warning: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 279 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};
   }
 }
 ''');
   }
 
   void test_typePromotionFromDynamic() {
     checkFile(r'''
 f() {
@@ skipping 309 matching lines @@
     // Regression test for https://github.com/dart-lang/sdk/issues/25069
     checkFile('''
 typedef int Foo();
 void foo() {}
 void main () {
   Foo x = /*error:INVALID_ASSIGNMENT,info:USE_OF_VOID_RESULT*/foo();
 }
 ''');
   }
 }