Isolates: allow sending of arbitrary objects in dart2js.

pkg/compiler/lib/src/js_emitter/old_emitter/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.
 
 part of dart2js.js_emitter;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
@@ skipping 56 matching lines @@
 
   CodeBuffer get mainBuffer {
     return getBuffer(compiler.deferredLoadTask.mainOutputUnit);
   }
 
   /**
    * List of expressions and statements that will be included in the
    * precompiled function.
    *
    * To save space, dart2js normally generates constructors and accessors
-   * dynamically. This doesn't work in CSP mode, and may impact startup time
-   * negatively. So dart2js will emit these functions to a separate file that
-   * can be optionally included to support CSP mode or for faster startup.
+   * dynamically. This doesn't work in CSP mode, so dart2js emits them directly
+   * when in CSP mode.
    */
   Map<OutputUnit, List<jsAst.Node>> _cspPrecompiledFunctions =
       new Map<OutputUnit, List<jsAst.Node>>();
 
   Map<OutputUnit, List<jsAst.Expression>> _cspPrecompiledConstructorNames =
       new Map<OutputUnit, List<jsAst.Expression>>();
 
   /**
    * Accumulate properties for classes and libraries, describing their
    * static/top-level members.
@@ skipping 69 matching lines @@
   String get finishIsolateConstructorName
       => '${namer.isolateName}.\$finishIsolateConstructor';
   String get isolatePropertiesName
       => '${namer.isolateName}.${namer.isolatePropertiesName}';
   String get lazyInitializerName
       => '${namer.isolateName}.\$lazy';
   String get initName => 'init';
   String get makeConstListProperty
       => namer.getMappedInstanceName('makeConstantList');
 
+  /// The name of the property that contains all field names.
+  ///
+  /// This property is added to constructors when isolate support is enabled.
+  static const String FIELD_NAMES_PROPERTY_NAME = r"$__fields__";
+
   /// For deferred loading we communicate the initializers via this global var.
   final String deferredInitializers = r"$dart_deferred_initializers";
 
   /// All the global state can be passed around with this variable.
   String get globalsHolder => namer.getMappedGlobalName("globalsHolder");
 
   jsAst.Expression generateEmbeddedGlobalAccess(String global) {
     return js(generateEmbeddedGlobalAccessString(global));
   }
 
   String generateEmbeddedGlobalAccessString(String global) {
     // TODO(floitsch): don't use 'init' as global embedder storage.
     return '$initName.$global';
   }
 
   jsAst.Expression isolateLazyInitializerAccess(Element element) {
-     return jsAst.js('#.#', [namer.globalObjectFor(element), 
+     return jsAst.js('#.#', [namer.globalObjectFor(element),
                              namer.getLazyInitializerName(element)]);
    }
 
   jsAst.Expression isolateStaticClosureAccess(Element element) {
      return jsAst.js('#.#()',
          [namer.globalObjectFor(element), namer.getStaticClosureName(element)]);
    }
-  
+
   jsAst.PropertyAccess globalPropertyAccess(Element element) {
     String name = namer.getNameX(element);
     jsAst.PropertyAccess pa = new jsAst.PropertyAccess.field(
         new jsAst.VariableUse(namer.globalObjectFor(element)),
         name);
     return pa;
   }
-  
+
   jsAst.PropertyAccess staticFieldAccess(Element element) {
       return globalPropertyAccess(element);
   }
-  
+
   jsAst.PropertyAccess staticFunctionAccess(Element element) {
       return globalPropertyAccess(element);
   }
-    
+
   jsAst.PropertyAccess classAccess(Element element) {
         return globalPropertyAccess(element);
   }
-  
+
   jsAst.PropertyAccess typedefAccess(Element element) {
        return globalPropertyAccess(element);
   }
 
   jsAst.FunctionDeclaration get generateAccessorFunction {
     const RANGE1_SIZE = RANGE1_LAST - RANGE1_FIRST + 1;
     const RANGE2_SIZE = RANGE2_LAST - RANGE2_FIRST + 1;
     const RANGE1_ADJUST = - (FIRST_FIELD_CODE - RANGE1_FIRST);
     const RANGE2_ADJUST = - (FIRST_FIELD_CODE + RANGE1_SIZE - RANGE2_FIRST);
     const RANGE3_ADJUST =
@@ skipping 57 matching lines @@
               accessors.push(property + "\$reflectable(" + fn + ");\\n");
             else
               accessors.push(property + fn + ";\\n");
           }
         }
 
         return field;
       }''');
   }
 
-  List get defineClassFunction {
+  List<jsAst.Node> get defineClassFunction {
     // First the class name, then the field names in an array and the members
     // (inside an Object literal).
     // The caller can also pass in the constructor as a function if needed.
     //
     // Example:
     // defineClass("A", ["x", "y"], {
     //  foo$1: function(y) {
     //   print(this.x + y);
     //  },
     //  bar$2: function(t, v) {
     //   this.x = t - v;
     //  },
     // });
 
-    var defineClass = js('''function(name, fields) {
-      var accessors = [];
+    bool hasIsolateSupport = compiler.hasIsolateSupport;
+    String fieldNamesProperty = FIELD_NAMES_PROPERTY_NAME;
 
-      var str = "function " + name + "(";
-      var body = "";
+    jsAst.Expression defineClass = js('''
+        function(name, fields) {
+          var accessors = [];
+    
+          var str = "function " + name + "(";
+          var body = "";
+          if (#hasIsolateSupport) { var fieldNames = ""; }
+    
+          for (var i = 0; i < fields.length; i++) {
+            if(i != 0) str += ", ";
+    
+            var field = generateAccessor(fields[i], accessors, name);
+            if (#hasIsolateSupport) { fieldNames += "'" + field + "',"; }
+            var parameter = "parameter_" + field;
+            str += parameter;
+            body += ("this." + field + " = " + parameter + ";\\n");
+          }
+          str += ") {\\n" + body + "}\\n";
+          str += name + ".builtin\$cls=\\"" + name + "\\";\\n";
+          str += "\$desc=\$collectedClasses." + name + ";\\n";
+          str += "if(\$desc instanceof Array) \$desc = \$desc[1];\\n";
+          str += name + ".prototype = \$desc;\\n";
+          if (typeof defineClass.name != "string") {
+            str += name + ".name=\\"" + name + "\\";\\n";
+          }
+          if (#hasIsolateSupport) {
+            str += name + ".$fieldNamesProperty=[" + fieldNames + "];\\n";
+          }
+          str += accessors.join("");
+    
+          return str;
+        }''', { 'hasIsolateSupport': hasIsolateSupport });
 
-      for (var i = 0; i < fields.length; i++) {
-        if(i != 0) str += ", ";
-
-        var field = generateAccessor(fields[i], accessors, name);
-        var parameter = "parameter_" + field;
-        str += parameter;
-        body += ("this." + field + " = " + parameter + ";\\n");
-      }
-      str += ") {\\n" + body + "}\\n";
-      str += name + ".builtin\$cls=\\"" + name + "\\";\\n";
-      str += "\$desc=\$collectedClasses." + name + ";\\n";
-      str += "if(\$desc instanceof Array) \$desc = \$desc[1];\\n";
-      str += name + ".prototype = \$desc;\\n";
-      if (typeof defineClass.name != "string") {
-        str += name + ".name=\\"" + name + "\\";\\n";
-      }
-      str += accessors.join("");
-
-      return str;
-    }''');
     // Declare a function called "generateAccessor".  This is used in
     // defineClassFunction (it's a local declaration in init()).
-    List<jsAst.Node> saveDefineClass = [];
-    if (compiler.hasIncrementalSupport) {
-      saveDefineClass.add(
-          js(r'self.$dart_unsafe_eval.defineClass = defineClass'));
-    }
-    return [
+    List result = <jsAst.Node>[
         generateAccessorFunction,
         js('$generateAccessorHolder = generateAccessor'),
         new jsAst.FunctionDeclaration(
-            new jsAst.VariableDeclaration('defineClass'), defineClass) ]
-        ..addAll(saveDefineClass);
+            new jsAst.VariableDeclaration('defineClass'), defineClass) ];
+
+    if (compiler.hasIncrementalSupport) {
+      result.add(
+          js(r'self.$dart_unsafe_eval.defineClass = defineClass'));
+    }
+
+    if (hasIsolateSupport) {
+      jsAst.Expression classIdExtractorAccess =
+          generateEmbeddedGlobalAccess(embeddedNames.CLASS_ID_EXTRACTOR);
+      var classIdExtractorAssignment =
+          js('# = function(o) { return o.constructor.name; }',
+              classIdExtractorAccess);
+
+      jsAst.Expression classFieldsExtractorAccess =
+          generateEmbeddedGlobalAccess(embeddedNames.CLASS_FIELDS_EXTRACTOR);
+      var classFieldsExtractorAssignment = js('''
+      # = function(o) {
+        var fieldNames = o.constructor.$fieldNamesProperty;
+        if (!fieldNames) return [];  // TODO(floitsch): do something else here.
+        var result = [];
+        result.length = fieldNames.length;
+        for (var i = 0; i < fieldNames.length; i++) {
+          result[i] = o[fieldNames[i]];
+        }
+        return result;
+      }''', classFieldsExtractorAccess);
+
+      jsAst.Expression instanceFromClassIdAccess =
+          generateEmbeddedGlobalAccess(embeddedNames.INSTANCE_FROM_CLASS_ID);
+      jsAst.Expression allClassesAccess =
+          generateEmbeddedGlobalAccess(embeddedNames.ALL_CLASSES);
+      var instanceFromClassIdAssignment =
+          js('# = function(name) { return new #[name](); }',
+             [instanceFromClassIdAccess, allClassesAccess]);
+
+      jsAst.Expression initializeEmptyInstanceAccess =
+          generateEmbeddedGlobalAccess(embeddedNames.INITIALIZE_EMPTY_INSTANCE);
+      var initializeEmptyInstanceAssignment = js('''
+      # = function(name, o, fields) {
+        #[name].apply(o, fields);
+        return o;
+      }''', [ initializeEmptyInstanceAccess, allClassesAccess ]);
+
+      result.addAll([classIdExtractorAssignment,
+                     classFieldsExtractorAssignment,
+                     instanceFromClassIdAssignment,
+                     initializeEmptyInstanceAssignment]);
+    }
+
+    return result;
   }
 
   /** Needs defineClass to be defined. */
   jsAst.Expression buildInheritFrom() {
     jsAst.Expression result = js(r'''
         function() {
           function tmp() {}
           var hasOwnProperty = Object.prototype.hasOwnProperty;
           return function (constructor, superConstructor) {
             tmp.prototype = superConstructor.prototype;
@@ skipping 948 matching lines @@
         ..write(',$_')
         ..write(jsAst.prettyPrint(initializers,
                                   compiler,
                                   monitor: compiler.dumpInfoTask))
         ..write(library == compiler.mainApp ? ',${n}1' : "")
         ..write('],$n');
   }
 
   void emitPrecompiledConstructor(OutputUnit outputUnit,
                                   String constructorName,
-                                  jsAst.Expression constructorAst) {
+                                  jsAst.Expression constructorAst,
+                                  List<String> fields) {
     cspPrecompiledFunctionFor(outputUnit).add(
         new jsAst.FunctionDeclaration(
             new jsAst.VariableDeclaration(constructorName), constructorAst));
-    cspPrecompiledFunctionFor(outputUnit).add(
-    js.statement(r'''{
-          #.builtin$cls = #;
-          if (!"name" in #)
-              #.name = #;
-          $desc=$collectedClasses.#;
+
+    String fieldNamesProperty = FIELD_NAMES_PROPERTY_NAME;
+    bool hasIsolateSupport = compiler.hasIsolateSupport;
+    jsAst.Node fieldNamesArray =
+        hasIsolateSupport ? js.stringArray(fields) : new jsAst.LiteralNull();
+
+    cspPrecompiledFunctionFor(outputUnit).add(js.statement(r'''
+        {
+          #constructorName.builtin$cls = #constructorNameString;
+          if (!"name" in #constructorName)
+              #constructorName.name = #constructorNameString;
+          $desc = $collectedClasses.#constructorName;
           if ($desc instanceof Array) $desc = $desc[1];
-          #.prototype = $desc;
+          #constructorName.prototype = $desc;
+          ''' /* next string is not a raw string */ '''
+          if (#hasIsolateSupport) {
+            #constructorName.$fieldNamesProperty = #fieldNamesArray;
+          } 
         }''',
-        [   constructorName, js.string(constructorName),
-            constructorName,
-            constructorName, js.string(constructorName),
-            constructorName,
-            constructorName
-         ]));
+        {"constructorName": constructorName,
+         "constructorNameString": js.string(constructorName),
+         "hasIsolateSupport": hasIsolateSupport,
+         "fieldNamesArray": fieldNamesArray}));
 
     cspPrecompiledConstructorNamesFor(outputUnit).add(js('#', constructorName));
   }
 
   /// Extracts the output name of the compiler's outputUri.
   String deferredPartFileName(OutputUnit outputUnit,
                               {bool addExtension: true}) {
     String outPath = compiler.outputUri != null
         ? compiler.outputUri.path
         : "out";
@@ skipping 42 matching lines @@
           js.string(typeReference));
       jsAst.Node declaration = new jsAst.ObjectInitializer([descriptor]);
       String mangledName = namer.getNameX(typedef);
       String reflectionName = getReflectionName(typedef, mangledName);
       getElementDescriptor(library)
           ..addProperty(mangledName, declaration)
           ..addProperty("+$reflectionName", js.string(''));
       // Also emit a trivial constructor for CSP mode.
       String constructorName = mangledName;
       jsAst.Expression constructorAst = js('function() {}');
+      List<String> fieldNames = [];
       emitPrecompiledConstructor(mainOutputUnit,
                                  constructorName,
-                                 constructorAst);
+                                 constructorAst,
+                                 fieldNames);
     }
   }
 
   void emitMangledNames() {
     if (!mangledFieldNames.isEmpty) {
       var keys = mangledFieldNames.keys.toList();
       keys.sort();
       var properties = [];
       for (String key in keys) {
         var value = js.string('${mangledFieldNames[key]}');
@@ skipping 696 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }