Support call methods on functions

lib/src/compiler/code_generator.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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 3162 matching lines @@
       return _emitNullSafe(node);
     }
 
     var result = _emitForeignJS(node);
     if (result != null) return result;
 
     var target = _getTarget(node);
     if (target == null || isLibraryPrefix(target)) {
       return _emitFunctionCall(node);
     }
+    if (node.methodName.name == 'call') {
+      var targetType = target.staticType;
+      if (targetType is FunctionType) {
+        // Call methods on function types should be handled as regular function
+        // invocations.
+        return _emitFunctionCall(node);
+      }
+      if (targetType.isDartCoreFunction) {
+        // TODO(vsm): Can a call method take generic type parameters?
+        return _emitDynamicInvoke(node, _visit(target),
+            _visit(node.argumentList) as List<JS.Expression>);
+      }
+    }
 
     return _emitMethodCall(target, node);
   }
 
   JS.Expression _emitMethodCall(Expression target, MethodInvocation node) {
     var args = _visit(node.argumentList) as List<JS.Expression>;
     var typeArgs = _emitInvokeTypeArguments(node);
 
     if (target is SuperExpression && !_superAllowed) {
       return _emitSuperHelperCall(typeArgs, args, target, node);
@@ skipping 73 matching lines @@
       assert(typeArgs == null); // Object methods don't take type args.
       return js.call('dart.#(#, #)', [name, jsTarget, args]);
     }
 
     jsTarget = new JS.PropertyAccess(jsTarget, memberName);
     if (typeArgs != null) jsTarget = new JS.Call(jsTarget, typeArgs);
 
     return new JS.Call(jsTarget, args);
   }
 
+  JS.Expression _emitDynamicInvoke(
+      InvocationExpression node, JS.Expression fn, List<JS.Expression> args) {
+    var typeArgs = _emitInvokeTypeArguments(node);
+    if (typeArgs != null) {
+      return js.call('dart.dgcall(#, #, #)',
+          [fn, new JS.ArrayInitializer(typeArgs), args]);
+    } else {
+      if (_inWhitelistCode(node, isCall: true)) {
+        return new JS.Call(fn, args);
+      }
+      return js.call('dart.dcall(#, #)', [fn, args]);
+    }
+  }
+
   /// Emits a function call, to a top-level function, local function, or
   /// an expression.
   JS.Expression _emitFunctionCall(InvocationExpression node) {
     var fn = _visit(node.function);
     var args = _visit(node.argumentList) as List<JS.Expression>;
     if (isDynamicInvoke(node.function)) {
-      var typeArgs = _emitInvokeTypeArguments(node);
-      if (typeArgs != null) {
-        return js.call('dart.dgcall(#, #, #)',
-            [fn, new JS.ArrayInitializer(typeArgs), args]);
-      } else {
-        if (_inWhitelistCode(node, isCall: true)) {
-          return new JS.Call(fn, args);
-        }
-        return js.call('dart.dcall(#, #)', [fn, args]);
-      }
+      return _emitDynamicInvoke(node, fn, args);
     } else {
       return new JS.Call(_applyInvokeTypeArguments(fn, node), args);
     }
   }
 
   JS.Expression _applyInvokeTypeArguments(
       JS.Expression target, InvocationExpression node) {
     var typeArgs = _emitInvokeTypeArguments(node);
     if (typeArgs == null) return target;
     return new JS.Call(target, typeArgs);
@@ skipping 2065 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';