Create isolate constructor dynamically.

lib/compiler/implementation/emitter.dart

 // Copyright (c) 2012, 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.
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
@@ skipping 10 matching lines @@
  * The code for the containing (used) methods must exist in the [:universe:].
  */
 class CodeEmitterTask extends CompilerTask {
   bool needsInheritFunction = false;
   bool needsDefineClass = false;
   bool needsClosureClass = false;
   final Namer namer;
   final NativeEmitter nativeEmitter;
   StringBuffer boundClosureBuffer;
   StringBuffer mainBuffer;
-  String isolatePrototype;
+  /** Shorter access to [isolatePropertiesName]. Both here in the code, as
+      well as in the generated code. */
+  String isolateProperties;
 
   CodeEmitterTask(Compiler compiler)
       : namer = compiler.namer,
         nativeEmitter = new NativeEmitter(compiler),
         boundClosureBuffer = new StringBuffer(),
         mainBuffer = new StringBuffer(),
         super(compiler);
 
   String get name() => 'CodeEmitter';
 
-  String get defineClassName() => '${namer.ISOLATE}.\$defineClass';
-  String get finishClassesName() => '${namer.ISOLATE}.\$finishClasses';
+  String get defineClassName()
+      => '${namer.ISOLATE}.\$defineClass';
+  String get finishClassesName()
+      => '${namer.ISOLATE}.\$finishClasses';
+  String get finishIsolateConstructorName()
+      => '${namer.ISOLATE}.\$finishIsolateConstructor';
+  String get pendingClassesName()
+      => '${namer.ISOLATE}.\$pendingClasses';
+  String get isolatePropertiesName()
+      => '${namer.ISOLATE}.${namer.ISOLATE_PROPERTIES}';
 
-  String buildDefineClassFunction(String isolate) {
+  String get defineClassFunction() {
     // Example:
     // defineClass("A", "B",
     // function(x) {          /* The JavaScript constructor. */
     //   this.x = x;
     // }, {                   /* The members inside an Object literal. */
     //  foo$1: function(y) {
     //   print(this.x + y);
     //  },
     //  bar$2: function(t, v) {
     //   this.x = t - v;
     //  },
     // });
     return """
 function(cls, superclass, constructor, prototype) {
-  $isolate.prototype[cls] = constructor;
+  $isolatePropertiesName[cls] = constructor;
   constructor.prototype = prototype;
   if (superclass !== "") {
-    $isolate.pendingClasses[cls] = superclass;
+    $pendingClassesName[cls] = superclass;
   }
 }""";
   }
 
-  String buildFinishClassesFunction(String isolate) {
+  String get finishClassesFunction() {
     // 'defineClass' does not require the classes to be constructed in order.
     // Classes are initially just stored in the 'pendingClasses' field.
     // 'finishClasses' takes all pending classes and sets up the prototype.
     // Once set up, the constructors prototype field satisfy:
     //  - it contains all (local) members.
     //  - its internal prototype (__proto__) points to the superclass'
     //    prototype field.
     //  - the prototype's constructor field points to the JavaScript
     //    constructor.
     // For engines where we have access to the '__proto__' we can manipulate
     // the object literal directly. For other engines we have to create a new
     // object and copy over the members.
     return '''
 function() {
-  var pendingClasses = $isolate.pendingClasses;
+  var pendingClasses = $pendingClassesName;
 '''/* FinishClasses can be called multiple times. This means that we need to
       clear the pendingClasses property. */'''
-  $isolate.pendingClasses = {};
+  $pendingClassesName = {};
   var finishedClasses = {};
   function finishClass(cls) {
     if (finishedClasses[cls]) return;
     finishedClasses[cls] = true;
     var superclass = pendingClasses[cls];
 '''/* The superclass is only false (empty string) for Dart's Object class. */'''
     if (!superclass) return;
     finishClass(superclass);
-    var constructor = $isolate.prototype[cls];
-    var superConstructor = $isolate.prototype[superclass];
+    var constructor = $isolatePropertiesName[cls];
+    var superConstructor = $isolatePropertiesName[superclass];
     var prototype = constructor.prototype;
     if (prototype.__proto__) {
 '''/* On Firefox and Webkit browsers we can manipulate the __proto__
       directly. */'''
       prototype.__proto__ = superConstructor.prototype;
       prototype.constructor = constructor;
     } else {
 '''/* On the remaining browsers we need to instantiate an object with the
       correct (internal) prototype set up correctly, and then copy the
       members. */'''
       function tmp() {};
       tmp.prototype = superConstructor.prototype;
       var newPrototype = new tmp();
       constructor.prototype = newPrototype;
       newPrototype.constructor = constructor;
 '''/* Opera does not support 'getOwnPropertyNames'. Therefore we use
       hosOwnProperty instead. */'''
       var hasOwnProperty = Object.prototype.hasOwnProperty;
       for (var member in prototype) {
         if (hasOwnProperty.call(prototype, member)) {
           newPrototype[member] = prototype[member];
         }
       }
     }
   }
   for (var cls in pendingClasses) finishClass(cls);
-};
-''';
+}''';
+  }
+
+  String get finishIsolateConstructorFunction() {
+    String isolate = namer.ISOLATE;
+    // We replace the old Isolate function with a new one that initializes
+    // all its field with the initial (and often final) value of all globals.
+    // This has two advantages:
+    //   1. the properties are in the object itself (thus avoiding to go through
+    //      the prototype when looking up globals.
+    //   2. a new isolate goes through a (usually well optimized) constructor
+    //      function of the form: "function() { this.x = ...; this.y = ...; }".
+    //
+    // Example: If [isolateProperties] is an object containing: x = 3 and
+    // A = function A() { /* constructor of class A. */ }, then we generate:
+    // str = "{
+    //   var isolateProperties = Isolate.$isolateProperties;
+    //   this.x = isolateProperties.x;
+    //   this.A = isolateProperties.A;
+    // }";
+    // which is then dynamically evaluated:
+    //   var newIsolate = new Function(str);
+    //
+    // We also copy over old values like the prototype, and the
+    // isolateProperties themselves.
+    return """function(oldIsolate) {
+  var isolateProperties = oldIsolate.${namer.ISOLATE_PROPERTIES};
+  var isolatePrototype = oldIsolate.prototype;
+  var str = "{\\n";
+  str += "var isolateProperties = $isolate.${namer.ISOLATE_PROPERTIES};\\n";
+  for (var staticName in isolateProperties) {
+    if (Object.prototype.hasOwnProperty.call(isolateProperties, staticName)) {
+      str += "this." + staticName + "= isolateProperties." + staticName + ";\\n";

[ngeoffray, 2012/05/07 09:48:45]

line too long

[floitsch, 2012/05/07 14:09:11]

done in CL 10388006.

+    }
+  }
+  str += "}\\n";
+  var newIsolate = new Function(str);
+  newIsolate.prototype = isolatePrototype;
+  isolatePrototype.constructor = newIsolate;
+  newIsolate.${namer.ISOLATE_PROPERTIES} = isolateProperties;
+  return newIsolate;
+}""";
   }
 
   void addDefineClassAndFinishClassFunctionsIfNecessary(StringBuffer buffer) {
     String isolate = namer.ISOLATE;
-    buffer.add("$defineClassName = ${buildDefineClassFunction(isolate)};\n");
-    buffer.add("$isolate.pendingClasses = {};\n");
-    buffer.add("$finishClassesName = ${buildFinishClassesFunction(isolate)};");
-    buffer.add("\n");
+    buffer.add("$defineClassName = $defineClassFunction;\n");
+    buffer.add("$pendingClassesName = {};\n");
+    buffer.add("$finishClassesName = $finishClassesFunction;\n");
+  }
+
+  void emitFinishIsolateConstructor(StringBuffer buffer) {
+    String name = finishIsolateConstructorName;
+    String value = finishIsolateConstructorFunction;
+    buffer.add("$name = $value;\n");
+  }
+
+  void emitFinishIsolateConstructorInvocation(StringBuffer buffer) {
+    String isolate = namer.ISOLATE;
+    buffer.add("$isolate = $finishIsolateConstructorName($isolate);\n");
   }
 
   void addParameterStub(FunctionElement member,
                         Selector selector,
                         void defineInstanceMember(String invocationName,
                                                   String definition)) {
     FunctionParameters parameters = member.computeParameters(compiler);
     int positionalArgumentCount = selector.positionalArgumentCount;
     if (positionalArgumentCount == parameters.parameterCount) {
       assert(selector.namedArgumentCount == 0);
@@ skipping 293 matching lines @@
 
   void emitFinishClassesInvocationIfNecessary(StringBuffer buffer) {
     if (needsDefineClass) buffer.add("$finishClassesName();\n");
   }
 
   void emitStaticFunctionsWithNamer(StringBuffer buffer,
                                     Map<Element, String> generatedCode,
                                     String functionNamer(Element element)) {
     generatedCode.forEach((Element element, String codeBlock) {
       if (!element.isInstanceMember()) {
-        buffer.add(isolatePrototype);
-        buffer.add('.${functionNamer(element)} = ');
-        buffer.add(codeBlock);
-        buffer.add(';\n\n');
+        String functionName = functionNamer(element);
+        buffer.add('$isolateProperties.$functionName = $codeBlock;\n\n');
       }
     });
   }
 
   void emitStaticFunctions(StringBuffer buffer) {
     emitStaticFunctionsWithNamer(buffer,
                                  compiler.universe.generatedCode,
                                  namer.getName);
     emitStaticFunctionsWithNamer(buffer,
                                  compiler.universe.generatedBailoutCode,
                                  namer.getBailoutName);
   }
 
   void emitStaticFunctionGetters(StringBuffer buffer) {
     Set<FunctionElement> functionsNeedingGetter =
         compiler.universe.staticFunctionsNeedingGetter;
     for (FunctionElement element in functionsNeedingGetter) {
       // The static function does not have the correct name. Since
       // [addParameterStubs] use the name to create its stubs we simply
       // create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
           new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, element);
       String staticName = namer.getName(element);
       int parameterCount = element.parameterCount(compiler);
       String invocationName =
           namer.instanceMethodName(element.getLibrary(), callElement.name,
                                    parameterCount);
-      buffer.add(isolatePrototype);
-      buffer.add(".$staticName.$invocationName = ");
-      buffer.add(isolatePrototype);
-      buffer.add(".$staticName;\n");
+      String fieldAccess = '$isolateProperties.$staticName';
+      buffer.add("$fieldAccess.$invocationName = $fieldAccess;\n");
       addParameterStubs(callElement, (String name, String value) {
-        buffer.add('$isolatePrototype.$staticName.$name = $value;\n');
+        buffer.add('$fieldAccess.$name = $value;\n');
       });
     }
   }
 
   void emitDynamicFunctionGetter(FunctionElement member,
                                  defineInstanceMember(String invocationName,
                                                       String definition)) {
     // For every method that has the same name as a property-get we create a
     // getter that returns a bound closure. Say we have a class 'A' with method
     // 'foo' and somewhere in the code there is a dynamic property get of
@@ skipping 85 matching lines @@
         }
         String joined = Strings.join(arguments, ", ");
         defineInstanceMember(
             invocationName,
             "function($joined) { return $getter.$closureCallName($joined); }");
       }
     }
   }
 
   void emitStaticNonFinalFieldInitializations(StringBuffer buffer) {
-    // Adds initializations inside the Isolate constructor.
-    // Example:
-    //    function Isolate() {
-    //       this.staticNonFinal = Isolate.prototype.someVal;
-    //       ...
-    //    }
     ConstantHandler handler = compiler.constantHandler;
     List<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
-    if (!staticNonFinalFields.isEmpty()) buffer.add('\n');
     for (Element element in staticNonFinalFields) {
-      buffer.add('  this.${namer.getName(element)} = ');
+      buffer.add('$isolateProperties.${namer.getName(element)} = ');
       compiler.withCurrentElement(element, () {
           handler.writeJsCodeForVariable(buffer, element);
         });
       buffer.add(';\n');
     }
   }
 
   void emitCompileTimeConstants(StringBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     List<Constant> constants = handler.getConstantsForEmission();
     bool addedMakeConstantList = false;
     for (Constant constant in constants) {
       String name = handler.getNameForConstant(constant);
       // The name is null when the constant is already a JS constant.
       // TODO(floitsch): every constant should be registered, so that we can
       // share the ones that take up too much space (like some strings).
       if (name === null) continue;
       if (!addedMakeConstantList && constant.isList()) {
         addedMakeConstantList = true;
         emitMakeConstantList(buffer);
       }
-      buffer.add('$isolatePrototype.$name = ');
+      buffer.add('$isolateProperties.$name = ');
       handler.writeJsCode(buffer, constant);
       buffer.add(';\n');
     }
   }
 
   void emitMakeConstantList(StringBuffer buffer) {
-    buffer.add(isolatePrototype);
+    buffer.add(namer.ISOLATE);
     buffer.add(@'''.makeConstantList = function(list) {
   list.immutable$list = true;
   list.fixed$length = true;
   return list;
 };
 ''');
   }
 
   void emitExtraAccessors(Element member,
                           void defineInstanceMember(String invocationName,
@@ skipping 161 matching lines @@
     ${mainCall};
   });
 } else {
   ${mainCall};
 }
 """);
   }
 
   String assembleProgram() {
     measure(() {
-      mainBuffer.add('function ${namer.ISOLATE}() {');
-      emitStaticNonFinalFieldInitializations(mainBuffer);
-      mainBuffer.add('}\n');
+      mainBuffer.add('function ${namer.ISOLATE}() {}\n');
       mainBuffer.add('init();\n\n');
       // Shorten the code by using [namer.CURRENT_ISOLATE] as temporary.
-      isolatePrototype = namer.CURRENT_ISOLATE;
-      mainBuffer.add('var $isolatePrototype = ${namer.ISOLATE}.prototype;\n');
+      isolateProperties = namer.CURRENT_ISOLATE;
+      mainBuffer.add('var $isolateProperties = $isolatePropertiesName;\n');
       emitClasses(mainBuffer);
       mainBuffer.add(boundClosureBuffer);
       // Clear the buffer, so that we can reuse it for the native classes.
       boundClosureBuffer.clear();
       emitStaticFunctions(mainBuffer);
       emitStaticFunctionGetters(mainBuffer);
       // We need to finish the classes before we construct compile time
       // constants.
       emitFinishClassesInvocationIfNecessary(mainBuffer);
       emitCompileTimeConstants(mainBuffer);
+      // Static field initializations require the classes and compile-time
+      // constants to be set up.
+      emitStaticNonFinalFieldInitializations(mainBuffer);
 
-      isolatePrototype = '${namer.ISOLATE}.prototype;\n';
-      mainBuffer.add(
-          'var ${namer.CURRENT_ISOLATE} = new ${namer.ISOLATE}();\n');
+      isolateProperties = isolatePropertiesName;
+      // The following code should not use the short-hand for the
+      // initialStatics.
+      mainBuffer.add('var ${namer.CURRENT_ISOLATE} = null;\n');
       nativeEmitter.emitDynamicDispatchMetadata();
-      nativeEmitter.assembleCode(mainBuffer);
       mainBuffer.add(boundClosureBuffer);
       emitFinishClassesInvocationIfNecessary(mainBuffer);
+
+      emitFinishIsolateConstructorInvocation(mainBuffer);
+      mainBuffer.add(
+        'var ${namer.CURRENT_ISOLATE} = new ${namer.ISOLATE}();\n');
+
+      nativeEmitter.assembleCode(mainBuffer);
       emitMain(mainBuffer);
       mainBuffer.add('function init() {\n');
+      mainBuffer.add('  $isolateProperties = {};\n');
       addDefineClassAndFinishClassFunctionsIfNecessary(mainBuffer);
+      emitFinishIsolateConstructor(mainBuffer);
       mainBuffer.add('}\n');
       compiler.assembledCode = mainBuffer.toString();
     });
     return compiler.assembledCode;
   }
 }