Rename Constant to ConstantValue and ConstExp to ConstantExpression.

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 'constants/expressions.dart';
 import 'constants/values.dart' show
-    Constant,
-    ConstructedConstant,
-    ListConstant,
-    StringConstant,
-    TypeConstant;
+    ConstantValue,
+    ConstructedConstantValue,
+    ListConstantValue,
+    StringConstantValue,
+    TypeConstantValue;
 
 import 'dart_types.dart' show
     DartType,
     InterfaceType,
     TypeKind;
 
 import 'dart2jslib.dart' show
     Compiler,
     CompilerTask,
     ConstantCompiler,
@@ skipping 104 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 =
+      ConstantValue 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') {
         analyzer.cachedElements[value] =
             builder.resolveUsageList(builder.convertConstantToUsageList(value));
       } else if (named.name.source == 'metaTargets') {
         analyzer.cachedElements[value] =
             builder.resolveUsageList(builder.convertConstantToUsageList(value));
       } else if (named.name.source == 'override') {
         analyzer.cachedElements[value] =
             builder.resolveUsageList(builder.convertConstantToUsageList(value));
       }
     }
   }
 }
 
 class MirrorUsageAnalyzer {
   final Compiler compiler;
   final MirrorUsageAnalyzerTask task;
   List<LibraryElement> wildcard;
   final Set<LibraryElement> librariesWithUsage;
-  final Map<Constant, List<String>> cachedStrings;
-  final Map<Constant, List<Element>> cachedElements;
+  final Map<ConstantValue, List<String>> cachedStrings;
+  final Map<ConstantValue, List<Element>> cachedElements;
   MirrorUsage mergedMirrorUsage;
 
   MirrorUsageAnalyzer(Compiler compiler, this.task)
       : compiler = compiler,
         librariesWithUsage = new Set<LibraryElement>(),
-        cachedStrings = new Map<Constant, List<String>>(),
-        cachedElements = new Map<Constant, List<Element>>();
+        cachedStrings = new Map<ConstantValue, List<String>>(),
+        cachedElements = new Map<ConstantValue, List<Element>>();
 
   /// Collect and merge all @MirrorsUsed annotations. As a side-effect, also
   /// compute which libraries have the annotation (which is used by
   /// [MirrorUsageAnalyzerTask.hasMirrorUsage]).
   void run() {
     wildcard = compiler.libraryLoader.libraries.toList();
     Map<LibraryElement, List<MirrorUsage>> usageMap =
         collectMirrorsUsedAnnotation();
     propagateOverrides(usageMap);
     Set<LibraryElement> librariesWithoutUsage = new Set<LibraryElement>();
@@ skipping 132 matching lines @@
     if (metaTargets == null) {
       metaTargets = b.metaTargets;
     } else if (metaTargets != wildcard && b.metaTargets != null) {
       metaTargets.addAll(b.metaTargets);
     }
     return new MirrorUsage(symbols, targets, metaTargets, null);
   }
 
   /// Convert a [constant] to an instance of [MirrorUsage] using information
   /// that was resolved during [MirrorUsageAnalyzerTask.validate].
-  MirrorUsage buildUsage(ConstructedConstant constant) {
-    Map<Element, Constant> fields = constant.fieldElements;
+  MirrorUsage buildUsage(ConstructedConstantValue constant) {
+    Map<Element, ConstantValue> fields = constant.fieldElements;
     VariableElement symbolsField = compiler.mirrorsUsedClass.lookupLocalMember(
         'symbols');
     VariableElement targetsField = compiler.mirrorsUsedClass.lookupLocalMember(
         'targets');
     VariableElement metaTargetsField =
         compiler.mirrorsUsedClass.lookupLocalMember(
             'metaTargets');
     VariableElement overrideField = compiler.mirrorsUsedClass.lookupLocalMember(
         'override');
 
@@ skipping 23 matching lines @@
         'override = $override'
         ')';
 
   }
 }
 
 class MirrorUsageBuilder {
   final MirrorUsageAnalyzer analyzer;
   final LibraryElement enclosingLibrary;
   final Spannable spannable;
-  final Constant constant;
+  final ConstantValue constant;
   final TreeElements elements;
 
   MirrorUsageBuilder(
       this.analyzer,
       this.enclosingLibrary,
       this.spannable,
       this.constant,
       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
   /// and a hint is emitted).
   List convertConstantToUsageList(
-      Constant constant, { bool onlyStrings: false }) {
+      ConstantValue constant, { bool onlyStrings: false }) {
     if (constant.isNull) {
       return null;
     } else if (constant.isList) {
-      ListConstant list = constant;
+      ListConstantValue list = constant;
       List result = onlyStrings ? <String> [] : [];
-      for (Constant entry in list.entries) {
+      for (ConstantValue entry in list.entries) {
         if (entry.isString) {
-          StringConstant string = entry;
-          result.add(string.value.slowToString());
+          StringConstantValue string = entry;
+          result.add(string.primitiveValue.slowToString());
         } else if (!onlyStrings && entry.isType) {
-          TypeConstant type = entry;
+          TypeConstantValue type = entry;
           result.add(type.representedType);
         } else {
           Spannable node = positionOf(entry);
           MessageKind kind = onlyStrings
               ? MessageKind.MIRRORS_EXPECTED_STRING
               : MessageKind.MIRRORS_EXPECTED_STRING_OR_TYPE;
           compiler.reportHint(
               node,
               kind, {'name': node, 'type': apiTypeOf(entry)});
         }
       }
       return result;
     } else if (!onlyStrings && constant.isType) {
-      TypeConstant type = constant;
+      TypeConstantValue type = constant;
       return [type.representedType];
     } else if (constant.isString) {
-      StringConstant string = constant;
+      StringConstantValue string = constant;
       var iterable =
-          string.value.slowToString().split(',').map((e) => e.trim());
+          string.primitiveValue.slowToString().split(',').map((e) => e.trim());
       return onlyStrings ? new List<String>.from(iterable) : iterable.toList();
     } else {
       Spannable node = positionOf(constant);
       MessageKind kind = onlyStrings
           ? MessageKind.MIRRORS_EXPECTED_STRING_OR_LIST
           : MessageKind.MIRRORS_EXPECTED_STRING_TYPE_OR_LIST;
       compiler.reportHint(
           node,
           kind, {'name': node, 'type': apiTypeOf(constant)});
       return null;
     }
   }
 
   /// Find the first non-implementation interface of constant.
-  DartType apiTypeOf(Constant constant) {
+  DartType apiTypeOf(ConstantValue constant) {
     DartType type = constant.computeType(compiler);
     LibraryElement library = type.element.library;
     if (type.isInterfaceType && library.isInternalLibrary) {
       InterfaceType interface = type;
       ClassElement cls = type.element;
       cls.ensureResolved(compiler);
       for (DartType supertype in cls.allSupertypes) {
         if (supertype.isInterfaceType
             && !supertype.element.library.isInternalLibrary) {
           return interface.asInstanceOf(supertype.element);
@@ skipping 105 matching lines @@
       if (element.isClass) {
         ClassElement cls = element;
         cls.ensureResolved(compiler);
       }
       return scope.localLookup(name);
     }
     return null;
   }
 
   /// Attempt to find a [Spannable] corresponding to constant.
-  Spannable positionOf(Constant constant) {
+  Spannable positionOf(ConstantValue constant) {
     Node node;
-    elements.forEachConstantNode((Node n, ConstExp c) {
+    elements.forEachConstantNode((Node n, ConstantExpression 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;
   }
 }