Compute frontend/backend specific constants.

sdk/lib/_internal/compiler/implementation/mirrors_used.dart

 // Copyright (c) 2013, 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.mirrors_used;
 
 import 'dart2jslib.dart' show
     Compiler,
     CompilerTask,
     Constant,
+    ConstantCompiler,
     ConstructedConstant,
     ListConstant,
     MessageKind,
     StringConstant,
     TreeElements,
     TypeConstant,
     invariant;
 
 import 'elements/elements.dart' show
     ClassElement,
@@ skipping 105 matching lines @@
             && librariesWithUsage.contains(library));
   }
 
   /// Call-back from the resolver to analyze MirorsUsed annotations. The result
   /// is stored in [analyzer] and later used to compute
   /// [:analyzer.mergedMirrorUsage:].
   void validate(NewExpression node, TreeElements mapping) {
     for (Node argument in node.send.arguments) {
       NamedArgument named = argument.asNamedArgument();
       if (named == null) continue;
-      Constant value = compiler.constantHandler.compileNodeWithDefinitions(
-          named.expression, mapping, isConst: true);
-
-      ConstantMapper mapper =
-          new ConstantMapper(compiler.constantHandler, mapping, compiler);
-      named.expression.accept(mapper);
+      ConstantCompiler constantCompiler = compiler.resolver.constantCompiler;
+      Constant value = constantCompiler.compileNode(named.expression, mapping);
 
       MirrorUsageBuilder builder =
           new MirrorUsageBuilder(
               analyzer, mapping.currentElement.getLibrary(), named.expression,
-              value, mapper.constantToNodeMap);
+              value, mapping);
 
       if (named.name.source == 'symbols') {
         analyzer.cachedStrings[value] =
             builder.convertConstantToUsageList(value, onlyStrings: true);
       } else if (named.name.source == 'targets') {
         analyzer.cachedElements[value] =
             builder.resolveUsageList(builder.convertConstantToUsageList(value));
       } else if (named.name.source == 'metaTargets') {
         analyzer.cachedElements[value] =
             builder.resolveUsageList(builder.convertConstantToUsageList(value));
@@ skipping 210 matching lines @@
         ')';
 
   }
 }
 
 class MirrorUsageBuilder {
   final MirrorUsageAnalyzer analyzer;
   final LibraryElement enclosingLibrary;
   final Spannable spannable;
   final Constant constant;
-  final Map<Constant, Node> constantToNodeMap;
+  final TreeElements elements;
 
   MirrorUsageBuilder(
       this.analyzer,
       this.enclosingLibrary,
       this.spannable,
       this.constant,
-      this.constantToNodeMap);
+      this.elements);
 
   Compiler get compiler => analyzer.compiler;
 
   /// Convert a constant to a list of [String] and [Type] values. If the
   /// constant is a single [String], it is assumed to be a comma-separated list
   /// of qualified names. If the constant is a [Type] t, the result is [:[t]:].
   /// Otherwise, the constant is assumed to represent a list of strings (each a
   /// qualified name) and types, and such a list is constructed.  If
   /// [onlyStrings] is true, the returned list is a [:List<String>:] and any
   /// [Type] values are treated as an error (meaning that the value is ignored
@@ skipping 164 matching lines @@
         ClassElement cls = element;
         cls.ensureResolved(compiler);
       }
       return scope.localLookup(name);
     }
     return null;
   }
 
   /// Attempt to find a [Spannable] corresponding to constant.
   Spannable positionOf(Constant constant) {
-    Node node = constantToNodeMap[constant];
+    Node node;
+    elements.forEachConstantNode((Node n, Constant c) {
+      if (node == null && c == constant) {
+        node = n;
+      }
+    });
     if (node == null) {
       // TODO(ahe): Returning [spannable] here leads to confusing error
       // messages.  For example, consider:
       // @MirrorsUsed(targets: fisk)
       // import 'dart:mirrors';
       //
       // const fisk = const [main];
       //
       // main() {}
       //
       // The message is:
       // example.dart:1:23: Hint: Can't use 'fisk' here because ...
       // Did you forget to add quotes?
       // @MirrorsUsed(targets: fisk)
       //                       ^^^^
       //
       // Instead of saying 'fisk' should pretty print the problematic constant
       // value.
       return spannable;
     }
     return node;
   }
 }