Introduce TypedefEntity

pkg/compiler/lib/src/world.dart

 // Copyright (c) 2012, 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.world;
 
 import 'closure.dart' show ClosureClassElement;
 import 'common.dart';
 import 'constants/constant_system.dart';
 import 'common_elements.dart' show CommonElements, ElementEnvironment;
 import 'elements/entities.dart';
 import 'elements/elements.dart'
     show
         ClassElement,
         Element,
         MemberElement,
         MethodElement,
-        MixinApplicationElement,
-        TypedefElement;
+        MixinApplicationElement;
 import 'elements/resolution_types.dart';
 import 'elements/types.dart';
 import 'js_backend/backend_usage.dart' show BackendUsage;
 import 'js_backend/interceptor_data.dart' show InterceptorData;
 import 'js_backend/native_data.dart' show NativeData;
 import 'js_backend/runtime_types.dart'
     show RuntimeTypesNeed, RuntimeTypesNeedBuilder;
 import 'ordered_typeset.dart';
 import 'options.dart';
 import 'types/masks.dart' show CommonMasks, FlatTypeMask, TypeMask;
@@ skipping 256 matching lines @@
   TypeMask getCachedMask(ClassEntity base, int flags, TypeMask createMask());
 
   /// Returns `true` if the field [element] is known to be effectively final.
   bool fieldNeverChanges(MemberEntity element);
 
   /// Extends the receiver type [mask] for calling [selector] to take live
   /// `noSuchMethod` handlers into account.
   TypeMask extendMaskIfReachesAll(Selector selector, TypeMask mask);
 
   /// Returns all resolved typedefs.
-  Iterable<TypedefElement> get allTypedefs;
+  Iterable<TypedefEntity> get allTypedefs;
 
   /// Returns the mask for the potential receivers of a dynamic call to
   /// [selector] on [mask].
   ///
   /// This will narrow the constraints of [mask] to a [TypeMask] of the
   /// set of classes that actually implement the selected member or implement
   /// the handling 'noSuchMethod' where the selected member is unimplemented.
   TypeMask computeReceiverType(Selector selector, TypeMask mask);
 
   /// Returns all the instance members that may be invoked with the
@@ skipping 74 matching lines @@
 }
 
 abstract class OpenWorld implements World {
   /// Called to add [cls] to the set of known classes.
   ///
   /// This ensures that class hierarchy queries can be performed on [cls] and
   /// classes that extend or implement it.
   void registerClass(covariant ClassEntity cls);
 
   void registerUsedElement(MemberEntity element);
-  void registerTypedef(TypedefElement typedef);
+  void registerTypedef(TypedefEntity typedef);
 
   ClosedWorld closeWorld();
 
   /// Returns an iterable over all mixin applications that mixin [cls].
   Iterable<ClassEntity> allMixinUsesOf(ClassEntity cls);
 }
 
 /// Enum values defining subset of classes included in queries.
 enum ClassQuery {
   /// Only the class itself is included.
   EXACT,
 
   /// The class and all subclasses (transitively) are included.
   SUBCLASS,
 
   /// The class and all classes that implement or subclass it (transitively)
   /// are included.
   SUBTYPE,
 }
 
 abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   final ConstantSystem constantSystem;
   final NativeData nativeData;
   final InterceptorData interceptorData;
   final BackendUsage backendUsage;
 
   FunctionSet _allFunctions;
 
-  final Set<TypedefElement> _allTypedefs;
+  final Set<TypedefEntity> _allTypedefs;
 
   final Map<ClassEntity, Set<ClassEntity>> mixinUses;
   Map<ClassEntity, List<ClassEntity>> _liveMixinUses;
 
   final Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses;
 
   // We keep track of subtype and subclass relationships in four
   // distinct sets to make class hierarchy analysis faster.
   final Map<ClassEntity, ClassHierarchyNode> _classHierarchyNodes;
   final Map<ClassEntity, ClassSet> _classSets;
@@ skipping 35 matching lines @@
       this.dartTypes,
       this.commonElements,
       this.constantSystem,
       this.nativeData,
       this.interceptorData,
       this.backendUsage,
       Set<ClassEntity> implementedClasses,
       this.liveNativeClasses,
       this.liveInstanceMembers,
       this.assignedInstanceMembers,
-      Set<TypedefElement> allTypedefs,
+      Set<TypedefEntity> allTypedefs,
       this.mixinUses,
       this.typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets)
       : this._implementedClasses = implementedClasses,
         this._allTypedefs = allTypedefs,
         this._classHierarchyNodes = classHierarchyNodes,
         this._classSets = classSets {
     _commonMasks = new CommonMasks(this);
   }
@@ skipping 522 matching lines @@
   /// Returns [ClassSet] for [cls] used to model the extends and implements
   /// relations of known classes.
   ///
   /// This method is only provided for testing. For queries on classes, use the
   /// methods defined in [ClosedWorld].
   ClassSet getClassSet(ClassEntity cls) {
     assert(checkClass(cls));
     return _classSets[cls];
   }
 
-  Iterable<TypedefElement> get allTypedefs => _allTypedefs;
+  Iterable<TypedefEntity> get allTypedefs => _allTypedefs;
 
   void _ensureFunctionSet() {
     if (_allFunctions == null) {
       // [FunctionSet] is created lazily because it is not used when we switch
       // from a frontend to a backend model before inference.
       _allFunctions = new FunctionSet(liveInstanceMembers);
     }
   }
 
   TypeMask computeReceiverType(Selector selector, TypeMask mask) {
@@ skipping 159 matching lines @@
       ConstantSystem constantSystem,
       NativeData nativeData,
       InterceptorData interceptorData,
       BackendUsage backendUsage,
       ResolutionWorldBuilder resolutionWorldBuilder,
       RuntimeTypesNeedBuilder rtiNeedBuilder,
       Set<ClassEntity> implementedClasses,
       Iterable<ClassEntity> liveNativeClasses,
       Iterable<MemberEntity> liveInstanceMembers,
       Iterable<MemberEntity> assignedInstanceMembers,
-      Set<TypedefElement> allTypedefs,
+      Set<TypedefEntity> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets})
       : super(
             elementEnvironment,
             dartTypes,
             commonElements,
             constantSystem,
             nativeData,
@@ skipping 133 matching lines @@
   void computeRtiNeed(ResolutionWorldBuilder resolutionWorldBuilder,
       RuntimeTypesNeedBuilder rtiNeedBuilder,
       {bool enableTypeAssertions}) {
     _rtiNeed = rtiNeedBuilder.computeRuntimeTypesNeed(
         resolutionWorldBuilder, this,
         enableTypeAssertions: enableTypeAssertions);
   }
 
   RuntimeTypesNeed get rtiNeed => _rtiNeed;
 }