Add additional strong mode inference.

pkg/analyzer/test/generated/resolver_test.dart

 // Copyright (c) 2014, 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 engine.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/context/context.dart' as newContext;
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 50 matching lines @@
   runReflectiveTests(TypeProviderImplTest);
   runReflectiveTests(TypeResolverVisitorTest);
   runReflectiveTests(CheckedModeCompileTimeErrorCodeTest);
   runReflectiveTests(ErrorResolverTest);
   runReflectiveTests(HintCodeTest);
   runReflectiveTests(MemberMapTest);
   runReflectiveTests(NonHintCodeTest);
   runReflectiveTests(SimpleResolverTest);
   runReflectiveTests(StrictModeTest);
   runReflectiveTests(TypePropagationTest);
+  runReflectiveTests(StrongModeStaticTypeAnalyzer2Test);
   runReflectiveTests(StrongModeTypePropagationTest);
 }
 
 /**
  * The class `AnalysisContextFactory` defines utility methods used to create analysis contexts
  * for testing purposes.
  */
 class AnalysisContextFactory {
   static String _DART_MATH = "dart:math";
 
@@ skipping 105 matching lines @@
     // dart:async
     //
     CompilationUnitElementImpl asyncUnit =
         new CompilationUnitElementImpl("async.dart");
     Source asyncSource = sourceFactory.forUri(DartSdk.DART_ASYNC);
     coreContext.setContents(asyncSource, "");
     asyncUnit.librarySource = asyncUnit.source = asyncSource;
     // Future
     ClassElementImpl futureElement =
         ElementFactory.classElement2("Future", ["T"]);
-    InterfaceType futureType = futureElement.type;
     //   factory Future.value([value])
     ConstructorElementImpl futureConstructor =
         ElementFactory.constructorElement2(futureElement, "value");
     futureConstructor.parameters = <ParameterElement>[
       ElementFactory.positionalParameter2("value", provider.dynamicType)
     ];
     futureConstructor.factory = true;
     (futureConstructor.type as FunctionTypeImpl).typeArguments =
         futureElement.type.typeArguments;
     futureElement.constructors = <ConstructorElement>[futureConstructor];
     //   Future then(onValue(T value), { Function onError });
     List<ParameterElement> parameters = <ParameterElement>[
       ElementFactory.requiredParameter2(
           "value", futureElement.typeParameters[0].type)
     ];
     FunctionTypeAliasElementImpl aliasElement =
         new FunctionTypeAliasElementImpl.forNode(null);
     aliasElement.synthetic = true;
     aliasElement.parameters = parameters;
     aliasElement.returnType = provider.dynamicType;
     aliasElement.enclosingElement = asyncUnit;
     FunctionTypeImpl aliasType = new FunctionTypeImpl.forTypedef(aliasElement);
     aliasElement.shareTypeParameters(futureElement.typeParameters);
     aliasType.typeArguments = futureElement.type.typeArguments;
+    DartType futureDynamicType =
+        futureElement.type.substitute4([provider.dynamicType]);
     MethodElement thenMethod = ElementFactory.methodElementWithParameters(
-        "then", futureElement.type.typeArguments, futureType, [
+        "then", futureElement.type.typeArguments, futureDynamicType, [
       ElementFactory.requiredParameter2("onValue", aliasType),
       ElementFactory.namedParameter2("onError", provider.functionType)
     ]);
     futureElement.methods = <MethodElement>[thenMethod];
     // Completer
     ClassElementImpl completerElement =
         ElementFactory.classElement2("Completer", ["T"]);
     ConstructorElementImpl completerConstructor =
         ElementFactory.constructorElement2(completerElement, null);
     (completerConstructor.type as FunctionTypeImpl).typeArguments =
@@ skipping 98 matching lines @@
     Source mathSource = sourceFactory.forUri(_DART_MATH);
     coreContext.setContents(mathSource, "");
     mathUnit.librarySource = mathUnit.source = mathSource;
     FunctionElement cosElement = ElementFactory.functionElement3(
         "cos",
         provider.doubleType.element,
         <ClassElement>[provider.numType.element],
         ClassElement.EMPTY_LIST);
     TopLevelVariableElement ln10Element = ElementFactory
         .topLevelVariableElement3("LN10", true, false, provider.doubleType);
+    FunctionElement maxElement = ElementFactory.functionElement3(
+        "max",
+        provider.numType.element,
+        <ClassElement>[provider.numType.element, provider.numType.element],
+        ClassElement.EMPTY_LIST);
     TopLevelVariableElement piElement = ElementFactory.topLevelVariableElement3(
         "PI", true, false, provider.doubleType);
     ClassElementImpl randomElement = ElementFactory.classElement2("Random");
     randomElement.abstract = true;
     ConstructorElementImpl randomConstructor =
         ElementFactory.constructorElement2(randomElement, null);
     randomConstructor.factory = true;
     ParameterElementImpl seedParam = new ParameterElementImpl("seed", 0);
     seedParam.parameterKind = ParameterKind.POSITIONAL;
     seedParam.type = provider.intType;
     randomConstructor.parameters = <ParameterElement>[seedParam];
     randomElement.constructors = <ConstructorElement>[randomConstructor];
     FunctionElement sinElement = ElementFactory.functionElement3(
         "sin",
         provider.doubleType.element,
         <ClassElement>[provider.numType.element],
         ClassElement.EMPTY_LIST);
     FunctionElement sqrtElement = ElementFactory.functionElement3(
         "sqrt",
         provider.doubleType.element,
         <ClassElement>[provider.numType.element],
         ClassElement.EMPTY_LIST);
     mathUnit.accessors = <PropertyAccessorElement>[
       ln10Element.getter,
       piElement.getter
     ];
-    mathUnit.functions = <FunctionElement>[cosElement, sinElement, sqrtElement];
+    mathUnit.functions = <FunctionElement>[
+      cosElement,
+      maxElement,
+      sinElement,
+      sqrtElement
+    ];
     mathUnit.topLevelVariables = <TopLevelVariableElement>[
       ln10Element,
       piElement
     ];
     mathUnit.types = <ClassElement>[randomElement];
     LibraryElementImpl mathLibrary = new LibraryElementImpl.forNode(
         coreContext, AstFactory.libraryIdentifier2(["dart", "math"]));
     mathLibrary.definingCompilationUnit = mathUnit;
     //
     // Set empty sources for the rest of the libraries.
@@ skipping 9577 matching lines @@
     }
   }
 }
 
 class SourceContainer_ChangeSetTest_test_toString implements SourceContainer {
   @override
   bool contains(Source source) => false;
 }
 
 /**
+ * Shared infrastructure for [StaticTypeAnalyzer2Test] and
+ * [StrongModeStaticTypeAnalyzer2Test].
+ */
+class _StaticTypeAnalyzer2TestShared extends ResolverTestCase {
+  String testCode;
+  Source testSource;
+  CompilationUnit testUnit;
+
+  SimpleIdentifier _findIdentifier(String search) {
+    SimpleIdentifier identifier = EngineTestCase.findNode(
+        testUnit, testCode, search, (node) => node is SimpleIdentifier);
+    return identifier;
+  }
+
+  void _resolveTestUnit(String code) {
+    testCode = code;
+    testSource = addSource(testCode);
+    LibraryElement library = resolve2(testSource);
+    assertNoErrors(testSource);
+    verify([testSource]);
+    testUnit = resolveCompilationUnit(testSource, library);
+  }
+}
+
+/**
  * Like [StaticTypeAnalyzerTest], but as end-to-end tests.
  */
 @reflectiveTest
