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 74 matching lines @@
           _isInstantiationOf(_hasElementOf(typeProvider.futureOrType));
       _isFutureOfDynamic = _isFutureOf([_isDynamic]);
       _isFutureOfInt = _isFutureOf([_isInt]);
       _isFutureOfNull = _isFutureOf([_isNull]);
       _isFutureOrOfInt = _isFutureOrOf([_isInt]);
       _isStreamOf = _isInstantiationOf(_hasElementOf(typeProvider.streamType));
     }
     return result;
   }
 
-  fail_constrainedByBounds3() async {
-    // 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);
+  @override
+  void setUp() {
+    super.setUp();
+    AnalysisOptionsImpl options = new AnalysisOptionsImpl();
+    options.strongMode = true;
+    resetWith(options: options);
+  }
+
+  test_constrainedByBounds3() async {

[Leaf, 2017/03/14 22:37:40]

Sort methods in file?

[Jennifer Messerly, 2017/03/14 23:49:09]

I can do that. It will destroy the diff, but that tradeoff is up to you, so I'll
go ahead and do it.

+    Source source = addSource(r'''
+      T f<T extends S, S extends int>(S x) => null;
+      void test() { var x = f(3); }
+   ''');
     TestAnalysisResult analysisResult = await computeAnalysisResult(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertNoErrors(source);
     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);
+    _isInt(call.staticType);
   }
 
-  fail_constrainedByBounds5() async {
+  test_constrainedByBounds5() async {
     // 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); }
    ''';
     Source source = addSource(code);
     TestAnalysisResult analysisResult = await computeAnalysisResult(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StrongModeCode.COULD_NOT_INFER]);
     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;
-    _isInt(call.staticType);
+    _isDynamic(call.staticType);
   }
 
-  fail_futureOr_downwards7() async {
+  test_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;
-    FutureOr<int> test() => mk(new Future.value(42));
+      T mk<T extends Future<int>>(T x) => null;
+      FutureOr<int> test() => mk(new Future.value(42));
     ''');
     _isFutureOfInt(invoke.staticType);
     _isFutureOfInt(invoke.argumentList.arguments[0].staticType);
   }
 
-  fail_futureOr_downwards8() async {
+  test_futureOr_downwards8() 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 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 {
+  test_pinning_multipleConstraints1() async {
     // 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]);
+    assertErrors(source,
+        [StrongModeCode.COULD_NOT_INFER, StrongModeCode.INVALID_CAST_LITERAL]);
     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);
+    _isInstantiationOf(_hasElement(elementB))([_isNull])(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);
    ''';
     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;
     DartType type = body.expression.staticType;
 
     Element elementB = AstFinder.getClass(unit, "B").element;
 
     _isInstantiationOf(_hasElement(elementB))([_isNum])(type);
   }
 
-  fail_pinning_multipleConstraints3() async {
+  test_pinning_multipleConstraints3() async {
     // 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, but do share a common supertype
     String code = r'''
     class A<S, T> {
       S s;
       T t;
     }
     class B<S> extends A<S, S> { B(S s); }
     A<int, double> test() => new B(3);
    ''';
     Source source = addSource(code);
     TestAnalysisResult analysisResult = await computeAnalysisResult(source);
     assertErrors(source, [
       StrongModeCode.COULD_NOT_INFER,
-      StaticTypeWarningCode.RETURN_OF_INVALID_TYPE
+      StrongModeCode.INVALID_CAST_LITERAL,
     ]);
     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);
+    _isInstantiationOf(_hasElement(elementB))([_isNull])(type);
   }
 
-  fail_returnType_variance2() async {
+  test_returnType_variance2() async {
     // 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 {
+  test_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);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = analysisResult.unit;
     FunctionDeclaration test = AstFinder.getTopLevelFunction(unit, "test");
     ExpressionFunctionBody body = test.functionExpression.body;
     MethodInvocation call = body.expression;
     _isNum(call.staticType);
     _isFunction2Of(_isFunction2Of(_isString, _isNum), _isNum)(
         call.staticInvokeType);
   }
 
-  @override
-  void setUp() {
-    super.setUp();
-    AnalysisOptionsImpl options = new AnalysisOptionsImpl();
-    options.strongMode = true;
-    resetWith(options: options);
-  }
-
   test_async_method_propagation() async {
     String code = r'''
       import "dart:async";
       class A {
         Future f0() => new Future.value(3);
         Future f1() async => new Future.value(3);
         Future f2() async => await new Future.value(3);
 
         Future<int> f3() => new Future.value(3);
         Future<int> f4() async => new Future.value(3);
@@ skipping 203 matching lines @@
         AstFinder.getStatementsInTopLevelFunction(unit, "test");
     VariableDeclarationStatement stmt = statements[0];
     VariableDeclaration decl = stmt.variables.variables[0];
     Expression call = decl.initializer;
     _isInt(call.staticType);
   }
 
   test_constrainedByBounds2() async {
     // 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.

[Leaf, 2017/03/14 22:37:40]

Looks like your code now handles right to left?  Update the comment to reflect
that this is a positive test now?

[Jennifer Messerly, 2017/03/14 23:49:09]

Done.

     String code = r'''
     T f<T extends S, S>(S x) => null;
     void test() { var x = f(3); }
    ''';
     Source source = addSource(code);
     TestAnalysisResult analysisResult = await computeAnalysisResult(source);
     assertNoErrors(source);
     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);
+    _isInt(call.staticType);
   }
 
   test_constrainedByBounds4() async {
     // Test that upwards inference with two type variables correctly
     // propogates from the constrained variable to the unconstrained
     // variable if they are ordered left to right, when the variable
     // appears co and contra variantly
     String code = r'''
     typedef To Func1<From, To>(From x);
     T f<S, T extends Func1<S, S>>(S x) => null;
@@ skipping 509 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 40 matching lines @@
   }
 
   test_futureOr_no_return() async {
     MethodInvocation invoke = await _testFutureOr(r'''
     FutureOr<T> mk<T>(Future<T> x) => x;
     Future<int> f;
     test() => f.then((int x) {});
     ''');
     _isFunction2Of(_isInt, _isNull)(
         invoke.argumentList.arguments[0].staticType);
-    _isFutureOfDynamic(invoke.staticType);
+    _isFutureOfNull(invoke.staticType);
   }
 
   test_futureOr_no_return_value() async {
     MethodInvocation invoke = await _testFutureOr(r'''
     FutureOr<T> mk<T>(Future<T> x) => x;
     Future<int> f;
     test() => f.then((int x) {return;});
     ''');
     _isFunction2Of(_isInt, _isNull)(
         invoke.argumentList.arguments[0].staticType);
-    _isFutureOfDynamic(invoke.staticType);
+    _isFutureOfNull(invoke.staticType);
   }
 
   test_futureOr_return_null() async {
     MethodInvocation invoke = await _testFutureOr(r'''
     FutureOr<T> mk<T>(Future<T> x) => x;
     Future<int> f;
     test() => f.then((int x) {});
     ''');
     _isFunction2Of(_isInt, _isNull)(
         invoke.argumentList.arguments[0].staticType);
-    _isFutureOfDynamic(invoke.staticType);
+    _isFutureOfNull(invoke.staticType);
   }
 
   test_futureOr_upwards1() async {
     // Test that upwards inference correctly prefers to instantiate type
     // variables with the "smaller" solution when both are possible.
     MethodInvocation invoke = await _testFutureOr(r'''
     Future<T> mk<T>(FutureOr<T> x) => null;
     dynamic test() => mk(new Future<int>.value(42));
     ''');
     _isFutureOfInt(invoke.staticType);
   }
 
   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_futureOrNull_no_return() async {
     MethodInvocation invoke = await _testFutureOr(r'''
     FutureOr<T> mk<T>(Future<T> x) => x;
     Future<int> f;
     test() => f.then<Null>((int x) {});
     ''');
     _isFunction2Of(_isInt, _isNull)(
         invoke.argumentList.arguments[0].staticType);
@@ skipping 705 matching lines @@
     FunctionDeclaration test = AstFinder.getTopLevelFunction(unit, "test");
     ExpressionFunctionBody body = test.functionExpression.body;
     FunctionType functionType = body.expression.staticType;
     DartType type = functionType.normalParameterTypes[0];
 
     Element elementA = AstFinder.getClass(unit, "A").element;
 
     _isInstantiationOf(_hasElement(elementA))([_isNum, _isNum])(type);
   }
 
+  test_inferConstructor_unknownTypeLowerBound() async {
+    Source source = addSource(r'''
+        class C<T> {
+          C(void callback(List<T> a));
+        }
+        test() {
+          // downwards inference pushes List<?> and in parameter position this
+          // becomes inferred as List<Null>.
+          var c = new C((items) {});
+        }
+        ''');
+    CompilationUnit unit = (await computeAnalysisResult(source)).unit;
+    assertNoErrors(source);
+    verify([source]);
+    DartType cType = AstFinder
+        .getTopLevelFunction(unit, "test")
+        .element
+        .localVariables[0]
+        .type;
+    Element elementC = AstFinder.getClass(unit, "C").element;
+
+    _isInstantiationOf(_hasElement(elementC))([_isNull])(cType);
+  }
+
+  test_inferConstructor_varianceForCallback2() async {
+    Source source = addSource(r'''
+        class C<T> {
+          C(void callback(List<T> a));
+        }
+        test() {
+          var c = new C((List items) {});
+        }
+        ''');
+    CompilationUnit unit = (await computeAnalysisResult(source)).unit;
+    assertNoErrors(source);
+    verify([source]);
+    DartType cType = AstFinder
+        .getTopLevelFunction(unit, "test")
+        .element
+        .localVariables[0]
+        .type;
+    Element elementC = AstFinder.getClass(unit, "C").element;
+
+    _isInstantiationOf(_hasElement(elementC))([_isDynamic])(cType);
+  }
+
+
   test_redirectingConstructor_propagation() async {
     String code = r'''
       class A {
         A() : this.named([]);
         A.named(List<String> x);
       }
    ''';
     CompilationUnit unit = await resolveSource(code);
 
     ConstructorDeclaration constructor =
@@ skipping 17 matching lines @@
     verify([source]);
     CompilationUnit unit = analysisResult.unit;
     FunctionDeclaration test = AstFinder.getTopLevelFunction(unit, "test");
     ExpressionFunctionBody body = test.functionExpression.body;
     MethodInvocation invoke = body.expression;
     _isFunction2Of(_isNum, _isFunction2Of(_isNum, _isString))(
         invoke.staticInvokeType);
   }
 
   test_returnType_variance3() async {
-    // Check that the variance heuristic chooses the less precise type
+    // Check that the variance heuristic chooses the most precise type
     // when the return type uses the variable in a contravariant position
     // and there is no downwards constraint.
     String code = r'''
     typedef To Func1<From, To>(From x);
     Func1<T, String> f<T>(T x, g(T x)) => null;
     dynamic test() => f(42, (num x) => x);
    ''';
     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;
     FunctionType functionType = body.expression.staticType;
     DartType type = functionType.normalParameterTypes[0];
-    _isNum(type);
+    _isInt(type);
   }
 
   test_returnType_variance4() async {
     // Check that the variance heuristic chooses the more precise type
     // when the return type uses the variable in a covariant position
     // and there is no downwards constraint
     String code = r'''
     typedef To Func1<From, To>(From x);
     Func1<String, T> f<T>(T x, g(T x)) => null;
     dynamic test() => f(42, (num x) => x);
@@ skipping 331 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;
 }
@@ skipping 687 matching lines @@
 class C<T> {
   void m<S0 extends T, S1 extends List<S0>>(S0 p0, S1 p1) {}
 
   void main() {
     m(null, null);
   }
 }
 ''';
     await resolveTestUnit(code);
     assertNoErrors(testSource);
-    expectStaticInvokeType('m(null', '(T, List<T>) → void');
+    expectStaticInvokeType('m(null', '(Null, Null) → 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');
+    expectStaticInvokeType('m(null)', '(Null) → 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]);
   }
@@ skipping 515 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);
   }
 }