fixes #27586, prefer context type in generic inference

pkg/analyzer/test/generated/strong_mode_test.dart

 // Copyright (c) 2016, 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.generated.strong_mode_test;
 
 import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
@@ skipping 70 matching lines @@
       _isFutureOrOf =
           _isInstantiationOf(_hasElementOf(typeProvider.futureOrType));
       _isFutureOfDynamic = _isFutureOf([_isDynamic]);
       _isFutureOfInt = _isFutureOf([_isInt]);
       _isFutureOrOfInt = _isFutureOrOf([_isInt]);
       _isStreamOf = _isInstantiationOf(_hasElementOf(typeProvider.streamType));
     }
     return result;
   }
 
   fail_constrainedByBounds3() async {

[Leaf, 2017/02/17 22:26:03]

I think I added these to test ordering behavior of inference in one of you CLs. 
Has this ordering behavior been removed/changed?  If so this should be updated
to test the new behavior.

[Jennifer Messerly, 2017/03/14 02:07:07]

it's passing now!

     // Test that upwards inference with two type variables does
     // not propogate from the constrained variable to the unconstrained
     // variable if they are ordered right to left, and that if the result
     // is not a valid instantiation an error is issued
     String code = r'''
     T f<T extends S, S extends int>(S x) => null;
     void test() { var x = f(3); }
    ''';
     Source source = addSource(code);
     TestAnalysisResult analysisResult = await computeAnalysisResult(source);
     assertErrors(
         source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
     CompilationUnit unit = analysisResult.unit;
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "test");
     VariableDeclarationStatement stmt = statements[0];
     VariableDeclaration decl = stmt.variables.variables[0];
     Expression call = decl.initializer;
     _isDynamic(call.staticType);
   }
 
   fail_constrainedByBounds5() async {

[Leaf, 2017/02/17 22:26:03]

ditto

[Jennifer Messerly, 2017/03/14 02:07:07]

same, this is now passing!

     // Test that upwards inference with two type variables does not
     // propogate from the constrained variable to the unconstrained
     // variable if they are ordered right to left, when the variable
     // appears co and contra variantly, and that an error is issued
     // for the non-matching bound.
     String code = r'''
     typedef To Func1<From, To>(From x);
     T f<T extends Func1<S, S>, S>(S x) => null;
     void test() { var x = f(3)(4); }
    ''';
@@ skipping 10 matching lines @@
     Expression call = decl.initializer;
     _isInt(call.staticType);
   }
 
   fail_futureOr_downwards7() async {
     // Test that downwards inference incorporates bounds correctly
     // when instantiating type variables.
     // TODO(leafp): I think this should pass once the inference changes
     // that jmesserly is adding are landed.
     MethodInvocation invoke = await _testFutureOr(r'''
     T mk<T extends int>(T x) => null;

[Leaf, 2017/02/17 22:26:03]

This test looks bogus.  I think maybe the intention was to check that we used
the bound to narrow the inferred type from FutureOr<int> to int?  So maybe the
argument to mk should be 42?  And the assertions should be checking for _isInt?

[Jennifer Messerly, 2017/03/14 02:07:07]

yup, I fixed it & it now passes

     FutureOr<int> test() => mk(new Future.value(42));
     ''');
     _isFutureOfInt(invoke.staticType);
     _isFutureOfInt(invoke.argumentList.arguments[0].staticType);
   }
 
   fail_futureOr_downwards8() async {

[Leaf, 2017/02/17 22:26:03]

Also looks bogus to me now - I think should be T extends Future<int>?  And then
should pass?

[Jennifer Messerly, 2017/03/14 02:07:07]

Hmmm, maybe you're right. I actually went ahead and fixed it before I saw your
comment, by allowing inference's way of combining constraints figure out that
GLB(FutureOr<int>, Future<Object>) should be Future<int>. But we could remove
that code easily.

     // Test that downwards inference incorporates bounds correctly
     // when instantiating type variables.
     // TODO(leafp): I think this should pass once the inference changes
     // that jmesserly is adding are landed.
     MethodInvocation invoke = await _testFutureOr(r'''
     T mk<T extends Future<Object>>(T x) => null;
     FutureOr<int> test() => mk(new Future.value(42));
     ''');
     _isFutureOfInt(invoke.staticType);
     _isFutureOfInt(invoke.argumentList.arguments[0].staticType);
   }
 
   fail_pinning_multipleConstraints1() async {

[Leaf, 2017/02/17 22:26:03]

Why is this failing?  Are we inferring Null?

[Jennifer Messerly, 2017/03/14 02:07:07]

it's passing now

     // Test that downwards inference with two different downwards covariant
     // constraints on the same parameter correctly fails to infer when
     // the types do not share a common subtype
     String code = r'''
     class A<S, T> {
       S s;
       T t;
     }
     class B<S> extends A<S, S> { B(S s); }
     A<int, String> test() => new B(3);
    ''';
     Source source = addSource(code);
     TestAnalysisResult analysisResult = await computeAnalysisResult(source);
     assertErrors(source, [StrongModeCode.COULD_NOT_INFER]);
     verify([source]);
     CompilationUnit unit = analysisResult.unit;
     FunctionDeclaration test = AstFinder.getTopLevelFunction(unit, "test");
     ExpressionFunctionBody body = test.functionExpression.body;
     DartType type = body.expression.staticType;
 
     Element elementB = AstFinder.getClass(unit, "B").element;
 
     _isInstantiationOf(_hasElement(elementB))([_isDynamic])(type);
   }
 
