Move compile-time constant registrations to the backend.

sdk/lib/_internal/compiler/implementation/resolution/members.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 resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
   /// A set of additional dependencies.  See [registerDependency] below.
   Set<Element> get otherDependencies;
 
   Element operator[](Node node);
   Selector getSelector(Send send);
   Selector getGetterSelectorInComplexSendSet(SendSet node);
   Selector getOperatorSelectorInComplexSendSet(SendSet node);
   DartType getType(Node node);
   void setSelector(Node node, Selector selector);
   void setGetterSelectorInComplexSendSet(SendSet node, Selector selector);
   void setOperatorSelectorInComplexSendSet(SendSet node, Selector selector);
   Selector getIteratorSelector(ForIn node);
   Selector getMoveNextSelector(ForIn node);
   Selector getCurrentSelector(ForIn node);
   Selector setIteratorSelector(ForIn node, Selector selector);
   Selector setMoveNextSelector(ForIn node, Selector selector);
   Selector setCurrentSelector(ForIn node, Selector selector);
+  void setConstant(Node node, Constant constant);
+  Constant getConstant(Node node);
 
   /**
    * Returns [:true:] if [node] is a type literal.
    *
    * Resolution marks this by setting the type on the node to be the
    * [:Type:] type.
    */
   bool isTypeLiteral(Send node);
 
   /// Register additional dependencies required by [currentElement].
   /// For example, elements that are used by a backend.
   void registerDependency(Element element);
 }
 
 class TreeElementMapping implements TreeElements {
   final Element currentElement;
   final Map<Spannable, Selector> selectors =
       new LinkedHashMap<Spannable, Selector>();
   final Map<Node, DartType> types = new LinkedHashMap<Node, DartType>();
   final Set<Node> superUses = new LinkedHashSet<Node>();
   final Set<Element> otherDependencies = new LinkedHashSet<Element>();
+  final Map<Node, Constant> constants = new Map<Node, Constant>();
   final int hashCode = ++hashCodeCounter;
   static int hashCodeCounter = 0;
 
   TreeElementMapping(this.currentElement);
 
   operator []=(Node node, Element element) {
     assert(invariant(node, () {
       FunctionExpression functionExpression = node.asFunctionExpression();
       if (functionExpression != null) {
         return !functionExpression.modifiers.isExternal();
@@ skipping 74 matching lines @@
   }
 
   Selector setCurrentSelector(ForIn node, Selector selector) {
     selectors[node.inToken] = selector;
   }
 
   Selector getCurrentSelector(ForIn node) {
     return selectors[node.inToken];
   }
 
+  void setConstant(Node node, Constant constant) {
+    constants[node] = constant;
+  }
+
+  Constant getConstant(Node node) {
+    return constants[node];
+  }
+
+

[ahe, 2013/09/30 11:05:26]

Extra line.

[Johnni Winther, 2013/10/01 11:21:48]

Done.

   bool isTypeLiteral(Send node) {
     return getType(node) != null;
   }
 
   void registerDependency(Element element) {
     otherDependencies.add(element.implementation);
   }
 
   String toString() => 'TreeElementMapping($currentElement)';
 }
@@ skipping 188 matching lines @@
   }
 
   TreeElements resolveMethodElement(FunctionElement element) {
     assert(invariant(element, element.isDeclaration));
     return compiler.withCurrentElement(element, () {
       bool isConstructor =
           identical(element.kind, ElementKind.GENERATIVE_CONSTRUCTOR);
       TreeElements elements =
           compiler.enqueuer.resolution.getCachedElements(element);
       if (elements != null) {
-        assert(isConstructor);
+        // TODO(karlklose): This should never happen, not even for constructors.

[ngeoffray, 2013/10/01 08:33:35]

Please add: TODO(...): remove this check. elements being null should never
happen, ...

[Johnni Winther, 2013/10/01 11:21:48]

Done.

+        assert(invariant(element, isConstructor,
+            message: 'Non-constructor element $element '
+                     'has already been analyzed.'));
         return elements;
       }
       if (element.isSynthesized) {
         Element target = element.targetConstructor;
         // Ensure the signature of the synthesized element is
         // resolved. This is the only place where the resolver is
         // seeing this element.
         element.computeSignature(compiler);
         if (!target.isErroneous()) {
           compiler.enqueuer.resolution.registerStaticUse(
@@ skipping 33 matching lines @@
           FunctionElement redirection =
               resolver.resolveInitializers(element, tree);
           if (redirection != null) {
             resolveRedirectingConstructor(resolver, tree, element, redirection);
           }
         } else if (element.isForwardingConstructor) {
           // Initializers will be checked on the original constructor.
         } else if (tree.initializers != null) {
           error(tree, MessageKind.FUNCTION_WITH_INITIALIZER);
         }
-        visitBody(visitor, tree.body);
+
+        if (!compiler.analyzeSignaturesOnly || tree.isRedirectingFactory) {

[ngeoffray, 2013/10/01 08:33:35]

What's this redirecting factory check? Please add a comment.

[Johnni Winther, 2013/10/01 11:21:48]

Added comment: We need to analyze the redirecting factory bodies to ensure that
we can analyze compile-time constants.

+          visitor.visit(tree.body);
+        }
 
         // Get the resolution tree and check that the resolved
         // function doesn't use 'super' if it is mixed into another
         // class. This is the part of the 'super' mixin check that
         // happens when a function is resolved after the mixin
         // application has been performed.
         TreeElements resolutionTree = visitor.mapping;
         ClassElement enclosingClass = element.getEnclosingClass();
         if (enclosingClass != null) {
           Set<MixinApplicationElement> mixinUses =
@@ skipping 35 matching lines @@
     SendSet send = tree.asSendSet();
     if (send != null) {
       // TODO(johnniwinther): Avoid analyzing initializers if
       // [Compiler.analyzeSignaturesOnly] is set.
       visitor.visit(send.arguments.head);
     } else if (element.modifiers.isConst()) {
       compiler.reportError(element, MessageKind.CONST_WITHOUT_INITIALIZER);
     }
 
     if (Elements.isStaticOrTopLevelField(element)) {
+      visitor.addPostProcessAction(element, () {
+        compiler.constantHandler.compileVariable(
+            element, isConst: element.modifiers.isConst());
+      });
       if (tree.asSendSet() != null) {
-        // TODO(13429): We could do better here by using the
-        // constant handler to figure out if it's a lazy field or not.
-        compiler.backend.registerLazyField(visitor.mapping);
+        if (!element.modifiers.isConst()) {

[ngeoffray, 2013/10/01 08:33:35]

Note that this is not fixing it: what we want to know here is whether the value
on the left hand side is a constant. Can't we eagerly request to compile it?

[Johnni Winther, 2013/10/01 11:21:48]

Added a TODO.

+          compiler.backend.registerLazyField(visitor.mapping);
+        }
       } else {
         compiler.enqueuer.resolution.registerInstantiatedClass(
             compiler.nullClass, visitor.mapping);
       }
     }
 
     // Perform various checks as side effect of "computing" the type.
     element.computeType(compiler);
 
     return visitor.mapping;
@@ skipping 561 matching lines @@
       annotation.resolutionState = STATE_STARTED;
 
       Node node = annotation.parseNode(compiler);
       Element annotatedElement = annotation.annotatedElement;
       Element context = annotatedElement.enclosingElement;
       if (context == null) {
         context = annotatedElement;
       }
       ResolverVisitor visitor = visitorFor(context);
       node.accept(visitor);
-      annotation.value = compiler.metadataHandler.compileNodeWithDefinitions(
+      annotation.value = compiler.constantHandler.compileNodeWithDefinitions(
           node, visitor.mapping, isConst: true);
+      compiler.backend.registerMetadataConstant(annotation.value,
+                                                visitor.mapping);
 
       annotation.resolutionState = STATE_DONE;
     }));
   }
 
   error(Node node, MessageKind kind, [arguments = const {}]) {
     // TODO(ahe): Make non-fatal.
     compiler.reportFatalError(node, kind, arguments);
   }
 }
@@ skipping 330 matching lines @@
     compiler.cancel(message, node: node);
   }
 
   void internalError(Node node, String message) {
     compiler.internalError(message, node: node);
   }
 
   void unimplemented(Node node, String message) {
     compiler.unimplemented(message, node: node);
   }
+
+  void addPostProcessAction(Element element, PostProcessAction action) {
+    compiler.enqueuer.resolution.addPostProcessAction(element, action);
+  }
 }
 
 abstract class LabelScope {
   LabelScope get outer;
   LabelElement lookup(String label);
 }
 
 class LabeledStatementLabelScope implements LabelScope {
   final LabelScope outer;
   final Map<String, LabelElement> labels;
@@ skipping 242 matching lines @@
         type = checkNoTypeArguments(type);
       } else {
         compiler.cancel("unexpected element kind ${element.kind}",
                         node: node);
       }
       // TODO(johnniwinther): We should not resolve type annotations after the
       // resolution queue has been closed. Currently the dart backend does so.
       // Remove the guarded when this is fixed.
       if (!compiler.enqueuer.resolution.queueIsClosed &&
           addTypeVariableBoundsCheck) {
-        compiler.enqueuer.resolution.addPostProcessAction(
+        visitor.addPostProcessAction(
             visitor.enclosingElement,
             () => checkTypeVariableBounds(node, type));
       }
     }
     visitor.useType(node, type);
     return type;
   }
 
   /// Checks the type arguments of [type] against the type variable bounds.
   void checkTypeVariableBounds(TypeAnnotation node, GenericType type) {
@@ skipping 355 matching lines @@
       initializerDo(parameterNode, (n) => n.accept(this));
       // Field parameters (this.x) are not visible inside the constructor. The
       // fields they reference are visible, but must be resolved independently.
       if (element.kind == ElementKind.FIELD_PARAMETER) {
         useElement(parameterNode, element);
       } else {
         defineElement(variableDefinitions.definitions.nodes.head, element);
       }
       parameterNodes = parameterNodes.tail;
     });
+    addPostProcessAction(enclosingElement, () {
+      functionParameters.forEachOptionalParameter((Element parameter) {
+        compiler.constantHandler.compileConstant(parameter);
+      });
+    });
     if (inCheckContext) {
       functionParameters.forEachParameter((Element element) {
         compiler.enqueuer.resolution.registerIsCheck(
             element.computeType(compiler), mapping);
       });
     }
   }
 
   visitCascade(Cascade node) {
     visit(node.expression);
@@ skipping 348 matching lines @@
         compiler.backend.registerTypeVariableExpression(mapping);
         // Set the type of the node to [Type] to mark this send as a
         // type variable expression.
         mapping.setType(node, compiler.typeClass.computeType(compiler));
         world.registerTypeLiteral(target, mapping);
       } else if (target.impliesType() && !sendIsMemberAccess) {
         // Set the type of the node to [Type] to mark this send as a
         // type literal.
         mapping.setType(node, compiler.typeClass.computeType(compiler));
         world.registerTypeLiteral(target, mapping);
+        analyzeConstant(node);
       }
     }
 
     bool resolvedArguments = false;
     if (node.isOperator) {
       String operatorString = node.selector.asOperator().source.stringValue;
       if (identical(operatorString, 'is')) {
         DartType type =
             resolveTypeExpression(node.typeAnnotationFromIsCheckOrCast);
         if (type != null) {
@@ skipping 203 matching lines @@
   }
 
   visitLiteralSymbol(LiteralSymbol node) {
     world.registerInstantiatedClass(compiler.symbolClass, mapping);
     world.registerStaticUse(compiler.symbolConstructor.declaration);
     world.registerConstSymbol(node.slowNameString, mapping);
     if (!validateSymbol(node, node.slowNameString, reportError: false)) {
       compiler.reportError(node, MessageKind.UNSUPPORTED_LITERAL_SYMBOL,
                            {'value': node.slowNameString});
     }
+    analyzeConstant(node);
   }
 
   visitStringJuxtaposition(StringJuxtaposition node) {
     world.registerInstantiatedClass(compiler.stringClass, mapping);
     node.visitChildren(this);
   }
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       visit(link.head);
@@ skipping 65 matching lines @@
         redirectionTarget.computeSignature(compiler);
     FunctionSignature constructorSignature =
         constructor.computeSignature(compiler);
     if (!targetSignature.isCompatibleWith(constructorSignature)) {
       assert(!isSubtype);
       compiler.backend.registerThrowNoSuchMethod(mapping);
     }
 
     // Register a post process to check for cycles in the redirection chain and
     // set the actual generative constructor at the end of the chain.
-    compiler.enqueuer.resolution.addPostProcessAction(constructor, () {
+    addPostProcessAction(constructor, () {
       compiler.resolver.resolveRedirectionChain(constructor, node);
     });
 
     world.registerStaticUse(redirectionTarget);
     world.registerInstantiatedClass(
         redirectionTarget.enclosingElement.declaration, mapping);
     if (isSymbolConstructor) {
       compiler.backend.registerSymbolConstructor(mapping);
     }
   }
@@ skipping 82 matching lines @@
       world.registerFactoryWithTypeArguments(mapping);
     }
     if (constructor.isGenerativeConstructor() && cls.isAbstract(compiler)) {
       warning(node, MessageKind.ABSTRACT_CLASS_INSTANTIATION);
       compiler.backend.registerAbstractClassInstantiation(mapping);
     }
 
     if (isSymbolConstructor) {
       if (node.isConst()) {
         Node argumentNode = node.send.arguments.head;
-        Constant name = compiler.metadataHandler.compileNodeWithDefinitions(
+        Constant name = compiler.constantHandler.compileNodeWithDefinitions(
             argumentNode, mapping, isConst: true);
         if (!name.isString()) {
           DartType type = name.computeType(compiler);
           compiler.reportError(argumentNode, MessageKind.STRING_EXPECTED,
                                    {'type': type});
         } else {
           StringConstant stringConstant = name;
           String nameString = stringConstant.toDartString().slowToString();
           if (validateSymbol(argumentNode, nameString)) {
             world.registerConstSymbol(nameString, mapping);
           }
         }
       } else {
         if (!compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(
                 enclosingElement)) {
           compiler.reportHint(
               node.newToken, MessageKind.NON_CONST_BLOAT,
               {'name': compiler.symbolClass.name});
         }
         world.registerNewSymbol(mapping);
       }
     } else if (isMirrorsUsedConstant) {
       compiler.mirrorUsageAnalyzerTask.validate(node, mapping);
     }
+    if (node.isConst()) {
+      analyzeConstant(node);
+    }
 
     return null;
   }
 
+  void analyzeConstant(Node node) {
+    addPostProcessAction(enclosingElement, () {
+      mapping.setConstant(node,
+          compiler.constantHandler.compileNodeWithDefinitions(
+              node, mapping, isConst: true));
+    });
+  }
+
   bool validateSymbol(Node node, String name, {bool reportError: true}) {
     if (name.isEmpty) return true;
     if (name.startsWith('_')) {
       if (reportError) {
         compiler.reportError(node, MessageKind.PRIVATE_IDENTIFIER,
                              {'value': name});
       }
       return false;
     }
     if (!symbolValidationPattern.hasMatch(name)) {
@@ skipping 63 matching lines @@
       listType = new InterfaceType(compiler.listClass,
                                    new Link<DartType>.fromList([typeArgument]));
     } else {
       compiler.listClass.computeType(compiler);
       listType = compiler.listClass.rawType;
     }
     mapping.setType(node, listType);
     world.registerInstantiatedType(listType, mapping);
     compiler.backend.registerRequiredType(listType, enclosingElement);
     visit(node.elements);
+    if (node.isConst()) {
+      analyzeConstant(node);
+    }
   }
 
   visitConditional(Conditional node) {
     node.visitChildren(this);
   }
 
   visitStringInterpolation(StringInterpolation node) {
     world.registerInstantiatedClass(compiler.stringClass, mapping);
     compiler.backend.registerStringInterpolation(mapping);
     node.visitChildren(this);
@@ skipping 195 matching lines @@
       compiler.reportError(arguments,
           MessageKind.TYPE_VARIABLE_IN_CONSTANT);
     }
     mapping.setType(node, mapType);
     world.registerInstantiatedClass(compiler.mapClass, mapping);
     if (node.isConst()) {
       compiler.backend.registerConstantMap(mapping);
     }
     compiler.backend.registerRequiredType(mapType, enclosingElement);
     node.visitChildren(this);
+    if (node.isConst()) {
+      analyzeConstant(node);
+    }
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     node.visitChildren(this);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
 
   visitSwitchStatement(SwitchStatement node) {
     node.expression.accept(this);
 
     TargetElement breakElement = getOrCreateTargetElement(node);
     Map<String, LabelElement> continueLabels = <String, LabelElement>{};
     Link<Node> cases = node.cases.nodes;
     while (!cases.isEmpty) {
       SwitchCase switchCase = cases.head;
       for (Node labelOrCase in switchCase.labelsAndCases) {
-        if (labelOrCase is! Label) continue;
+        CaseMatch caseMatch = labelOrCase.asCaseMatch();
+        if (caseMatch != null) {
+          analyzeConstant(caseMatch.expression);
+          continue;
+        }
         Label label = labelOrCase;
         String labelName = label.slowToString();
 
         LabelElement existingElement = continueLabels[labelName];
         if (existingElement != null) {
           // It's an error if the same label occurs twice in the same switch.
           compiler.reportError(
               label,
               MessageKind.DUPLICATE_LABEL.error, {'labelName': labelName});
           compiler.reportInfo(
@@ skipping 185 matching lines @@
                 // generating multiple errors for the same cyclicity.
                 warning(typeNode.name, MessageKind.CYCLIC_TYPE_VARIABLE,
                     {'typeVariableName': variableElement.name});
               }
               break;
             }
             seenTypeVariables = seenTypeVariables.prepend(element);
             bound = element.bound;
           }
         }
-        compiler.enqueuer.resolution.addPostProcessAction(
-            element, checkTypeVariableBound);
+        addPostProcessAction(element, checkTypeVariableBound);
       } else {
         variableElement.bound = compiler.objectClass.computeType(compiler);
       }
       nodeLink = nodeLink.tail;
       typeLink = typeLink.tail;
     }
     assert(typeLink.isEmpty);
   }
 }
 
@@ skipping 19 matching lines @@
     signature.forEachParameter((Element element) {
       defineElement(element.parseNode(compiler), element);
     });
 
     element.alias = compiler.computeFunctionType(element, signature);
 
     void checkCyclicReference() {
       var visitor = new TypedefCyclicVisitor(compiler, element);
       type.accept(visitor, null);
     }
-    compiler.enqueuer.resolution.addPostProcessAction(element,
-                                                      checkCyclicReference);
+    addPostProcessAction(element, checkCyclicReference);
   }
 }
 
 // TODO(johnniwinther): Replace with a traversal on the AST when the type
 // annotations in typedef alias are stored in a [TreeElements] mapping.
 class TypedefCyclicVisitor extends DartTypeVisitor {
   final Compiler compiler;
   final TypedefElement element;
   bool hasCyclicReference = false;
 
@@ skipping 975 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }