dart2js cps: Access to lazily initialized fields.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart

 // Copyright (c) 2013, 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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
@@ skipping 634 matching lines @@
       : this.value = new Reference<Primitive>(value);
 
   Expression plug(Expression expr) {
     assert(body == null);
     return body = expr;
   }
 
   accept(Visitor visitor) => visitor.visitSetStatic(this);
 }
 
+/// Reads the value of a lazily initialized static field.
+///
+/// If the field has not yet been initialized, its initializer is evaluated
+/// and assigned to the field.
+///
+/// [continuation] is then invoked with the value of the field as argument.
+class GetLazyStatic extends Expression {
+  final FieldElement element;
+  final Reference<Continuation> continuation;
+  final SourceInformation sourceInformation;
+
+  GetLazyStatic(this.element,
+                Continuation cont,
+                this.sourceInformation)
+      : continuation = new Reference<Continuation>(cont);
+
+  accept(Visitor visitor) => visitor.visitGetLazyStatic(this);
+}
+
 /// Creates an object for holding boxed variables captured by a closure.
 class CreateBox extends Primitive implements JsSpecificNode {
   accept(Visitor visitor) => visitor.visitCreateBox(this);
 }
 
 /// Creates an instance of a class and initializes its fields and runtime type
 /// information.
 class CreateInstance extends Primitive implements JsSpecificNode {
   final ClassElement classElement;
 
@@ skipping 191 matching lines @@
 class Body extends InteriorNode {
   Expression body;
   final Continuation returnContinuation;
   Body(this.body, this.returnContinuation);
   accept(Visitor visitor) => visitor.visitBody(this);
 }
 
 /// A function definition, consisting of parameters and a body.  The parameters
 /// include a distinguished continuation parameter (held by the body).
 class FunctionDefinition extends RootNode {
-  final FunctionElement element;
+  final ExecutableElement element;
   final Parameter thisParameter;
   /// Mixed list of [Parameter]s and [MutableVariable]s.
   final List<Definition> parameters;
   final Body body;
   final List<ConstDeclaration> localConstants;
 
   /// Values for optional parameters.
   final List<ConstantExpression> defaultParameterValues;
 
   FunctionDefinition(this.element,
@@ skipping 150 matching lines @@
   T visitInvokeMethodDirectly(InvokeMethodDirectly node);
   T visitInvokeConstructor(InvokeConstructor node);
   T visitConcatenateStrings(ConcatenateStrings node);
   T visitThrow(Throw node);
   T visitRethrow(Rethrow node);
   T visitBranch(Branch node);
   T visitTypeOperator(TypeOperator node);
   T visitSetMutableVariable(SetMutableVariable node);
   T visitDeclareFunction(DeclareFunction node);
   T visitSetStatic(SetStatic node);
+  T visitGetLazyStatic(GetLazyStatic node);
 
   // Definitions.
   T visitLiteralList(LiteralList node);
   T visitLiteralMap(LiteralMap node);
   T visitConstant(Constant node);
   T visitReifyTypeVar(ReifyTypeVar node);
   T visitCreateFunction(CreateFunction node);
   T visitGetMutableVariable(GetMutableVariable node);
   T visitParameter(Parameter node);
   T visitContinuation(Continuation node);
@@ skipping 190 matching lines @@
   }
 
   processDeclareFunction(DeclareFunction node) {}
   visitDeclareFunction(DeclareFunction node) {
     processDeclareFunction(node);
     visit(node.variable);
     visit(node.definition);
     visit(node.body);
   }
 
+  processGetLazyStatic(GetLazyStatic node) {}
+  visitGetLazyStatic(GetLazyStatic node) {
+    processGetLazyStatic(node);
+    processReference(node.continuation);
+  }
+
   // Definitions.
 
   processLiteralList(LiteralList node) {}
   visitLiteralList(LiteralList node) {
     processLiteralList(node);
     node.values.forEach(processReference);
   }
 
   processLiteralMap(LiteralMap node) {}
   visitLiteralMap(LiteralMap node) {
@@ skipping 126 matching lines @@
     processNonTailThrow(node);
     processReference(node.value);
   }
 
   processCreateInvocationMirror(CreateInvocationMirror node) {}
   visitCreateInvocationMirror(CreateInvocationMirror node) {
     processCreateInvocationMirror(node);
     node.arguments.forEach(processReference);
   }
 }