-class StaticTypeAnalyzer2Test extends ResolverTestCase {
-  String testCode;
-  Source testSource;
-  CompilationUnit testUnit;
-
+class StaticTypeAnalyzer2Test extends _StaticTypeAnalyzer2TestShared {
   void test_FunctionExpressionInvocation_block() {
     String code = r'''
 main() {
   var foo = (() { return 1; })();
 }
 ''';
     _resolveTestUnit(code);
     SimpleIdentifier identifier = _findIdentifier('foo');
     VariableDeclaration declaration =
         identifier.getAncestor((node) => node is VariableDeclaration);
@@ skipping 71 matching lines @@
 """;
     _resolveTestUnit(code);
     SimpleIdentifier identifier = _findIdentifier("p()");
     expect(identifier.staticType, DynamicTypeImpl.instance);
     {
       FunctionType type = identifier.propagatedType;
       expect(type, isNotNull);
       expect(type.name, 'Foo');
     }
   }
-
-  SimpleIdentifier _findIdentifier(String search) {
-    SimpleIdentifier identifier = EngineTestCase.findNode(
-        testUnit, testCode, search, (node) => node is SimpleIdentifier);
-    return identifier;
-  }
-
-  void _resolveTestUnit(String code) {
-    testCode = code;
-    testSource = addSource(testCode);
-    LibraryElement library = resolve2(testSource);
-    assertNoErrors(testSource);
-    verify([testSource]);
-    testUnit = resolveCompilationUnit(testSource, library);
-  }
 }
 
 @reflectiveTest
 class StaticTypeAnalyzerTest extends EngineTestCase {
   /**
    * The error listener to which errors will be reported.
    */
   GatheringErrorListener _listener;
 
   /**
@@ skipping 1790 matching lines @@
     Source source = addSource(r'''
 int f() {
   num n = 1234;
   return n & 0x0F;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 }
 
+/**
+ * Strong mode static analyzer end to end tests
+ */
+@reflectiveTest
+class StrongModeStaticTypeAnalyzer2Test extends _StaticTypeAnalyzer2TestShared {
+  void setUp() {
+    AnalysisOptionsImpl options = new AnalysisOptionsImpl();
+    options.strongMode = true;
+    resetWithOptions(options);
+  }
+
+  void test_ternaryOperator_null_right() {
+    String code = r'''
+main() {
+  var foo = (true) ? 3 : null;
+}
+''';
+    _resolveTestUnit(code);
+
+    SimpleIdentifier identifier = _findIdentifier('foo');
+    VariableDeclaration declaration =
+        identifier.getAncestor((node) => node is VariableDeclaration);
+    expect(declaration.initializer.staticType.name, 'int');
+    expect(declaration.initializer.propagatedType, isNull);
+  }
+
+  void test_ternaryOperator_null_left() {
+    String code = r'''
+main() {
+  var foo = (true) ? null : 3;
+}
+''';
+    _resolveTestUnit(code);
+
+    SimpleIdentifier identifier = _findIdentifier('foo');
+    VariableDeclaration declaration =
+        identifier.getAncestor((node) => node is VariableDeclaration);
+    expect(declaration.initializer.staticType.name, 'int');
+    expect(declaration.initializer.propagatedType, isNull);
+  }
+
+  void test_dynamicObjectMethod_toString() {
+    String code = r'''
+main() {
+  dynamic a = null;
+  var foo = a.toString();
+}
+''';
+    _resolveTestUnit(code);
+
+    SimpleIdentifier identifier = _findIdentifier('foo');
+    VariableDeclaration declaration =
+        identifier.getAncestor((node) => node is VariableDeclaration);
+    expect(declaration.initializer.staticType.name, 'String');
+    expect(declaration.initializer.propagatedType, isNull);
+  }
+
+  void test_dynamicObjectGetter_hashCode() {
+    String code = r'''
+main() {
+  dynamic a = null;
+  var foo = a.hashCode;
+}
+''';
+    _resolveTestUnit(code);
+
+    SimpleIdentifier identifier = _findIdentifier('foo');
+    VariableDeclaration declaration =
+        identifier.getAncestor((node) => node is VariableDeclaration);
+    expect(declaration.initializer.staticType.name, 'int');
+    expect(declaration.initializer.propagatedType, isNull);
+  }
+
+  void test_pseudoGeneric_max_intInt() {
+    String code = r'''
+import 'dart:math';
+main() {
+  var foo = max(1, 2);
+}
+''';
+    _resolveTestUnit(code);
+
+    SimpleIdentifier identifier = _findIdentifier('foo');
+    VariableDeclaration declaration =
+        identifier.getAncestor((node) => node is VariableDeclaration);
+    expect(declaration.initializer.staticType.name, 'int');
+    expect(declaration.initializer.propagatedType, isNull);
+  }
+
+  void test_pseudoGeneric_max_doubleDouble() {
+    String code = r'''
+import 'dart:math';
+main() {
+  var foo = max(1.0, 2.0);
+}
+''';
+    _resolveTestUnit(code);
+
+    SimpleIdentifier identifier = _findIdentifier('foo');
+    VariableDeclaration declaration =
+        identifier.getAncestor((node) => node is VariableDeclaration);
+    expect(declaration.initializer.staticType.name, 'double');
+    expect(declaration.initializer.propagatedType, isNull);
+  }
+
+  void test_pseudoGeneric_max_intDouble() {
+    String code = r'''
+import 'dart:math';
+main() {
+  var foo = max(1, 2.0);
+}
+''';
+    _resolveTestUnit(code);
+
+    SimpleIdentifier identifier = _findIdentifier('foo');
+    VariableDeclaration declaration =
+        identifier.getAncestor((node) => node is VariableDeclaration);
+    expect(declaration.initializer.staticType.name, 'num');
+    expect(declaration.initializer.propagatedType, isNull);
+  }
+
+  void test_pseudoGeneric_then() {
+    String code = r'''
+import 'dart:async';
+String toString(int x) => x.toString();
+main() {
+  Future<int> bar = null;
+  var foo = bar.then(toString);
+}
+''';
+    _resolveTestUnit(code);
+
+    SimpleIdentifier identifier = _findIdentifier('foo');
+    VariableDeclaration declaration =
+        identifier.getAncestor((node) => node is VariableDeclaration);
+    InterfaceType stringType = typeProvider.stringType;
+    InterfaceType futureType = typeProvider.futureType;
+    InterfaceType futureOfStringType =
+        futureType.substitute4(<DartType>[stringType]);
+
+    expect(declaration.initializer.staticType.toString(), "Future<String>");
+    expect(declaration.initializer.propagatedType, isNull);
+  }
+}
+
 @reflectiveTest
 class StrongModeTypePropagationTest extends ResolverTestCase {
   @override
   void setUp() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.strongMode = true;
     resetWithOptions(options);
   }
 
   void test_foreachInference_dynamic_disabled() {
@@ skipping 2658 matching lines @@
         // check propagated type
         FunctionType propagatedType = node.propagatedType as FunctionType;
         expect(propagatedType.returnType, test.typeProvider.stringType);
       } on AnalysisException catch (e, stackTrace) {
         thrownException[0] = new CaughtException(e, stackTrace);
       }
     }
     return null;
   }
 }