dart2js cps: Access to lazily initialized fields.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.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.
 
 library dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 204 matching lines @@
   /// Normalizes the argument list of a dynamic invocation (i.e. where the
   /// target element is unknown).
   ///
   /// For the JS backend, normalizes order of named arguments.
   ///
   /// For the Dart backend, returns [arguments].
   List<ir.Primitive> normalizeDynamicArguments(
       CallStructure callStructure,
       List<ir.Primitive> arguments);
 
+  /// Read the value of [field].
+  ir.Primitive buildStaticFieldGet(FieldElement field, SourceInformation src);
+
   /// Creates a [TypedSelector] variant of [newSelector] using the type of
   /// [oldSelector], if available.
   ///
   /// This is needed to preserve inferred receiver types when creating new
   /// selectors.
   Selector useSelectorType(Selector newSelector, Selector oldSelector) {
     // TODO(asgerf,johnniwinther): This works but it is brittle.
     //     We should decouple selectors from inferred receiver type masks.
     // TODO(asgerf): Use this whenever we create a selector for a dynamic call.
     if (oldSelector is TypedSelector) {
@@ skipping 513 matching lines @@
 
   @override
   ir.Primitive visitLocalFunctionGet(
       ast.Send node,
       LocalFunctionElement function,
       _) {
     return irBuilder.buildLocalFunctionGet(function);
   }
 
   @override
-  ir.Primitive handleStaticFieldGet(ast.Send node, FieldElement field, _) {
-    return field.isConst
-        ? irBuilder.buildConstant(getConstantForVariable(field))
-        : irBuilder.buildStaticFieldGet(field,
-              sourceInformation: sourceInformationBuilder.buildGet(node));
-  }
-
-  @override
   ir.Primitive handleStaticFunctionGet(
       ast.Send node,
       MethodElement function,
       _) {
     // TODO(karlklose): support foreign functions.
     if (function.isForeign(compiler.backend)) {
       return giveup(node, 'handleStaticFunctionGet: foreign: $function');
     }
     return irBuilder.buildStaticFunctionGet(function);
   }
@@ skipping 305 matching lines @@
       ast.Send node,
       LocalFunctionElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return irBuilder.buildLocalFunctionInvocation(function, callStructure,
         translateDynamicArguments(arguments, callStructure));
   }
 
   @override
+  ir.Primitive handleStaticFieldGet(ast.Send node, FieldElement field, _) {
+    return buildStaticFieldGet(field, sourceInformationBuilder.buildGet(node));
+  }
+
+  @override
   ir.Primitive handleStaticFieldInvoke(
       ast.Send node,
       FieldElement field,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
-    ir.Primitive target = irBuilder.buildStaticFieldGet(field);
+    SourceInformation src = sourceInformationBuilder.buildGet(node);
+    ir.Primitive target = buildStaticFieldGet(field, src);
     return irBuilder.buildCallInvocation(target,
         callStructure,
         translateDynamicArguments(arguments, callStructure));
   }
 
   @override
   ir.Primitive handleStaticFunctionInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
@@ skipping 310 matching lines @@
     return irBuilder.buildLocalVariableSet(element, visit(rhs));
   }
 
   @override
   ir.Primitive handleStaticFieldCompound(
       ast.Send node,
       FieldElement field,
       op.AssignmentOperator operator,
       ast.Node rhs,
       _) {
+    SourceInformation src = sourceInformationBuilder.buildGet(node);
     return translateCompound(
-        getValue: () => irBuilder.buildStaticFieldGet(field),
+        getValue: () => buildStaticFieldGet(field, src),
         operator: operator,
         rhs: rhs,
         setValue: (ir.Primitive result) {
           irBuilder.buildStaticFieldSet(field, result);
         });
   }
 
   @override
   ir.Primitive handleStaticFieldPostfixPrefix(
       ast.Send node,
       FieldElement field,
       op.IncDecOperator operator,
       arg,
       {bool isPrefix}) {
+    SourceInformation src = sourceInformationBuilder.buildGet(node);
     return translatePrefixPostfix(
-        getValue: () => irBuilder.buildStaticFieldGet(field),
+        getValue: () => buildStaticFieldGet(field, src),
         operator: operator,
         setValue: (ir.Primitive result) {
           irBuilder.buildStaticFieldSet(field, result);
         },
         isPrefix: isPrefix);
   }
 
   @override
   ir.Primitive handleStaticFieldSet(
       ast.SendSet node,
@@ skipping 863 matching lines @@
     Selector selector = new Selector.setter(parameter.name, null);
     return buildStaticNoSuchMethod(selector, [visit(rhs)]);
   }
 
   @override
   ir.Primitive errorFinalStaticFieldCompound(
       ast.Send node,
       FieldElement field,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
+    SourceInformation src = sourceInformationBuilder.buildGet(node);
     return translateCompound(
-        getValue: () => irBuilder.buildStaticFieldGet(field),
+        getValue: () => buildStaticFieldGet(field, src),
         operator: operator,
         rhs: rhs,
         setValue: (value) => buildStaticNoSuchMethod(
             new Selector.setter(field.name, field.library), [value]));
   }
 
   @override
   ir.Primitive errorFinalStaticFieldSet(
       ast.SendSet node,
       FieldElement field,
@@ skipping 30 matching lines @@
         node);
     return buildInstanceNoSuchMethod(selector, [visit(rhs)]);
   }
 
   @override
   ir.Primitive errorFinalTopLevelFieldCompound(
       ast.Send node,
       FieldElement field,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
+    SourceInformation src = sourceInformationBuilder.buildGet(node);
     return translateCompound(
-        getValue: () => irBuilder.buildStaticFieldGet(field),
+        getValue: () => buildStaticFieldGet(field, src),
         operator: operator,
         rhs: rhs,
         setValue: (value) => buildStaticNoSuchMethod(
             new Selector.setter(field.name, field.library), [value]));
   }
 
   @override
   ir.Primitive errorFinalTopLevelFieldSet(
       ast.SendSet node,
       FieldElement field,
@@ skipping 574 matching lines @@
 
   @override
   ir.Primitive buildRuntimeError(String message) {
     return giveup(null, 'Build runtime error: $message');
   }
 
   @override
   ir.Primitive buildAbstractClassInstantiationError(ClassElement element) {
     return giveup(null, 'Abstract class instantiation: ${element.name}');
   }
+
+  ir.Primitive buildStaticFieldGet(FieldElement field, SourceInformation src) {
+    return irBuilder.buildStaticFieldLazyGet(field, src);
+  }
 }
 
 /// The [IrBuilder]s view on the information about the program that has been
 /// computed in resolution and and type interence.
 class GlobalProgramInformation {
   final Compiler _compiler;
   JavaScriptBackend get _backend => _compiler.backend;
 
   GlobalProgramInformation(this._compiler);
 
@@ skipping 118 matching lines @@
         case ElementKind.GENERATIVE_CONSTRUCTOR_BODY:
           root = buildConstructorBody(element);
           break;
 
         case ElementKind.FUNCTION:
         case ElementKind.GETTER:
         case ElementKind.SETTER:
           root = buildFunction(element);
           break;
 
+        case ElementKind.FIELD:
+          if (Elements.isStaticOrTopLevel(element)) {
+            root = buildStaticFieldInitializer(element);
+          } else {
+            // Instance field initializers are inlined in the constructor,
+            // so we shouldn't need to build anything here.
+            // TODO(asgerf): But what should we return?
+            return null;
+          }
+          break;
+
         default:
           compiler.internalError(element, "Unexpected element type $element");
       }
       new CleanupPass().visit(root);
       return root;
     });
   }
 
