Fix calling object methods and properties on function types

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 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ skipping 245 matching lines @@
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     CascadeExpression fetch(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       CascadeExpression exp = decl.initializer;
       return exp;
     }
+
     Element elementA = AstFinder.getClass(unit, "A").element;
 
     CascadeExpression cascade = fetch(0);
     _isInstantiationOf(_hasElement(elementA))([_isInt])(cascade.staticType);
     MethodInvocation invoke = cascade.cascadeSections[0];
     FunctionExpression function = invoke.argumentList.arguments[1];
     ExecutableElement f0 = function.element;
     _isListOf(_isInt)(f0.type.returnType);
     expect(f0.type.normalParameterTypes[0], typeProvider.intType);
   }
@@ skipping 100 matching lines @@
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       FunctionExpression exp = decl.initializer;
       return exp.element.type;
     }
+
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isString, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
   void test_functionLiteral_assignment_unTypedArguments() {
     String code = r'''
       typedef T Function2<S, T>(S x);
 
       void main () {
         Function2<int, String> l0 = (x) => null;
         Function2<int, String> l1 = (x) => "hello";
         Function2<int, String> l2 = (x) => "hello";
         Function2<int, String> l3 = (x) => 3;
         Function2<int, String> l4 = (x) {return 3;};
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       FunctionExpression exp = decl.initializer;
       return exp.element.type;
     }
+
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isInt, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
   void test_functionLiteral_body_propagation() {
     String code = r'''
       typedef T Function2<S, T>(S x);
@@ skipping 13 matching lines @@
       VariableDeclaration decl = stmt.variables.variables[0];
       FunctionExpression exp = decl.initializer;
       FunctionBody body = exp.body;
       if (body is ExpressionFunctionBody) {
         return body.expression;
       } else {
         Statement stmt = (body as BlockFunctionBody).block.statements[0];
         return (stmt as ReturnStatement).expression;
       }
     }
