Fix static type analysis of function invocation expressions.

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/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 254 matching lines @@
       contextElement,
       context2dElement,
       ElementFactory.classElement("DivElement", elementType),
       documentElement,
       elementElement,
       htmlDocumentElement,
       ElementFactory.classElement("InputElement", elementType),
       ElementFactory.classElement("SelectElement", elementType)
     ];
     htmlUnit.functions = <FunctionElement>[
-      ElementFactory.functionElement3("query", elementElement, <ClassElement>[
-        provider.stringType.element
-      ], ClassElementImpl.EMPTY_ARRAY)
+      ElementFactory.functionElement3("query", elementElement,
+          <ClassElement>[provider.stringType.element],
+          ClassElementImpl.EMPTY_ARRAY)
     ];
     TopLevelVariableElementImpl document = ElementFactory
         .topLevelVariableElement3(
             "document", false, true, htmlDocumentElement.type);
     htmlUnit.topLevelVariables = <TopLevelVariableElement>[document];
     htmlUnit.accessors = <PropertyAccessorElement>[document.getter];
     LibraryElementImpl htmlLibrary = new LibraryElementImpl.forNode(
         coreContext, AstFactory.libraryIdentifier2(["dart", "dom", "html"]));
     htmlLibrary.definingCompilationUnit = htmlUnit;
     //
     // dart:math
     //
     CompilationUnitElementImpl mathUnit =
         new CompilationUnitElementImpl("math.dart");
     Source mathSource = sourceFactory.forUri(_DART_MATH);
     coreContext.setContents(mathSource, "");
     mathUnit.source = mathSource;
     FunctionElement cosElement = ElementFactory.functionElement3("cos",
-        provider.doubleType.element, <ClassElement>[
-      provider.numType.element
-    ], ClassElementImpl.EMPTY_ARRAY);
+        provider.doubleType.element, <ClassElement>[provider.numType.element],
+        ClassElementImpl.EMPTY_ARRAY);
     TopLevelVariableElement ln10Element = ElementFactory
         .topLevelVariableElement3("LN10", true, false, provider.doubleType);
     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
-    ], ClassElementImpl.EMPTY_ARRAY);
+        provider.doubleType.element, <ClassElement>[provider.numType.element],
+        ClassElementImpl.EMPTY_ARRAY);
     FunctionElement sqrtElement = ElementFactory.functionElement3("sqrt",
-        provider.doubleType.element, <ClassElement>[
-      provider.numType.element
-    ], ClassElementImpl.EMPTY_ARRAY);
+        provider.doubleType.element, <ClassElement>[provider.numType.element],
+        ClassElementImpl.EMPTY_ARRAY);
     mathUnit.accessors = <PropertyAccessorElement>[
       ln10Element.getter,
       piElement.getter
     ];
     mathUnit.functions = <FunctionElement>[cosElement, sinElement, sqrtElement];
     mathUnit.topLevelVariables = <TopLevelVariableElement>[
       ln10Element,
       piElement
     ];
     mathUnit.types = <ClassElement>[randomElement];
@@ skipping 1199 matching lines @@
     ConstructorElementImpl constructor =
         ElementFactory.constructorElement2(classA, constructorName);
     String parameterName = "a";
     ParameterElement parameter = ElementFactory.namedParameter(parameterName);
     constructor.parameters = <ParameterElement>[parameter];
     classA.constructors = <ConstructorElement>[constructor];
     ConstructorName name = AstFactory.constructorName(
         AstFactory.typeName(classA), constructorName);
     name.staticElement = constructor;
     InstanceCreationExpression creation = AstFactory.instanceCreationExpression(
-        Keyword.NEW, name, [
-      AstFactory.namedExpression2(parameterName, AstFactory.integer(0))
-    ]);
+        Keyword.NEW, name,
+        [AstFactory.namedExpression2(parameterName, AstFactory.integer(0))]);
     _resolveNode(creation);
     expect(creation.staticElement, same(constructor));
     expect((creation.argumentList.arguments[
         0] as NamedExpression).name.label.staticElement, same(parameter));
     _listener.assertNoErrors();
   }
 
   void test_visitMethodInvocation() {
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier left = AstFactory.identifier3("i");
@@ skipping 3099 matching lines @@
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     PropertyAccessorElement getter =
         ElementFactory.getterElement(methodName, false, _typeProvider.intType);
     classI2.accessors = <PropertyAccessorElement>[getter];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI2.type, classI1.type];
     MemberMap mapA =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapA.get(methodName), isNull);
-    _assertErrors(classA, [
-      StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD
-    ]);
+    _assertErrors(classA,
+        [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD]);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_int_str() {
     // class I1 { int m(); }
     // class I2 { String m(); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElement methodM1 =
         ElementFactory.methodElement(methodName, null, [_typeProvider.intType]);
@@ skipping 24 matching lines @@
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     PropertyAccessorElement getter =
         ElementFactory.getterElement(methodName, false, _typeProvider.intType);
     classI2.accessors = <PropertyAccessorElement>[getter];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI1.type, classI2.type];
     MemberMap mapA =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapA.get(methodName), isNull);
