dart2js: support tear-offs in the startup emitter.

pkg/compiler/lib/src/js_emitter/startup_emitter/fragment_emitter.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.
 
 part of dart2js.js_emitter.startup_emitter.model_emitter;
 
 /// The fast startup emitter's goal is to minimize the amount of work that the
 /// JavaScript engine has to do before it can start running user code.
 ///
 /// Whenever possible, the emitter uses object literals instead of updating
@@ skipping 94 matching lines @@
 // The runtime ensures that const-lists cannot be modified.
 function makeConstList(list) {
   // By assigning a function to the properties they become part of the
   // hidden class. The actual values of the fields don't matter, since we
   // only check if they exist.
   list.immutable\$list = Array;
   list.fixed\$length = Array;
   return list;
 }
 
-// TODO(floitsch): provide code for tear-offs.
+// This variable is used by the tearOffCode to guarantee unique functions per
+// tear-offs.
+var functionCounter = 0;
+#tearOffCode;
+
+// Each deferred hunk comes with its own types which are added to the end
+// of the types-array.
+// The `funTypes` passed to the `installTearOff` function below is relative to
+// the hunk the function comes from. The `typesOffset` variable encodes the
+// offset at which the new types will be added.
+var typesOffset = 0;
+
+// Adapts the stored data, so it's suitable for a tearOff call.
+//
+// Stores the tear-off getter-function in the [container]'s [getterName]
+// property.
+//
+// The [container] is either a class (that is, its prototype), or the holder for
+// static functions.
+//
+// The argument [funsOrNames] is an array of strings or functions. If it is a
+// name, then the function should be fetched from the container. The first
+// entry in that array *must* be a string.
+//
+// TODO(floitsch): Change tearOffCode to accept the data directly, or create a
+// different tearOffCode?
+function installTearOff(
+    container, getterName, isStatic, isIntercepted, requiredParameterCount,
+    optionalParameterDefaultValues, callNames, funsOrNames, funType) {
+  var funs = [];
+  for (var i = 0; i < funsOrNames.length; i++) {
+    var fun = funsOrNames[i];
+    if ((typeof fun) == 'string') fun = container[fun];
+    fun.#callName = callNames[i];
+    funs.push(fun);
+  }
+
+  funs[0][#argumentCount] = requiredParameterCount;
+  funs[0][#defaultArgumentValues] = optionalParameterDefaultValues;
+  var reflectionInfo = funType;
+  if (typeof reflectionInfo == "number") {
+    // The reflectionInfo can either be a function, or a pointer into the types
+    // table. If it points into the types-table we need to update the index,
+    // in case the tear-off is part of a deferred hunk.
+    reflectionInfo = reflectionInfo + typesOffset;
+  }
+  var name = funsOrNames[0];
+  container[getterName] =
+      tearOff(funs, reflectionInfo, isStatic, name, isIntercepted);
+}
 
 // Instead of setting the interceptor tags directly we use this update
 // function. This makes it easier for deferred fragments to contribute to the
 // embedded global.
 function setOrUpdateInterceptorsByTag(newTags) {
   var tags = #embeddedInterceptorTags;
   if (!tags) {
     #embeddedInterceptorTags = newTags;
     return;
   }
   copyProperties(newTags, tags);
 }
 
 // Instead of setting the leaf tags directly we use this update
 // function. This makes it easier for deferred fragments to contribute to the
 // embedded global.
 function setOrUpdateLeafTags(newTags) {
   var tags = #embeddedLeafTags;
   if (!tags) {
     #embeddedLeafTags = newTags;
     return;
   }
   copyProperties(newTags, tags);
 }
 
 // Updates the types embedded global.
 function updateTypes(newTypes) {
   var types = #embeddedTypes;
+  // This relies on the fact that types are added *after* the tear-offs have
+  // been installed. The tear-off function uses the types-length to figure
+  // out at which offset its types are located. If the types were added earlier
+  // the offset would be wrong.
   types.push.apply(types, newTypes);
 }
 
 // Updates the given holder with the properties of the [newHolder].
 // This function is used when a deferred fragment is initialized.
 function updateHolder(holder, newHolder) {
   // TODO(floitsch): updating the prototype (instead of copying) is
   // *horribly* inefficient in Firefox. There we should just copy the
   // properties.
   var oldPrototype = holder.__proto__;
   newHolder.__proto__ = oldPrototype;
   holder.__proto__ = newHolder;
   return holder;
 }
 
 // Every deferred hunk (i.e. fragment) is a function that we can invoke to
 // initialize it. At this moment it contributes its data to the main hunk.
 function initializeDeferredHunk(hunk) {
+  // Update the typesOffset for the next deferred library.
+  typesOffset = #embeddedTypes.length;
+
   // TODO(floitsch): extend natives.
   hunk(inherit, mixin, lazy, makeConstList, installTearOff,
        updateHolder, updateTypes, updateInterceptorsByTag, updateLeafTags,
        #embeddedGlobalsObject, #holdersList, #staticState);
 }
 
 // Creates the holders.
 #holders;
 // TODO(floitsch): if name is not set (for example in IE), run through all
 // functions and set the name.
@@ skipping 107 matching lines @@
 
   js.Statement emitMainFragment(Program program) {
     MainFragment fragment = program.fragments.first;
 
     return js.js.statement(mainBoilerplate,
         {'deferredInitializer': emitDeferredInitializerGlobal(program.loadMap),
          'typeNameProperty': js.string(ModelEmitter.typeNameProperty),
          'cyclicThrow': backend.emitter.staticFunctionAccess(
                  backend.getCyclicThrowHelper()),
          'operatorIsPrefix': js.string(namer.operatorIsPrefix),
+         'tearOffCode': new js.Block(buildTearOffCode(backend)),
          'embeddedTypes': generateEmbeddedGlobalAccess(TYPES),
          'embeddedInterceptorTags':
              generateEmbeddedGlobalAccess(INTERCEPTORS_BY_TAG),
          'embeddedLeafTags': generateEmbeddedGlobalAccess(LEAF_TAGS),
          'embeddedGlobalsObject': js.js("init"),
          'holdersList': new js.ArrayInitializer(program.holders.map((holder) {
            return js.js("#", holder.name);
          }).toList()),
          'staticStateDeclaration': new js.VariableDeclaration(
              namer.staticStateHolder, allowRename: false),
@@ skipping 121 matching lines @@
   }
 
   /// Emits the given [method].
   ///
   /// A Dart method might result in several JavaScript functions, if it
   /// requires stubs. The returned map contains the original method and all
   /// the stubs it needs.
   Map<js.Name, js.Expression> emitStaticMethod(StaticMethod method) {
     Map<js.Name, js.Expression> jsMethods = <js.Name, js.Expression>{};
 
+    // We don't need to install stub-methods. They can only be used when there
+    // are tear-offs, in which case they are emitted there.
+    assert(() {
+      if (method is StaticDartMethod) {
+        return method.needsTearOff || method.parameterStubs.isEmpty;
+      }
+      return true;
+    });
     jsMethods[method.name] = method.code;
-    // TODO(floitsch): can there be anything else than a StaticDartMethod?
-    if (method is StaticDartMethod) {
-      for (ParameterStubMethod stubMethod in method.parameterStubs) {
-        jsMethods[stubMethod.name] = stubMethod.code;
-      }
-    }
 
     return jsMethods;
   }
 
   /// Emits a constructor for the given class [cls].
   ///
   /// The constructor is statically built.
   js.Expression emitConstructor(Class cls) {
     List<js.Name> fieldNames = const <js.Name>[];
 
@@ skipping 34 matching lines @@
   // TODO(floitsch): we could avoid that property if we knew that it wasn't
   //    needed.
   js.Expression emitPrototype(Class cls) {
     Iterable<Method> methods = cls.methods;
     Iterable<Method> isChecks = cls.isChecks;
     Iterable<Method> callStubs = cls.callStubs;
     Iterable<Method> typeVariableReaderStubs = cls.typeVariableReaderStubs;
     Iterable<Method> noSuchMethodStubs = cls.noSuchMethodStubs;
     Iterable<Method> gettersSetters = generateGettersSetters(cls);
     Iterable<Method> allMethods =
-    [methods, isChecks, callStubs, typeVariableReaderStubs,
+        [methods, isChecks, callStubs, typeVariableReaderStubs,
     noSuchMethodStubs, gettersSetters].expand((x) => x);
 
     List<js.Property> properties = <js.Property>[];
 
     if (cls.superclass == null) {
       properties.add(new js.Property(js.string("constructor"),
       classReference(cls)));
       properties.add(new js.Property(namer.operatorIs(cls.element),
       js.number(1)));
     }
@@ skipping 125 matching lines @@
                 [classReference(cls), js.quoteName(method.aliasName),
                  classReference(cls), js.quoteName(method.name)]));
 
           }
         }
       }
     }
     return new js.Block(assignments);
   }
 
+  /// Encodes the optional default values so that the runtime Function.apply
+  /// can use them.
+  js.Expression _encodeOptionalParameterDefaultValues(DartMethod method) {
+    // TODO(herhut): Replace [js.LiteralNull] with [js.ArrayHole].
+    if (method.optionalParameterDefaultValues is List) {
+      List<ConstantValue> defaultValues = method.optionalParameterDefaultValues;
+      Iterable<js.Expression> elements =
+          defaultValues.map(generateConstantReference);
+      return new js.ArrayInitializer(elements.toList());
+    } else {
+      Map<String, ConstantValue> defaultValues =
+          method.optionalParameterDefaultValues;
+      List<js.Property> properties = <js.Property>[];
+      defaultValues.forEach((String name, ConstantValue value) {
+        properties.add(new js.Property(js.string(name),
+        generateConstantReference(value)));
+      });
+      return new js.ObjectInitializer(properties);
+    }
+  }
+
+  /// Emits the statement that installs a tear off for a method.
+  ///
+  /// Tear-offs might be passed to `Function.apply` which means that all
+  /// calling-conventions (with or without optional positional/named arguments)
+  /// are possible. As such, the tear-off needs enough information to fill in
+  /// missing parameters.
+  js.Statement emitInstallTearOff(js.Expression container, DartMethod method) {
+    List<js.Name> callNames = <js.Name>[];
+    List<js.Expression> funsOrNames = <js.Expression>[];
+
+    /// Adds the stub-method's code or name to the [funsOrNames] array.
+    ///
+    /// Static methods don't need stub-methods except for tear-offs. As such,
+    /// they are not emitted in the prototype, but directly passed here.
+    ///
+    /// Instance-methods install the stub-methods in their prototype, and we
+    /// use string-based redirections to find them there.
+    void addFunOrName(StubMethod stubMethod) {
+      if (method.isStatic) {
+        funsOrNames.add(stubMethod.code);
+      } else {
+        funsOrNames.add(js.quoteName(stubMethod.name));
+      }
+    }
+
+    callNames.add(method.callName);
+    // The first entry in the funsOrNames-array must be a string.
+    funsOrNames.add(js.quoteName(method.name));
+    for (ParameterStubMethod stubMethod in method.parameterStubs) {
+      callNames.add(stubMethod.callName);
+      addFunOrName(stubMethod);
+    }
+
+    js.ArrayInitializer callNameArray =
+        new js.ArrayInitializer(callNames.map(js.quoteName).toList());
+    js.ArrayInitializer funsOrNamesArray = new js.ArrayInitializer(funsOrNames);
+
+    bool isIntercepted = false;
+    if (method is InstanceMethod) {
+      isIntercepted = backend.isInterceptedMethod(method.element);
+    }
+    int requiredParameterCount = 0;
+    js.Expression optionalParameterDefaultValues = new js.LiteralNull();
+    if (method.canBeApplied) {
+      requiredParameterCount = method.requiredParameterCount;
+      optionalParameterDefaultValues =
+          _encodeOptionalParameterDefaultValues(method);
+    }
+
+    return js.js.statement('''
+        installTearOff(#container, #getterName, #isStatic, #isIntercepted,
+                       #requiredParameterCount, #optionalParameterDefaultValues,
+                       #callNames, #funsOrNames, #funType)''',
+        {
+          "container": container,
+          "getterName": js.quoteName(method.tearOffName),
+          "isStatic": new js.LiteralBool(method.isStatic),
+          "isIntercepted": new js.LiteralBool(isIntercepted),
+          "requiredParameterCount": js.number(requiredParameterCount),
+          "optionalParameterDefaultValues": optionalParameterDefaultValues,
+          "callNames": callNameArray,
+          "funsOrNames": funsOrNamesArray,
+          "funType": method.functionType,
+        });
+  }
+
   /// Emits the section that installs tear-off getters.
-  js.Statement emitInstallTearOffs(fragment) {
-    throw new UnimplementedError('emitInstallTearOffs');
+  js.Statement emitInstallTearOffs(Fragment fragment) {
+    List<js.Statement> inits = <js.Statement>[];
+
+    for (Library library in fragment.libraries) {
+      for (StaticMethod method in library.statics) {
+        // TODO(floitsch): can there be anything else than a StaticDartMethod?
+        if (method is StaticDartMethod) {
+          if (method.needsTearOff) {
+            Holder holder = method.holder;
+            inits.add(
+                emitInstallTearOff(new js.VariableUse(holder.name), method));
+          }
+        }
+      }
+      for (Class cls in library.classes) {
+        for (InstanceMethod method in cls.methods) {
+          if (method.needsTearOff) {
+            js.Expression container = js.js("#.prototype", classReference(cls));
+            inits.add(emitInstallTearOff(container, method));
+          }
+        }
+      }
+    }
+    return new js.Block(inits);
   }
 
   /// Emits the constants section.
   js.Statement emitConstants(Fragment fragment) {
     List<js.Statement> assignments = <js.Statement>[];
     for (Constant constant in fragment.constants) {
       // TODO(floitsch): instead of just updating the constant holder, we should
       // find the constants that don't have any dependency on other constants
       // and create an object-literal with them (and assign it to the
       // constant-holder variable).
@@ skipping 44 matching lines @@
   }
 
   emitEmbeddedGlobals(program) {
     throw new UnimplementedError('emitEmbeddedGlobals');
   }
 
   emitNativeSupport(fragment) {
     throw new UnimplementedError('emitNativeSupport');
   }
 }