+
     Asserter<InterfaceType> assertListOfString = _isListOf(_isString);
     assertListOfString(functionReturnValue(0).staticType);
     assertListOfString(functionReturnValue(1).staticType);
     assertListOfString(functionReturnValue(2).staticType);
     assertListOfString(functionReturnValue(3).staticType);
   }
 
   void test_functionLiteral_functionExpressionInvocation_typedArguments() {
     String code = r'''
       class Mapper<F, T> {
@@ skipping 10 matching lines @@
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       ExpressionStatement stmt = statements[i];
       FunctionExpressionInvocation invk = stmt.expression;
       FunctionExpression exp = invk.argumentList.arguments[0];
       return exp.element.type;
     }
+
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isString, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
   void test_functionLiteral_functionExpressionInvocation_unTypedArguments() {
     String code = r'''
       class Mapper<F, T> {
@@ skipping 10 matching lines @@
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       ExpressionStatement stmt = statements[i];
       FunctionExpressionInvocation invk = stmt.expression;
       FunctionExpression exp = invk.argumentList.arguments[0];
       return exp.element.type;
     }
+
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isInt, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
   void test_functionLiteral_functionInvocation_typedArguments() {
     String code = r'''
       String map(String mapper(int x)) => mapper(null);
 
       void main () {
         map((int x) => null);
         map((int x) => "hello");
         map((String x) => "hello");
         map((int x) => 3);
         map((int x) {return 3;});
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       ExpressionStatement stmt = statements[i];
       MethodInvocation invk = stmt.expression;
       FunctionExpression exp = invk.argumentList.arguments[0];
       return exp.element.type;
     }
+
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isString, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
   void test_functionLiteral_functionInvocation_unTypedArguments() {
     String code = r'''
       String map(String mapper(int x)) => mapper(null);
 
       void main () {
         map((x) => null);
         map((x) => "hello");
         map((x) => "hello");
         map((x) => 3);
         map((x) {return 3;});
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       ExpressionStatement stmt = statements[i];
       MethodInvocation invk = stmt.expression;
       FunctionExpression exp = invk.argumentList.arguments[0];
       return exp.element.type;
     }
+
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isInt, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
   void test_functionLiteral_methodInvocation_typedArguments() {
     String code = r'''
       class Mapper<F, T> {
@@ skipping 10 matching lines @@
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       ExpressionStatement stmt = statements[i];
       MethodInvocation invk = stmt.expression;
       FunctionExpression exp = invk.argumentList.arguments[0];
       return exp.element.type;
     }
+
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isString, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
   void test_functionLiteral_methodInvocation_unTypedArguments() {
     String code = r'''
       class Mapper<F, T> {
@@ skipping 10 matching lines @@
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       ExpressionStatement stmt = statements[i];
       MethodInvocation invk = stmt.expression;
       FunctionExpression exp = invk.argumentList.arguments[0];
       return exp.element.type;
     }
+
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isInt, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
   void test_functionLiteral_unTypedArgument_propagation() {
     String code = r'''
       typedef T Function2<S, T>(S x);
@@ skipping 14 matching lines @@
       VariableDeclaration decl = stmt.variables.variables[0];
       FunctionExpression exp = decl.initializer;
       FunctionBody body = exp.body;
       if (body is ExpressionFunctionBody) {
         return body.expression;
       } else {
         Statement stmt = (body as BlockFunctionBody).block.statements[0];
         return (stmt as ReturnStatement).expression;
       }
     }
+
     expect(functionReturnValue(0).staticType, typeProvider.intType);
     expect(functionReturnValue(1).staticType, typeProvider.intType);
     expect(functionReturnValue(2).staticType, typeProvider.intType);
     expect(functionReturnValue(3).staticType, typeProvider.dynamicType);
     expect(functionReturnValue(4).staticType, typeProvider.stringType);
   }
 
   void test_inference_hints() {
     Source source = addSource(r'''
       void main () {
@@ skipping 504 matching lines @@
       MethodDeclaration method =
           AstFinder.getMethodInClass(unit, "A", methodName);
       FunctionBody body = method.body;
       if (body is ExpressionFunctionBody) {
         return body.expression;
       } else {
         Statement stmt = (body as BlockFunctionBody).block.statements[0];
         return (stmt as ReturnStatement).expression;
       }
     }
+
     Asserter<InterfaceType> assertListOfString = _isListOf(_isString);
     assertListOfString(methodReturnValue("m0").staticType);
     assertListOfString(methodReturnValue("m1").staticType);
   }
 
   void test_redirectingConstructor_propagation() {
     String code = r'''
       class A {
         A() : this.named([]);
         A.named(List<String> x);
@@ skipping 111 matching lines @@
 ''');
     expectIdentifierType('methodTearOffInst', "(int) → int");
     expectIdentifierType('staticTearOffInst', "(int) → int");
     expectIdentifierType('staticFieldTearOffInst', "(int) → int");
     expectIdentifierType('topFunTearOffInst', "(int) → int");
     expectIdentifierType('topFieldTearOffInst', "(int) → int");
     expectIdentifierType('localTearOffInst', "(int) → int");
     expectIdentifierType('paramTearOffInst', "(int) → int");
   }
 
+  void objectMethodOnFunctions_helper(String code) {
+    resolveTestUnit(code);
+    expectIdentifierType('t0', "String");
+    expectIdentifierType('t1', "() → String");
+    expectIdentifierType('t2', "int");
+    expectIdentifierType('t3', "String");
+    expectIdentifierType('t4', "() → String");
+    expectIdentifierType('t5', "int");
+  }
+
   void setUp() {
     super.setUp();
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.strongMode = true;
     resetWithOptions(options);
   }
 
   void test_dynamicObjectGetter_hashCode() {
     String code = r'''
 main() {
@@ skipping 632 matching lines @@
 ''';
     resolveTestUnit(code);
     expectIdentifierType('ai', "A<dynamic>");
     expectIdentifierType('bi', "B<num>");
     expectIdentifierType('ci', "C<int, B<int>, B<dynamic>>");
     expectIdentifierType('aa', "A<dynamic>");
     expectIdentifierType('bb', "B<num>");
     expectIdentifierType('cc', "C<int, B<int>, B<dynamic>>");
   }
 
+  void test_objectMethodOnFunctions_Anonymous() {
+    String code = r'''
+void main() {
+  var f = (x) => 3;
+  // No errors, correct type
+  var t0 = f.toString();
+  var t1 = f.toString;
+  var t2 = f.hashCode;
+
+  // Expressions, no errors, correct type
+  var t3 = (f).toString();
+  var t4 = (f).toString;
+  var t5 = (f).hashCode;
+
+  // Cascades, no errors
+  f..toString();
+  f..toString;
+  f..hashCode;
+
+  // Expression cascades, no errors
+  (f)..toString();
+  (f)..toString;
+  (f)..hashCode;
+}''';
+    objectMethodOnFunctions_helper(code);
+  }
+
+  void test_objectMethodOnFunctions_Function() {
+    String code = r'''
+void main() {
+  Function f;
+  // No errors, correct type
+  var t0 = f.toString();
+  var t1 = f.toString;
+  var t2 = f.hashCode;
+
+  // Expressions, no errors, correct type
+  var t3 = (f).toString();
+  var t4 = (f).toString;
+  var t5 = (f).hashCode;
+
+  // Cascades, no errors
+  f..toString();
+  f..toString;
+  f..hashCode;
+
+  // Expression cascades, no errors
+  (f)..toString();
+  (f)..toString;
+  (f)..hashCode;
+}''';
+    objectMethodOnFunctions_helper(code);
+  }
+
+  void test_objectMethodOnFunctions_Static() {
+    String code = r'''
+int f(int x) => null;
+void main() {
+  // No errors, correct type
+  var t0 = f.toString();
+  var t1 = f.toString;
+  var t2 = f.hashCode;
+
+  // Expressions, no errors, correct type
+  var t3 = (f).toString();
+  var t4 = (f).toString;
+  var t5 = (f).hashCode;
+
+  // Cascades, no errors
+  f..toString();
+  f..toString;
+  f..hashCode;
+
+  // Expression cascades, no errors
+  (f)..toString();
+  (f)..toString;
+  (f)..hashCode;
+}''';
+    objectMethodOnFunctions_helper(code);
+  }
+
+  void test_objectMethodOnFunctions_Typedef() {
+    String code = r'''
+typedef bool Predicate<T>(T object);
+
+void main() {
+  Predicate<int> f;
+  // No errors, correct type
+  var t0 = f.toString();
+  var t1 = f.toString;
+  var t2 = f.hashCode;
+
+  // Expressions, no errors, correct type
+  var t3 = (f).toString();
+  var t4 = (f).toString;
+  var t5 = (f).hashCode;
+
+  // Cascades, no errors
+  f..toString();
+  f..toString;
+  f..hashCode;
+
+  // Expression cascades, no errors
+  (f)..toString();
+  (f)..toString;
+  (f)..hashCode;
+}''';
+    objectMethodOnFunctions_helper(code);
+  }
+
   void test_setterWithDynamicTypeIsError() {
     Source source = addSource(r'''
 class A {
   dynamic set f(String s) => null;
 }
 dynamic set g(int x) => null;
 ''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [
       StaticWarningCode.NON_VOID_RETURN_FOR_SETTER,
@@ skipping 18 matching lines @@
   void test_setterWithNoVoidType() {
     Source source = addSource(r'''
 class A {
   set f(String s) {
     return '42';
   }
 }
 set g(int x) => 42;
 ''');
     computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,]);
+    assertErrors(source, [
+      StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
+    ]);
     verify([source]);
   }
 
   void test_setterWithNoVoidType_returningVoid() {
     Source source = addSource(r'''
 void returnsVoid() {}
 class A {
   set f(String s) => returnsVoid();
 }
 set g(int x) => returnsVoid();
@@ skipping 287 matching lines @@
 main() {
   var v = x;
   v; // marker
 }
 int x = 3;
 ''';
     assertPropagatedAssignedType(code, typeProvider.intType, null);
     assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 }