Use entities in most of MirrorsData (part 2)

pkg/compiler/lib/src/js_backend/mirrors_data.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.
 
-import '../closure.dart';
 import '../common.dart';
 import '../common_elements.dart';
 import '../compiler.dart';
 import '../constants/values.dart';
-import '../elements/elements.dart';
+import '../elements/elements.dart' show AbstractFieldElement, Element;
 import '../elements/entities.dart';
 import '../elements/names.dart';
 import '../elements/types.dart';
 import '../options.dart';
 import '../world.dart';
 import '../universe/world_builder.dart';
 import '../util/emptyset.dart';
 
 abstract class MirrorsData {
   /// True if a call to preserveMetadataMarker has been seen.  This means that
@@ skipping 118 matching lines @@
   /// Called by [MirrorUsageAnalyzerTask] after it has merged all @MirrorsUsed
   /// annotations. The arguments corresponds to the unions of the corresponding
   /// fields of the annotations.
   void registerMirrorUsage(
       Set<String> symbols, Set<Element> targets, Set<Element> metaTargets);
 
   /// Called when `const Symbol(name)` is seen.
   void registerConstSymbol(String name);
 
   void maybeMarkClosureAsNeededForReflection(
-      ClosureClassElement globalizedElement,
-      MethodElement callFunction,
-      LocalFunctionElement function);
+      ClassEntity closureClass, FunctionEntity callMethod, Local localFunction);
 
   void computeMembersNeededForReflection(
       ResolutionWorldBuilder worldBuilder, ClosedWorld closedWorld);
 }
 
-class MirrorsDataImpl implements MirrorsData, MirrorsDataBuilder {
+abstract class MirrorsDataImpl implements MirrorsData, MirrorsDataBuilder {
   /// True if a call to preserveMetadataMarker has been seen.  This means that
   /// metadata must be retained for dart:mirrors to work correctly.
   bool mustRetainMetadata = false;
 
   /// True if any metadata has been retained.  This is slightly different from
   /// [mustRetainMetadata] and tells us if any metadata was retained.  For
   /// example, if [mustRetainMetadata] is true but there is no metadata in the
   /// program, this variable will stil be false.
   bool hasRetainedMetadata = false;
 
@@ skipping 62 matching lines @@
   }
 
   /// Should [name] be retained for reflection?
   bool shouldRetainName(String name) {
     if (hasInsufficientMirrorsUsed) return mustPreserveNames;
     if (name == '') return false;
     return symbolsUsed.contains(name);
   }
 
   @override
-  bool retainMetadataOfMember(covariant MemberElement element) {
+  bool retainMetadataOfMember(MemberEntity element) {
     if (mustRetainMetadata) {
       hasRetainedMetadata = true;
       if (isMemberReferencedFromMirrorSystem(element)) {
         _addConstantsForEmission(
             getMemberMetadata(element, includeParameterMetadata: true));
         return true;
       }
     }
     return false;
   }
@@ skipping 31 matching lines @@
         Iterable<ConstantValue> constants = getLibraryMetadata(element);
         if (addForEmission) {
           _addConstantsForEmission(constants);
         }
         return true;
       }
     }
     return false;
   }
 
