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,
@@ skipping 638 matching lines @@
       buffer.add("$finishClassesName($classesCollector);\n");
       // Reset the map.
       buffer.add("$classesCollector = {};\n");
     }
   }
 
   void emitStaticFunctionsWithNamer(CodeBuffer buffer,
                                     Map<Element, CodeBuffer> generatedCode,
                                     String functionNamer(Element element)) {
     generatedCode.forEach((Element element, CodeBuffer functionBuffer) {
-      if (!element.isInstanceMember()) {
+      if (!element.isInstanceMember() && element.kind != ElementKind.FIELD) {

[kasperl, 2012/08/16 14:41:37]

Don't we have an element.isField() tester?

[floitsch, 2012/08/16 22:52:33]

Done.

         String functionName = functionNamer(element);
         buffer.add('$isolateProperties.$functionName = ');
         addMappings(functionBuffer, buffer.length);
         buffer.add(functionBuffer);
         buffer.add(';\n\n');
       }
     });
   }
 
   void emitStaticFunctions(CodeBuffer buffer) {
@@ skipping 157 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) {
+    String nonBailoutElementNamer(Element element) {
+      if (element.kind == ElementKind.FIELD) {

[kasperl, 2012/08/16 14:41:37]

isField

[floitsch, 2012/08/16 22:52:33]

Done.

+        return namer.getLazyInitializerName(element);
+      } else {
+        return namer.getName(element);
+      }
+    }
+
+    String bailoutElementNamer(Element element) {
+      if (element.kind == ElementKind.FIELD) {

[kasperl, 2012/08/16 14:41:37]

isField

[floitsch, 2012/08/16 22:52:33]

Done.

+        return namer.getLazyInitializerBailoutName(element);
+      } else {
+        return namer.getBailoutName(element);
+      }
+    }
+
+    ConstantHandler handler = compiler.constantHandler;
+    List<VariableElement> lazyFields =
+        handler.getLazilyInitializedFieldsForEmission();
+    if (!lazyFields.isEmpty()) {
+      JavaScriptBackend backend = compiler.backend;
+      String isolatePropertiesSentinelAccess =
+          '$isolateProperties.${namer.LAZY_INITIALIZATION_SENTINEL}';
+      buffer.add('$isolatePropertiesSentinelAccess = {};\n');
+      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.
+        String fieldName = namer.getName(element);
+        String lazyGetterName =
+            '$isolateProperties.${namer.getLazyInitializerName(element)}';
+        // We store the function that computes the initial value as field of
+        // the lazy getter.
+        // The lazy getter itself will be replaced at first access.
+        String directFieldAccess = namer.isolateAccess(element);
+        String sentinelAccess =
+            '${namer.CURRENT_ISOLATE}.${namer.LAZY_INITIALIZATION_SENTINEL}';
+        buffer.add('''
+$lazyGetterName = function() {

[kasperl, 2012/08/16 14:41:37]

As we discussed, I think this needs to do the try-catch dance. Maybe you can add
a helper function (parameterized with a closure or the field name) that deals
with that to make the code shorter?

[floitsch, 2012/08/16 22:52:33]

Done.

+  var value = $directFieldAccess;
+  if (value === $sentinelAccess) {
+    value = ${namer.isolateLazyInitializerAccess(element)}.lazy();
+    $directFieldAccess = value;
+  }
+  ${namer.isolateLazyInitializerAccess(element)} = function() { return $directFieldAccess; };
+  return value;
+};
+''');
+        buffer.add('$lazyGetterName.lazy = ');
+        buffer.add(code);
+        buffer.add('\n$isolateProperties.${namer.getName(element)} = ');
+        buffer.add(isolatePropertiesSentinelAccess);
+        buffer.add(';\n');
+      }
+    }
+  }
+
   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 274 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';
@@ skipping 32 matching lines @@
         sourceName = token.slowToString();
       }
       int totalOffset = bufferOffset + offset;
       sourceMapBuilder.addMapping(
           sourceFile, token.charOffset, sourceName, totalOffset);
     });
   }
 }
 
 typedef void DefineMemberFunction(String invocationName, CodeBuffer definition);