dart2js: support isolates 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.
+///
+/// When serializing static functions we transmit the
+/// name of the static function, but not the name of the function's getter. We
+/// store the getter-function on the static function itself, which allows us to
+/// find it easily.
+const String tearOffPropertyName = r'$tearOff';
+
+/// The name of the property that stores the list of fields on a constructor.
+///
+/// This property is only used when isolates are used.
+///
+/// When serializing objects we extract all fields from any given object.
+/// We extract the names of all fields from a fresh empty object. This list
+/// is cached on the constructor in this property to to avoid too many
+/// allocations.
+const String cachedClassFieldNames = r'$cachedFieldNames';
+
 /// 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
 /// objects.
 ///
 /// Example:
 ///
 ///     // Holders are initialized directly with the classes and static
 ///     // functions.
@@ skipping 118 matching lines @@
 // 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) {
+  // A function can have several stubs (for example to fill in optional
+  // arguments). We collect these functions in the `funs` array.
   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;
+  // The main function to which all stubs redirect.
+  var fun = funs[0];
+
+  fun[#argumentCount] = requiredParameterCount;
+  fun[#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] =
+  var getterFunction =
       tearOff(funs, reflectionInfo, isStatic, name, isIntercepted);
+  container[getterName] = getterFunction;
+  if (isStatic) {
+    fun.$tearOffPropertyName = getterFunction;
+  }
 }
 
 // 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;
@@ skipping 39 matching lines @@
   // 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,
        #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.
 
 // TODO(floitsch): we should build this object as a literal.
 var #staticStateDeclaration = {};
 
 // Sets the prototypes of classes.
 #prototypes;
@@ skipping 109 matching lines @@
          '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),
          '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),
@@ skipping 99 matching lines @@
           new js.VariableDeclarationList(holders
               .map(emitHolderInitialization)
               .toList())),
       js.js.statement('var holders = #', new js.ArrayInitializer(
           holders
               .map((holder) => new js.VariableUse(holder.name))
               .toList(growable: false)))];
     return new js.Block(statements);
   }
 
+  /// Returns a reference to the constant holder, or the JS-literal `null`.
+  js.Expression buildConstantHolderReference(Program program) {
+    Holder constantHolder = program.holders
+        .firstWhere((Holder holder) => holder.isConstantsHolder,
+                    orElse: () => null);
+    if (constantHolder == null) return new js.LiteralNull();
+    return new js.VariableUse(constantHolder.name);
+  }
+
   /// 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.
@@ skipping 466 matching lines @@
 
     return new js.Property(js.string(MANGLED_GLOBAL_NAMES),
                            new js.ObjectInitializer(names));
   }
 
   /// Emits the [GET_TYPE_FROM_NAME] embedded global.
   ///
   /// This embedded global provides a way to go from a class name (which is
   /// also the constructor's name) to the constructor itself.
   js.Property emitGetTypeFromName() {
-    // TODO(floitsch): Fix getTypeFromName. It's too inefficient.
-    // The current implementation relies on the fact that the names in holders
-    // are unique across all holders.
-    // TODO(floitsch): constants and other globals may share the same name.
-    //   If a global happens to have the same (minified) name this code breaks.
-    //   A follow-up CL has a fix for this.
-    js.Expression function =
-        js.js( """function(name) {
-                    for (var i = 0; i < holders.length; i++) {
-                      // Relies on the fact that all variables are unique.
-                      if (holders[i][name]) return holders[i][name];
-                    }
-                  }""");
+    js.Expression function = js.js("getGlobalFromName");
     return new js.Property(js.string(GET_TYPE_FROM_NAME), function);
   }
 
   /// Emits the [METADATA] embedded global.
   ///
   /// The metadata itself has already been computed earlier and is stored in
   /// the [program].
   List<js.Property> emitMetadata(Program program) {
     List<js.Property> metadataGlobals = <js.Property>[];
 
@@ skipping 26 matching lines @@
     }
 
     if (program.hasIsolateSupport) {
       String staticStateName = namer.staticStateHolder;
       // TODO(floitsch): this doesn't create a new isolate, but just reuses
       // the current static state. Since we don't run multiple isolates in the
       // same JavaScript context (except for testing) this shouldn't have any
       // impact on real-world programs, though.
       globals.add(
           new js.Property(js.string(CREATE_NEW_ISOLATE),
-          js.js('function () { return $staticStateName; }')));
-      // TODO(floitsch): add remaining isolate functions.
+                          js.js('function () { return $staticStateName; }')));
+
+      js.Expression nameToClosureFunction = js.js('''
+        // First fetch the static function. From there we can execute its
+        // getter function which builds a Dart closure.
+        function(name) {
+           var staticFunction = getGlobalFromName(name);
+           var getterFunction = staticFunction.$tearOffPropertyName;
+           return getterFunction();
+         }''');
+      globals.add(new js.Property(js.string(STATIC_FUNCTION_NAME_TO_CLOSURE),
+                                  nameToClosureFunction));
+
+      globals.add(
+          new js.Property(js.string(CLASS_ID_EXTRACTOR),
+                          js.js('function(o) { return o.constructor.name; }')));
+
+      js.Expression extractFieldsFunction = js.js('''
+      function(o) {
+        var constructor = o.constructor;
+        var fieldNames = constructor.$cachedClassFieldNames;
+        if (!fieldNames) {
+          // Extract the fields from an empty unmodified object.
+          var empty = new constructor();
+          // This gives us the keys that the constructor sets.
+          fieldNames = constructor.$cachedClassFieldNames = Object.keys(empty);
+        }
+        var result = new Array(fieldNames.length);
+        for (var i = 0; i < fieldNames.length; i++) {
+          result[i] = o[fieldNames[i]];
+        }
+        return result;
+      }''');
+      globals.add(new js.Property(js.string(CLASS_FIELDS_EXTRACTOR),
+                                  extractFieldsFunction));
+
+      js.Expression createInstanceFromClassIdFunction = js.js('''
+        function(name) {
+          var constructor = getGlobalFromName(name);
+          return new constructor();
+        }
+      ''');
+      globals.add(new js.Property(js.string(INSTANCE_FROM_CLASS_ID),
+                                  createInstanceFromClassIdFunction));
+
+      js.Expression initializeEmptyInstanceFunction = js.js('''
+      function(name, o, fields) {
+        var constructor = o.constructor;
+        // By construction the object `o` is an empty object with the same
+        // keys as the one we used in the extract-fields function.
+        var fieldNames = Object.keys(o);
+        if (fieldNames.length != fields.length) {
+          throw new Error("Mismatch during deserialization.");
+        }
+        for (var i = 0; i < fields.length; i++) {
+          o[fieldNames[i]] = fields[i];
+        }
+        return o;
+      }''');
+      globals.add(new js.Property(js.string(INITIALIZE_EMPTY_INSTANCE),
+                                  initializeEmptyInstanceFunction));
     }
 
     globals.add(emitMangledGlobalNames());
 
     // The [MANGLED_NAMES] table is only relevant for reflection.
     // TODO(floitsch): verify that this is correct.
     globals.add(new js.Property(js.string(MANGLED_NAMES),
                                 new js.ObjectInitializer([])));
 
     globals.add(emitGetTypeFromName());
@@ skipping 70 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);
   }
-}
+}