-  fail_pinning_multipleConstraints2() async {
+  test_pinning_multipleConstraints2() async {
     // Test that downwards inference with two identical downwards covariant
     // constraints on the same parameter correctly infers and pins the type
     String code = r'''
     class A<S, T> {
       S s;
       T t;
     }
     class B<S> extends A<S, S> { B(S s); }
     A<num, num> test() => new B(3);
    ''';
@@ skipping 33 matching lines @@
     CompilationUnit unit = analysisResult.unit;
     FunctionDeclaration test = AstFinder.getTopLevelFunction(unit, "test");
     ExpressionFunctionBody body = test.functionExpression.body;
     DartType type = body.expression.staticType;
 
     Element elementB = AstFinder.getClass(unit, "B").element;
 
     _isInstantiationOf(_hasElement(elementB))([_isDynamic])(type);
   }
 
-  fail_returnType_variance2() async {
+  pass_returnType_variance2() async {

[Leaf, 2017/02/17 22:26:03]

Should this be test_?  Or is this a valid prefix?

[Jennifer Messerly, 2017/03/14 02:07:07]

good catch. fixed & test passes :)

     // Check that downwards inference correctly pins a type parameter
     // when the parameter is constrained in a covariant position
     String code = r'''
     typedef To Func1<From, To>(From x);
     Func1<String, T> f<T>(T x) => null;
     Func1<String, num> test() => f(42);
    ''';
     Source source = addSource(code);
     TestAnalysisResult analysisResult = await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = analysisResult.unit;
     FunctionDeclaration test = AstFinder.getTopLevelFunction(unit, "test");
     ExpressionFunctionBody body = test.functionExpression.body;
     MethodInvocation invoke = body.expression;
     _isFunction2Of(_isNum, _isFunction2Of(_isString, _isNum))(
         invoke.staticInvokeType);
   }
 
-  fail_returnType_variance6() async {
+  pass_returnType_variance6() async {
     // Check that pinning works correctly with a partial type
     // when the return type uses the variable in a covariant position
     String code = r'''
     typedef To Func1<From, To>(From x);
     Func1<String, T> f<T>(T x) => null;
     T g<T, S>(Func1<S, T> f) => null;
     num test() => g(f(3));
    ''';
     Source source = addSource(code);
     TestAnalysisResult analysisResult = await computeAnalysisResult(source);
@@ skipping 732 matching lines @@
     _isFutureOf([_isNum])(invoke.argumentList.arguments[0].staticType);
   }
 
   test_futureOr_downwards6() async {
     // Test that downwards inference doesn't decompose FutureOr
     // when instantiating type variables.
     MethodInvocation invoke = await _testFutureOr(r'''
     T mk<T>(T x) => null;
     FutureOr<int> test() => mk(new Future.value(42));
     ''');
-    _isFutureOfInt(invoke.staticType);
+    _isFutureOrOfInt(invoke.staticType);
     _isFutureOfInt(invoke.argumentList.arguments[0].staticType);
   }
 
   test_futureOr_downwards9() async {
     // Test that downwards inference decomposes correctly with
     // other composite types
     MethodInvocation invoke = await _testFutureOr(r'''
     List<T> mk<T>(T x) => null;
     FutureOr<List<int>> test() => mk(3);
     ''');
@@ skipping 51 matching lines @@
 
   test_futureOr_upwards2() async {
     // Test that upwards inference fails when the solution doesn't
     // match the bound.
     MethodInvocation invoke = await _testFutureOr(
         r'''
     Future<T> mk<T extends Future<Object>>(FutureOr<T> x) => null;
     dynamic test() => mk(new Future<int>.value(42));
     ''',
         errors: [StrongModeCode.COULD_NOT_INFER]);
-    _isFutureOf([_isObject])(invoke.staticType);
+    _isFutureOfInt(invoke.staticType);
   }
 
   test_futureOr_assignFromValue() async {
     // Test a T can be assigned to FutureOr<T>.
     MethodInvocation invoke = await _testFutureOr(r'''
     FutureOr<T> mk<T>(T x) => x;
     test() => mk(42);
     ''');
     _isFutureOrOfInt(invoke.staticType);
   }
@@ skipping 1123 matching lines @@
         Expression exp = (statements[i] as ExpressionStatement).expression;
         expect(exp.staticType, typeProvider.dynamicType);
       }
     }
 
     checkBody("C");
     checkBody("D");
   }
 
   test_genericFunction_upwardsAndDownwards() async {
-    // Regression tests for https://github.com/dart-lang/sdk/issues/27151.
+    // Regression tests for https://github.com/dart-lang/sdk/issues/27586.
     await resolveTestUnit(r'List<num> x = [1, 2];');
-    expectInitializerType('x', 'List<int>');
+    expectInitializerType('x', 'List<num>');
   }
 
