Use entities in most of MirrorsData

pkg/compiler/lib/src/kernel/element_map_impl.dart

 // Copyright (c) 2017, 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.kernel.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 66 matching lines @@
 
   List<LibraryEntity> _libraryList = <LibraryEntity>[];
   List<ClassEntity> _classList = <ClassEntity>[];
   List<MemberEntity> _memberList = <MemberEntity>[];
   List<TypeVariableEntity> _typeVariableList = <TypeVariableEntity>[];
 
   /// List of library environments by `IndexedLibrary.libraryIndex`. This is
   /// used for fast lookup into library classes and members.
   List<LibraryEnv> _libraryEnvs = <LibraryEnv>[];
 
+  /// List of library data by `IndexedLibrary.libraryIndex`. This is used for
+  /// fast lookup into library properties.
+  List<LibraryData> _libraryData = <LibraryData>[];
+
   /// List of class environments by `IndexedClass.classIndex`. This is used for
   /// fast lookup into class members.
   List<ClassEnv> _classEnvs = <ClassEnv>[];
 
   /// List of class data by `IndexedClass.classIndex`. This is used for
   /// fast lookup into class properties.
   List<ClassData> _classData = <ClassData>[];
 
   /// List of member data by `IndexedMember.memberIndex`. This is used for
   /// fast lookup into member properties.
@@ skipping 504 matching lines @@
     assert(checkFamily(cls));
     return _classEnvs[cls.classIndex].cls;
   }
 }
 
 /// Mixin that implements the abstract methods in [KernelToElementMapBase].
 abstract class ElementCreatorMixin {
   ProgramEnv get _env;
   List<LibraryEntity> get _libraryList;
   List<LibraryEnv> get _libraryEnvs;
+  List<LibraryData> get _libraryData;
   List<ClassEntity> get _classList;
   List<ClassEnv> get _classEnvs;
   List<ClassData> get _classData;
   List<MemberEntity> get _memberList;
   List<MemberData> get _memberData;
   List<TypeVariableEntity> get _typeVariableList;
 
   Map<ir.Library, IndexedLibrary> _libraryMap = <ir.Library, IndexedLibrary>{};
   Map<ir.Class, IndexedClass> _classMap = <ir.Class, IndexedClass>{};
   Map<ir.TypeParameter, IndexedTypeVariable> _typeVariableMap =
@@ skipping 25 matching lines @@
       _libraryEnvs.add(libraryEnv ?? _env.lookupLibrary(canonicalUri));
       String name = node.name;
       if (name == null) {
         // Use the file name as script name.
         String path = canonicalUri.path;
         name = path.substring(path.lastIndexOf('/') + 1);
       }
       LibraryEntity library =
           createLibrary(_libraryMap.length, name, canonicalUri);
       _libraryList.add(library);
+      _libraryData.add(new LibraryData(node));
       return library;
     });
   }
 
   void addClosureClass(KernelClosureClass cls, InterfaceType supertype) {
     cls.classIndex = _classEnvs.length;
     _classEnvs.add(new ClassEnv.closureClass());
     _classList.add(cls);
 
     // Create a classData and set up the interfaces and subclass
@@ skipping 611 matching lines @@
     return library;
   }
 
   @override
   bool isDeferredLoadLibraryGetter(MemberEntity member) {
     // TODO(redemption): Support these.
     return false;
   }
 
   @override
-  Iterable<ConstantValue> getMemberMetadata(covariant IndexedMember member) {
+  Iterable<ConstantValue> getLibraryMetadata(covariant IndexedLibrary library) {
+    LibraryData libraryData = elementMap._libraryData[library.libraryIndex];
+    return libraryData.getMetadata(elementMap);
+  }
+
+  @override
+  Iterable<ConstantValue> getClassMetadata(covariant IndexedClass cls) {
+    ClassData classData = elementMap._classData[cls.classIndex];
+    return classData.getMetadata(elementMap);
+  }
+
+  @override
+  Iterable<ConstantValue> getTypedefMetadata(TypedefEntity typedef) {
+    // TODO(redemption): Support this.
+    throw new UnsupportedError('ElementEnvironment.getTypedefMetadata');
+  }
+
+  @override
+  Iterable<ConstantValue> getMemberMetadata(covariant IndexedMember member,
+      {bool includeParameterMetadata: false}) {
+    // TODO(redemption): Support includeParameterMetadata.
     MemberData memberData = elementMap._memberData[member.memberIndex];
     return memberData.getMetadata(elementMap);
   }
 
   @override
   FunctionType getFunctionTypeOfTypedef(TypedefEntity typedef) {
     // TODO(redemption): Support this.
     throw new UnsupportedError('ElementEnvironment.getTypedefAlias');
   }
 }
@@ skipping 485 matching lines @@
     implements
         KernelToWorldBuilder {
   JsKernelToElementMap(DiagnosticReporter reporter, Environment environment,
       KernelToElementMapForImpactImpl _elementMap)
       : super(reporter, environment) {
     _env = _elementMap._env;
     for (int libraryIndex = 0;
         libraryIndex < _elementMap._libraryEnvs.length;
         libraryIndex++) {
       LibraryEnv env = _elementMap._libraryEnvs[libraryIndex];
+      LibraryData data = _elementMap._libraryData[libraryIndex];
       LibraryEntity oldLibrary = _elementMap._libraryList[libraryIndex];
       LibraryEntity newLibrary = convertLibrary(oldLibrary);
       _libraryMap[env.library] = newLibrary;
       _libraryList.add(newLibrary);
+      _libraryData.add(data.copy());
       _libraryEnvs.add(env);
     }
     for (int classIndex = 0;
         classIndex < _elementMap._classEnvs.length;
         classIndex++) {
       ClassEnv env = _elementMap._classEnvs[classIndex];
       ClassData data = _elementMap._classData[classIndex];
       ClassEntity oldClass = _elementMap._classList[classIndex];
       IndexedLibrary oldLibrary = oldClass.library;
       LibraryEntity newLibrary = _libraryList[oldLibrary.libraryIndex];
@@ skipping 167 matching lines @@
       if (data.constructorBody != null) {
         f(data.constructorBody);
       }
     });
   }
 
   String getDeferredUri(ir.LibraryDependency node) {
     throw new UnimplementedError('JsKernelToElementMap.getDeferredUri');
   }
 }