Compute frontend/backend specific constants.

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;
   Setlet<Node> get superUses;
 
   /// Iterables of the dependencies that this [TreeElement] records of
   /// [currentElement].
   Iterable<Element> get allElements;
-  Iterable<Constant> get allConstants;
+  void forEachConstantNode(f(Node n, Constant c));
 
   /// A set of additional dependencies.  See [registerDependency] below.
   Setlet<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);
@@ skipping 213 matching lines @@
     Map<VariableElement, List<Node>> accessMap =
         accessedByClosureIn.putIfAbsent(contextNode,
           () => new Map<VariableElement, List<Node>>());
     accessMap.putIfAbsent(element, () => <Node>[]).add(accessNode);
   }
 
   String toString() => 'TreeElementMapping($currentElement)';
 
   Iterable<Element> get allElements => elements;
 
-  Iterable<Constant> get allConstants => constants.values;
+  void forEachConstantNode(f(Node n, Constant c)) => constants.forEach(f);
 }
 
 class ResolverTask extends CompilerTask {
-  ResolverTask(Compiler compiler) : super(compiler);
+  final ConstantCompiler constantCompiler;
+
+  ResolverTask(Compiler compiler, this.constantCompiler) : super(compiler);
 
   String get name => 'Resolver';
 
   TreeElements resolve(Element element) {
     return measure(() {
       if (Elements.isErroneousElement(element)) return null;
 
       for (MetadataAnnotation metadata in element.metadata) {
         metadata.ensureResolved(compiler);
       }
@@ skipping 313 matching lines @@
       compiler.reportError(element, MessageKind.CONST_WITHOUT_INITIALIZER);
     } else if (modifiers.isFinal() && !element.isInstanceMember()) {
       compiler.reportError(element, MessageKind.FINAL_WITHOUT_INITIALIZER);
     } else {
       compiler.enqueuer.resolution.registerInstantiatedClass(
           compiler.nullClass, visitor.mapping);
     }
 
     if (Elements.isStaticOrTopLevelField(element)) {
       visitor.addDeferredAction(element, () {
-        compiler.constantHandler.compileVariable(
-            element, isConst: element.modifiers.isConst());
+        if (element.modifiers.isConst()) {
+          constantCompiler.compileConstant(element);
+        } else {
+          constantCompiler.compileVariable(element);
+        }
       });
       if (initializer != null) {
         if (!element.modifiers.isConst()) {
           // TODO(johnniwinther): Determine the const-ness eagerly to avoid
           // unnecessary registrations.
           compiler.backend.registerLazyField(visitor.mapping);
         }
       }
     }
 
@@ skipping 52 matching lines @@
     }
 
     // [target] is now the actual target of the redirections.  Run through
     // the constructors again and set their [redirectionTarget], so that we
     // do not have to run the loop for these constructors again. Furthermore,
     // compute [redirectionTargetType] for each factory by computing the
     // substitution of the target type with respect to the factory type.
     while (!seen.isEmpty) {
       FunctionElementX factory = seen.removeLast();
 
-      TreeElements treeElements =
-          compiler.enqueuer.resolution.getCachedElements(factory);
+      // [factory] must already be analyzed but the [TreeElements] might not
+      // have been stored in the enqueuer cache yet.
+      // TODO(johnniwinther): Store [TreeElements] in the cache before
+      // resolution of the element.
+      TreeElements treeElements = factory.treeElements;
+      assert(invariant(node, treeElements != null,
+          message: 'No TreeElements cached for $factory.'));
       FunctionExpression functionNode = factory.parseNode(compiler);
       Return redirectionNode = functionNode.body;
       InterfaceType factoryType =
           treeElements.getType(redirectionNode.expression);
 
       targetType = targetType.substByContext(factoryType);
       factory.redirectionTarget = target;
       factory.redirectionTargetType = targetType;
     }
   }
@@ skipping 500 matching lines @@
       Node node = annotation.parseNode(compiler);
       // TODO(johnniwinther): Find the right analyzable element to hold the
       // [TreeElements] for the annotation.
       Element annotatedElement = annotation.annotatedElement;
       Element context = annotatedElement.enclosingElement;
       if (context == null) {
         context = annotatedElement;
       }
       ResolverVisitor visitor = visitorFor(context);
       node.accept(visitor);
-      annotation.value = compiler.constantHandler.compileNodeWithDefinitions(
-          node, visitor.mapping, isConst: true);
-      compiler.backend.registerMetadataConstant(annotation.value,
-                                                visitor.mapping);
-
+      annotation.value =
+          constantCompiler.compileMetadata(annotation, node, visitor.mapping);
+      // TODO(johnniwinther): Register the relation between the annotation
+      // and the annotated element instead. This will allow the backed to
+      // retrieve the backend constant and only registered metadata on the
+      // elements for which it is needed. (Issue 17732).
+      compiler.backend.registerMetadataConstant(
+          annotation.value, visitor.mapping);
       annotation.resolutionState = STATE_DONE;
     }));
   }
 
   error(Spannable node, MessageKind kind, [arguments = const {}]) {
     // TODO(ahe): Make non-fatal.
     compiler.reportFatalError(node, kind, arguments);
   }
 
   Link<MetadataAnnotation> resolveMetadata(Element element,
                                            VariableDefinitions node) {
     LinkBuilder<MetadataAnnotation> metadata =
         new LinkBuilder<MetadataAnnotation>();
     for (Metadata annotation in node.metadata.nodes) {
       ParameterMetadataAnnotation metadataAnnotation =
           new ParameterMetadataAnnotation(annotation);
       metadataAnnotation.annotatedElement = element;
       metadata.addLast(metadataAnnotation.ensureResolved(compiler));
     }
     return metadata.toLink();
   }
 }
 
