Lazy implementation of final variables.

lib/compiler/implementation/js_backend/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,
                            FunctionElement other)
       : super.from(name, other, other.enclosingElement);
 
   isInstanceMember() => true;
 }
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
  * 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;
+  bool needsLazyInitializer = false;
   final Namer namer;
   NativeEmitter nativeEmitter;
   CodeBuffer boundClosureBuffer;
   CodeBuffer mainBuffer;
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
   final Map<int, String> boundClosureCache;
 
@@ skipping 18 matching lines @@
   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 get supportsProtoName()
       => 'supportsProto';
+  String get lazyInitializerName()
+      => '${namer.ISOLATE}.\$lazy';
 
   final String GETTER_SUFFIX = "?";
   final String SETTER_SUFFIX = "!";
   final String GETTER_SETTER_SUFFIX = "=";
 
   String get generateGetterSetterFunction() {
     return """
 function(field, prototype) {
   var len = field.length;
   var lastChar = field[len - 1];
@@ skipping 167 matching lines @@
   }
   str += "}\\n";
   var newIsolate = new Function(str);
   newIsolate.prototype = isolatePrototype;
   isolatePrototype.constructor = newIsolate;
   newIsolate.${namer.ISOLATE_PROPERTIES} = isolateProperties;
   return newIsolate;
 }""";
   }
 
+  String get lazyInitializerFunction() {
+    String isolate = namer.CURRENT_ISOLATE;
+    return """
+function(prototype, fieldName, getterName, lazyValue) {
+  var sentinel = {};
+  prototype[fieldName] = sentinel;
+  var getter = new Function("{ return $isolate." + fieldName + ";}");
+  prototype[getterName] = function() {
+    var result = $isolate[fieldName];
+    try {
+      if (result === sentinel) {

[kasperl, 2012/08/17 09:30:04]

I guess this doesn't catch cyclic initialization. I just keeps on truckin'.

[floitsch, 2012/09/04 17:32:21]

Done.

+        try {
+          result = $isolate[fieldName] = lazyValue();
+        } catch (e) {
+          if ($isolate[fieldName] === sentinel) {
+            $isolate[fieldName] = null;
+          }
+          throw e;
+        }
+      }
+      return result;
+    } finally {
+      $isolate[getterName] = getter;
+    }
+  };
+}""";
+  }
+
   void addDefineClassAndFinishClassFunctionsIfNecessary(CodeBuffer buffer) {
     if (needsDefineClass) {
-      String isolate = namer.ISOLATE;
       buffer.add("$defineClassName = $defineClassFunction;\n");
       buffer.add(protoSupportCheck);
       buffer.add("$pendingClassesName = {};\n");
       buffer.add("$finishClassesName = $finishClassesFunction;\n");
     }
   }
 
+  void addLazyInitializerFunctionIfNecessary(CodeBuffer buffer) {
+    if (needsLazyInitializer) {
+      buffer.add("$lazyInitializerName = $lazyInitializerFunction;\n");
+    }
+  }
+
   void emitFinishIsolateConstructor(CodeBuffer buffer) {
     String name = finishIsolateConstructorName;
     String value = finishIsolateConstructorFunction;
     buffer.add("$name = $value;\n");
   }
 
   void emitFinishIsolateConstructorInvocation(CodeBuffer buffer) {
     String isolate = namer.ISOLATE;
     buffer.add("$isolate = $finishIsolateConstructorName($isolate);\n");
   }