-    _assertErrors(classA, [
-      StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD
-    ]);
+    _assertErrors(classA,
+        [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD]);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_numOfRequiredParams() {
     // class I1 { dynamic m(int, [int]); }
     // class I2 { dynamic m(int, int, int); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElementImpl methodM1 =
         ElementFactory.methodElement(methodName, _typeProvider.dynamicType);
@@ skipping 4834 matching lines @@
   foo();
 }
 """;
     _resolveTestUnit(code);
     // "foo" should be resolved to the "Foo" type
     SimpleIdentifier identifier = _findIdentifier("foo();");
     DartType type = identifier.staticType;
     expect(type, new isInstanceOf<FunctionType>());
   }
 
+  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);
+    expect(declaration.initializer.staticType.isDynamic, isTrue);
+    expect(declaration.initializer.propagatedType, isNull);
+  }
+
+  void test_FunctionExpressionInvocation_expression() {
+    String code = r'''
+main() {
+  var foo = (() => 1)();
+}
+''';
+    _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_FunctionExpressionInvocation_curried() {
+    String code = r'''
+typedef int F();
+F f() => null;
+main() {
+  var foo = f()();
+}
+''';
+    _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_MethodInvocation_nameType_parameter_FunctionTypeAlias() {
     String code = r"""
 typedef Foo();
 main(Foo foo) {
   foo();
 }
 """;
     _resolveTestUnit(code);
     // "foo" should be resolved to the "Foo" type
     SimpleIdentifier identifier = _findIdentifier("foo();");
@@ skipping 412 matching lines @@
     FormalParameter p1 = AstFactory.simpleFormalParameter3("p1");
     _setType(p1, dynamicType);
     FormalParameter p2 = AstFactory.simpleFormalParameter3("p2");
     _setType(p2, dynamicType);
     FunctionExpression node = _resolvedFunctionExpression(
         AstFactory.formalParameterList([p1, p2]),
         AstFactory.blockFunctionBody2());
     _analyze5(p1);
     _analyze5(p2);
     DartType resultType = _analyze(node);
-    _assertFunctionType(dynamicType,
-        <DartType>[dynamicType, dynamicType], null, null, resultType);
+    _assertFunctionType(dynamicType, <DartType>[
+      dynamicType,
+      dynamicType
+    ], null, null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_normal_expression() {
     // (p1, p2) -> 0
     DartType dynamicType = _typeProvider.dynamicType;
     FormalParameter p = AstFactory.simpleFormalParameter3("p");
     _setType(p, dynamicType);
     FunctionExpression node = _resolvedFunctionExpression(
         AstFactory.formalParameterList([p]),
@@ skipping 13 matching lines @@
     FormalParameter p2 = AstFactory.namedFormalParameter(
         AstFactory.simpleFormalParameter3("p2"), _resolvedInteger(0));
     _setType(p2, dynamicType);
     FunctionExpression node = _resolvedFunctionExpression(
         AstFactory.formalParameterList([p1, p2]),
         AstFactory.blockFunctionBody2());
     _analyze5(p2);
     DartType resultType = _analyze(node);
     Map<String, DartType> expectedNamedTypes = new HashMap<String, DartType>();
     expectedNamedTypes["p2"] = dynamicType;
-    _assertFunctionType(dynamicType,
-        <DartType>[dynamicType], null, expectedNamedTypes, resultType);
+    _assertFunctionType(dynamicType, <DartType>[dynamicType], null,
+        expectedNamedTypes, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_normalAndNamed_expression() {
     // (p1, {p2 : 0}) -> 0
     DartType dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = AstFactory.simpleFormalParameter3("p1");
     _setType(p1, dynamicType);
     FormalParameter p2 = AstFactory.namedFormalParameter(
         AstFactory.simpleFormalParameter3("p2"), _resolvedInteger(0));
     _setType(p2, dynamicType);
     FunctionExpression node = _resolvedFunctionExpression(
         AstFactory.formalParameterList([p1, p2]),
         AstFactory.expressionFunctionBody(_resolvedInteger(0)));
     _analyze5(p2);
     DartType resultType = _analyze(node);
     Map<String, DartType> expectedNamedTypes = new HashMap<String, DartType>();
     expectedNamedTypes["p2"] = dynamicType;
-    _assertFunctionType(_typeProvider.intType,
-        <DartType>[dynamicType], null, expectedNamedTypes, resultType);
+    _assertFunctionType(_typeProvider.intType, <DartType>[dynamicType], null,
+        expectedNamedTypes, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_normalAndPositional_block() {
     // (p1, [p2 = 0]) {}
     DartType dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = AstFactory.simpleFormalParameter3("p1");
     _setType(p1, dynamicType);
     FormalParameter p2 = AstFactory.positionalFormalParameter(
         AstFactory.simpleFormalParameter3("p2"), _resolvedInteger(0));
     _setType(p2, dynamicType);
     FunctionExpression node = _resolvedFunctionExpression(
         AstFactory.formalParameterList([p1, p2]),
         AstFactory.blockFunctionBody2());
     _analyze5(p1);
     _analyze5(p2);
     DartType resultType = _analyze(node);
-    _assertFunctionType(dynamicType,
-        <DartType>[dynamicType], <DartType>[dynamicType], null, resultType);
+    _assertFunctionType(dynamicType, <DartType>[dynamicType],
+        <DartType>[dynamicType], null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_normalAndPositional_expression() {
     // (p1, [p2 = 0]) -> 0
     DartType dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = AstFactory.simpleFormalParameter3("p1");
     _setType(p1, dynamicType);
     FormalParameter p2 = AstFactory.positionalFormalParameter(
         AstFactory.simpleFormalParameter3("p2"), _resolvedInteger(0));
     _setType(p2, dynamicType);
     FunctionExpression node = _resolvedFunctionExpression(
         AstFactory.formalParameterList([p1, p2]),
         AstFactory.expressionFunctionBody(_resolvedInteger(0)));
     _analyze5(p1);
     _analyze5(p2);
     DartType resultType = _analyze(node);
-    _assertFunctionType(_typeProvider.intType,
-        <DartType>[dynamicType], <DartType>[dynamicType], null, resultType);
+    _assertFunctionType(_typeProvider.intType, <DartType>[dynamicType],
+        <DartType>[dynamicType], null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_positional_block() {
     // ([p1 = 0, p2 = 0]) {}
     DartType dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = AstFactory.positionalFormalParameter(
         AstFactory.simpleFormalParameter3("p1"), _resolvedInteger(0));
     _setType(p1, dynamicType);
     FormalParameter p2 = AstFactory.positionalFormalParameter(
         AstFactory.simpleFormalParameter3("p2"), _resolvedInteger(0));
     _setType(p2, dynamicType);
     FunctionExpression node = _resolvedFunctionExpression(
         AstFactory.formalParameterList([p1, p2]),
         AstFactory.blockFunctionBody2());
     _analyze5(p1);
     _analyze5(p2);
     DartType resultType = _analyze(node);
-    _assertFunctionType(dynamicType,
-        null, <DartType>[dynamicType, dynamicType], null, resultType);
+    _assertFunctionType(dynamicType, null, <DartType>[
+      dynamicType,
+      dynamicType
+    ], null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_positional_expression() {
     // ([p1 = 0, p2 = 0]) -> 0
     DartType dynamicType = _typeProvider.dynamicType;
     FormalParameter p = AstFactory.positionalFormalParameter(
         AstFactory.simpleFormalParameter3("p"), _resolvedInteger(0));
     _setType(p, dynamicType);
     FunctionExpression node = _resolvedFunctionExpression(
@@ skipping 82 matching lines @@
     // new C.m()
     ClassElementImpl classElement = ElementFactory.classElement2("C");
     String constructorName = "m";
     ConstructorElementImpl constructor =
         ElementFactory.constructorElement2(classElement, constructorName);
     constructor.returnType = classElement.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
     constructor.type = constructorType;
     classElement.constructors = <ConstructorElement>[constructor];
     InstanceCreationExpression node = AstFactory.instanceCreationExpression2(
-        null, AstFactory.typeName(classElement), [
-      AstFactory.identifier3(constructorName)
-    ]);
+        null, AstFactory.typeName(classElement),
+        [AstFactory.identifier3(constructorName)]);
     node.staticElement = constructor;
     expect(_analyze(node), same(classElement.type));
     _listener.assertNoErrors();
   }
 
   void test_visitInstanceCreationExpression_typeParameters() {
     // new C<I>()
     ClassElementImpl elementC = ElementFactory.classElement2("C", ["E"]);
     ClassElementImpl elementI = ElementFactory.classElement2("I");
     ConstructorElementImpl constructor =
@@ skipping 69 matching lines @@
     DartType resultType = _analyze(node);
     _assertType2(_typeProvider.listType
         .substitute4(<DartType>[_typeProvider.dynamicType]), resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitMapLiteral_empty() {
     // {}
     Expression node = AstFactory.mapLiteral2();
     DartType resultType = _analyze(node);
-    _assertType2(_typeProvider.mapType.substitute4(<DartType>[
-      _typeProvider.dynamicType,
-      _typeProvider.dynamicType
-    ]), resultType);
+    _assertType2(_typeProvider.mapType.substitute4(
+            <DartType>[_typeProvider.dynamicType, _typeProvider.dynamicType]),
+        resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitMapLiteral_nonEmpty() {
     // {"k" : 0}
     Expression node = AstFactory
         .mapLiteral2([AstFactory.mapLiteralEntry("k", _resolvedInteger(0))]);
     DartType resultType = _analyze(node);
-    _assertType2(_typeProvider.mapType.substitute4(<DartType>[
-      _typeProvider.dynamicType,
-      _typeProvider.dynamicType
-    ]), resultType);
+    _assertType2(_typeProvider.mapType.substitute4(
+            <DartType>[_typeProvider.dynamicType, _typeProvider.dynamicType]),
+        resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitMethodInvocation_then() {
     // then()
     Expression node = AstFactory.methodInvocation(null, "then");
     _analyze(node);
     _listener.assertNoErrors();
   }
 
@@ skipping 3163 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;
   }
 }