Use the entity model for dump_info.

pkg/compiler/lib/src/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 'dart:collection' show Queue;
 
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
@@ skipping 115 matching lines @@
   /// lib1_lib2_lib2 should be loaded, then the hunks lib1_lib2 and lib1_lib3
   /// can be loaded in parallel. And finally lib1 can be loaded.
   final Map<String, List<OutputUnit>> hunksToLoad =
       new Map<String, List<OutputUnit>>();
 
   /// A cache of the result of calling `computeImportDeferName` on the keys of
   /// this map.
   final Map<ImportElement, String> _importDeferName = <ImportElement, String>{};
 
   /// A mapping from elements and constants to their output unit. Query this via
-  /// [outputUnitForElement]
+  /// [outputUnitForEntity]
   final Map<Entity, ImportSet> _elementToSet = new Map<Entity, ImportSet>();
 
   /// A mapping from constants to their output unit. Query this via
   /// [outputUnitForConstant]
   final Map<ConstantValue, ImportSet> _constantToSet =
       new Map<ConstantValue, ImportSet>();
 
   Iterable<ImportElement> get _allDeferredImports =>
       _deferredImportDescriptions.keys;
 
@@ skipping 11 matching lines @@
         super(compiler.measurer) {
     mainOutputUnit = new OutputUnit(true, 'main', new Set<ImportElement>());
     importSets.mainSet.unit = mainOutputUnit;
     allOutputUnits.add(mainOutputUnit);
   }
 
   JavaScriptBackend get backend => compiler.backend;
   DiagnosticReporter get reporter => compiler.reporter;
 
   /// Returns the [OutputUnit] where [element] belongs.
-  OutputUnit outputUnitForElement(Entity entity) {
+  OutputUnit outputUnitForEntity(Entity entity) {
     // TODO(johnniwinther): Support use of entities by splitting maps by
     // entity kind.
     if (!isProgramSplit) return mainOutputUnit;
     Element element = entity;
     element = element.implementation;
     while (!_elementToSet.containsKey(element)) {
       // TODO(21051): workaround: it looks like we output annotation constants
       // for classes that we don't include in the output. This seems to happen
       // when we have reflection but can see that some classes are not needed.
       // We still add the annotation but don't run through it below (where we
       // assign every element to its output unit).
       if (element.enclosingElement == null) {
         _elementToSet[element] = importSets.mainSet;
         break;
       }
       element = element.enclosingElement.implementation;
     }
     return _elementToSet[element].unit;
   }
 
   /// Returns the [OutputUnit] where [element] belongs.
   OutputUnit outputUnitForClass(ClassEntity element) {
-    return outputUnitForElement(element);
+    return outputUnitForEntity(element);
   }
 
   /// Returns the [OutputUnit] where [element] belongs.
   OutputUnit outputUnitForMember(MemberEntity element) {
-    return outputUnitForElement(element);
+    return outputUnitForEntity(element);
   }
 
   /// Direct access to the output-unit to element relation used for testing.
   OutputUnit getOutputUnitForElementForTesting(Entity element) {
     return _elementToSet[element]?.unit;
   }
 
   /// Returns the [OutputUnit] where [constant] belongs.
   OutputUnit outputUnitForConstant(ConstantValue constant) {
     if (!isProgramSplit) return mainOutputUnit;
     return _constantToSet[constant]?.unit;
   }
 
   /// Direct access to the output-unit to constants map used for testing.
   Iterable<ConstantValue> get constantsForTesting => _constantToSet.keys;
 
   bool isDeferred(Entity element) {
-    return outputUnitForElement(element) != mainOutputUnit;
+    return outputUnitForEntity(element) != mainOutputUnit;
   }
 
   bool isDeferredClass(ClassEntity element) {
-    return outputUnitForElement(element) != mainOutputUnit;
+    return outputUnitForEntity(element) != mainOutputUnit;
   }
 
   /// Returns the unique name for the deferred import of [prefix].
   String getImportDeferName(Spannable node, PrefixElement prefix) {
     String name = _importDeferName[prefix.deferredImport];
     if (name == null) {
       reporter.internalError(node, "No deferred name for $prefix.");
     }
     return name;
   }
 
   /// Returns the names associated with each deferred import in [unit].
   Iterable<String> getImportNames(OutputUnit unit) {
     return unit._imports.map((i) => _importDeferName[i]);
   }
 
   /// Returns `true` if element [to] is reachable from element [from] without
   /// crossing a deferred import.
   ///
   /// For example, if we have two deferred libraries `A` and `B` that both
   /// import a library `C`, then even though elements from `A` and `C` end up in
   /// different output units, there is a non-deferred path between `A` and `C`.
   bool hasOnlyNonDeferredImportPaths(Entity from, Entity to) {
-    OutputUnit outputUnitFrom = outputUnitForElement(from);
-    OutputUnit outputUnitTo = outputUnitForElement(to);
+    OutputUnit outputUnitFrom = outputUnitForEntity(from);
+    OutputUnit outputUnitTo = outputUnitForEntity(to);
     if (outputUnitTo == mainOutputUnit) return true;
     if (outputUnitFrom == mainOutputUnit) return false;
     return outputUnitTo._imports.containsAll(outputUnitFrom._imports);
   }
 
   void registerConstantDeferredUse(
       DeferredConstantValue constant, PrefixElement prefix) {
     var newSet = importSets.singleton(prefix.deferredImport);
     assert(
         _constantToSet[constant] == null || _constantToSet[constant] == newSet);
@@ skipping 1131 matching lines @@
         ConstructedConstantValue constant = value;
         StringConstantValue s = constant.fields.values.single;
         result = s.primitiveValue;
         break;
       }
     }
   }
   assert(result != null);
   return result;
 }