+  test_genericFunction_upwardsAndDownwards_Object() async {
+    // Regression tests for https://github.com/dart-lang/sdk/issues/27625.
+    await resolveTestUnit(r'''
+List<Object> aaa = [];
+List<Object> bbb = [1, 2, 3];
+List<Object> ccc = [null];
+List<Object> ddd = [1 as dynamic];
+List<Object> eee = [new Object()];
+    ''');
+    expectInitializerType('aaa', 'List<Object>');
+    expectInitializerType('bbb', 'List<Object>');
+    expectInitializerType('ccc', 'List<Object>');
+    expectInitializerType('ddd', 'List<Object>');
+    expectInitializerType('eee', 'List<Object>');
+  }
+
+
   test_genericMethod() async {
     await resolveTestUnit(r'''
 class C<E> {
   List/*<T>*/ f/*<T>*/(E e) => null;
 }
 main() {
   C<String> cOfString;
 }
 ''');
     expectFunctionType('f', '<T>(E) → List<T>',
@@ skipping 629 matching lines @@
   void main() {
     m(null, null);
   }
 }
 ''';
     await resolveTestUnit(code);
     assertNoErrors(testSource);
     expectStaticInvokeType('m(null', '(T, List<T>) → void');
   }
 
+  test_instantiateToBounds_method_ok_referenceOther_before2() async {
+    String code = r'''
+class C<T> {
+  Map<S0, S1> m<S0 extends T, S1 extends List<S0>>() => null;
+
+  void main() {
+    m();
+  }
+}
+''';
+    await resolveTestUnit(code);
+    assertNoErrors(testSource);
+    expectStaticInvokeType('m();', '() → Map<T, List<T>>');
+  }
+
   test_instantiateToBounds_method_ok_simpleBounds() async {
     String code = r'''
 class C<T> {
   void m<S extends T>(S p0) {}
 
   void main() {
     m(null);
   }
 }
 ''';
     await resolveTestUnit(code);
     assertNoErrors(testSource);
     expectStaticInvokeType('m(null)', '(T) → void');
   }
 
+  test_instantiateToBounds_method_ok_simpleBounds2() async {
+    String code = r'''
+class C<T> {
+  S m<S extends T>() => null;
+
+  void main() {
+    m();
+  }
+}
+''';
+    await resolveTestUnit(code);
+    assertNoErrors(testSource);
+    expectStaticInvokeType('m();', '() → T');
+  }
+
   test_notInstantiatedBound_direct_class_class() async {
     String code = r'''
 class A<T extends int> {}
 class C<T extends A> {}
 ''';
     await resolveTestUnit(code, noErrors: false);
     assertErrors(testSource, [StrongModeCode.NOT_INSTANTIATED_BOUND]);
   }
 
   test_notInstantiatedBound_direct_class_typedef() async {
@@ skipping 513 matching lines @@
   var v = x;
   v; // marker
 }
 int x = 3;
 ''';
     CompilationUnit unit = await resolveSource(code);
     assertPropagatedAssignedType(code, unit, typeProvider.intType, null);
     assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 }