Introduce TypedefEntity

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';
@@ skipping 82 matching lines @@
   /// annotation.
   bool isLibraryReferencedFromMirrorSystem(covariant LibraryEntity element);
 
   /// Returns `true` if the typedef [element] needs reflection information at
   /// runtime.
   ///
   /// This property is used to tag emitted elements with a marker which is
   /// checked by the runtime system to throw an exception if an element is
   /// accessed (invoked, get, set) that is not accessible for the reflective
   /// system.
-  bool isTypedefAccessibleByReflection(TypedefElement element);
+  bool isTypedefAccessibleByReflection(covariant TypedefEntity element);
 
   /// Returns `true` if the class [element] needs reflection information at
   /// runtime.
   ///
   /// This property is used to tag emitted elements with a marker which is
   /// checked by the runtime system to throw an exception if an element is
   /// accessed (invoked, get, set) that is not accessible for the reflective
   /// system.
   bool isClassAccessibleByReflection(ClassEntity element);
 
   /// Returns `true` if the member [element] needs reflection information at
   /// runtime.
   ///
   /// This property is used to tag emitted elements with a marker which is
   /// checked by the runtime system to throw an exception if an element is
   /// accessed (invoked, get, set) that is not accessible for the reflective
   /// system.
   bool isMemberAccessibleByReflection(MemberEntity element);
 
   // TODO(johnniwinther): Remove this.
   @deprecated
   bool isAccessibleByReflection(Element element);
 
   bool retainMetadataOfLibrary(covariant LibraryEntity element,
       {bool addForEmission: true});
-  bool retainMetadataOfTypedef(TypedefElement element);
+  bool retainMetadataOfTypedef(covariant TypedefEntity element);
   bool retainMetadataOfClass(covariant ClassEntity element);
   bool retainMetadataOfMember(covariant MemberEntity element);
   bool retainMetadataOfParameter(ParameterElement element);
 
   /// Returns true if this element has to be enqueued due to
   /// mirror usage. Might be a subset of [referencedFromMirrorSystem] if
   /// normal tree shaking is still active ([isTreeShakingDisabled] is false).
   bool requiredByMirrorSystem(Element element);
 }
 
@@ skipping 46 matching lines @@
   bool mustPreserveUris = false;
 
   /// Set of symbols that the user has requested for reflection.
   final Set<String> symbolsUsed = new Set<String>();
 
   /// Set of elements that the user has requested for reflection.
   final Set<MemberEntity> membersInMirrorsUsedTargets = new Set<MemberEntity>();
   final Set<ClassEntity> classesInMirrorsUsedTargets = new Set<ClassEntity>();
   final Set<LibraryEntity> librariesInMirrorsUsedTargets =
       new Set<LibraryEntity>();
-  final Set<TypedefElement> _typedefsInMirrorsUsedTargets =
-      new Set<TypedefElement>();
+  final Set<TypedefEntity> _typedefsInMirrorsUsedTargets =
+      new Set<TypedefEntity>();
 
   /// List of annotations provided by user that indicate that the annotated
   /// element must be retained.
   final Set<ClassEntity> metaTargetsUsed = new Set<ClassEntity>();
 
   // TODO(johnniwinther): Avoid the need for this.
   final Compiler _compiler;
 
   final CompilerOptions _options;
 
@@ skipping 130 matching lines @@
           AbstractFieldElement field = target;
           if (field.getter != null) {
             membersInMirrorsUsedTargets.add(field.getter);
           }
           if (field.setter != null) {
             membersInMirrorsUsedTargets.add(field.setter);
           }
         } else if (target.isClass) {
           classesInMirrorsUsedTargets.add(target as ClassEntity);
         } else if (target.isTypedef) {
-          _typedefsInMirrorsUsedTargets.add(target);
+          _typedefsInMirrorsUsedTargets.add(target as TypedefEntity);
         } else if (target.isLibrary) {
           librariesInMirrorsUsedTargets.add(target as LibraryEntity);
         } else if (target != null) {
           membersInMirrorsUsedTargets.add(target as MemberEntity);
         }
       }
     }
     if (metaTargets != null) {
       for (dynamic element in metaTargets) {
         if (element is ClassEntity) {
@@ skipping 291 matching lines @@
     if (foundClosure) {
       ClassElement cls = _commonElements.closureClass;
       _classesNeededForReflection.add(cls);
     }
     Set<FunctionEntity> closurizedMembers = worldBuilder.closurizedMembers;
     if (closurizedMembers.any(_membersNeededForReflection.contains)) {
       ClassElement cls = _commonElements.boundClosureClass;
       _classesNeededForReflection.add(cls);
     }
     // Add typedefs.
-    _typedefsNeededForReflection.addAll(
-        closedWorld.allTypedefs.where(isTypedefReferencedFromMirrorSystem));
+    for (TypedefElement element in closedWorld.allTypedefs) {
+      if (isTypedefReferencedFromMirrorSystem(element)) {
+        _typedefsNeededForReflection.add(element);
+      }
+    }
     // Register all symbols of reflectable elements
     for (ClassElement element in _classesNeededForReflection) {
       symbolsUsed.add(element.name);
     }
     for (TypedefElement element in _typedefsNeededForReflection) {
       symbolsUsed.add(element.name);
     }
     for (MemberElement element in _membersNeededForReflection) {
       symbolsUsed.add(element.name);
     }
@@ skipping 14 matching lines @@
   }
 
   /// 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));
     }
   }
 }