Handle calls through call methods

This CL makes us recognizes calls through call methods as not requiring dynamic invokes.  The analyzer seems to do the wrong thing on the return types though, so we'll still get casts on the results.  Bug filed here: dartbug.com/23252 .

This fixes #7.

BUG=
[email protected]

Review URL: https://codereview.chromium.org/1092183003

Author: leafpetersen

lib/src/checker/checker.dart

@@ -505,11 +505,11 @@ class CodeChecker extends RecursiveAstVisitor {
   void checkFunctionApplication(
       Expression node, Expression f, ArgumentList list) {
     if (_rules.isDynamicCall(f)) {
-      // TODO(vsm): For a function object, we should still be able to derive a
-      // function type from it.
+      // If f is Function and this is a method invocation, we should have
+      // gotten an analyzer error, so no need to issue another error.
       _recordDynamicInvoke(node);
     } else {
-      checkArgumentList(list, _rules.getStaticType(f));
+      checkArgumentList(list, _rules.getTypeAsCaller(f));
     }
   }
 

lib/src/checker/rules.dart

@@ -42,6 +42,32 @@ abstract class TypeRules {
 
   DartType getStaticType(Expression expr) => expr.staticType;
 
+  /// Given a type t, if t is an interface type with a call method
+  /// defined, return the function type for the call method, otherwise
+  /// return null.
+  FunctionType getCallMethodType(DartType t) {
+    if (t is InterfaceType) {
+      ClassElement element = t.element;
+      InheritanceManager manager = new InheritanceManager(element.library);
+      FunctionType callType = manager.lookupMemberType(t, "call");
+      return callType;
+    }
+    return null;
+  }
+
+  /// Given an expression, return its type assuming it is
+  /// in the caller position of a call (that is, accounting
+  /// for the possibility of a call method).  Returns null
+  /// if expression is not statically callable.
+  FunctionType getTypeAsCaller(Expression applicand) {
+    var t = getStaticType(applicand);
+    if (t is InterfaceType) {
+      return getCallMethodType(t);
+    }
+    if (t is FunctionType) return t;
+    return null;
+  }
+
   DartType elementType(Element e);
 
   bool isDynamic(DartType t);
@@ -185,16 +211,6 @@ class RestrictedRules extends TypeRules {
     throw new StateError("Unexpected type");
   }
 
-  FunctionType getCallMethodType(DartType t) {
-    if (t is InterfaceType) {
-      ClassElement element = t.element;
-      InheritanceManager manager = new InheritanceManager(element.library);
-      FunctionType callType = manager.lookupMemberType(t, "call");
-      return callType;
-    }
-    return null;
-  }
-
   /// Check that f1 is a subtype of f2. [ignoreReturn] is used in the DDC
   /// checker to determine whether f1 would be a subtype of f2 if the return
   /// type of f1 is set to match f2's return type.
@@ -536,12 +552,12 @@ class RestrictedRules extends TypeRules {
   /// invocation.
   bool isDynamicCall(Expression call) {
     if (options.ignoreTypes) return true;
-    var t = getStaticType(call);
-    // TODO(jmesserly): fix handling of types with `call` methods. These are not
-    // FunctionType, but they also aren't dynamic calls.
-    if (t.isDynamic || t.isDartCoreFunction || t is! FunctionType) {
-      return true;
-    }
+    var t = getTypeAsCaller(call);
+    // TODO(leafp): This will currently return true if t is Function
+    // This is probably the most correct thing to do for now, since
+    // this code is also used by the back end.  Maybe revisit at some
+    // point?
+    if (t == null) return true;
     // Dynamic as the parameter type is treated as bottom.  A function with
     // a dynamic parameter type requires a dynamic call in general.
     // However, as an optimization, if we have an original definition, we know

test/checker/checker_test.dart

@@ -14,6 +14,55 @@ import '../test_util.dart';
 void main() {
   configureTest();
 
+  test('dynamic invocation', () {
+    testChecker({
+      '/main.dart': '''
+
+      class A {
+        dynamic call(dynamic x) => x;
+      }
+      class B extends A {
+        int call(int x) => x;
+        double col(double x) => x;
+      }
+      void main() {
+        {
+          B f = new B();
+          int x;
+          double y;
+          // The analyzer has what I believe is a bug (dartbug.com/23252) which
+          // causes the return type of calls to f to be treated as dynamic.
+          x = /*info:DynamicCast should be pass*/f(3);
+          x = /*severe:StaticTypeError*/f.col(3.0);
+          y = /*info:DynamicCast should be severe:StaticTypeError*/f(3);
+          y = f.col(3.0);
+          f(/*severe:StaticTypeError*/3.0);
+          f.col(/*severe:StaticTypeError*/3);
+        }
+        {
+          Function f = new B();
+          int x;
+          double y;
+          x = /*info:DynamicCast, info:DynamicInvoke*/f(3);
+          x = /*info:DynamicCast, info:DynamicInvoke*/f.col(3.0);
+          y = /*info:DynamicCast, info:DynamicInvoke*/f(3);
+          y = /*info:DynamicCast, info:DynamicInvoke*/f.col(3.0);
+          (/*info:DynamicInvoke*/f(3.0));
+          (/*info:DynamicInvoke*/f.col(3));
+        }
+        {
+          A f = new B();
+          int x;
+          double y;
+          x = /*info:DynamicCast, info:DynamicInvoke*/f(3);
+          y = /*info:DynamicCast, info:DynamicInvoke*/f(3);
+          (/*info:DynamicInvoke*/f(3.0));
+        }
+      }
+    '''
+    });
+  });
+
   test('conversion and dynamic invoke', () {
     testChecker({
       '/helper.dart': '''
@@ -91,6 +140,7 @@ void main() {
 
         baz().toString();
         baz().hashCode;
+      }
     '''
     });
   });