Support globals in frog isolates.

frog/gen.dart

 // Copyright (c) 2011, 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.
 
 /**
  * Top level generator object for writing code and keeping track of
  * dependencies.
  *
  * Should have two compilation models, but only one implemented so far.
  *
  * 1. Do a top-level resolution of all types and their members.
  * 2. Start from main and walk the call-graph compiling members as needed.
  * 2a. That includes compiling overriding methods and calling methods by
  *     selector when invoked on var.
  * 3. Spit out all required code.
  */
 class WorldGenerator {
   MethodMember main;
   CodeWriter writer;
+
+  /** 
+   * Whether the app has any static fields used. Note this could still be true
+   * and [globals] be empty if no static field has a default initialization.
+   */
+  bool hasStatics = false;

[jimhug, 2011/11/18 17:49:17]

FYI - Nice comment - this could also be very relevant if we decided to start
using a null sentinel object and thus may need to initialize some of these
fields to the sentinel.

+
+  /** Global const and static field initializations. */
   Map<String, GlobalValue> globals;
   CoreJs corejs;
   bool _inheritsGenerated = false;
 
   WorldGenerator(this.main, this.writer): globals = {}, corejs = new CoreJs();
 
   run() {
     var metaGen = new MethodGenerator(main, null);
     var mainCall = main.invoke(metaGen, null, null, Arguments.EMPTY);
     main.declaringType.markUsed();
 
     // TODO(jimhug): Better way to capture hidden control flow.
     world.corelib.types['BadNumberFormatException'].markUsed();
     world.coreimpl.types['NumImplementation'].markUsed();
     world.coreimpl.types['StringImplementation'].markUsed();
     genMethod(
         world.coreimpl.types['StringImplementation'].getMember('contains'));
 
     // Only include isolate-specific code if isolates are used.
     if (world.corelib.types['Isolate'].isUsed
         || world.coreimpl.types['ReceivePortImpl'].isUsed) {
       corejs.useIsolates = true;
       MethodMember isolateMain =
-          world.coreimpl.topType.resolveMember('startAsIsolate').members[0];
+          world.coreimpl.topType.resolveMember('startRootIsolate').members[0];
       mainCall = isolateMain.invoke(metaGen, null, null,
           new Arguments(null, [main._get(metaGen, main.definition, null)]));
     }
 
     writeTypes(world.coreimpl);
     writeTypes(world.corelib);
 
     // Write the main library. This will cause all libraries to be written in
     // the topographic sort order.
     writeTypes(main.declaringType.library);
 
-    _writeGlobals();
+    writeGlobals();
     writer.writeln('${mainCall.code};');
   }
 
   GlobalValue globalForStaticField(FieldMember field, Value fieldValue,
       List<Value> dependencies) {
+    hasStatics = true;
     var fullname = "${field.declaringType.jsname}.${field.jsname}";
     if (!globals.containsKey(fullname)) {
       globals[fullname] = new GlobalValue.fromStatic(
           field, fieldValue, dependencies);
     }
     return globals[fullname];
   }
 
   GlobalValue globalForConst(EvaluatedValue exp, List<Value> dependencies) {
     var code = exp.canonicalCode;
@@ skipping 216 matching lines @@
   }
 
   _writeStaticField(FieldMember field) {
     // Final static fields must be constants which will be folded and inlined.
     if (field.isFinal) return;
 
     var fullname = "${field.declaringType.jsname}.${field.jsname}";
     if (globals.containsKey(fullname)) {
       var value = globals[fullname];
       if (field.declaringType.isTop && !field.isNative) {
-        writer.writeln('var ${field.jsname} = ${value.exp.code};');
+        writer.writeln('\$globals.${field.jsname} = ${value.exp.code};');
       } else {
-        writer.writeln(
-          '${field.declaringType.jsname}.${field.jsname} = ${value.exp.code};');
+        writer.writeln('\$globals.${field.declaringType.jsname}_${field.jsname}'
+            + ' = ${value.exp.code};');
       }
     }
     // No need to write code for a static class field with no initial value.
   }
 
   _writeField(FieldMember field) {
     // Generate declarations for static top-level fields with no value.
     if (field.declaringType.isTop && !field.isNative && field.value == null) {
       writer.writeln('var ${field.jsname};');
     }
@@ skipping 36 matching lines @@
       writer.exitBlock('});');
     }
   }
 
   _writeMethod(Member method) {
     if (method.generator != null) {
       method.generator.writeDefinition(writer, null);
     }
   }
 
-  _writeGlobals() {
+  writeGlobals() {
     if (globals.length > 0) {
       writer.comment('//  ********** Globals **************');
+      var list = globals.getValues();
+      list.sort((a, b) => a.compareTo(b));
+
+      // put all static field initializations in a method
+      writer.enterBlock('function \$static_init(){');

[Jennifer Messerly, 2011/11/18 01:46:39]

presumably library top-level variables need to go in here too?

[Jennifer Messerly, 2011/11/18 01:47:03]

Ignore this comment. I forgot to delete it :)

+      for (var global in list) {
+        if (global.field != null) {
+          _writeStaticField(global.field);
+        }
+      }
+      writer.exitBlock('}');
+
+      // Keep const expressions shared across isolates. Note that the frog
+      // isolate library needs this because we wrote it's bootstrap and
+      // book-keeping directly in Dart. Specifically, that code uses
+      // [HashMapImplementation] which internally uses a constant expression.
+      for (var global in list) {
+        if (global.field == null) {
+          writer.writeln('${global.name} = ${global.exp.code};');
+        }
+      }
     }
-    var list = globals.getValues();
-    list.sort((a, b) => a.compareTo(b));
-    for (var global in list) {
-      if (global.field != null) {
-        _writeStaticField(global.field);
-      } else {
-        writer.writeln('var ${global.name} = ${global.exp.code};');
+
+    if (!corejs.useIsolates) {
+      if (hasStatics) {
+        writer.writeln('var \$globals = {};');
+      }
+      if (globals.length > 0) {
+        writer.writeln('\$static_init();');
       }
     }
   }
 
   /** Order a list of values in a Map by SourceSpan, then by name. */
   List _orderValues(Map map) {
     // TODO(jmesserly): should we copy the list?
     // Right now, the Maps are returning a copy already.
     List values = map.getValues();
     values.sort(_compareMembers);
@@ skipping 1894 matching lines @@
       result.add(new Value(world.varType, '\$$i', null, /*needsTemp:*/false));
     }
     for (int i = bareCount; i < length; i++) {
       var name = getName(i);
       if (name == null) name = '\$$i';
       result.add(new Value(world.varType, name, null, /*needsTemp:*/false));
     }
     return new Arguments(nodes, result);
   }
 }