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 234 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, cls, fields) {
+    bool hasIsolateSupport = compiler.hasIsolateSupport;
+    String fieldNamesProperty = r"$__fields__";
+
+    jsAst.Expression defineClass = js('''function(name, cls, fields) {
       var accessors = [];
 
       var str = "function " + cls + "(";
       var body = "";
+      if (#hasIsolateSupport) { var fieldNames = ""; }
 
       for (var i = 0; i < fields.length; i++) {
         if(i != 0) str += ", ";
 
         var field = generateAccessor(fields[i], accessors, cls);
+        if (#hasIsolateSupport) { fieldNames += "'" + field + "',"; }
         var parameter = "parameter_" + field;
         str += parameter;
         body += ("this." + field + " = " + parameter + ";\\n");
       }
       str += ") {\\n" + body + "}\\n";
       str += cls + ".builtin\$cls=\\"" + name + "\\";\\n";
       str += "\$desc=\$collectedClasses." + cls + ";\\n";
       str += "if(\$desc instanceof Array) \$desc = \$desc[1];\\n";
       str += cls + ".prototype = \$desc;\\n";
       if (typeof defineClass.name != "string") {
         str += cls + ".name=\\"" + cls + "\\";\\n";
       }
+      if (#hasIsolateSupport) {
+        str += cls + ".$fieldNamesProperty=[" + fieldNames + "];\\n";
+      }
       str += accessors.join("");
 
       return str;
-    }''');
+    }''', { 'hasIsolateSupport': hasIsolateSupport });
+
     // Declare a function called "generateAccessor".  This is used in
     // defineClassFunction (it's a local declaration in init()).
-    return [
+    List result = <jsAst.Node>[
         generateAccessorFunction,
         js('$generateAccessorHolder = generateAccessor'),
         new jsAst.FunctionDeclaration(
             new jsAst.VariableDeclaration('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 1696 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }