Handle calls through call methods

lib/src/checker/rules.dart

 // Copyright (c) 2015, 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 dev_compiler.src.checker.rules;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
@@ skipping 24 matching lines @@
   bool isIntType(DartType t) => t == provider.intType;
   bool isNumType(DartType t) => t == provider.intType.superclass;
   bool isStringType(DartType t) => t == provider.stringType;
   bool isNonNullableType(DartType t) => false;
   bool maybeNonNullableType(DartType t) => false;
 
   StaticInfo checkAssignment(Expression expr, DartType t, bool constContext);
 
   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);
   bool isDynamicTarget(Expression expr);
   bool isDynamicCall(Expression call);
 }
 
 class DartRules extends TypeRules {
   DartRules(TypeProvider provider) : super(provider);
 
@@ skipping 123 matching lines @@
       var typeArguments = t.typeArguments;
       for (var typeArgument in typeArguments) {
         if (!_isTop(typeArgument)) return false;
       }
       return true;
     }
 
     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.
   // [fuzzyArrows] indicates whether or not the f1 and f2 should be
   // treated as fuzzy arrow types (and hence dynamic parameters to f2 treated as
   // bottom).
   bool isFunctionSubTypeOf(FunctionType f1, FunctionType f2,
       {bool fuzzyArrows: true, bool ignoreReturn: false}) {
     final r1s = f1.normalParameterTypes;
     final o1s = f1.optionalParameterTypes;
@@ skipping 321 matching lines @@
   bool isDynamic(DartType t) => options.ignoreTypes || t.isDynamic;
 
   /// Returns `true` if the target expression is dynamic.
   bool isDynamicTarget(Expression target) =>
       options.ignoreTypes || utils.isDynamicTarget(target);
 
   /// Returns `true` if the expression is a dynamic function call or method
   /// 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
     // dynamic is reified as Object - in this case a regular call is fine.
     if (call is SimpleIdentifier) {
       var element = call.staticElement;
       if (element is FunctionElement || element is MethodElement) {
         // An original declaration.
         return false;
       }
@@ skipping 268 matching lines @@
     var entries = e.entries;
     bool inferEntry(MapLiteralEntry entry) {
       return _inferExpression(entry.key, kType, errors) &&
           _inferExpression(entry.value, vType, errors);
     }
     var b = entries.every(inferEntry);
     if (b) annotateMapLiteral(e, targs);
     return b;
   }
 }