Support generation of tearoffs for instance methods.

sdk/lib/_internal/compiler/js_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:_js_embedded_names' show
     GET_TYPE_FROM_NAME,
     GET_ISOLATE_TAG,
     INTERCEPTED_NAMES,
@@ skipping 1946 matching lines @@
    *
    * Further assumes that [reflectionInfo] is the end of the array created by
    * [dart2js.js_emitter.ContainerBuilder.addMemberMethod] starting with
    * required parameter count.
    *
    * Caution: this function may be called when building constants.
    * TODO(ahe): Don't call this function when building constants.
    */
   static fromTearOff(receiver,
                      List functions,
-                     List reflectionInfo,
+                     var reflectionInfo,
                      bool isStatic,
                      jsArguments,
                      String propertyName) {
     JS_EFFECT(() {
       BoundClosure.receiverOf(JS('BoundClosure', 'void 0'));
       BoundClosure.selfOf(JS('BoundClosure', 'void 0'));
     });
     // TODO(ahe): All the place below using \$ should be rewritten to go
     // through the namer.
     var function = JS('', '#[#]', functions, 0);
     String name = JS('String|Null', '#.\$stubName', function);
     String callName = JS('String|Null', '#.\$callName', function);
 
-    JS('', '#.\$reflectionInfo = #', function, reflectionInfo);
-    ReflectionInfo info = new ReflectionInfo(function);
+    var functionType;
+    if (reflectionInfo is List) {
+      JS('', '#.\$reflectionInfo = #', function, reflectionInfo);
+      ReflectionInfo info = new ReflectionInfo(function);
+      functionType = info.functionType;
+    } else {
+      functionType = reflectionInfo;
+    }
 
-    var functionType = info.functionType;
 
     // function tmp() {};
     // tmp.prototype = BC.prototype;
     // var proto = new tmp;
     // for each computed prototype property:
     //   proto[property] = ...;
     // proto._init = BC;
     // var dynClosureConstructor =
     //     new Function('self', 'target', 'receiver', 'name',
     //                  'this._init(self, target, receiver, name)');
@@ skipping 62 matching lines @@
       var getReceiver = isIntercepted
           ? RAW_DART_FUNCTION_REF(BoundClosure.receiverOf)
           : RAW_DART_FUNCTION_REF(BoundClosure.selfOf);
       signatureFunction = JS(
         '',
         'function(f,r){'
           'return function(){'
             'return f.apply({\$receiver:r(this)},arguments)'
           '}'
         '}(#,#)', functionType, getReceiver);
-    } else {
+    } else if (functionType != null) {
+      // TODO(herhut): Disallow null again once we have function types.
       throw 'Error in reflectionInfo.';
     }
 
     JS('', '#[#] = #', prototype, JS_SIGNATURE_NAME(), signatureFunction);
 
     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) {
@@ skipping 238 matching lines @@
 /// Called from implicit method getter (aka tear-off).
 closureFromTearOff(receiver,
                    functions,
                    reflectionInfo,
                    isStatic,
                    jsArguments,
                    name) {
   return Closure.fromTearOff(
       receiver,
       JSArray.markFixedList(functions),
-      JSArray.markFixedList(reflectionInfo),
+      reflectionInfo is List ? JSArray.markFixedList(reflectionInfo) : reflectionInfo,
       JS('bool', '!!#', isStatic),
       jsArguments,
       JS('String', '#', name));
 }
 
 /// Represents an implicit closure of a function.
 class TearOffClosure extends Closure {
 }
 
 /// Represents a 'tear-off' closure, that is an instance method bound
@@ skipping 1112 matching lines @@
   throw new MainError("No top-level function named 'main'.");
 }
 
 void badMain() {
   throw new MainError("'main' is not a function.");
 }
 
 void mainHasTooManyParameters() {
   throw new MainError("'main' expects too many parameters.");
 }