Allow use of deferred type-literals in non-constant contexts.

pkg/compiler/lib/src/compile_time_constants.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.
 
 library dart2js.compile_time_constant_evaluator;
 
 import 'constant_system_dart.dart';
 import 'constants/constant_system.dart';
 import 'constants/expressions.dart';
 import 'constants/values.dart';
@@ skipping 30 matching lines @@
   /// if possible.
   void compileVariable(VariableElement element);
 
   /// Compiles the compile-time constant for [node], or reports an error if
   /// [node] is not a compile-time constant.
   ///
   /// Depending on implementation, the constant compiler might also compute
   /// the compile-time constant for the backend interpretation of constants.
   ///
   /// The returned constant is always of the frontend interpretation.
-  ConstantExpression compileNode(Node node, TreeElements elements);
+  ConstantExpression compileNode(Node node, TreeElements elements,
+                                 {bool enforceConst: true});

[Johnni Winther, 2015/04/30 09:15:03]

Document [enforceConst].

[sigurdm, 2015/04/30 11:21:44]

Done.

 
   /// Compiles the compile-time constant for the value [metadata], or reports an
   /// error if the value is not a compile-time constant.
   ///
   /// Depending on implementation, the constant compiler might also compute
   /// the compile-time constant for the backend interpretation of constants.
   ///
   /// The returned constant is always of the frontend interpretation.
   ConstantExpression compileMetadata(MetadataAnnotation metadata,
                                      Node node,
@@ skipping 144 matching lines @@
   ConstantExpression compileNodeWithDefinitions(Node node,
                                                 TreeElements definitions,
                                                 {bool isConst: true}) {
     assert(node != null);
     CompileTimeConstantEvaluator evaluator = new CompileTimeConstantEvaluator(
         this, definitions, compiler, isConst: isConst);
     AstConstant constant = evaluator.evaluate(node);
     return constant != null ? constant.expression : null;
   }
 
-  ConstantExpression compileNode(Node node, TreeElements elements) {
-    return compileNodeWithDefinitions(node, elements);
+  ConstantExpression compileNode(Node node, TreeElements elements,
+                                 {bool enforceConst: true}) {
+    return compileNodeWithDefinitions(node, elements, isConst: enforceConst);
   }
 
   ConstantExpression compileMetadata(MetadataAnnotation metadata,
                                      Node node,
                                      TreeElements elements) {
     return compileNodeWithDefinitions(node, elements);
   }
 
   void forgetElement(Element element) {
     initialVariableValues.remove(element);
@@ skipping 234 matching lines @@
               text,
               constantSystem.createString(new LiteralDartString(text))))];
     AstConstant constant = makeConstructedConstant(
         compiler, handler, context, node, type, compiler.symbolConstructor,
         CallStructure.ONE_ARG,
         arguments, arguments);
     return new AstConstant(
         context, node, new SymbolConstantExpression(constant.value, text));
   }
 
