Use ConstExp for storing 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 'cps_ir/const_expression.dart';
+
 import 'dart2jslib.dart' show
     Compiler,
     CompilerTask,
     Constant,
     ConstantCompiler,
     ConstructedConstant,
     ListConstant,
     MessageKind,
     StringConstant,
     TreeElements,
@@ skipping 108 matching lines @@
   }
 
   /// 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;
       ConstantCompiler constantCompiler = compiler.resolver.constantCompiler;
-      Constant value = constantCompiler.compileNode(named.expression, mapping);
+      Constant value =
+          constantCompiler.compileNode(named.expression, mapping).value;
 
       MirrorUsageBuilder builder =
           new MirrorUsageBuilder(
               analyzer, mapping.analyzedElement.library, named.expression,
               value, mapping);
 
       if (named.name.source == 'symbols') {
         analyzer.cachedStrings[value] =
             builder.convertConstantToUsageList(value, onlyStrings: true);
       } else if (named.name.source == 'targets') {
@@ skipping 108 matching lines @@
   /// annotations are represented as [MirrorUsage].
   List<MirrorUsage> mirrorsUsedOnLibraryTag(LibraryElement library,
                                             Import tag) {
     LibraryElement importedLibrary = library.getLibraryFromTag(tag);
     if (importedLibrary != compiler.mirrorsLibrary) {
       return null;
     }
     List<MirrorUsage> result = <MirrorUsage>[];
     for (MetadataAnnotation metadata in tag.metadata) {
       metadata.ensureResolved(compiler);
-      Element element = metadata.value.computeType(compiler).element;
+      Element element = metadata.constant.value.computeType(compiler).element;
       if (element == compiler.mirrorsUsedClass) {
-        result.add(buildUsage(metadata.value));
+        result.add(buildUsage(metadata.constant.value));
       }
     }
     return result;
   }
 
   /// Merge all [MirrorUsage] instances accross all libraries.
   MirrorUsage mergeUsages(Map<LibraryElement, List<MirrorUsage>> usageMap) {
     Set<MirrorUsage> usagesToMerge = new Set<MirrorUsage>();
     usageMap.forEach((LibraryElement library, List<MirrorUsage> usages) {
       librariesWithUsage.add(library);
@@ skipping 277 matching lines @@
         cls.ensureResolved(compiler);
       }
       return scope.localLookup(name);
     }
     return null;
   }
 
   /// Attempt to find a [Spannable] corresponding to constant.
   Spannable positionOf(Constant constant) {
     Node node;
-    elements.forEachConstantNode((Node n, Constant c) {
-      if (node == null && c == constant) {
+    elements.forEachConstantNode((Node n, ConstExp c) {
+      if (node == null && c.value == 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;
   }
 }