@@ skipping 107 matching lines @@
                          DefineMemberFunction defineInstanceMember) {
     Set<Selector> selectors = compiler.codegenWorld.invokedNames[member.name];
     if (selectors == null) return;
     for (Selector selector in selectors) {
       if (!selector.applies(member, compiler)) continue;
       addParameterStub(member, selector, defineInstanceMember);
     }
   }
 
   bool instanceFieldNeedsGetter(Element member) {
-    assert(member.kind === ElementKind.FIELD);
+    assert(member.isField());
     return compiler.codegenWorld.hasInvokedGetter(member, compiler);
   }
 
   bool instanceFieldNeedsSetter(Element member) {
-    assert(member.kind === ElementKind.FIELD);
+    assert(member.isField());
     return (member.modifiers === null || !member.modifiers.isFinal())
         && compiler.codegenWorld.hasInvokedSetter(member, compiler);
   }
 
   String compiledFieldName(Element member) {
-    assert(member.kind === ElementKind.FIELD);
+    assert(member.isField());
     return member.isNative()
         ? member.name.slowToString()
         : namer.getName(member);
   }
 
   void addInstanceMember(Element member,
                          DefineMemberFunction defineInstanceMember) {
     // TODO(floitsch): we don't need to deal with members of
     // uninstantiated classes, that have been overwritten by subclasses.
 
-    if (member.kind === ElementKind.FUNCTION
-        || member.kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY
-        || member.kind === ElementKind.GETTER
-        || member.kind === ElementKind.SETTER) {
+    if (member.isFunction()
+        || member.isGenerativeConstructorBody()
+        || member.isGetter()
+        || member.isSetter()) {
       if (member.modifiers !== null && member.modifiers.isAbstract()) return;
       CodeBuffer codeBuffer = compiler.codegenWorld.generatedCode[member];
       if (codeBuffer == null) return;
       defineInstanceMember(namer.getName(member), codeBuffer);
       codeBuffer = compiler.codegenWorld.generatedBailoutCode[member];
       if (codeBuffer !== null) {
         defineInstanceMember(compiler.namer.getBailoutName(member), codeBuffer);
       }
       FunctionElement function = member;
       FunctionSignature parameters = function.computeSignature(compiler);
       if (!parameters.optionalParameters.isEmpty()) {
         addParameterStubs(member, defineInstanceMember);
       }
-    } else if (member.kind !== ElementKind.FIELD) {
+    } else if (!member.isField()) {
       compiler.internalError('unexpected kind: "${member.kind}"',
                              element: member);
     }
     emitExtraAccessors(member, defineInstanceMember);
   }
 
   Set<Element> emitClassFields(ClassElement classElement, CodeBuffer buffer) {
     // If the class is never instantiated we still need to set it up for
     // inheritance purposes, but we can simplify its JavaScript constructor.
     bool isInstantiated =
@@ skipping 207 matching lines @@
   }
 
   void emitFinishClassesInvocationIfNecessary(CodeBuffer buffer) {
     if (needsDefineClass) {
       buffer.add("$finishClassesName($classesCollector);\n");
       // Reset the map.
       buffer.add("$classesCollector = {};\n");
     }
   }
 
+  void emitStaticFunctionWithNamer(CodeBuffer buffer,
+                                   Element element,
+                                   CodeBuffer functionBuffer,
+                                   String functionNamer(Element element)) {
+    String functionName = functionNamer(element);
+    buffer.add('$isolateProperties.$functionName = ');
+    addMappings(functionBuffer, buffer.length);
+    buffer.add(functionBuffer);
+    buffer.add(';\n\n');
+  }
   void emitStaticFunctionsWithNamer(CodeBuffer buffer,
                                     Map<Element, CodeBuffer> generatedCode,
                                     String functionNamer(Element element)) {
     generatedCode.forEach((Element element, CodeBuffer functionBuffer) {
-      if (!element.isInstanceMember()) {
-        String functionName = functionNamer(element);
-        buffer.add('$isolateProperties.$functionName = ');
-        addMappings(functionBuffer, buffer.length);
-        buffer.add(functionBuffer);
-        buffer.add(';\n\n');
+      if (!element.isInstanceMember() && !element.isField()) {
+        emitStaticFunctionWithNamer(
+            buffer, element, functionBuffer,functionNamer);
       }
     });
   }
 
   void emitStaticFunctions(CodeBuffer buffer) {
     emitStaticFunctionsWithNamer(buffer,
                                  compiler.codegenWorld.generatedCode,
                                  namer.getName);
     emitStaticFunctionsWithNamer(buffer,
                                  compiler.codegenWorld.generatedBailoutCode,
@@ skipping 111 matching lines @@
     CodeBuffer getterBuffer = new CodeBuffer();
     getterBuffer.add(
         "function() { return new $closureClass(this, '$targetName'); }");
     defineInstanceMember(getterName, getterBuffer);
   }
 
   void emitCallStubForGetter(Element member,
                              Set<Selector> selectors,
                              DefineMemberFunction defineInstanceMember) {
     String getter;
-    if (member.kind == ElementKind.GETTER) {
+    if (member.isGetter()) {
       getter = "this.${namer.getterName(member.getLibrary(), member.name)}()";
     } else {
       String name = namer.instanceFieldName(member.getLibrary(), member.name);
       getter = "this.$name";
     }
     for (Selector selector in selectors) {
       if (selector.applies(member, compiler)) {
         String invocationName =
             namer.instanceMethodInvocationName(member.getLibrary(), member.name,
                                                selector);
@@ skipping 20 matching lines @@
         handler.getStaticNonFinalFieldsForEmission();
     for (Element element in staticNonFinalFields) {
       buffer.add('$isolateProperties.${namer.getName(element)} = ');
       compiler.withCurrentElement(element, () {
           handler.writeJsCodeForVariable(buffer, element);
         });
       buffer.add(';\n');
     }
   }
 
+  void emitLazilyInitializedStaticFields(CodeBuffer buffer) {
+    ConstantHandler handler = compiler.constantHandler;
+    List<VariableElement> lazyFields =
+        handler.getLazilyInitializedFieldsForEmission();
+    if (!lazyFields.isEmpty()) {
+      needsLazyInitializer = true;
+      for (VariableElement element in lazyFields) {
+        StringBuffer code = compiler.codegenWorld.generatedCode[element];
+        assert(code != null);
+        // The code only computes the initial value. We build the lazy-check
+        // here:
+        //   lazyInitializer(prototype, fieldName, getterName, initialValue);
+        buffer.add("$lazyInitializerName(");
+        buffer.add(isolateProperties);
+        buffer.add(", '");
+        buffer.add(namer.getName(element));
+        buffer.add("', '");
+        buffer.add(namer.getLazyInitializerName(element));
+        buffer.add("', ");
+        addMappings(code, buffer.length);
+        buffer.add(code);
+        buffer.add(");\n");
+
+        CodeBuffer bailoutCode =
+            compiler.codegenWorld.generatedBailoutCode[element];
+        if (bailoutCode != null) {
+          Function functionNamer = namer.getLazyInitializerBailoutName;
+          emitStaticFunctionWithNamer(
+              buffer, element, bailoutCode, functionNamer);
+        }
+      }
+    }
+  }
+
   void emitCompileTimeConstants(CodeBuffer 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;
@@ skipping 12 matching lines @@
     buffer.add(@'''.makeConstantList = function(list) {
   list.immutable$list = true;
   list.fixed$length = true;
   return list;
 };
 ''');
   }
 
   void emitExtraAccessors(Element member,
                           DefineMemberFunction defineInstanceMember) {
-    if (member.kind == ElementKind.GETTER || member.kind == ElementKind.FIELD) {
+    if (member.isGetter() || member.isField()) {
       Set<Selector> selectors = compiler.codegenWorld.invokedNames[member.name];
       if (selectors !== null && !selectors.isEmpty()) {
         emitCallStubForGetter(member, selectors, defineInstanceMember);
       }
-    } else if (member.kind == ElementKind.FUNCTION) {
+    } else if (member.isFunction()) {
       if (compiler.codegenWorld.hasInvokedGetter(member, compiler)) {
         emitDynamicFunctionGetter(member, defineInstanceMember);
       }
     }
   }
 
   void emitNoSuchMethodHandlers(DefineMemberFunction defineInstanceMember) {
     // Do not generate no such method handlers if there is no class.
     if (compiler.codegenWorld.instantiatedClasses.isEmpty()) return;
 
@@ skipping 237 matching lines @@
       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);
+      emitLazilyInitializedStaticFields(mainBuffer);
 
       isolateProperties = isolatePropertiesName;
       // The following code should not use the short-hand for the
       // initialStatics.
       mainBuffer.add('var ${namer.CURRENT_ISOLATE} = null;\n');
       mainBuffer.add(boundClosureBuffer);
       emitFinishClassesInvocationIfNecessary(mainBuffer);
       // After this assignment we will produce invalid JavaScript code if we use
       // the classesCollector variable.
       classesCollector = 'classesCollector should not be used from now on';
 
       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);
+      addLazyInitializerFunctionIfNecessary(mainBuffer);
       emitFinishIsolateConstructor(mainBuffer);
       mainBuffer.add('}\n');
       compiler.assembledCode = mainBuffer.toString();
 
       if (generateSourceMap) {
         SourceFile compiledFile = new SourceFile(null, compiler.assembledCode);
         String sourceMap = sourceMapBuilder.build(compiledFile);
         // TODO(podivilov): We should find a better way to return source maps to
         // compiler. Using diagnostic handler for that purpose is a temporary
         // hack.
@@ skipping 12 matching lines @@
         sourceName = token.slowToString();
       }
       int totalOffset = bufferOffset + offset;
       sourceMapBuilder.addMapping(
           sourceFile, token.charOffset, sourceName, totalOffset);
     });
   }
 }
 
 typedef void DefineMemberFunction(String invocationName, CodeBuffer definition);