-  AstConstant makeTypeConstant(Node node, DartType elementType) {
+  ConstantExpression makeTypeConstant(DartType elementType) {
     DartType constantType =
         compiler.backend.typeImplementation.computeType(compiler);
-    return new AstConstant(
-        context, node, new TypeConstantExpression(
-            new TypeConstantValue(elementType, constantType),
-            elementType));
+    return new TypeConstantExpression(
+        new TypeConstantValue(elementType, constantType), elementType);
   }
 
   /// Returns true if the prefix of the send resolves to a deferred import
   /// prefix.
   bool isDeferredUse(Send send) {
     if (send == null) return false;
     return compiler.deferredLoadTask
         .deferredPrefixElement(send, elements) != null;
   }
 
   AstConstant visitIdentifier(Identifier node) {
     Element element = elements[node];
     if (Elements.isClass(element) || Elements.isTypedef(element)) {
       TypeDeclarationElement typeDeclarationElement = element;
       DartType type = typeDeclarationElement.rawType;
-      return makeTypeConstant(node, type);
+      return new AstConstant(element, node, makeTypeConstant(type));
     }
     return signalNotCompileTimeConstant(node);
   }
 
   // TODO(floitsch): provide better error-messages.
   AstConstant visitSend(Send send) {
     Element element = elements[send];
     if (send.isPropertyAccess) {
-      if (isDeferredUse(send)) {
-        return signalNotCompileTimeConstant(send,
-            message: MessageKind.DEFERRED_COMPILE_TIME_CONSTANT);
-      }
+      ConstantExpression result;
+
       if (Elements.isStaticOrTopLevelFunction(element)) {
         FunctionElementX function = element;
         function.computeType(compiler);
-        return new AstConstant(
-            context, send, new FunctionConstantExpression(
-                new FunctionConstantValue(function),
-                function));
+        result = new FunctionConstantExpression(
+            new FunctionConstantValue(function), function);
       } else if (Elements.isStaticOrTopLevelField(element)) {
-        ConstantExpression result;
+        ConstantExpression elementExpression;
         if (element.isConst) {
-          result = handler.compileConstant(element);
+          elementExpression = handler.compileConstant(element);
         } else if (element.isFinal && !isEvaluatingConstant) {
-          result = handler.compileVariable(element);
+          elementExpression = handler.compileVariable(element);
         }
-        if (result != null) {
-          return new AstConstant(
-              context, send,
-              new VariableConstantExpression(result.value, element));
+        if (elementExpression != null) {
+          result =
+              new VariableConstantExpression(elementExpression.value, element);
         }
       } else if (Elements.isClass(element) || Elements.isTypedef(element)) {
         assert(elements.isTypeLiteral(send));
-        return makeTypeConstant(send, elements.getTypeLiteralType(send));
+        result = makeTypeConstant(elements.getTypeLiteralType(send));
       } else if (send.receiver != null) {
         if (send.selector.asIdentifier().source == "length") {
           AstConstant left = evaluate(send.receiver);
           if (left != null && left.value.isString) {
             StringConstantValue stringConstantValue = left.value;
             DartString string = stringConstantValue.primitiveValue;
             IntConstantValue length = constantSystem.createInt(string.length);
-            return new AstConstant(
-                context, send, new VariableConstantExpression(length, element));
+            result = new VariableConstantExpression(length, element);
           }
         }
         // Fall through to error handling.
       } else if (!Elements.isUnresolved(element)
                  && element.isVariable
                  && element.isConst) {
-        ConstantExpression result = handler.compileConstant(element);
-        if (result != null) {
-          return new AstConstant(
-              context, send,
-              new VariableConstantExpression(result.value, element));
+        ConstantExpression variableExpression =
+            handler.compileConstant(element);
+        if (variableExpression != null) {
+          result = new VariableConstantExpression(variableExpression.value,
+                                                  element);
         }
       }
-      return signalNotCompileTimeConstant(send);
+      if (result == null) {
+        return signalNotCompileTimeConstant(send);
+      }
+      if (isDeferredUse(send)) {
+        if (isEvaluatingConstant) {
+          error(send, MessageKind.DEFERRED_COMPILE_TIME_CONSTANT);
+        }
+        PrefixElement prefix = compiler.deferredLoadTask
+            .deferredPrefixElement(send, elements);
+        result = new DeferredConstantExpression(
+            new DeferredConstantValue(result.value, prefix),
+            result,
+            prefix);
+        compiler.deferredLoadTask
+            .registerConstantDeferredUse(result.value, prefix);
+      }
+      return new AstConstant(context, send, result);
     } else if (send.isCall) {
       if (element == compiler.identicalFunction
           && send.argumentCount() == 2) {
         AstConstant left = evaluate(send.argumentsNode.nodes.head);
         AstConstant right = evaluate(send.argumentsNode.nodes.tail.head);
         if (left == null || right == null) {
           return null;
         }
         ConstantValue result =
             constantSystem.identity.fold(left.value, right.value);
@@ skipping 174 matching lines @@
     Map<Node, AstConstant> concreteArgumentMap =
         <Node, AstConstant>{};
     for (Link<Node> link = send.arguments; !link.isEmpty; link = link.tail) {
       Node argument = link.head;
       NamedArgument namedArgument = argument.asNamedArgument();
       if (namedArgument != null) {
         argument = namedArgument.expression;
       }
       concreteArgumentMap[argument] = evaluateConstant(argument);
     }
-
     List<AstConstant> normalizedArguments =
         evaluateArgumentsToConstructor(
           node, callStructure, send.arguments, constructor.implementation,
           compileArgument: (node) => concreteArgumentMap[node]);
     List<AstConstant> concreteArguments =
         concreteArgumentMap.values.toList();
 
     if (constructor == compiler.intEnvironment ||
         constructor == compiler.boolEnvironment ||
         constructor == compiler.stringEnvironment) {
@@ skipping 390 matching lines @@
   ConstantValue get value => expression.value;
 
   String toString() => expression.toString();
 }
 
 /// A synthetic constant used to recover from errors.
 class ErroneousAstConstant extends AstConstant {
   ErroneousAstConstant(Element element, Node node)
       : super(element, node, new ErroneousConstantExpression());
 }