Allow arity checks on dynamic function types

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 115 matching lines @@
       var bound = t.element.bound;
       if (bound == null) {
         bound = provider.dynamicType;
       }
       return _nonnullableTypes.any((DartType p) => isSubTypeOf(p, bound));
     } else {
       return false;
     }
   }
 
+  bool _anyParameterType(FunctionType ft, bool predicate(DartType t)) {
+    return ft.normalParameterTypes.any(predicate) ||
+        ft.optionalParameterTypes.any(predicate) ||
+        ft.namedParameterTypes.values.any(predicate);
+  }
+
   // TODO(leafp): Revisit this.
   bool isGroundType(DartType t) {
-    if (t is FunctionType) return false;
     if (t is TypeParameterType) return false;
     if (t.isDynamic) return true;
 
-    // t must be an InterfaceType.
-    var typeArguments = (t as InterfaceType).typeArguments;
-    for (var typeArgument in typeArguments) {
-      if (!typeArgument.isDynamic) return false;
+    if (t is FunctionType) {
+      if (!t.returnType.isDynamic ||
+          _anyParameterType(t, (pt) => !pt.isDynamic)) {
+        return false;
+      } else {
+        return true;
+      }
     }
 
-    return true;
+    if (t is InterfaceType) {
+      var typeArguments = t.typeArguments;
+      for (var typeArgument in typeArguments) {
+        if (!typeArgument.isDynamic) 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;
@@ skipping 344 matching lines @@
     // 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;
       }
     }
+
     var ft = t as FunctionType;
-    for (var parameterType in ft.normalParameterTypes) {
-      if (parameterType.isDynamic) return true;
-    }
-    for (var parameterType in ft.optionalParameterTypes) {
-      if (parameterType.isDynamic) return true;
-    }
-    for (var parameterType in ft.namedParameterTypes.values) {
-      if (parameterType.isDynamic) return true;
-    }
-    return false;
+    return _anyParameterType(ft, (pt) => pt.isDynamic);
   }
 }