Rename Constant to ConstantValue and ConstExp to ConstantExpression.

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

 // Copyright (c) 2014, 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 deferred_load;
 
 import 'constants/expressions.dart';
 import 'constants/values.dart' show
-    Constant,
-    ConstructedConstant,
-    DeferredConstant,
-    StringConstant;
+    ConstantValue,
+    ConstructedConstantValue,
+    DeferredConstantValue,
+    StringConstantValue;
 
 import 'dart2jslib.dart' show
     Backend,
     Compiler,
     CompilerTask,
     invariant,
     MessageKind;
 
 import 'dart_backend/dart_backend.dart' show
     DartBackend;
@@ skipping 107 matching lines @@
       new Map<String, List<OutputUnit>>();
   final Map<Import, String> importDeferName = new Map<Import, String>();
 
   /// A mapping from elements and constants to their output unit. Query this via
   /// [outputUnitForElement]
   final Map<Element, OutputUnit> _elementToOutputUnit =
       new Map<Element, OutputUnit>();
 
   /// A mapping from constants to their output unit. Query this via
   /// [outputUnitForConstant]
-  final Map<Constant, OutputUnit> _constantToOutputUnit =
-      new Map<Constant, OutputUnit>();
+  final Map<ConstantValue, OutputUnit> _constantToOutputUnit =
+      new Map<ConstantValue, OutputUnit>();
 
   /// All the imports with a [DeferredLibrary] annotation, mapped to the
   /// [LibraryElement] they import.
   /// The main library is included in this set for convenience.
   final Map<Import, LibraryElement> _allDeferredImports =
       new Map<Import, LibraryElement>();
 
   // For each deferred import we want to know exactly what elements have to
   // be loaded.
   Map<Import, Set<Element>> _importedDeferredBy = null;
-  Map<Import, Set<Constant>> _constantsDeferredBy = null;
+  Map<Import, Set<ConstantValue>> _constantsDeferredBy = null;
 
   Set<Element> _mainElements = new Set<Element>();
 
   DeferredLoadTask(Compiler compiler) : super(compiler) {
     mainOutputUnit.imports.add(_fakeMainImport);
   }
 
   Backend get backend => compiler.backend;
 
   /// Returns the [OutputUnit] where [element] belongs.
@@ skipping 10 matching lines @@
       if (element.enclosingElement == null) {
         _elementToOutputUnit[element] = mainOutputUnit;
         break;
       }
       element = element.enclosingElement.implementation;
     }
     return _elementToOutputUnit[element];
   }
 
   /// Returns the [OutputUnit] where [constant] belongs.
