Allow getField of methods.

sdk/lib/_internal/lib/js_helper.dart

 // Copyright (c) 2013, 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 _js_helper;
 
 import 'dart:collection';
 import 'dart:_isolate_helper' show
     IsolateNatives,
     leaveJsAsync,
@@ skipping 165 matching lines @@
 
   _getCachedInvocation(Object object) {
     var interceptor = getInterceptor(object);
     var receiver = object;
     var name = _internalName;
     var arguments = _arguments;
     // TODO(ngeoffray): If this functionality ever become performance
     // critical, we might want to dynamically change [interceptedNames]
     // to be a JavaScript object with intercepted names as property
     // instead of a JavaScript array.
+    // TODO(floitsch): we already add stubs (tear-off getters) as properties
+    //    in init.interceptedNames.

[karlklose, 2014/04/01 08:32:23]

Align indentation with TODO above.

[floitsch, 2014/04/01 14:03:19]

Done.

+    //    Finish the transition and always use the object as hashtable.
     bool isIntercepted =
-        JS('int', '#.indexOf(#)', interceptedNames, name) != -1;
+        JS("bool",
+            'Object.prototype.hasOwnProperty.call(init.interceptedNames, #) ||'
+            '#.indexOf(#) !== -1',
+            name, interceptedNames, name);
     if (isIntercepted) {
       receiver = interceptor;
       if (JS('bool', '# === #', object, interceptor)) {
         interceptor = null;
       }
     } else {
       interceptor = null;
     }
     bool isCatchAll = false;
     var method = JS('var', '#[#]', receiver, name);
     if (JS('bool', 'typeof # != "function"', method) ) {
       String baseName = _symbol_dev.Symbol.getName(memberName);
       method = JS('', '#[# + "*"]', receiver, baseName);
       if (method == null) {
         interceptor = getInterceptor(object);
         method = JS('', '#[# + "*"]', interceptor, baseName);
         if (method != null) {
           isIntercepted = true;
           receiver = interceptor;
         } else {
           interceptor = null;
         }
       }
       isCatchAll = true;
     }
     if (JS('bool', 'typeof # == "function"', method)) {
-      if (!hasReflectableProperty(method)) {
+      // TODO(floitsch): bound or tear-off closure does not guarantee that the
+      // function is reflectable.

[karlklose, 2014/04/01 08:32:23]

Perhaps we should add a failing test to make sure we fix this.

[floitsch, 2014/04/01 14:03:19]

Filed 17939 and added test.

+      bool isReflectable = hasReflectableProperty(method) ||
+          object is BoundClosure ||
+          object is TearOffClosure;
+      if (!isReflectable) {
         throwInvalidReflectionError(_symbol_dev.Symbol.getName(memberName));
       }
       if (isCatchAll) {
         return new CachedCatchAllInvocation(
             name, method, isIntercepted, interceptor);
       } else {
         return new CachedInvocation(name, method, isIntercepted, interceptor);
       }
     } else {
       // In this case, receiver doesn't implement name.  So we should
@@ skipping 1754 matching lines @@
 
     // Create a closure and "monkey" patch it with call stubs.
     var trampoline = function;
     var isIntercepted = false;
     if (!isStatic) {
       if (JS('bool', '#.length == 1', jsArguments)) {
         // Intercepted call.
         isIntercepted = true;
       }
       trampoline = forwardCallTo(receiver, function, isIntercepted);
+      JS('', '#.\$reflectionInfo = #', trampoline, reflectionInfo);
     } else {
       JS('', '#.\$name = #', prototype, propertyName);
     }
 
     var signatureFunction;
     if (JS('bool', 'typeof # == "number"', functionType)) {
       signatureFunction =
           JS('', '(function(s){return function(){return init.metadata[s]}})(#)',
              functionType);
     } else if (!isStatic
@@ skipping 17 matching lines @@
     JS('', '#[#] = #', prototype, callName, trampoline);
     for (int i = 1; i < functions.length; i++) {
       var stub = functions[i];
       var stubCallName = JS('String|Null', '#.\$callName', stub);
       if (stubCallName != null) {
         JS('', '#[#] = #', prototype, stubCallName,
            isStatic ? stub : forwardCallTo(receiver, stub, isIntercepted));
       }
     }
 
-    JS('', '#["call*"] = #', prototype, function);
+    JS('', '#["call*"] = #', prototype, trampoline);

[floitsch, 2014/03/31 20:12:01]

I think this was always wrong, and just never hit.
When we go through the call* of a tear-off we don't want to provide the receiver
(which would be the case for `function`).

 
     return constructor;
   }
 
   static cspForwardCall(int arity, bool isSuperCall, String stubName,
                         function) {
     var getSelf = RAW_DART_FUNCTION_REF(BoundClosure.selfOf);
     // Handle intercepted stub-names with the default slow case.
     if (isSuperCall) arity = -1;
     switch (arity) {
@@ skipping 1283 matching lines @@
     JS('', '#.addEventListener("error", #, false)',
        script, convertDartClosureToJS((event) {
       completer.completeError(
           new DeferredLoadException("Loading $uri failed."));
     }, 1));
     JS('', 'document.body.appendChild(#)', script);
 
     return completer.future;
   });
 }