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;
 
 const String deferredExtension = "part.js";
 /// For deferred loading we communicate the initializers via this global var.
 const String deferredInitializersGlobal = r"$__dart_deferred_initializers__";
 
@@ skipping 98 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.
+// TODO(floitsch): Change tearOffCode to accept the data directly, or create a
+// different tearOffCode?
+function installTearOff(container, getterName,
+                       isStatic, isIntercepted, requiredParameterCount,

[Siggi Cherem (dart-lang), 2015/07/22 20:51:28]

missing 1 space of indentation (FWIW, I don't think args alignment is worth the
effort, I'd be happy with just +4 here).

[floitsch, 2015/07/29 17:27:15]

Done.

+                       optionalParameterDefaultValues,
+                       callNames, funNames, funType) {
+  var funs = [];
+  for (var i = 0; i < funNames.length; i++) {
+    var fun = container[funNames[i]];
+    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 = funNames[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;
   types.push.apply(types, newTypes);
+  // This relies on the fact that types are added *after* the tear-offs have

[Siggi Cherem (dart-lang), 2015/07/22 20:51:28]

nit: move the comment above the push call?

[floitsch, 2015/07/29 17:27:15]

Done. and added more comments.

+  // been installed.
 }
 
 // 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 321 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.Name> funNames = <js.Name>[];
+
+    callNames.add(method.callName);
+    funNames.add(method.name);
+    for (ParameterStubMethod stubMethod in method.parameterStubs) {
+      callNames.add(stubMethod.callName);
+      funNames.add(stubMethod.name);
+    }
+
+    js.ArrayInitializer callNameArray =
+        new js.ArrayInitializer(callNames.map(js.quoteName).toList());
+    js.ArrayInitializer funNameArray =
+        new js.ArrayInitializer(funNames.map(js.quoteName).toList());
+
+    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);
+    }
+
+// TODO(floitsch): this can be more efficient.

[Siggi Cherem (dart-lang), 2015/07/22 20:51:28]

what are you referring to by `this`?

[floitsch, 2015/07/29 17:27:15]

removed.
The tear-off function is redirecting to another function, but in the end it
shouldn't be a bottle-neck.

+    return js.js.statement('''
+        installTearOff(#container, #getterName, #isStatic, #isIntercepted,
+                       #requiredParameterCount, #optionalParameterDefaultValues,
+                       #callNames, #funNames, #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,
+          "funNames": funNameArray,
+          "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 41 matching lines @@
   }
 
   emitEmbeddedGlobals(program) {
     throw new UnimplementedError('emitEmbeddedGlobals');
   }
 
   emitNativeSupport(fragment) {
     throw new UnimplementedError('emitNativeSupport');
   }
 }