Handle compile-time constness for conditionals and type literal calls.

sdk/lib/_internal/compiler/implementation/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.
 
 part of dart2js;
 
 /**
  * The [ConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
@@ skipping 73 matching lines @@
   /**
    * Returns the a compile-time constant if the variable could be compiled
    * eagerly. If the variable needs to be initialized lazily returns `null`.
    * If the variable is `const` but cannot be compiled eagerly reports an
    * error.
    */
   Constant compileVariableWithDefinitions(VariableElement element,
                                           TreeElements definitions,
                                           {bool isConst: false}) {
     return measure(() {
-      // Initializers for parameters must be const.
-      isConst = isConst || element.modifiers.isConst()
-          || !Elements.isStaticOrTopLevel(element);
       if (!isConst && lazyStatics.contains(element)) return null;
 
       Node node = element.parseNode(compiler);
       if (pendingVariables.contains(element)) {
         if (isConst) {
           compiler.reportFatalError(
               node, MessageKind.CYCLIC_COMPILE_TIME_CONSTANTS);
         } else {
           lazyStatics.add(element);
           return null;
@@ skipping 37 matching lines @@
       pendingVariables.remove(element);
       return value;
     });
   }
 
   Constant compileNodeWithDefinitions(Node node,
                                       TreeElements definitions,
                                       {bool isConst: false}) {
     return measure(() {
       assert(node != null);
+      Constant constant = definitions.getConstant(node);
+      if (constant != null) {
+        return constant;
+      }
       CompileTimeConstantEvaluator evaluator = new CompileTimeConstantEvaluator(
           this, definitions, compiler, isConst: isConst);
-      return evaluator.evaluate(node);
+      constant = evaluator.evaluate(node);
+      if (constant != null) {
+        definitions.setConstant(node, constant);
+      }
+      return constant;
     });
   }
 
   /**
    * Returns an [Iterable] of static non final fields that need to be
    * initialized. The fields list must be evaluated in order since they might
    * depend on each other.
    */
   Iterable<VariableElement> getStaticNonFinalFieldsForEmission() {
     return initialVariableValues.keys.where((element) {
@@ skipping 223 matching lines @@
     List<Constant> createArguments(_) {
       return [constantSystem.createString(
         new DartString.literal(node.slowNameString), node)];
     }
     return makeConstructedConstant(
         node, type, compiler.symbolConstructor, createArguments);
   }
 
   Constant makeTypeConstant(Element element) {
     DartType elementType = element.computeType(compiler).asRaw();
     compiler.backend.registerTypeLiteral(

[karlklose, 2013/10/02 11:08:55]

Move this registration.

[Johnni Winther, 2013/10/02 12:39:33]

Done.

         element, compiler.enqueuer.codegen, elements);
     DartType constantType =
         compiler.backend.typeImplementation.computeType(compiler);
     return new TypeConstant(elementType, constantType);
   }
 
   // TODO(floitsch): provide better error-messages.
   Constant visitSend(Send send) {
     Element element = elements[send];
     if (send.isPropertyAccess) {
       if (Elements.isStaticOrTopLevelFunction(element)) {
         return new FunctionConstant(element);
       } else if (Elements.isStaticOrTopLevelField(element)) {
         Constant result;
         if (element.modifiers.isConst()) {
           result = handler.compileConstant(element);
         } else if (element.modifiers.isFinal() && !isEvaluatingConstant) {
           result = handler.compileVariable(element);
         }
         if (result != null) return result;
       } else if (Elements.isClass(element) || Elements.isTypedef(element)) {
+        assert(elements.isTypeLiteral(send));
         return makeTypeConstant(element);
       } else if (send.receiver != null) {
         // Fall through to error handling.
       } else if (!Elements.isUnresolved(element)
                  && element.isVariable()
                  && element.modifiers.isConst()) {
         Constant result = handler.compileConstant(element);
         if (result != null) return result;
       }
       return signalNotCompileTimeConstant(send);
     } else if (send.isCall) {
       if (identical(element, compiler.identicalFunction)
           && send.argumentCount() == 2) {
         Constant left = evaluate(send.argumentsNode.nodes.head);
         Constant right = evaluate(send.argumentsNode.nodes.tail.head);
         Constant result = constantSystem.identity.fold(left, right);
         if (result != null) return result;
       } else if (Elements.isClass(element) || Elements.isTypedef(element)) {
-        return makeTypeConstant(element);
+        // The node itself is not a constant but we register the selector (the
+        // identifier that refers to the class/typedef) as a constant.
+        Constant typeConstant = makeTypeConstant(element);
+        elements.setConstant(send.selector, typeConstant);
       }
       return signalNotCompileTimeConstant(send);
     } else if (send.isPrefix) {
       assert(send.isOperator);
       Constant receiverConstant = evaluate(send.receiver);
       if (receiverConstant == null) return null;
       Operator op = send.selector;
       Constant folded;
       switch (op.source.stringValue) {
         case "!":
@@ skipping 97 matching lines @@
             folded = areIdentical.negate();
           }
           break;
       }
       if (folded == null) return signalNotCompileTimeConstant(send);
       return folded;
     }
     return signalNotCompileTimeConstant(send);
   }
 
+  Constant visitConditional(Conditional node) {
+    Constant condition = evaluate(node.condition);
+    if (condition == null || !condition.isBool()) {
+      return signalNotCompileTimeConstant(node);

[ngeoffray, 2013/10/02 10:44:43]

IF condition is not bool, we might want a different error message.

[Johnni Winther, 2013/10/02 12:39:33]

Done.

+    }
+    Constant thenExpression = evaluate(node.thenExpression);
+    Constant elseExpression = evaluate(node.elseExpression);

[ngeoffray, 2013/10/02 10:44:43]

IS evaluating both expressions a requirement from the spec?

[Johnni Winther, 2013/10/02 12:39:33]

We don't need to evaluate them but we need to check that both are const, which
currently is done simultaneously.

+    BoolConstant boolCondition = condition;
+    return boolCondition.value ? thenExpression : elseExpression;
+  }
+
   Constant visitSendSet(SendSet node) {
     return signalNotCompileTimeConstant(node);
   }
 
   /**
    * Returns the list of constants that are passed to the static function.
    *
    * Invariant: [target] must be an implementation element.
    */
   List<Constant> evaluateArgumentsToConstructor(Node node,
@@ skipping 284 matching lines @@
           if (fieldValue == null) {
             // Use the default value.
             fieldValue = handler.compileConstant(field);
           }
           jsNewArguments.add(fieldValue);
         },
         includeSuperAndInjectedMembers: true);
     return jsNewArguments;
   }
 }