Extract ResolutionWorldBuilderBase from ElementResolutionWorldBuilder

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, SynthesizedCallMethodElementX;
 import 'common/backend_api.dart' show BackendClasses;
 import 'common.dart';
 import 'constants/constant_system.dart';
@@ skipping 346 matching lines @@
   /// Adds the closure class [cls] to the inference world. The class is
   /// considered directly instantiated.
   void registerClosureClass(ClassElement cls);
 }
 
 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(ClassElement cls);
+  void registerClass(ClassEntity cls);
 
-  void registerUsedElement(MemberElement element);
+  void registerUsedElement(MemberEntity element);
   void registerTypedef(TypedefElement typedef);
 
   ClosedWorld closeWorld(DiagnosticReporter reporter);
 
   /// Returns an iterable over all mixin applications that mixin [cls].
-  Iterable<MixinApplicationElement> allMixinUsesOf(ClassElement 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,
 }
 
 class ClosedWorldImpl implements ClosedWorld, ClosedWorldRefiner {
   final JavaScriptBackend _backend;
   BackendClasses get backendClasses => _backend.backendClasses;
   InterceptorData get interceptorData => _backend.interceptorData;
   FunctionSet _allFunctions;
 
   final Iterable<TypedefElement> _allTypedefs;
 
-  final Map<ClassElement, Set<MixinApplicationElement>> _mixinUses;
+  final Map<ClassEntity, Set<ClassEntity>> _mixinUses;
   Map<ClassElement, List<MixinApplicationElement>> _liveMixinUses;
 
-  final Map<ClassElement, Set<ClassElement>> _typesImplementedBySubclasses;
+  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<ClassElement, ClassHierarchyNode> _classHierarchyNodes;
-  final Map<ClassElement, ClassSet> _classSets;
+  final Map<ClassEntity, ClassHierarchyNode> _classHierarchyNodes;
+  final Map<ClassEntity, ClassSet> _classSets;
 
   final Map<ClassElement, Map<ClassElement, bool>> _subtypeCoveredByCache =
       <ClassElement, Map<ClassElement, bool>>{};
 
   final Set<Element> functionsCalledInLoop = new Set<Element>();
   final Map<Element, SideEffects> sideEffects = new Map<Element, SideEffects>();
 
   final Set<Element> sideEffectsFreeElements = new Set<Element>();
 
   final Set<Element> elementsThatCannotThrow = new Set<Element>();
 
   final Set<Element> functionsThatMightBePassedToApply =
       new Set<FunctionElement>();
 
   CommonMasks _commonMasks;
 
   final CommonElements commonElements;
 
   final ResolutionWorldBuilder _resolverWorld;
 
   bool get isClosed => true;
 
   ClosedWorldImpl(
       {JavaScriptBackend backend,
       this.commonElements,
       ResolutionWorldBuilder resolutionWorldBuilder,
       FunctionSetBuilder functionSetBuilder,
       Iterable<TypedefElement> allTypedefs,
-      Map<ClassElement, Set<MixinApplicationElement>> mixinUses,
-      Map<ClassElement, Set<ClassElement>> typesImplementedBySubclasses,
-      Map<ClassElement, ClassHierarchyNode> classHierarchyNodes,
-      Map<ClassElement, ClassSet> classSets})
+      Map<ClassEntity, Set<ClassEntity>> mixinUses,
+      Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
+      Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
+      Map<ClassEntity, ClassSet> classSets})
       : this._backend = backend,
         this._resolverWorld = resolutionWorldBuilder,
         this._allTypedefs = allTypedefs,
         this._mixinUses = mixinUses,
         this._typesImplementedBySubclasses = typesImplementedBySubclasses,
         this._classHierarchyNodes = classHierarchyNodes,
         this._classSets = classSets {
     _commonMasks = new CommonMasks(this);
     _allFunctions = functionSetBuilder.close(this);
   }
@@ skipping 457 matching lines @@
         _subtypeCoveredByCache[x] ??= <ClassElement, bool>{};
     return secondMap[y] ??= subtypesOf(x).every((ClassElement cls) =>
         isSubclassOf(cls, y) || isSubclassOfMixinUseOf(cls, y));
   }
 
   /// Returns `true` if any subclass of [superclass] implements [type].
   bool hasAnySubclassThatImplements(
       ClassElement superclass, ClassElement type) {
     assert(isClosed);
 
-    Set<ClassElement> subclasses =
+    Set<ClassEntity> subclasses =
         _typesImplementedBySubclasses[superclass.declaration];
     if (subclasses == null) return false;
     return subclasses.contains(type);
   }
 
   @override
   bool hasElementIn(ClassElement cls, Selector selector, Element element) {
     // Use [:implementation:] of [element]
     // because our function set only stores declarations.
     Element result = findMatchIn(cls, selector);
@@ skipping 264 matching lines @@
       return getMightBePassedToApply(element.expression);
     }
     return functionsThatMightBePassedToApply.contains(element);
   }
 
   @override
   bool getCurrentlyKnownMightBePassedToApply(Element element) {
     return getMightBePassedToApply(element);
   }
 }