Remove ConstantExpression.value

pkg/compiler/lib/src/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 'compile_time_constants.dart' show
     ConstantCompiler;
 import 'constants/expressions.dart';
 import 'constants/values.dart' show
@@ skipping 119 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;
       ConstantValue value =
-          constantCompiler.compileNode(named.expression, mapping).value;
+          constantCompiler.getConstantValue(
+              constantCompiler.compileNode(named.expression, mapping));
 
       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.constant.value.getType(compiler.coreTypes).element;
+      ConstantValue value =
+          compiler.constants.getConstantValue(metadata.constant);
+      Element element = value.getType(compiler.coreTypes).element;
       if (element == compiler.mirrorsUsedClass) {
-        result.add(buildUsage(metadata.constant.value));
+        result.add(buildUsage(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 278 matching lines @@
       }
       return scope.localLookup(name);
     }
     return null;
   }
 
   /// Attempt to find a [Spannable] corresponding to constant.
   Spannable positionOf(ConstantValue constant) {
     Node node;
     elements.forEachConstantNode((Node n, ConstantExpression c) {
-      if (node == null && c.value == constant) {
+      if (node == null && compiler.constants.getConstantValue(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;
   }
 }