Compute frontend/backend specific constants.

sdk/lib/_internal/compiler/implementation/resolution/members.dart

Index: sdk/lib/_internal/compiler/implementation/resolution/members.dart
diff --git a/sdk/lib/_internal/compiler/implementation/resolution/members.dart b/sdk/lib/_internal/compiler/implementation/resolution/members.dart
index 51a468952ef8fb65b1469bf056f39ae43fe1162e..c87f1877849d09cf4371feea73decc5ce7f4b6c1 100644
--- a/sdk/lib/_internal/compiler/implementation/resolution/members.dart
+++ b/sdk/lib/_internal/compiler/implementation/resolution/members.dart
@@ -11,7 +11,7 @@ abstract class TreeElements {
   /// 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;
@@ -245,11 +245,13 @@ class TreeElementMapping implements TreeElements {
 
   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';
 
@@ -580,8 +582,11 @@ class ResolverTask extends CompilerTask {
 
     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()) {
@@ -1176,11 +1181,14 @@ class ResolverTask extends CompilerTask {
       }
       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;
     }));
   }
@@ -1204,23 +1212,6 @@ class ResolverTask extends CompilerTask {
   }
 }
 
-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;
@@ -2204,7 +2195,7 @@ class ResolverVisitor extends MappingVisitor<Element> {
     });
     addDeferredAction(enclosingElement, () {
       functionParameters.forEachOptionalParameter((Element parameter) {
-        compiler.constantHandler.compileConstant(parameter);
+        compiler.resolver.constantCompiler.compileConstant(parameter);
       });
     });
     if (inCheckContext) {
@@ -2584,7 +2575,13 @@ class ResolverVisitor extends MappingVisitor<Element> {
         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) {
@@ -3054,8 +3051,8 @@ class ResolverVisitor extends MappingVisitor<Element> {
     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,
@@ -3103,12 +3100,12 @@ class ResolverVisitor extends MappingVisitor<Element> {
     }
   }
 
-  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);
       }
 
@@ -4458,7 +4455,7 @@ class VariableDefinitionsVisitor extends CommonResolverVisitor<Identifier> {
       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);
         });
       }
     }