Lazy implementation of final variables.

lib/compiler/implementation/js_backend/backend.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.
 
 typedef void Recompile(Element element);
 
 class ReturnInfo {
   HType returnType;
   List<Element> compiledFunctions;
 
@@ skipping 309 matching lines @@
         fieldSettersType = new Map<Element, Map<Element, HType>>(),
         returnInfo = new Map<Element, ReturnInfo>(),
         invalidateAfterCodegen = new List<Element>(),
         super(compiler) {
     builder = new SsaBuilderTask(this);
     optimizer = new SsaOptimizerTask(this);
     generator = new SsaCodeGeneratorTask(this);
     argumentTypes = new ArgumentTypesRegistry(this);
   }
 
+  Element get cyclicThrowHelper() {
+    return compiler.findHelper(const SourceString("throwCyclicInit"));
+  }
+
   JavaScriptItemCompilationContext createItemCompilationContext() {
     return new JavaScriptItemCompilationContext();
   }
 
   void enqueueHelpers(Enqueuer world) {
     enqueueAllTopLevelFunctions(compiler.jsHelperLibrary, world);
     enqueueAllTopLevelFunctions(compiler.interceptorsLibrary, world);
     for (var helper in [const SourceString('Closure'),
                         const SourceString('ConstantMap'),
                         const SourceString('ConstantProtoMap')]) {
       var e = compiler.findHelper(helper);
       if (e !== null) world.registerInstantiatedClass(e);
     }
   }
 
   void codegen(WorkItem work) {
+    if (work.element.kind.category == ElementCategory.VARIABLE) {
+      Constant initialValue = compiler.constantHandler.compileWorkItem(work);
+      if (initialValue !== null) {
+        return;
+      } else {
+        // If the constant-handler was not able to produce a result we have to
+        // go through the builder (below) to generate the lazy initializer for
+        // the static variable.
+        // We also need to register the use of the cyclic-error helper.
+        compiler.enqueuer.codegen.registerStaticUse(cyclicThrowHelper);
+      }
+    }
+
     HGraph graph = builder.build(work);
     optimizer.optimize(work, graph);
     if (work.allowSpeculativeOptimization
         && optimizer.trySpeculativeOptimizations(work, graph)) {
       CodeBuffer codeBuffer = generator.generateBailoutMethod(work, graph);
       compiler.codegenWorld.addBailoutCode(work, codeBuffer);
       optimizer.prepareForSpeculativeOptimizations(work, graph);
       optimizer.optimize(work, graph);
     }
-    CodeBuffer codeBuffer = generator.generateMethod(work, graph);
+    CodeBuffer codeBuffer = generator.generateCode(work, graph);
     compiler.codegenWorld.addGeneratedCode(work, codeBuffer);
-    invalidateAfterCodegen.forEach(
-      compiler.enqueuer.codegen.eagerRecompile);
+    invalidateAfterCodegen.forEach(compiler.enqueuer.codegen.eagerRecompile);
     invalidateAfterCodegen.clear();
   }
 
   void processNativeClasses(Enqueuer world,
                             Collection<LibraryElement> libraries) {
     native.processNativeClasses(world, emitter, libraries);
   }
 
   void assembleProgram() {
     emitter.assembleProgram();
@@ skipping 208 matching lines @@
           return const SourceString('listSuperTypeCheck');
         }
       } else if (nativeCheck) {
         return const SourceString('callTypeCheck');
       } else {
         return const SourceString('propertyTypeCheck');
       }
     }
   }
 }