dart2js: emit tear-offs in new emitter.

pkg/compiler/lib/src/js_emitter/new_emitter/model_emitter.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.new_js_emitter.model_emitter;
 
 import '../../dart2jslib.dart' show Compiler;
 import '../../js/js.dart' as js;
 import '../../js_backend/js_backend.dart' show
     JavaScriptBackend,
     Namer,
     ConstantEmitter;
 
 import 'package:_internal/compiler/js_lib/shared/embedded_names.dart' show
     DEFERRED_LIBRARY_URIS,
     DEFERRED_LIBRARY_HASHES,
     GET_TYPE_FROM_NAME,
     INITIALIZE_LOADED_HUNK,
     IS_HUNK_INITIALIZED,
     IS_HUNK_LOADED,
     MANGLED_GLOBAL_NAMES,
     METADATA,
     TYPE_TO_INTERCEPTOR_MAP;
 
-import '../js_emitter.dart' show NativeGenerator;
+import '../js_emitter.dart' show NativeGenerator, buildTearOffCode;
 import '../model.dart';
 
 class ModelEmitter {
   final Compiler compiler;
   final Namer namer;
   final ConstantEmitter constantEmitter;
 
   JavaScriptBackend get backend => compiler.backend;
 
   /// For deferred loading we communicate the initializers via this global var.
@@ skipping 65 matching lines @@
     } else {
       nativeBoilerplate = js.js.statement(";");
     }
 
     js.Expression code = new js.ArrayInitializer(elements);
 
     return js.js.statement(
         boilerplate,
         {'deferredInitializer': emitDeferredInitializerGlobal(program.loadMap),
          'holders': emitHolders(fragment.holders),
+         'tearOff': buildTearOffCode(backend),
+         'parseFunctionDescriptor':
+           js.js.statement(parseFunctionDescriptorBoilerplate),
          'cyclicThrow':
            backend.emitter.staticFunctionAccess(backend.getCyclicThrowHelper()),
          'outputContainsConstantList': program.outputContainsConstantList,
          'embeddedGlobals': emitEmbeddedGlobals(program),
          'constants': emitConstants(fragment.constants),
          'staticNonFinals':
            emitStaticNonFinalFields(fragment.staticNonFinalFields),
          'nativeBoilerplate': nativeBoilerplate,
          'operatorIsPrefix': js.string(namer.operatorIsPrefix),
          'eagerClasses': emitEagerClassInitializations(fragment.libraries),
@@ skipping 267 matching lines @@
     List elements = [js.string(cls.superclassName),
                      js.number(cls.superclassHolderIndex)];
 
     if (cls.isMixinApplication) {
       MixinApplication mixin = cls;
       elements.add(js.string(mixin.mixinClass.name));
       elements.add(js.number(mixin.mixinClass.holder.index));
     } else {
       elements.add(_generateConstructor(cls));
     }
-    Iterable<Method> methods = cls.methods.expand((Method method) {
-      // TODO(floitsch): can there be anything else than a DartMethod?
-      if (method is DartMethod) {
-        return [method]..addAll(method.parameterStubs);
-      } else {
-        return [method];
-      }
-    });
+    Iterable<Method> methods = cls.methods;
     Iterable<Method> isChecks = cls.isChecks;
     Iterable<Method> gettersSetters = _generateGettersSetters(cls);
     Iterable<Method> allMethods =
         [methods, isChecks, gettersSetters].expand((x) => x);
-    elements.addAll(allMethods.expand((e) => [js.string(e.name), e.code]));
+    elements.addAll(allMethods.expand(emitInstanceMethod));
     return unparse(compiler, new js.ArrayInitializer(elements));
   }
 
   js.Expression emitLazyInitializer(StaticField field) {
     assert(field.isLazy);
     return unparse(compiler, field.code);
   }
 
+  static final String parseFunctionDescriptorBoilerplate = r"""
+function parseFunctionDescriptor(proto, name, desc) {
+  if (desc instanceof Array) {

[zarah, 2015/02/02 08:20:10]

It would be nice with a comment here describing the encoding or a pointer to
somewhere else where it is described.

+    proto[name] = desc[0];
+    var funs = [desc[0]];
+    funs[0].$callName = desc[1];
+    for (var pos = 4; pos < desc.length; pos += 3) {
+      var stub = desc[pos+2];
+      stub.$callName = desc[pos+1];
+      proto[desc[pos]] = stub;
+      funs.push(stub);
+    }
+    if (desc[2] != null) {
+      // TODO(floitsch): desc[3] should be the reflectionInfo, not
+      // isIntercepted.
+      var isIntercepted = desc[3];
+      var reflectionInfo = null;
+      proto[desc[2]] = tearOff(funs, reflectionInfo, false, name, isIntercepted);
+    }
+  } else {
+    proto[name] = desc;
+  }
+}
+""";
+
+  Iterable<js.Expression> emitInstanceMethod(Method method) {
+
+    List<js.Expression> makeNameCodePair(Method method) {
+      return [js.string(method.name), method.code];
+    }
+
+    List<js.Expression> makeNameCallNameCodeTriplet(ParameterStubMethod stub) {
+      js.Expression callName = stub.callName == null
+          ? new js.LiteralNull()
+          : js.string(stub.callName);
+      return [js.string(stub.name), callName, stub.code];
+    }
+
+    if (method is DartMethod) {
+      if (method.needsTearOff) {
+        bool isIntercepted = backend.isInterceptedMethod(method.element);
+        // [name, [function, callName, tearOffName, functionType,
+        //     stub1_name, stub1_callName, stub1_code, ...]
+        var data = [method.code];
+        data.add(js.string(method.callName));
+        data.add(js.string(method.tearOffName));
+        // TODO(floitsch): this field should be the type, not the bool if the
+        // method is intercepted.
+        // data.add(new js.LiteralNull());
+        data.add(new js.LiteralBool(isIntercepted));
+        data.addAll(method.parameterStubs.expand(makeNameCallNameCodeTriplet));
+        return [js.string(method.name), new js.ArrayInitializer(data)];
+      } else {
+        // TODO(floitsch): not the most efficient way...
+        return ([method]..addAll(method.parameterStubs)).expand(makeNameCodePair);

[zarah, 2015/02/02 08:20:11]

long line.

+      }
+    } else {
+      return makeNameCodePair(method);
+    }
+  }
+
   Iterable<js.Expression> emitStaticMethod(StaticMethod method) {
     js.Expression holderIndex = js.number(method.holder.index);
     List<js.Expression> output = <js.Expression>[];
 
     void _addMethod(Method method) {
       js.Expression unparsed = unparse(compiler, method.code);
       output.add(js.string(method.name));
       output.add(holderIndex);
       output.add(unparsed);
     }
 
     _addMethod(method);
     // TODO(floitsch): can there be anything else than a StaticDartMethod?
     if (method is StaticDartMethod) {
       method.parameterStubs.forEach(_addMethod);
     }
     return output;
   }
 
   static final String boilerplate = """
 {
 // Declare deferred-initializer global.
 #deferredInitializer;
 
 !function(start, program) {
-
+  var functionCounter = 0;
   // Initialize holder objects.
   #holders;
 
   function setupProgram() {
     for (var i = 0; i < program.length - 1; i++) {
       setupLibrary(program[i]);
     }
     setupLazyStatics(program[i]);
   }
 
@@ skipping 68 matching lines @@
       constructor.apply(object, arguments);
       return object;
     };
 
     // We store the ensureResolved function on the patch function to make it
     // possible to resolve superclass references without constructing instances.
     patch.ensureResolved = ensureResolved;
     holder[name] = patch;
   }
 
+  #tearOff;
+
+  #parseFunctionDescriptor;
+
   function compileConstructor(name, descriptor) {
     descriptor = compile(name, descriptor);
     var prototype = determinePrototype(descriptor);
     var constructor;
     // $mixinFormatDescription.
     if (typeof descriptor[2] !== 'function') {
       constructor = compileMixinConstructor(name, prototype, descriptor);
       for (var i = 4; i < descriptor.length; i += 2) {
-        prototype[descriptor[i]] = descriptor[i + 1];
+        parseFunctionDescriptor(prototype, descriptor);
       }
     } else {
       constructor = descriptor[2];
       for (var i = 3; i < descriptor.length; i += 2) {
-        prototype[descriptor[i]] = descriptor[i + 1];
+        parseFunctionDescriptor(prototype, descriptor[i], descriptor[i+1]);
       }
     }
     constructor.builtin\$cls = name;  // Needed for RTI.
     constructor.prototype = prototype;
     prototype[#operatorIsPrefix + name] = constructor;
     prototype.constructor = constructor;
     return constructor;
   }
 
   function compileMixinConstructor(name, prototype, descriptor) {
@@ skipping 66 matching lines @@
 
   var end = Date.now();
   print('Setup: ' + (end - start) + ' ms.');
 
   #main();  // Start main.
 
 }(Date.now(), #code)
 }""";
 
 }