Lazy implementation of final variables.

lib/compiler/implementation/compiler.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.
 
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
 const bool REPORT_EXCESS_RESOLUTION = false;
@@ skipping 701 matching lines @@
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
       if (phase == PHASE_COMPILING) {
         log('Compiled ${codegenWorld.generatedCode.length} methods.');
       } else {
         log('Recompiled ${world.recompilationCandidates.processed} methods.');
       }
       progress.reset();
     }
     if (work.element.kind.category == ElementCategory.VARIABLE) {
-      constantHandler.compileWorkItem(work);
-    } else {
-      backend.codegen(work);
+      Constant initialValue = 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.
+        world.registerStaticUse(cyclicThrowHelper);
+      }
     }
+    backend.codegen(work);
   }
 
   void registerInstantiatedClass(ClassElement cls) {
     enqueuer.resolution.registerInstantiatedClass(cls);
     enqueuer.codegen.registerInstantiatedClass(cls);
   }
 
   DartType resolveTypeAnnotation(Element element, TypeAnnotation annotation) {
     return resolver.resolveTypeAnnotation(element, annotation);
   }
@@ skipping 13 matching lines @@
     withCurrentElement(element,
                        () => resolver.resolveTypedef(element));
   }
 
   FunctionType computeFunctionType(Element element,
                                    FunctionSignature signature) {
     return withCurrentElement(element,
         () => resolver.computeFunctionType(element, signature));
   }
 
+  bool isLazilyInitialized(VariableElement element) {
+    Constant initialValue = compileVariable(element);
+    return initialValue === null;
+  }
+
+  /** Compiles compile-time constants. Must not return `null`. */
+  Constant compileConstant(VariableElement element) {
+    return withCurrentElement(element, () {
+      return constantHandler.compileConstant(element);
+    });
+  }
+
   Constant compileVariable(VariableElement element) {
     return withCurrentElement(element, () {
       return constantHandler.compileVariable(element);
     });
   }
 
   reportWarning(Node node, var message) {
     if (message is TypeWarning) {
       // TODO(ahe): Don't supress these warning when the type checker
       // is more complete.
@@ skipping 72 matching lines @@
   }
 
   Script readScript(Uri uri, [ScriptTag node]) {
     unimplemented('Compiler.readScript');
   }
 
   String get legDirectory {
     unimplemented('Compiler.legDirectory');
   }
 
+  Element get cyclicThrowHelper() {
+    return findHelper(const SourceString("throwCyclicInit"));
+  }
+
   Element findHelper(SourceString name)
       => jsHelperLibrary.findLocal(name);
   Element findInterceptor(SourceString name)
       => interceptorsLibrary.findLocal(name);
 
   bool get isMockCompilation => false;
 }
 
 class CompilerTask {
   final Compiler compiler;
@@ skipping 56 matching lines @@
     final endOffset = end.charOffset + end.slowCharCount;
 
     // [begin] and [end] might be the same for the same empty token. This
     // happens for instance when scanning '$$'.
     assert(endOffset >= beginOffset);
     return f(beginOffset, endOffset);
   }
 
   String toString() => 'SourceSpan($uri, $begin, $end)';
 }