Fix for explicit 'call' invocation and property get.

[email protected], [email protected]

Bug:
Change-Id: I17b11d2cfe53ed69ce251d8a7363f9aaf278e89b
Reviewed-on: https://dart-review.googlesource.com/33145
Reviewed-by: Paul Berry <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/fasta/resolution_applier.dart

@@ -440,8 +440,13 @@ class ResolutionApplier extends GeneralizingAstVisitor {
 
     node.staticInvokeType = invokeType;
     node.staticType = resultType;
-    node.methodName.staticElement = invokeElement;
-    node.methodName.staticType = invokeType;
+
+    if (node.methodName.name == 'call' && invokeElement == null) {
+      // Don't resolve explicit call() invocation of function types.
+    } else {
+      node.methodName.staticElement = invokeElement;
+      node.methodName.staticType = invokeType;
+    }
 
     if (invokeType is FunctionType) {
       if (node.typeArguments != null &&

pkg/analyzer/lib/src/fasta/resolution_storer.dart

@@ -455,7 +455,8 @@ class ResolutionStorer extends TypeInferenceListener {
     _replaceType(invokeType, resultOffset);
 
     if (!isImplicitCall) {
-      throw new UnimplementedError(); // TODO(scheglov): handle this case
+      _replaceReference(const NullNode('explicit-call'));
+      _replaceType(const NullType());
     }
     super.genericExpressionExit("methodInvocation", expression, inferredType);
   }
@@ -495,8 +496,8 @@ class ResolutionStorer extends TypeInferenceListener {
 
   @override
   void propertyGetExitCall(Expression expression, DartType inferredType) {
-    throw new UnimplementedError(); // TODO(scheglov): handle this case
-    // super.propertyGetExitCall(expression, inferredType);
+    _recordReference(const NullNode('explicit-call'), expression.fileOffset);
+    _recordType(const NullType(), expression.fileOffset);
   }
 
   @override

pkg/analyzer/test/generated/non_error_resolver_kernel_test.dart

@@ -308,13 +308,6 @@ class NonErrorResolverTest_Kernel extends NonErrorResolverTest_Driver {
     return super.test_undefinedIdentifier_synthetic_whenMethodName();
   }
 
-  @override
-  @failingTest
-  @potentialAnalyzerProblem
-  test_undefinedMethod_functionExpression_callMethod() async {
-    return super.test_undefinedMethod_functionExpression_callMethod();
-  }
-
   @override
   @failingTest
   @potentialAnalyzerProblem

pkg/analyzer/test/src/dart/analysis/base.dart

@@ -67,11 +67,6 @@ class BaseAnalysisDriverTest {
 
   bool get disableChangesAndCacheAllResults => false;
 
-  /**
-   * Whether to enable the Dart 2.0 preview.
-   */
-  bool previewDart2 = false;
-
   /**
    * Whether to enable the Dart 2.0 Common Front End.
    */

pkg/analyzer/test/src/dart/analysis/driver_test.dart

@@ -3181,6 +3181,73 @@ void g(C c) {
     _assertArgumentToParameter(arguments[2], methodElement.parameters[2]);
   }
 
+  test_methodInvocation_explicitCall_classTarget() async {
+    addTestFile(r'''
+class C {
+  double call(int p) => 0.0;
+}
+main() {
+  new C().call(0);
+}
+''');
+    AnalysisResult result = await driver.getResult(testFile);
+    expect(result.errors, isEmpty);
+    var typeProvider = result.unit.element.context.typeProvider;
+
+    ClassDeclaration cNode = result.unit.declarations[0];
+    ClassElement cElement = cNode.element;
+    MethodElement callElement = cElement.methods[0];
+
+    List<Statement> statements = _getMainStatements(result);
+
+    ExpressionStatement statement = statements[0];
+    MethodInvocation invocation = statement.expression;
+
+    expect(invocation.staticType, typeProvider.doubleType);
+    expect(invocation.staticInvokeType.toString(), '(int) → double');
+
+    SimpleIdentifier methodName = invocation.methodName;
+    expect(methodName.staticElement, same(callElement));
+    expect(methodName.staticType.toString(), '(int) → double');
+  }
+
+  test_methodInvocation_explicitCall_functionTarget() async {
+    addTestFile(r'''
+main(double computation(int p)) {
+  computation.call(1);
+}
+''');
+    AnalysisResult result = await driver.getResult(testFile);
+    expect(result.errors, isEmpty);
+    var typeProvider = result.unit.element.context.typeProvider;
+
+    FunctionDeclaration main = result.unit.declarations[0];
+    FunctionElement mainElement = main.element;
+    ParameterElement parameter = mainElement.parameters[0];
+
+    BlockFunctionBody mainBody = main.functionExpression.body;
+    List<Statement> statements = mainBody.block.statements;
+
+    ExpressionStatement statement = statements[0];
+    MethodInvocation invocation = statement.expression;
+
+    expect(invocation.staticType, typeProvider.doubleType);
+    expect(invocation.staticInvokeType.toString(), '(int) → double');
+
+    SimpleIdentifier target = invocation.target;
+    expect(target.staticElement, same(parameter));
+    expect(target.staticType.toString(), '(int) → double');
+
+    SimpleIdentifier methodName = invocation.methodName;
+    if (useCFE) {
+      expect(methodName.staticElement, isNull);
+      expect(methodName.staticType, isNull);
+    } else {
+      expect(methodName.staticElement, same(parameter));
+      expect(methodName.staticType, parameter.type);
+    }
+  }
+
   test_methodInvocation_instanceMethod_forwardingStub() async {
     addTestFile(r'''
 class A {
@@ -3839,6 +3906,38 @@ class C {
     expect(identifier.staticType, typeProvider.intType);
   }
 
+  test_prefixedIdentifier_explicitCall() async {
+    addTestFile(r'''
+main(double computation(int p)) {
+  computation.call;
+}
+''');
+    AnalysisResult result = await driver.getResult(testFile);
+    expect(result.errors, isEmpty);
+    var typeProvider = result.unit.element.context.typeProvider;
+
+    FunctionDeclaration main = result.unit.declarations[0];
+    FunctionElement mainElement = main.element;
+    ParameterElement parameter = mainElement.parameters[0];
+
+    BlockFunctionBody mainBody = main.functionExpression.body;
+    List<Statement> statements = mainBody.block.statements;
+
+    ExpressionStatement statement = statements[0];
+    PrefixedIdentifier prefixed = statement.expression;
+
+    expect(prefixed.prefix.staticElement, same(parameter));
+    expect(prefixed.prefix.staticType.toString(), '(int) → double');
+
+    SimpleIdentifier methodName = prefixed.identifier;
+    expect(methodName.staticElement, isNull);
+    if (useCFE) {
+      expect(methodName.staticType, isNull);
+    } else {
+      expect(methodName.staticType, typeProvider.dynamicType);
+    }
+  }
+
   test_prefixedIdentifier_importPrefix_className() async {
     var libPath = _p('/test/lib/lib.dart');
     provider.newFile(libPath, '''

pkg/front_end/testcases/ast_builder.status

@@ -9,7 +9,6 @@ accessors: Crash
 annotation_top: Crash
 argument_mismatch: Crash
 bad_setter_abstract: Crash
-call: Crash
 cascade: Crash
 classes: Crash
 duplicated_named_args_3: Crash