-  Iterable<ConstantValue> getLibraryMetadata(LibraryElement element) {
+  Iterable<ConstantValue> getLibraryMetadata(LibraryEntity element) {
     return _elementEnvironment.getLibraryMetadata(element);
   }
 
-  Iterable<ConstantValue> getClassMetadata(ClassElement element) {
+  Iterable<ConstantValue> getClassMetadata(ClassEntity element) {
     return _elementEnvironment.getClassMetadata(element);
   }
 
   Iterable<ConstantValue> getMemberMetadata(MemberEntity element,
       {bool includeParameterMetadata}) {
     return _elementEnvironment.getMemberMetadata(element,
         includeParameterMetadata: includeParameterMetadata);
   }
 
-  Iterable<ConstantValue> getTypedefMetadata(TypedefElement element) {
+  Iterable<ConstantValue> getTypedefMetadata(TypedefEntity element) {
     return _elementEnvironment.getTypedefMetadata(element);
   }
 
   void _addConstantsForEmission(Iterable<ConstantValue> constants) {
     for (ConstantValue constant in constants) {
       CodegenWorldBuilder worldBuilder = _compiler.codegenWorldBuilder;
       worldBuilder.addCompileTimeConstantForEmission(constant);
     }
   }
 
@@ skipping 145 matching lines @@
         _typedefMatchesMirrorsMetaTarget(element) ||
         _typedefsInMirrorsUsedTargets.contains(element);
   }
 
   bool _libraryReferencedFromMirrorSystem(LibraryEntity element) {
     return hasInsufficientMirrorsUsed ||
         _libraryMatchesMirrorsMetaTarget(element) ||
         librariesInMirrorsUsedTargets.contains(element);
   }
 
-  bool _libraryMatchesMirrorsMetaTarget(LibraryElement element) {
+  bool _libraryMatchesMirrorsMetaTarget(LibraryEntity element) {
     if (metaTargetsUsed.isEmpty) return false;
     return _matchesMirrorsMetaTarget(getLibraryMetadata(element));
   }
 
   bool _classMatchesMirrorsMetaTarget(ClassEntity element) {
     if (metaTargetsUsed.isEmpty) return false;
     return _matchesMirrorsMetaTarget(getClassMetadata(element));
   }
 
-  bool _memberMatchesMirrorsMetaTarget(MemberElement element) {
+  bool _memberMatchesMirrorsMetaTarget(MemberEntity element) {
     if (metaTargetsUsed.isEmpty) return false;
     return _matchesMirrorsMetaTarget(
         getMemberMetadata(element, includeParameterMetadata: false));
   }
 
-  bool _typedefMatchesMirrorsMetaTarget(TypedefElement element) {
+  bool _typedefMatchesMirrorsMetaTarget(TypedefEntity element) {
     if (metaTargetsUsed.isEmpty) return false;
     return _matchesMirrorsMetaTarget(getTypedefMetadata(element));
   }
 
   /**
    * Returns `true` if the element is needed because it has an annotation
    * of a type that is used as a meta target for reflection.
    */
   bool _matchesMirrorsMetaTarget(Iterable<ConstantValue> constants) {
     if (metaTargetsUsed.isEmpty) return false;
     for (ConstantValue constant in constants) {
       DartType type = constant.getType(_commonElements);
       if (type is InterfaceType && metaTargetsUsed.contains(type.element))
         return true;
     }
     return false;
   }
 
   void createImmutableSets() {
-    _classesNeededForReflection = const ImmutableEmptySet<ClassElement>();
-    _typedefsNeededForReflection = const ImmutableEmptySet<TypedefElement>();
-    _membersNeededForReflection = const ImmutableEmptySet<MemberElement>();
-    _closuresNeededForReflection =
-        const ImmutableEmptySet<LocalFunctionElement>();
+    _classesNeededForReflection = const ImmutableEmptySet<ClassEntity>();
+    _typedefsNeededForReflection = const ImmutableEmptySet<TypedefEntity>();
+    _membersNeededForReflection = const ImmutableEmptySet<MemberEntity>();
+    _closuresNeededForReflection = const ImmutableEmptySet<Local>();
+  }
+
+  bool isLibraryInternal(LibraryEntity library) {
+    return library.canonicalUri.scheme == 'dart' &&
+        library.canonicalUri.path.startsWith('_');
+  }
+
+  /// Whether [cls] is 'injected'.
+  ///
+  /// An injected class is declared in a patch library with no corresponding
+  /// class in the origin library.
+  // TODO(redemption): Detect injected classes from .dill.
+  bool isClassInjected(ClassEntity cls) => false;
+
+  bool isClassResolved(ClassEntity cls) => true;
+
+  void forEachConstructor(
+      ClassEntity cls, void f(ConstructorEntity constructor)) {
+    _elementEnvironment.forEachConstructor(cls, f);
+  }
+
+  void forEachClassMember(
+      ClassEntity cls, void f(MemberEntity member, Name memberName)) {
+    _elementEnvironment.forEachClassMember(cls,
+        (ClassEntity declarer, MemberEntity member) {
+      if (member.isSetter) {
+        f(member, member.memberName.setter);
+      } else {
+        f(member, member.memberName.getter);
+      }
+    });
   }
 
   /**
    * Visits all classes and computes whether its members are needed for
    * reflection.
    *
    * We have to precompute this set as we cannot easily answer the need for
    * reflection locally when looking at the member: We lack the information by
    * which classes a member is inherited. Called after resolution is complete.
    *
@@ skipping 16 matching lines @@
     // Compute a mapping from class to the closures it contains, so we
     // can include the correct ones when including the class.
     Map<ClassEntity, List<Local>> closureMap =
         new Map<ClassEntity, List<Local>>();
     for (Local closure in worldBuilder.localFunctions) {
       closureMap
           .putIfAbsent(closure.memberContext.enclosingClass, () => [])
           .add(closure);
     }
     bool foundClosure = false;
-    for (ClassElement cls in worldBuilder.directlyInstantiatedClasses) {
+    for (ClassEntity cls in worldBuilder.directlyInstantiatedClasses) {
       // Do not process internal classes.
-      if (cls.library.isInternalLibrary || cls.isInjected) continue;
+      if (isLibraryInternal(cls.library) || isClassInjected(cls)) continue;
       if (isClassReferencedFromMirrorSystem(cls)) {
         Set<Name> memberNames = new Set<Name>();
         // 1) the class (should be resolved)
-        assert(cls.isResolved, failedAt(cls));
+        assert(isClassResolved(cls), failedAt(cls));
         _classesNeededForReflection.add(cls);
         // 2) its constructors (if resolved)
-        cls.constructors.forEach((Element _constructor) {
-          ConstructorElement constructor = _constructor;
+        forEachConstructor(cls, (ConstructorEntity constructor) {
           if (worldBuilder.isMemberUsed(constructor)) {
             _membersNeededForReflection.add(constructor);
           }
         });
         // 3) all members, including fields via getter/setters (if resolved)
-        cls.forEachClassMember((Member member) {
-          MemberElement element = member.element;
-          if (worldBuilder.isMemberUsed(element)) {
-            memberNames.add(member.name);
-            _membersNeededForReflection.add(element);
-            element.nestedClosures.forEach((FunctionElement _callFunction) {
-              SynthesizedCallMethodElementX callFunction = _callFunction;
-              _membersNeededForReflection.add(callFunction);
-              _classesNeededForReflection.add(callFunction.closureClass);
-            });
+        forEachClassMember(cls, (MemberEntity member, Name memberName) {
+          if (worldBuilder.isMemberUsed(member)) {
+            memberNames.add(memberName);
+            _membersNeededForReflection.add(member);
           }
         });
         // 4) all overriding members of subclasses/subtypes (should be resolved)
         if (closedWorld.hasAnyStrictSubtype(cls)) {
-          closedWorld.forEachStrictSubtypeOf(cls, (ClassEntity _subcls) {
-            ClassElement subcls = _subcls;
-            subcls.forEachClassMember((Member member) {
-              if (memberNames.contains(member.name)) {
+          closedWorld.forEachStrictSubtypeOf(cls, (ClassEntity subcls) {
+            forEachClassMember(subcls, (MemberEntity member, Name memberName) {
+              if (memberNames.contains(memberName)) {
                 // TODO(20993): find out why this assertion fails.
                 // assert(worldBuilder.isMemberUsed(member.element),
                 //     failedAt(member.element));
-                if (worldBuilder.isMemberUsed(member.element)) {
-                  _membersNeededForReflection.add(member.element);
+                if (worldBuilder.isMemberUsed(member)) {
+                  _membersNeededForReflection.add(member);
                 }
               }
             });
           });
         }
         // 5) all its closures
         List<Local> closures = closureMap[cls];
         if (closures != null) {
           _closuresNeededForReflection.addAll(closures);
           foundClosure = true;
         }
       } else {
         // check members themselves
-        cls.constructors.forEach((Element _element) {
-          ConstructorElement element = _element;
+        forEachConstructor(cls, (ConstructorEntity element) {
           if (!worldBuilder.isMemberUsed(element)) return;
           if (_memberReferencedFromMirrorSystem(element)) {
             _membersNeededForReflection.add(element);
           }
         });
-        cls.forEachClassMember((Member member) {
-          if (!worldBuilder.isMemberUsed(member.element)) return;
-          if (_memberReferencedFromMirrorSystem(member.element)) {
-            _membersNeededForReflection.add(member.element);
+        forEachClassMember(cls, (MemberEntity member, _) {
+          if (!worldBuilder.isMemberUsed(member)) return;
+          if (_memberReferencedFromMirrorSystem(member)) {
+            _membersNeededForReflection.add(member);
           }
         });
         // Also add in closures. Those might be reflectable is their enclosing
         // member is.
         List<Local> closures = closureMap[cls];
         if (closures != null) {
           for (Local closure in closures) {
             MemberEntity member = closure.memberContext;
             if (_memberReferencedFromMirrorSystem(member)) {
               _closuresNeededForReflection.add(closure);
               foundClosure = true;
             }
           }
         }
       }
     }
     // We also need top-level non-class elements like static functions and
     // global fields. We use the resolution queue to decide which elements are
     // part of the live world.
-    for (LibraryElement lib in _compiler.libraryLoader.libraries) {
-      if (lib.isInternalLibrary) continue;
-      lib.forEachLocalMember((Element element) {
-        if (element.isClass || element.isTypedef) return;
-        MemberElement member = element;
+    for (LibraryEntity lib in _elementEnvironment.libraries) {
+      if (isLibraryInternal(lib)) continue;
+      _elementEnvironment.forEachLibraryMember(lib, (MemberEntity member) {
         if (worldBuilder.isMemberUsed(member) &&
             isMemberReferencedFromMirrorSystem(member)) {
           _membersNeededForReflection.add(member);
         }
       });
     }
     // And closures inside top-level elements that do not have a surrounding
     // class. These will be in the [:null:] bucket of the [closureMap].
     if (closureMap.containsKey(null)) {
       for (Local closure in closureMap[null]) {
@@ skipping 30 matching lines @@
     for (MemberEntity element in _membersNeededForReflection) {
       symbolsUsed.add(element.name);
     }
     for (Local element in _closuresNeededForReflection) {
       symbolsUsed.add(element.name);
     }
   }
 
   // TODO(20791): compute closure classes after resolution and move this code to
   // [computeMembersNeededForReflection].
-  void maybeMarkClosureAsNeededForReflection(
-      ClosureClassElement globalizedElement,
-      MethodElement callFunction,
-      LocalFunctionElement function) {
-    if (!_closuresNeededForReflection.contains(function)) return;
-    _membersNeededForReflection.add(callFunction);
-    _classesNeededForReflection.add(globalizedElement);
+  void maybeMarkClosureAsNeededForReflection(ClassEntity closureClass,
+      FunctionEntity callMethod, Local localFunction) {
+    if (!_closuresNeededForReflection.contains(localFunction)) return;
+    _membersNeededForReflection.add(callMethod);
+    _classesNeededForReflection.add(closureClass);
   }
 
   /// Called when `const Symbol(name)` is seen.
   void registerConstSymbol(String name) {
     symbolsUsed.add(name);
     if (name.endsWith('=')) {
       symbolsUsed.add(name.substring(0, name.length - 1));
     }
   }
 }