-class ConstantMapper extends Visitor {
-  final Map<Constant, Node> constantToNodeMap = new Map<Constant, Node>();
-  final CompileTimeConstantEvaluator evaluator;
-
-  ConstantMapper(ConstantHandler handler,
-                 TreeElements elements,
-                 Compiler compiler)
-      : evaluator = new CompileTimeConstantEvaluator(
-          handler, elements, compiler, isConst: false);
-
-  visitNode(Node node) {
-    Constant constant = evaluator.evaluate(node);
-    if (constant != null) constantToNodeMap[constant] = node;
-    node.visitChildren(this);
-  }
-}
-
 class InitializerResolver {
   final ResolverVisitor visitor;
   final Map<Element, Node> initialized;
   Link<Node> initializers;
   bool hasSuper;
 
   InitializerResolver(this.visitor)
     : initialized = new Map<Element, Node>(), hasSuper = false;
 
   error(Node node, MessageKind kind, [arguments = const {}]) {
@@ skipping 964 matching lines @@
       // fields they reference are visible, but must be resolved independently.
       if (element.kind == ElementKind.FIELD_PARAMETER) {
         useElement(parameterNode, element);
       } else {
         defineElement(parameterNode, element);
       }
       parameterNodes = parameterNodes.tail;
     });
     addDeferredAction(enclosingElement, () {
       functionParameters.forEachOptionalParameter((Element parameter) {
-        compiler.constantHandler.compileConstant(parameter);
+        compiler.resolver.constantCompiler.compileConstant(parameter);
       });
     });
     if (inCheckContext) {
       functionParameters.forEachParameter((Element element) {
         compiler.enqueuer.resolution.registerIsCheck(
             element.computeType(compiler), mapping);
       });
     }
   }
 
@@ skipping 359 matching lines @@
         // type variable expression.
         mapping.setType(node, compiler.typeClass.computeType(compiler));
         world.registerTypeLiteral(target, mapping);
       } else if (target.impliesType() && (!sendIsMemberAccess || node.isCall)) {
         // 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);
 
         // Don't try to make constants of calls to type literals.
-        analyzeConstant(node, isConst: !node.isCall);
+        if (!node.isCall) {
+          analyzeConstant(node);
+        } else {
+          // The node itself is not a constant but we register the selector (the
+          // identifier that refers to the class/typedef) as a constant.
+          analyzeConstant(node.selector);
+        }
       }
       if (isPotentiallyMutableTarget(target)) {
         if (enclosingElement != target.enclosingElement) {
           for (Node scope in promotionScope) {
             mapping.setAccessedByClosureIn(scope, target, node);
           }
         }
       }
     }
 
@@ skipping 449 matching lines @@
       world.registerFactoryWithTypeArguments(mapping);
     }
     if (constructor.isGenerativeConstructor() && cls.isAbstract) {
       warning(node, MessageKind.ABSTRACT_CLASS_INSTANTIATION);
       compiler.backend.registerAbstractClassInstantiation(mapping);
     }
 
     if (isSymbolConstructor) {
       if (node.isConst()) {
         Node argumentNode = node.send.arguments.head;
-        Constant name = compiler.constantHandler.compileNodeWithDefinitions(
-            argumentNode, mapping, isConst: true);
+        Constant name = compiler.resolver.constantCompiler.compileNode(
+            argumentNode, mapping);
         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);
           }
@@ skipping 27 matching lines @@
       if (cls == compiler.stringClass) continue;
       Element equals = cls.lookupMember('==');
       if (equals.getEnclosingClass() != compiler.objectClass) {
         compiler.reportError(spannable,
                              MessageKind.CONST_MAP_KEY_OVERRIDES_EQUALS,
                              {'type': keyType});
       }
     }
   }
 
-  void analyzeConstant(Node node, {bool isConst: true}) {
+  void analyzeConstant(Node node) {
     addDeferredAction(enclosingElement, () {
-      Constant constant = compiler.constantHandler.compileNodeWithDefinitions(
-          node, mapping, isConst: isConst);
+      Constant constant =
+          compiler.resolver.constantCompiler.compileNode(node, mapping);
 
-      if (isConst && constant != null && constant.isMap) {
+      if (constant.isMap) {
         checkConstMapKeysDontOverrideEquals(node, constant);
       }
 
       // The type constant that is an argument to JS_INTERCEPTOR_CONSTANT names
       // a class that will be instantiated outside the program by attaching a
       // native class dispatch record referencing the interceptor.
       if (argumentsToJsInterceptorConstant != null &&
           argumentsToJsInterceptorConstant.contains(node)) {
         if (constant.isType) {
           TypeConstant typeConstant = constant;
@@ skipping 1329 matching lines @@
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       Identifier name = visit(link.head);
       VariableElement element = new VariableElementX(
           name.source, kind, resolver.enclosingElement,
           variables, name.token);
       resolver.defineElement(link.head, element);
       if (definitions.modifiers.isConst()) {
         compiler.enqueuer.resolution.addDeferredAction(element, () {
-          compiler.constantHandler.compileVariable(element, isConst: true);
+          compiler.resolver.constantCompiler.compileConstant(element);
         });
       }
     }
   }
 }
 
 class ConstructorResolver extends CommonResolverVisitor<Element> {
   final ResolverVisitor resolver;
   bool inConstContext;
   DartType type;
@@ skipping 186 matching lines @@
   TreeElements _treeElements;
 
   bool get hasTreeElements => _treeElements != null;
 
   TreeElements get treeElements {
     assert(invariant(this, _treeElements !=null,
         message: "TreeElements have not been computed for $this."));
     return _treeElements;
   }
 }