Lazy implementation of final variables.

lib/compiler/implementation/ssa/codegen.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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler);
   String get name => 'SSA code generator';
   NativeEmitter get nativeEmitter => backend.emitter.nativeEmitter;
 
 
   js.Fun buildJavaScriptFunction(FunctionElement element,
                                  List<js.Parameter> parameters,
                                  js.Block body) {
     FunctionExpression expression = element.cachedNode;
     js.Fun result = new js.Fun(parameters, body);
     result.sourcePosition = expression.getBeginToken();
     result.endSourcePosition = expression.getEndToken();
     return result;
   }
 
   CodeBuffer prettyPrint(js.Node node, Element positionElement) {
     return js.prettyPrint(node, compiler, positionElement);
   }
 
+  CodeBuffer generateCode(WorkItem work, HGraph graph) {
+    if (work.element.isField()) {
+      return generateLazyInitializer(work, graph);
+    } else {
+      return generateMethod(work, graph);
+    }
+  }
+
+  CodeBuffer generateLazyInitializer(work, graph) {
+    return measure(() {
+      compiler.tracer.traceGraph("codegen", graph);
+      List<js.Parameter> parameters = <js.Parameter>[];
+      SsaOptimizedCodeGenerator codegen = new SsaOptimizedCodeGenerator(
+          backend, work, parameters, new Map<Element, String>());
+      codegen.visitGraph(graph);
+      js.Block body = codegen.body;
+      Element element = work.element;
+      js.Fun fun = new js.Fun(parameters, body);
+      return prettyPrint(fun, element);
+    });
+  }
+
   CodeBuffer generateMethod(WorkItem work, HGraph graph) {
     return measure(() {
       JavaScriptItemCompilationContext context = work.compilationContext;
       HTypeMap types = context.types;
       graph.exit.predecessors.forEach((block) {
         assert(block.last is HGoto || block.last is HReturn);
         if (block.last is HReturn) {
           backend.registerReturnType(work.element, types[block.last.inputs[0]]);
         } else {
           backend.registerReturnType(work.element, HType.NULL);
@@ skipping 1917 matching lines @@
             backend.registerNonCallStaticUse(node);
             break;
           }
         }
       }
     });
     world.registerStaticUse(node.element);
     push(new js.VariableUse(compiler.namer.isolateAccess(node.element)));
   }
 
+  void visitLazyStatic(HLazyStatic node) {
+    Element element = node.element;
+    world.registerStaticUse(element);
+    String lazyGetter = compiler.namer.isolateLazyInitializerAccess(element);
+    js.VariableUse target = new js.VariableUse(lazyGetter);
+    js.Call call = new js.Call(target, <js.Expression>[]);
+    push(call, node);
+  }
+
   void visitStaticStore(HStaticStore node) {
     world.registerStaticUse(node.element);
     js.VariableUse variableUse =
         new js.VariableUse(compiler.namer.isolateAccess(node.element));
     use(node.inputs[0]);
     push(new js.Assignment(variableUse, pop()), node);
   }
 
   void visitStringConcat(HStringConcat node) {
     if (isEmptyString(node.left)) {
@@ skipping 454 matching lines @@
       arguments.add(new js.LiteralNumber('0'));
     }
 
     js.Expression bailoutTarget;
     if (element.isInstanceMember()) {
       // TODO(ngeoffray): This does not work in case we come from a
       // super call. We must make bailout names unique.
       String bailoutName = namer.getBailoutName(element);
       bailoutTarget = new js.PropertyAccess.field(new js.This(), bailoutName);
     } else {
+      assert(!element.isField());
       bailoutTarget = new js.VariableUse(namer.isolateBailoutAccess(element));
     }
     js.Call call = new js.Call(bailoutTarget, arguments);
     attachLocation(call, guard);
     return new js.Return(call);
   }
 
   void visitTypeGuard(HTypeGuard node) {
     HInstruction input = node.guarded;
     Element indexingBehavior = compiler.jsIndexingBehaviorInterface;
@@ skipping 441 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }