dart2js: fix a few TODOs 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 name of the property that stores the tear-off getter on a static
 /// function.
 ///
 /// This property is only used when isolates are used.
@@ skipping 50 matching lines @@
 
 (function() {
 // Copies the own properties from [from] to [to].
 function copyProperties(from, to) {
   var keys = Object.keys(from);
   for (var i = 0; i < keys.length; i++) {
     to[keys[i]] = from[keys[i]];
   }
 }
 
+var supportsDirectProtoAccess = (function () {
+  var cls = function () {};
+  cls.prototype = {'p': {}};
+  var object = new cls();
+  return object.__proto__ &&
+         object.__proto__.p === cls.prototype.p;
+})();
+
+var functionsHaveName = (function() {
+  function t() {};
+  return (typeof t.name == 'string')
+})();
+
+var isChrome = (typeof window != 'undefined') &&
+    (typeof window.chrome != 'undefined');
+
+// Sets the name property of functions, if the JS engine doesn't set the name
+// itself.
+// As of 2015 only IE doesn't set the name.
+function setFunctionNamesIfNecessary(holders) {
+  if (functionsHaveName) return;
+  for (var i = 0; i < holders.length; i++) {
+    var holder = holders[i];
+    var keys = Object.keys(holder);
+    for (var j = 0; j < keys.length; j++) {
+      var key = keys[j];
+      var f = holder[key];
+      if (typeof f == 'function') f.name = key;
+    }
+  }
+}
+
 // Makes [cls] inherit from [sup].
 // On Chrome, Firefox and recent IEs this happens by updating the internal
 // proto-property of the classes 'prototype' field.
 // Older IEs use `Object.create` and copy over the properties.
 function inherit(cls, sup) {
-  // TODO(floitsch): IE doesn't support changing the __proto__ property. There,
-  // we need to copy the properties instead.
   cls.#typeNameProperty = cls.name;  // Needed for RTI.
   cls.prototype.constructor = cls;
   cls.prototype[#operatorIsPrefix + cls.name] = cls;
 
   // The superclass is only null for the Dart Object.
   if (sup != null) {
-    cls.prototype.__proto__ = sup.prototype;
+    if (supportsDirectProtoAccess) {
+      // Firefox doesn't like to update the prototypes, but when setting up
+      // the hierarchy chain it's ok.
+      cls.prototype.__proto__ = sup.prototype;
+      return;
+    }
+    var clsPrototype = Object.create(sup.prototype);
+    copyProperties(cls.prototype, clsPrototype);
+    cls.prototype = clsPrototype;
   }
 }
 
 // Mixes in the properties of [mixin] into [cls].
 function mixin(cls, mixin) {
   copyProperties(mixin.prototype, cls.prototype);
 }
 
 // Creates a lazy field.
 //
@@ skipping 31 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;
 }
 
+function convertToFastObject(properties) {
+  // Create an instance that uses 'properties' as prototype. This should
+  // make 'properties' a fast object.
+  function t() {};
+  t.prototype = properties;
+  new t();
+  return properties;
+}
+
 // 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.
@@ skipping 77 matching lines @@
   // 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;
+  // Firefox doesn't like when important objects have their prototype chain
+  // updated. We therefore do this only on V8.
+  if (isChrome) {
+    var oldPrototype = holder.__proto__;
+    newHolder.__proto__ = oldPrototype;
+    holder.__proto__ = newHolder;
+  } else {
+    copyProperties(newHolder, holder);
+  }
   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, setOrUpdateInterceptorsByTag,
-       setOrUpdateLeafTags,
+  hunk(inherit, mixin, lazy, makeConstList, convertToFastObject, installTearOff,
+       setFunctionNamesIfNecessary, updateHolder, updateTypes,
+       setOrUpdateInterceptorsByTag, setOrUpdateLeafTags,
        #embeddedGlobalsObject, #holdersList, #staticState);
 }
 
 // Returns the global with the given [name].
 function getGlobalFromName(name) {
   // TODO(floitsch): we are running through all holders. Since negative
   // lookups are expensive we might need to improve this.
   // Relies on the fact that all names are unique across all holders.
   for (var i = 0; i < holders.length; i++) {
     // The constant holder reuses the same names. Therefore we must skip it.
     if (holders[i] == #constantHolderReference) continue;
     // Relies on the fact that all variables are unique.
     if (holders[i][name]) return holders[i][name];
   }
 }
 
 // Creates the holders.
 #holders;
-// TODO(floitsch): if name is not set (for example in IE), run through all
-// functions and set the name.
+
+// If the name is not set on the functions, do it now.
+setFunctionNamesIfNecessary(#holdersList);
 
 // TODO(floitsch): we should build this object as a literal.
 var #staticStateDeclaration = {};
 
 // Sets the prototypes of classes.
 #prototypes;
 // Sets aliases of methods (on the prototypes of classes).
 #aliases;
 // Installs the tear-offs of functions.
 #tearOffs;
@@ skipping 18 matching lines @@
 #invokeMain;
 })();
 }''';
 
 /// Deferred fragments (aka 'hunks') are built similarly to the main fragment.
 ///
 /// However, at specific moments they need to contribute their data.
 /// For example, once the holders have been created, they are included into
 /// the main holders.
 const String deferredBoilerplate = '''
-function(inherit, mixin, lazy, makeConstList, installTearOff,
-          updateHolder, updateTypes,
-          setOrUpdateInterceptorsByTag, setOrUpdateLeafTags,
-          #embeddedGlobalsObject, holdersList, #staticState) {
+function(inherit, mixin, lazy, makeConstList, convertToFastObject,
+         installTearOff, setFunctionNamesIfNecessary, updateHolder, updateTypes,
+         setOrUpdateInterceptorsByTag, setOrUpdateLeafTags,
+         #embeddedGlobalsObject, holdersList, #staticState) {
 
 // Builds the holders. They only contain the data for new holders.
 #holders;
+
+// If the name is not set on the functions, do it now.
+setFunctionNamesIfNecessary(#deferredHoldersList);
+
 // Updates the holders of the main-fragment. Uses the provided holdersList to
 // access the main holders.
 // The local holders are replaced by the combined holders. This is necessary
 // for the inheritance setup below.
 #updateHolders;
 // Sets the prototypes of the new classes.
 #prototypes;
 // Sets aliases of methods (on the prototypes of classes).
 #aliases;
 // Installs the tear-offs of functions.
@@ skipping 42 matching lines @@
 
   js.Expression classReference(Class cls) {
     return js.js('#.#', [cls.holder.name, cls.name]);
   }
 
   js.Statement emitMainFragment(
       Program program,
       Map<DeferredFragment, _DeferredFragmentHash> deferredLoadHashes) {
     MainFragment fragment = program.fragments.first;
 
+    Iterable<Holder> nonStaticStateHolders = program.holders
+        .where((Holder holder) => !holder.isStaticStateHolder);
+
     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()),
+         'holdersList': new js.ArrayInitializer(nonStaticStateHolders
+             .map((holder) => js.js("#", holder.name))
+             .toList(growable: false)),
          'staticStateDeclaration': new js.VariableDeclaration(
              namer.staticStateHolder, allowRename: false),
          'staticState': js.js('#', namer.staticStateHolder),
          'constantHolderReference': buildConstantHolderReference(program),
          'holders': emitHolders(program.holders, fragment),
          'callName': js.string(namer.callNameField),
          'argumentCount': js.string(namer.requiredParameterField),
          'defaultArgumentValues': js.string(namer.defaultValuesField),
          'prototypes': emitPrototypes(fragment),
          'inheritance': emitInheritance(fragment),
          'aliases': emitInstanceMethodAliases(fragment),
          'tearOffs': emitInstallTearOffs(fragment),
          'constants': emitConstants(fragment),
          'staticNonFinalFields': emitStaticNonFinalFields(fragment),
          'lazyStatics': emitLazilyInitializedStatics(fragment),
          'embeddedGlobals': emitEmbeddedGlobals(program, deferredLoadHashes),
          'nativeSupport': program.needsNativeSupport
               ? emitNativeSupport(fragment)
               : new js.EmptyStatement(),
          'invokeMain': fragment.invokeMain,
          });
   }
 
   js.Expression emitDeferredFragment(DeferredFragment fragment,
-                                    js.Expression deferredTypes,
-                                    List<Holder> holders) {
+                                     js.Expression deferredTypes,
+                                     List<Holder> holders) {
+    List<Holder> nonStaticStateHolders = holders
+        .where((Holder holder) => !holder.isStaticStateHolder)
+        .toList(growable: false);
+
     List<js.Statement> updateHolderAssignments = <js.Statement>[];
-    for (int i = 0; i < holders.length; i++) {
-      Holder holder = holders[i];
-      if (holder.isStaticStateHolder) continue;
+    for (int i = 0; i < nonStaticStateHolders.length; i++) {
+      Holder holder = nonStaticStateHolders[i];
       updateHolderAssignments.add(js.js.statement(
           '#holder = updateHolder(holdersList[#index], #holder)',
           {'index': js.number(i),
-            'holder': new js.VariableUse(holder.name)}));
+           'holder': new js.VariableUse(holder.name)}));
     }
 