+  ir.FunctionDefinition buildStaticFieldInitializer(FieldElement element) {
+    if (!backend.constants.lazyStatics.contains(element)) {
+      return null; // Nothing to do.
+    }
+    closureClassMap =
+        compiler.closureToClassMapper.computeClosureToClassMapping(
+            element,
+            element.node,
+            elements);
+    IrBuilder builder = getBuilderFor(element);
+    return withBuilder(builder, () {
+      ir.Primitive initialValue = visit(element.initializer);
+      irBuilder.buildReturn(initialValue);
+      return irBuilder.makeLazyFieldInitializer();
+    });
+  }
+
   /// Builds the IR for an [expression] taken from a different [context].
   ///
   /// Such expressions need to be compiled with a different [sourceFile] and
   /// [elements] mapping.
   ir.Primitive inlineExpression(AstElement context, ast.Expression expression) {
     JsIrBuilderVisitor visitor = new JsIrBuilderVisitor(
         context.resolvedAst.elements,
         compiler,
         sourceInformationBuilder.forContext(context));
     return visitor.withBuilder(irBuilder, () => visitor.visit(expression));
@@ skipping 497 matching lines @@
         [irBuilder.buildStringConstant(message)]);
   }
 
   @override
   ir.Primitive buildAbstractClassInstantiationError(ClassElement element) {
     return irBuilder.buildStaticFunctionInvocation(
         backend.getThrowAbstractClassInstantiationError(),
         new CallStructure.unnamed(1),
         [irBuilder.buildStringConstant(element.name)]);
   }
+
+  @override
+  ir.Primitive handleStaticFieldGet(ast.Send node, FieldElement field, _) {
+    SourceInformation src = sourceInformationBuilder.buildGet(node);
+    return buildStaticFieldGet(field, src);
+  }
+
+  ir.Primitive buildStaticFieldGet(FieldElement field, SourceInformation src) {
+    ConstantExpression constant =
+        backend.constants.getConstantForVariable(field);
+    if (constant != null && !field.isAssignable) {
+      return irBuilder.buildConstant(constant);
+    } else if (backend.constants.lazyStatics.contains(field)) {
+      return irBuilder.buildStaticFieldLazyGet(field, src);
+    } else {
+      return irBuilder.buildStaticFieldGet(field, src);
+    }
+  }
 }
 
 /// Perform simple post-processing on the initial CPS-translated root term.
 ///
 /// This pass performs backend-independent post-processing on the translated
 /// term.  It is implemented separately from the optimization passes because
 /// it is required for correctness of the implementation.
 ///
 /// It performs the following translations:
 ///   - Replace [ir.LetPrim] binding a [ir.NonTailThrow] with a [ir.Throw]
@@ skipping 52 matching lines @@
     node.body = replacementFor(node.body);
   }
 }
 
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends ir.RecursiveVisitor {
   processReference(ir.Reference reference) {
     reference.unlink();
   }
 }