Record types of invoked variables.

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/java_core.dart';
 import 'package:analyzer/src/generated/java_junit.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
@@ skipping 114 matching lines @@
     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(null);
+    FunctionTypeAliasElementImpl aliasElement = new FunctionTypeAliasElementImpl.forNode(null);
     aliasElement.synthetic = true;
     aliasElement.shareParameters(parameters);
     aliasElement.returnType = provider.dynamicType;
     FunctionTypeImpl aliasType = new FunctionTypeImpl.con2(aliasElement);
     aliasElement.shareTypeParameters(futureElement.typeParameters);
     aliasType.typeArguments = futureElement.type.typeArguments;
     MethodElement thenMethod = ElementFactory.methodElementWithParameters("then", futureElement.type.typeArguments, futureType, [
         ElementFactory.requiredParameter2("onValue", aliasType),
         ElementFactory.namedParameter2("onError", provider.functionType)]);
     futureElement.methods = <MethodElement> [thenMethod];
@@ skipping 6261 matching lines @@
     functionNode.name.staticElement = functionElement;
     (unit.element as CompilationUnitElementImpl).functions = <FunctionElement> [functionElement];
     return functionNode;
   }
 
   FunctionTypeAlias _createResolvedFunctionTypeAlias() {
     CompilationUnit unit = _createResolvedCompilationUnit();
     FunctionTypeAlias aliasNode = AstFactory.typeAlias(AstFactory.typeName4("A", []), "F", AstFactory.typeParameterList([]), AstFactory.formalParameterList([]));
     unit.declarations.add(aliasNode);
     SimpleIdentifier aliasName = aliasNode.name;
-    FunctionTypeAliasElement aliasElement = new FunctionTypeAliasElementImpl(aliasName);
+    FunctionTypeAliasElement aliasElement = new FunctionTypeAliasElementImpl.forNode(aliasName);
     aliasName.staticElement = aliasElement;
     (unit.element as CompilationUnitElementImpl).typeAliases = <FunctionTypeAliasElement> [aliasElement];
     return aliasNode;
   }
 
   MethodDeclaration _createResolvedMethodDeclaration() {
     ClassDeclaration classNode = _createResolvedClassDeclaration();
     String methodName = "f";
     MethodDeclaration methodNode = AstFactory.methodDeclaration(null, null, null, null, AstFactory.identifier3(methodName), AstFactory.formalParameterList([]));
     classNode.members.add(methodNode);
@@ skipping 2011 matching lines @@
     SimpleIdentifier identifier = parameter.identifier;
     Element element = identifier.staticElement;
     if (element is! ParameterElement) {
       element = new ParameterElementImpl.forNode(identifier);
       identifier.staticElement = element;
     }
     (element as ParameterElementImpl).type = type;
   }
 }
 
+
+/**
+ * Like [StaticTypeAnalyzerTest], but as end-to-end tests.
+ */
+class StaticTypeAnalyzer2Test extends ResolverTestCase {
+  String testCode;
+  Source testSource;
+  CompilationUnit testUnit;
+
+  void test_MethodInvocation_nameType_localVariable() {
+    String code = r"""
+typedef Foo();
+main() {
+  Foo foo;
+  foo();
+}
+""";
+    _resolveTestUnit(code);
+    // "foo" should be resolved to the "Foo" type
+    SimpleIdentifier identifier = _findIdentifier("foo();");
+    DartType type = identifier.staticType;
+    _ut.expect(type, new _ut.isInstanceOf<FunctionType>());
+  }
+
+  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();");
+    DartType type = identifier.staticType;
+    _ut.expect(type, new _ut.isInstanceOf<FunctionType>());
+  }
+
+  void test_MethodInvocation_nameType_parameter_propagatedType() {
+    String code = r"""
+typedef Foo();
+main(p) {
+  if (p is Foo) {
+    p();
+  }
+}
+""";
+    _resolveTestUnit(code);
+    SimpleIdentifier identifier = _findIdentifier("p()");
+    _ut.expect(identifier.staticType, DynamicTypeImpl.instance);
+    {
+      FunctionType type = identifier.propagatedType;
+      _ut.expect(type, _ut.isNotNull);
+      _ut.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 = resolve(testSource);
+    assertNoErrors(testSource);
+    verify([testSource]);
+    testUnit = resolveCompilationUnit(testSource, library);
+  }
+}
+
 /**
  * Instances of the class `StaticTypeVerifier` verify that all of the nodes in an AST
  * structure that should have a static type associated with them do have a static type.
  */
 class StaticTypeVerifier extends GeneralizingAstVisitor<Object> {
   /**
    * A list containing all of the AST Expression nodes that were not resolved.
    */
   List<Expression> _unresolvedExpressions = new List<Expression>();
 
@@ skipping 932 matching lines @@
     manager.enterScope();
     JUnitTestCase.assertNull(manager.getType(ElementFactory.localVariableElement2("v")));
   }
 
   void test_getType_noScope() {
     TypeOverrideManager manager = new TypeOverrideManager();
     JUnitTestCase.assertNull(manager.getType(ElementFactory.localVariableElement2("v")));
   }
 }
 
+
 class TypePropagationTest extends ResolverTestCase {
   void fail_mergePropagatedTypesAtJoinPoint_1() {
     // https://code.google.com/p/dart/issues/detail?id=19929
     _assertTypeOfMarkedExpression(EngineTestCase.createSource([
         "f1(x) {",
         "  var y = [];",
         "  if (x) {",
         "    y = 0;",
         "  } else {",
         "    y = '';",
@@ skipping 1655 matching lines @@
   runReflectiveTests(ScopeTest);
   runReflectiveTests(DeclarationMatcherTest);
   runReflectiveTests(ElementResolverTest);
   runReflectiveTests(IncrementalResolverTest);
   runReflectiveTests(InheritanceManagerTest);
   runReflectiveTests(LibraryElementBuilderTest);
   runReflectiveTests(LibraryResolver2Test);
   runReflectiveTests(LibraryResolverTest);
   runReflectiveTests(LibraryTest);
   runReflectiveTests(StaticTypeAnalyzerTest);
+  runReflectiveTests(StaticTypeAnalyzer2Test);
   runReflectiveTests(SubtypeManagerTest);
   runReflectiveTests(TypeOverrideManagerTest);
   runReflectiveTests(TypeProviderImplTest);
   runReflectiveTests(TypeResolverVisitorTest);
   runReflectiveTests(CheckedModeCompileTimeErrorCodeTest);
   runReflectiveTests(ErrorResolverTest);
   runReflectiveTests(HintCodeTest);
   runReflectiveTests(MemberMapTest);
   runReflectiveTests(NonHintCodeTest);
   runReflectiveTests(SimpleResolverTest);
   runReflectiveTests(StrictModeTest);
   runReflectiveTests(TypePropagationTest);
 }