-    // TODO(floitsch): if name is not set, run through all functions and set the
-    // name for IE.
     // TODO(floitsch): don't just reference 'init'.
     return js.js(deferredBoilerplate,
     {'embeddedGlobalsObject': new js.Parameter('init'),
      'staticState': new js.Parameter(namer.staticStateHolder),
      'holders': emitHolders(holders, fragment),
+     'deferredHoldersList': new js.ArrayInitializer(nonStaticStateHolders
+         .map((holder) => js.js("#", holder.name))
+         .toList(growable: false)),
      'updateHolders': new js.Block(updateHolderAssignments),
      'prototypes': emitPrototypes(fragment),
      'inheritance': emitInheritance(fragment),
      'aliases': emitInstanceMethodAliases(fragment),
      'tearOffs': emitInstallTearOffs(fragment),
      'constants': emitConstants(fragment),
      'staticNonFinalFields': emitStaticNonFinalFields(fragment),
      'lazyStatics': emitLazilyInitializedStatics(fragment),
      'types': deferredTypes,
      // TODO(floitsch): only call emitNativeSupport if we need native.
@@ skipping 727 matching lines @@
   ///
   /// We don't try to reduce the size of the native data, but rather build
   /// JavaScript object literals that contain all the information directly.
   /// This means that the output size is bigger, but that the startup is faster.
   ///
   /// This function is the static equivalent of
   /// [NativeGenerator.buildNativeInfoHandler].
   js.Statement emitNativeSupport(Fragment fragment) {
     List<js.Statement> statements = <js.Statement>[];
 
-    if (NativeGenerator.needsIsolateAffinityTagInitialization(backend)) {
+    // The isolate-affinity tag must only be initialized once per program.
+    if (fragment.isMainFragment &&
+        NativeGenerator.needsIsolateAffinityTagInitialization(backend)) {
       statements.add(NativeGenerator.generateIsolateAffinityTagInitialization(
               backend,
               generateEmbeddedGlobalAccess,
-              // TODO(floitsch): convertToFastObject. (Needed for "interning" of
-              // strings).
-              js.js("(function(x) { return x; })", [])));
+              js.js("""
+        // On V8, the 'intern' function converts a string to a symbol, which

[Siggi Cherem (dart-lang), 2015/08/04 01:54:54]

any reason why not define this as a function with a name and use it in both
places?

[floitsch, 2015/08/04 11:54:53]

The copy is from a different emitter. We could create a new generator (like for
other stubs), but I'm not sure it's worth it.

If you think, we should do that, leave a comment, and I will do a follow-up CL.

+        // makes property access much faster.
+        function (s) {
+          var o = {};
+          o[s] = 1;
+          return Object.keys(convertToFastObject(o))[0];
+        }""", [])));
     }
 
     Map<String, js.Expression> interceptorsByTag = <String, js.Expression>{};
     Map<String, js.Expression> leafTags = <String, js.Expression>{};
     js.Statement subclassAssignment = new js.EmptyStatement();
 
     for (Library library in fragment.libraries) {
       for (Class cls in library.classes) {
         if (cls.nativeLeafTags != null) {
           for (String tag in cls.nativeLeafTags) {
@@ skipping 22 matching lines @@
     }
     statements.add(js.js.statement("setOrUpdateInterceptorsByTag(#);",
         js.objectLiteral(interceptorsByTag)));
     statements.add(js.js.statement("setOrUpdateLeafTags(#);",
         js.objectLiteral(leafTags)));
     statements.add(subclassAssignment);
 
     return new js.Block(statements);
   }
 }