-  OutputUnit outputUnitForConstant(Constant constant) {
+  OutputUnit outputUnitForConstant(ConstantValue constant) {
     if (!isProgramSplit) return mainOutputUnit;
 
     return _constantToOutputUnit[constant];
   }
 
   bool isDeferred(Element element) {
     return outputUnitForElement(element) != mainOutputUnit;
   }
 
   /// Returns true if e1 and e2 are in the same output unit.
   bool inSameOutputUnit(Element e1, Element e2) {
     return outputUnitForElement(e1) == outputUnitForElement(e2);
   }
 
-  void registerConstantDeferredUse(DeferredConstant constant,
+  void registerConstantDeferredUse(DeferredConstantValue constant,
                                    PrefixElement prefix) {
     OutputUnit outputUnit = new OutputUnit();
     outputUnit.imports.add(prefix.deferredImport);
     _constantToOutputUnit[constant] = outputUnit;
   }
 
   /// Answers whether [element] is explicitly deferred when referred to from
   /// [library].
   bool _isExplicitlyDeferred(Element element, LibraryElement library) {
     Link<Import> imports = _getImports(element, library);
@@ skipping 18 matching lines @@
     return library.getImportsFor(element);
   }
 
   /// Finds all elements and constants that [element] depends directly on.
   /// (not the transitive closure.)
   ///
   /// Adds the results to [elements] and [constants].
   void _collectAllElementsAndConstantsResolvedFrom(
       Element element,
       Set<Element> elements,
-      Set<Constant> constants,
+      Set<ConstantValue> constants,
       isMirrorUsage) {
 
     /// Recursively add the constant and its dependencies to [constants].
-    void addConstants(Constant constant) {
+    void addConstants(ConstantValue constant) {
       if (constants.contains(constant)) return;
       constants.add(constant);
-      if (constant is ConstructedConstant) {
+      if (constant is ConstructedConstantValue) {
         elements.add(constant.type.element);
       }
       constant.getDependencies().forEach(addConstants);
     }
 
     /// Collects all direct dependencies of [element].
     ///
     /// The collected dependent elements and constants are are added to
     /// [elements] and [constants] respectively.
     void collectDependencies(Element element) {
@@ skipping 23 matching lines @@
       treeElements.forEachConstantNode((Node node, _) {
         // Explicitly depend on the backend constants.
         addConstants(
             backend.constants.getConstantForNode(node, treeElements).value);
       });
       elements.addAll(treeElements.otherDependencies);
     }
 
     // TODO(sigurdm): How is metadata on a patch-class handled?
     for (MetadataAnnotation metadata in element.metadata) {
-      ConstExp constant = backend.constants.getConstantForMetadata(metadata);
+      ConstantExpression constant = backend.constants.getConstantForMetadata(metadata);
       if (constant != null) {
         addConstants(constant.value);
       }
     }
     if (element.isClass) {
       // If we see a class, add everything its live instance members refer
       // to.  Static members are not relevant, unless we are processing
       // extra dependencies due to mirrors.
       void addLiveInstanceMember(Element element) {
         if (!compiler.enqueuer.resolution.isLive(element)) return;
@@ skipping 60 matching lines @@
     return result;
   }
 
   /// Recursively traverses the graph of dependencies from [element], mapping
   /// deferred imports to each dependency it needs in the sets
   /// [_importedDeferredBy] and [_constantsDeferredBy].
   void _mapDependencies(Element element, Import import,
                         {isMirrorUsage: false}) {
     Set<Element> elements = _importedDeferredBy.putIfAbsent(import,
         () => new Set<Element>());
-    Set<Constant> constants = _constantsDeferredBy.putIfAbsent(import,
-        () => new Set<Constant>());
+    Set<ConstantValue> constants = _constantsDeferredBy.putIfAbsent(import,
+        () => new Set<ConstantValue>());
 
     // Only process elements once, unless we are doing dependencies due to
     // mirrors, which are added in additional traversals.
     if (!isMirrorUsage && elements.contains(element)) return;
     // Anything used directly by main will be loaded from the start
     // We do not need to traverse it again.
     if (import != _fakeMainImport && _mainElements.contains(element)) return;
 
     // Here we modify [_importedDeferredBy].
     elements.add(element);
@@ skipping 33 matching lines @@
     }
 
     // For each deferred import we analyze all elements reachable from the
     // imported library through non-deferred imports.
     handleLibrary(LibraryElement library, Import deferredImport) {
       library.implementation.forEachLocalMember((Element element) {
         mapDependenciesIfResolved(element, deferredImport);
       });
 
       for (MetadataAnnotation metadata in library.metadata) {
-        ConstExp constant =
+        ConstantExpression constant =
             backend.constants.getConstantForMetadata(metadata);
         if (constant != null) {
           _mapDependencies(constant.value.computeType(compiler).element,
               deferredImport);
         }
       }
       for (LibraryTag tag in library.tags) {
         for (MetadataAnnotation metadata in tag.metadata) {
-          ConstExp constant =
+          ConstantExpression constant =
               backend.constants.getConstantForMetadata(metadata);
           if (constant != null) {
             _mapDependencies(constant.value.computeType(compiler).element,
                 deferredImport);
           }
         }
       }
     }
 
     for (Import deferredImport in _allDeferredImports.keys) {
@@ skipping 16 matching lines @@
       String result;
       if (import == _fakeMainImport) {
         result = "main";
       } else if (import.isDeferred) {
         result = import.prefix.toString();
       } else {
         Link<MetadataAnnotation> metadatas = import.metadata;
         assert(metadatas != null);
         for (MetadataAnnotation metadata in metadatas) {
           metadata.ensureResolved(compiler);
           Element element = metadata.constant.value.computeType(compiler).element;

[sigurdm, 2014/10/01 07:46:47]

Not your code, but long line

[Johnni Winther, 2014/10/01 08:21:23]

Done.

           if (element == deferredLibraryClass) {
-            ConstructedConstant constant = metadata.constant.value;
-            StringConstant s = constant.fields[0];
-            result = s.value.slowToString();
+            ConstructedConstantValue constant = metadata.constant.value;
+            StringConstantValue s = constant.fields[0];
+            result = s.primitiveValue.slowToString();
             break;
           }
         }
       }
       assert(result != null);
       importDeferName[import] = makeUnique(result, usedImportNames);;
     }
 
     int counter = 1;
 
@@ skipping 39 matching lines @@
   }
 
   void onResolutionComplete(FunctionElement main) {
     if (!isProgramSplit) {
       allOutputUnits.add(mainOutputUnit);
       return;
     }
     if (main == null) return;
     LibraryElement mainLibrary = main.library;
     _importedDeferredBy = new Map<Import, Set<Element>>();
-    _constantsDeferredBy = new Map<Import, Set<Constant>>();
+    _constantsDeferredBy = new Map<Import, Set<ConstantValue>>();
     _importedDeferredBy[_fakeMainImport] = _mainElements;
 
     measureElement(mainLibrary, () {
 
       // Starting from main, traverse the program and find all dependencies.
       _mapDependencies(compiler.mainFunction, _fakeMainImport);
 
       // Also add "global" dependencies to the main OutputUnit.  These are
       // things that the backend need but cannot associate with a particular
       // element, for example, startRootIsolate.  This set also contains
       // elements for which we lack precise information.
       for (Element element in compiler.globalDependencies.otherDependencies) {
         _mapDependencies(element, _fakeMainImport);
       }
 
       // Now check to see if we have to add more elements due to mirrors.
       if (compiler.mirrorsLibrary != null) {
         _addMirrorElements();
       }
 
       // Build the OutputUnits using these two maps.
       Map<Element, OutputUnit> elementToOutputUnitBuilder =
           new Map<Element, OutputUnit>();
-      Map<Constant, OutputUnit> constantToOutputUnitBuilder =
-          new Map<Constant, OutputUnit>();
+      Map<ConstantValue, OutputUnit> constantToOutputUnitBuilder =
+          new Map<ConstantValue, OutputUnit>();
 
       // Reverse the mappings. For each element record an OutputUnit collecting
       // all deferred imports mapped to this element. Same for constants.
       for (Import import in _importedDeferredBy.keys) {
         for (Element element in _importedDeferredBy[import]) {
           // Only one file should be loaded when the program starts, so make
           // sure that only one OutputUnit is created for [fakeMainImport].
           if (import == _fakeMainImport) {
             elementToOutputUnitBuilder[element] = mainOutputUnit;
           } else {
             elementToOutputUnitBuilder
                 .putIfAbsent(element, () => new OutputUnit())
                 .imports.add(import);
           }
         }
-        for (Constant constant in _constantsDeferredBy[import]) {
+        for (ConstantValue constant in _constantsDeferredBy[import]) {
           // Only one file should be loaded when the program starts, so make
           // sure that only one OutputUnit is created for [fakeMainImport].
           if (import == _fakeMainImport) {
             constantToOutputUnitBuilder[constant] = mainOutputUnit;
           } else {
             constantToOutputUnitBuilder
                 .putIfAbsent(constant, () => new OutputUnit())
                 .imports.add(import);
           }
         }
       }
 
       // Release maps;
       _importedDeferredBy = null;
       _constantsDeferredBy = null;
 
       // Find all the output units elements/constants have been mapped to, and
       // canonicalize them.
       elementToOutputUnitBuilder.forEach(
           (Element element, OutputUnit outputUnit) {
         OutputUnit representative = allOutputUnits.lookup(outputUnit);
         if (representative == null) {
           representative = outputUnit;
           allOutputUnits.add(representative);
         }
         _elementToOutputUnit[element] = representative;
       });
       constantToOutputUnitBuilder.forEach(
-          (Constant constant, OutputUnit outputUnit) {
+          (ConstantValue constant, OutputUnit outputUnit) {
         OutputUnit representative = allOutputUnits.lookup(outputUnit);
         if (representative == null) {
           representative = outputUnit;
           allOutputUnits.add(representative);
         }
         _constantToOutputUnit[constant] = representative;
       });
 
       // Generate a unique name for each OutputUnit.
       _assignNamesToOutputUnits(allOutputUnits);
@@ skipping 140 matching lines @@
     Element maybePrefix = elements[identifier];
     if (maybePrefix != null && maybePrefix.isPrefix) {
       PrefixElement prefixElement = maybePrefix;
       if (prefixElement.isDeferred) {
         return prefixElement;
       }
     }
     return null;
   }
 }