Fix behavior when typed JS interop getters are called as functions.

pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart

 // Copyright (c) 2014, 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 dart2js.js_emitter.program_builder;
 
 import '../js_emitter.dart' show
     ClassStubGenerator,
     CodeEmitterTask,
     computeMixinClass,
@@ skipping 12 matching lines @@
     Names,
     Selectors;
 import '../../compiler.dart' show
     Compiler;
 import '../../constants/values.dart' show
     ConstantValue,
     InterceptorConstantValue;
 import '../../core_types.dart' show
     CoreClasses;
 import '../../dart_types.dart' show
-    DartType;
+    DartType,
+    FunctionType,
+    TypedefType;
 import '../../elements/elements.dart' show
     ClassElement,
     Element,
     Elements,
     FieldElement,
     FunctionElement,
     FunctionSignature,
+    GetterElement,
     LibraryElement,
     MethodElement,
     Name,
     ParameterElement,
     TypedefElement,
     VariableElement;
 import '../../js/js.dart' as js;
 import '../../js_backend/backend_helpers.dart' show
     BackendHelpers;
 import '../../js_backend/js_backend.dart' show
@@ skipping 349 matching lines @@
                 if (stubNames.add(stubName.key)) {
                   interceptorClass.callStubs.add(_buildStubMethod(
                       stubName,
                       js.js('function(obj, v) { return obj.# = v }',
                           [member.name]),
                       element: member));
                 }
               }
             }
 
+            bool isFunctionLike = false;
+            FunctionType functionType;
+
             if (member.isFunction) {
+              FunctionElement fn = member;
+              functionType = fn.type;
+            } else if (member.isGetter) {
+              GetterElement getter = member;
+              DartType returnType = getter.type.returnType;
+              if (returnType.isFunctionType) {
+                functionType = returnType;
+              } else if (_compiler.types.isSubtype(returnType, backend.coreTypes.functionType)) {

[Siggi Cherem (dart-lang), 2015/10/30 16:59:57]

Like we chatted in person, let's do 2 small changes:
 - accept any dynamic getter
 - guard the use of types under the --trust-type-annotations flag


Q for Stephen: should we just turn this on by default? One idea we discussed was
to have it unguarded or define an internal boolean that is set to true to guard
the logic so we can easily find it later (sort of like a separate flag that is
not exposed on the commandline).

[Siggi Cherem (dart-lang), 2015/10/30 17:00:49]

Another idea here would be to ask users to annotate the code with metadata
rather than using the type, to indicate their intent. For example:

  @JS('bar')
  class Bar {
    @JSMethod
    get foo;
  }


or let users opt-in/opt-out from this feature at the class level:

  @JS('bar', functionGettersAreMethods: true)
  class Bar {
    Function get foo;
  }

[Jacob, 2015/10/30 19:47:17]

NOOOO.  1. this means the analyzer can't do error checking as you would get if
you wrote

typedef SomeFunctionSignature(..,..)

SomeFunctionSignature get foo;

2. Annotation handling in dart2js is a pain...

3. adding functionGettersAreMethods isn't very discoverable. users will omit the
annotation and wonder why they can't call their functions.

+                if (returnType.isTypedef) {
+                  TypedefType typedef = returnType;
+                  functionType = typedef.element.functionSignature.type;
+                } else {
+                  // Other misc function type such as coreTypes.Function.
+                  // Allow any number of arguments.
+                  isFunctionLike = true;
+                }
+              }
+            } // TODO(jacobr): handle field elements.
+
+            if (isFunctionLike || functionType != null) {
+              int minArgs;
+              int maxArgs;
+              if (functionType != null) {
+                minArgs = functionType.parameterTypes.length;
+                maxArgs = minArgs + functionType.optionalParameterTypes.length;
+              } else {
+                minArgs = 0;
+                maxArgs = 1000;

[Siggi Cherem (dart-lang), 2015/10/30 16:59:57]

what if I want 1001!? ;-)

[Jacob, 2015/10/30 19:47:17]

discussed offline. switched to 32767
also cleaned up code bellow to not throw after 52 args.

+              }
               var selectors =
                   _compiler.codegenWorld.invocationsByName(member.name);
               FunctionElement fn = member;
               // Named arguments are not yet supported. In the future we
               // may want to map named arguments to an object literal containing
               // all named arguments.
               if (selectors != null && !selectors.isEmpty) {
                 for (var selector in selectors.keys) {
                   // Check whether the arity matches this member.
                   var argumentCount = selector.argumentCount;
-                  if (argumentCount > fn.parameters.length) break;
-                  if (argumentCount < fn.parameters.length &&
-                      !fn.parameters[argumentCount].isOptional) break;
+                  // JS interop does not support named arguments.
+                  if (selector.namedArgumentCount > 0) break;
+                  if (argumentCount < minArgs) break;
+                  if (argumentCount > maxArgs) break;
                   var stubName = namer.invocationName(selector);
                   if (!stubNames.add(stubName.key)) break;
                   var candidateParameterNames =
                       'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLOMOPQRSTUVWXYZ';
                   var parameters = new List<String>.generate(argumentCount,
                       (i) => candidateParameterNames[i]);
 
                   interceptorClass.callStubs.add(_buildStubMethod(
                       stubName,
                       js.js('function(receiver, #) { return receiver.#(#) }',
@@ skipping 530 matching lines @@
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 
   Holder _registerStaticStateHolder() {
     return _registry.registerHolder(
         namer.staticStateHolder, isStaticStateHolder: true);
   }
 }