Extract ClosedWorldImpl from WorldImpl.

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 'cache_strategy.dart';
-import 'closure.dart' show SynthesizedCallMethodElementX;
+import 'closure.dart' show ClosureClassElement, SynthesizedCallMethodElementX;
 import 'common/backend_api.dart' show BackendClasses;
 import 'common.dart';
 import 'constants/constant_system.dart';
 import 'core_types.dart' show CoreTypes, CoreClasses, CommonElements;
 import 'dart_types.dart';
 import 'elements/elements.dart'
     show
         ClassElement,
         Element,
         FunctionElement,
         MixinApplicationElement,
         TypedefElement,
         FieldElement;
 import 'js_backend/backend.dart' show JavaScriptBackend;
 import 'ordered_typeset.dart';
 import 'types/masks.dart' show CommonMasks, FlatTypeMask, TypeMask;
 import 'universe/class_set.dart';
-import 'universe/function_set.dart' show FunctionSet;
+import 'universe/function_set.dart' show FunctionSet, FunctionSetBuilder;
 import 'universe/selector.dart' show Selector;
 import 'universe/side_effects.dart' show SideEffects;
 import 'universe/world_builder.dart'
     show InstantiationInfo, ResolutionWorldBuilder;
 import 'util/util.dart' show Link;
 
 /// Common superinterface for [OpenWorld] and [ClosedWorld].
 abstract class World {}
 
 /// The [ClosedWorld] represents the information known about a program when
@@ skipping 306 matching lines @@
 
   void registerUsedElement(Element element);
   void registerTypedef(TypedefElement typedef);
 
   ClosedWorld closeWorld(DiagnosticReporter reporter);
 
   /// Returns an iterable over all mixin applications that mixin [cls].
   Iterable<MixinApplicationElement> allMixinUsesOf(ClassElement cls);
 }
 
-class WorldImpl implements ClosedWorld, ClosedWorldRefiner, OpenWorld {
+class WorldImpl implements OpenWorld {
   bool _closed = false;
-
-  TypeMask getCachedMask(ClassElement base, int flags, TypeMask createMask()) {
-    Map<ClassElement, TypeMask> cachedMasks =
-        _canonicalizedTypeMasks[flags] ??= <ClassElement, TypeMask>{};
-    return cachedMasks.putIfAbsent(base, createMask);
+  ClosedWorld _closedWorldCache;
+
+  final JavaScriptBackend _backend;
+  FunctionSetBuilder _allFunctions;
+
+  final Set<TypedefElement> _allTypedefs = new Set<TypedefElement>();
+
+  final Map<ClassElement, Set<MixinApplicationElement>> _mixinUses =
+      new Map<ClassElement, Set<MixinApplicationElement>>();
+
+  // We keep track of subtype and subclass relationships in four
+  // distinct sets to make class hierarchy analysis faster.
+  final Map<ClassElement, ClassHierarchyNode> _classHierarchyNodes =
+      <ClassElement, ClassHierarchyNode>{};
+  final Map<ClassElement, ClassSet> _classSets = <ClassElement, ClassSet>{};
+
+  final Map<ClassElement, Map<ClassElement, bool>> _subtypeCoveredByCache =
+      <ClassElement, Map<ClassElement, bool>>{};
+
+  final Set<Element> alreadyPopulated;
+
+  final CommonElements commonElements;
+
+  final CoreTypes coreTypes;
+
+  final CacheStrategy cacheStrategy;
+
+  final ResolutionWorldBuilder resolverWorld;
+
+  bool get isClosed => _closed;
+
+  WorldImpl(this.resolverWorld, this._backend, this.commonElements,
+      this.coreTypes, CacheStrategy cacheStrategy)
+      : this.cacheStrategy = cacheStrategy,
+        alreadyPopulated = cacheStrategy.newSet() {
+    _allFunctions = new FunctionSetBuilder();
+  }
+
+  /// Returns an iterable over all mixin applications that mixin [cls].
+  Iterable<MixinApplicationElement> allMixinUsesOf(ClassElement cls) {
+    Iterable<MixinApplicationElement> uses = _mixinUses[cls];
+    return uses != null ? uses : const <MixinApplicationElement>[];
+  }
+
+  /// 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) => _registerClass(cls);
+
+  void _registerClass(ClassElement cls, {bool isDirectlyInstantiated: false}) {
+    _ensureClassSet(cls);
+    if (isDirectlyInstantiated) {
+      _updateClassHierarchyNodeForClass(cls, directlyInstantiated: true);
+    }
+  }
+
+  void registerTypedef(TypedefElement typdef) {
+    _allTypedefs.add(typdef);
+  }
+
+  ClassHierarchyNode _ensureClassHierarchyNode(ClassElement cls) {
+    cls = cls.declaration;
+    return _classHierarchyNodes.putIfAbsent(cls, () {
+      ClassHierarchyNode parentNode;
+      if (cls.superclass != null) {
+        parentNode = _ensureClassHierarchyNode(cls.superclass);
+      }
+      return new ClassHierarchyNode(parentNode, cls);
+    });
+  }
+
+  ClassSet _ensureClassSet(ClassElement cls) {
+    cls = cls.declaration;
+    return _classSets.putIfAbsent(cls, () {
+      ClassHierarchyNode node = _ensureClassHierarchyNode(cls);
+      ClassSet classSet = new ClassSet(node);
+
+      for (InterfaceType type in cls.allSupertypes) {
+        // TODO(johnniwinther): Optimization: Avoid adding [cls] to
+        // superclasses.
+        ClassSet subtypeSet = _ensureClassSet(type.element);
+        subtypeSet.addSubtype(node);
+      }
+      if (cls.isMixinApplication) {
+        // TODO(johnniwinther): Store this in the [ClassSet].
+        MixinApplicationElement mixinApplication = cls;
+        if (mixinApplication.mixin != null) {
+          // If [mixinApplication] is malformed [mixin] is `null`.
+          registerMixinUse(mixinApplication, mixinApplication.mixin);
+        }
+      }
+
+      return classSet;
+    });
+  }
+
+  void _updateSuperClassHierarchyNodeForClass(ClassHierarchyNode node) {
+    // Ensure that classes implicitly implementing `Function` are in its
+    // subtype set.
+    ClassElement cls = node.cls;
+    if (cls != commonElements.functionClass &&
+        cls.implementsFunction(commonElements)) {
+      ClassSet subtypeSet = _ensureClassSet(commonElements.functionClass);
+      subtypeSet.addSubtype(node);
+    }
+    if (!node.isInstantiated && node.parentNode != null) {
+      _updateSuperClassHierarchyNodeForClass(node.parentNode);
+    }
+  }
+
+  void _updateClassHierarchyNodeForClass(ClassElement cls,
+      {bool directlyInstantiated: false, bool abstractlyInstantiated: false}) {
+    ClassHierarchyNode node = _ensureClassHierarchyNode(cls);
+    _updateSuperClassHierarchyNodeForClass(node);
+    if (directlyInstantiated) {
+      node.isDirectlyInstantiated = true;
+    }
+    if (abstractlyInstantiated) {
+      node.isAbstractlyInstantiated = true;
+    }
+  }
+
+  ClosedWorld closeWorld(DiagnosticReporter reporter) {
+    Map<ClassElement, Set<ClassElement>> typesImplementedBySubclasses =
+        new Map<ClassElement, Set<ClassElement>>();
+
+    /// Updates the `isDirectlyInstantiated` and `isIndirectlyInstantiated`
+    /// properties of the [ClassHierarchyNode] for [cls].
+
+    void addSubtypes(ClassElement cls, InstantiationInfo info) {
+      if (!info.hasInstantiation) {
+        return;
+      }
+      if (cacheStrategy.hasIncrementalSupport && !alreadyPopulated.add(cls)) {
+        return;
+      }
+      assert(cls.isDeclaration);
+      if (!cls.isResolved) {
+        reporter.internalError(cls, 'Class "${cls.name}" is not resolved.');

[Siggi Cherem (dart-lang), 2016/12/20 15:36:36]

related to the discussion in the other CL - this would be a case where we could
simply do an invariant assert and remove the reporter argument, correct?

[Johnni Winther, 2016/12/21 08:41:25]

Yes. Will do later.

+      }
+
+      _updateClassHierarchyNodeForClass(cls,
+          directlyInstantiated: info.isDirectlyInstantiated,
+          abstractlyInstantiated: info.isAbstractlyInstantiated);
+
+      // Walk through the superclasses, and record the types
+      // implemented by that type on the superclasses.
+      ClassElement superclass = cls.superclass;
+      while (superclass != null) {
+        Set<Element> typesImplementedBySubclassesOfCls =
+            typesImplementedBySubclasses.putIfAbsent(
+                superclass, () => new Set<ClassElement>());
+        for (DartType current in cls.allSupertypes) {
+          typesImplementedBySubclassesOfCls.add(current.element);
+        }
+        superclass = superclass.superclass;
+      }
+    }
+
+    // Use the [:seenClasses:] set to include non-instantiated
+    // classes: if the superclass of these classes require RTI, then
+    // they also need RTI, so that a constructor passes the type
+    // variables to the super constructor.
+    resolverWorld.forEachInstantiatedClass(addSubtypes);
+
+    _closed = true;
+    return _closedWorldCache = new ClosedWorldImpl(
+        backend: _backend,
+        commonElements: commonElements,
+        coreTypes: coreTypes,
+        resolverWorld: resolverWorld,
+        functionSetBuilder: _allFunctions,
+        allTypedefs: _allTypedefs,
+        mixinUses: _mixinUses,
+        typesImplementedBySubclasses: typesImplementedBySubclasses,
+        classHierarchyNodes: _classHierarchyNodes,
+        classSets: _classSets);
+  }
+
+  void registerMixinUse(
+      MixinApplicationElement mixinApplication, ClassElement mixin) {
+    // TODO(johnniwinther): Add map restricted to live classes.
+    // We don't support patch classes as mixin.
+    assert(mixin.isDeclaration);
+    Set<MixinApplicationElement> users =
+        _mixinUses.putIfAbsent(mixin, () => new Set<MixinApplicationElement>());
+    users.add(mixinApplication);
+  }
+
+  void registerUsedElement(Element element) {
+    if (element.isInstanceMember && !element.isAbstract) {
+      _allFunctions.add(element);
+    }
+  }
+
+  ClosedWorld get closedWorldCache {
+    assert(isClosed);
+    return _closedWorldCache;
+  }
+}
+
+/// 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;
+  FunctionSet _allFunctions;
+
+  final Iterable<TypedefElement> _allTypedefs;
+
+  final Map<ClassElement, Set<MixinApplicationElement>> _mixinUses;
+  Map<ClassElement, List<MixinApplicationElement>> _liveMixinUses;
+
+  final Map<ClassElement, Set<ClassElement>> _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<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 CoreTypes coreTypes;
+
+  final ResolutionWorldBuilder _resolverWorld;
+
+  bool get isClosed => true;
+
+  ClosedWorldImpl(
+      {JavaScriptBackend backend,
+      this.commonElements,
+      this.coreTypes,
+      ResolutionWorldBuilder resolverWorld,
+      FunctionSetBuilder functionSetBuilder,
+      Iterable<TypedefElement> allTypedefs,
+      Map<ClassElement, Set<MixinApplicationElement>> mixinUses,
+      Map<ClassElement, Set<ClassElement>> typesImplementedBySubclasses,
+      Map<ClassElement, ClassHierarchyNode> classHierarchyNodes,
+      Map<ClassElement, ClassSet> classSets})
+      : this._backend = backend,
+        this._resolverWorld = resolverWorld,
+        this._allTypedefs = allTypedefs,
+        this._mixinUses = mixinUses,
+        this._typesImplementedBySubclasses = typesImplementedBySubclasses,
+        this._classHierarchyNodes = classHierarchyNodes,
+        this._classSets = classSets {
+    _commonMasks = new CommonMasks(this);
+    _allFunctions = functionSetBuilder.close(this);
   }
 
   /// Cache of [FlatTypeMask]s grouped by the 8 possible values of the
   /// `FlatTypeMask.flags` property.
   final List<Map<ClassElement, TypeMask>> _canonicalizedTypeMasks =
       new List<Map<ClassElement, TypeMask>>.filled(8, null);
 
+  FunctionSet get allFunctions => _allFunctions;
+
+  CommonMasks get commonMasks {
+    assert(isClosed);
+    return _commonMasks;
+  }
+
+  CoreClasses get coreClasses => commonElements;
+
+  ConstantSystem get constantSystem => _backend.constantSystem;
+
+  TypeMask getCachedMask(ClassElement base, int flags, TypeMask createMask()) {
+    Map<ClassElement, TypeMask> cachedMasks =
+        _canonicalizedTypeMasks[flags] ??= <ClassElement, TypeMask>{};
+    return cachedMasks.putIfAbsent(base, createMask);
+  }
+
   bool checkInvariants(ClassElement cls, {bool mustBeInstantiated: true}) {
     return invariant(cls, cls.isDeclaration,
                 message: '$cls must be the declaration.') &&
             invariant(cls, cls.isResolved,
                 message:
                     '$cls must be resolved.') /* &&
       // TODO(johnniwinther): Reinsert this or similar invariant.
       (!mustBeInstantiated ||
        invariant(cls, isInstantiated(cls),
                  message: '$cls is not instantiated.'))*/
@@ skipping 63 matching lines @@
     ClassHierarchyNode node = _classHierarchyNodes[cls.declaration];
     return node != null && node.isIndirectlyInstantiated;
   }
 
   @override
   bool isAbstract(ClassElement cls) => cls.isAbstract;
 
   /// Returns `true` if [cls] is implemented by an instantiated class.
   bool isImplemented(ClassElement cls) {
     assert(isClosed);
-    return resolverWorld.isImplemented(cls);
+    return _resolverWorld.isImplemented(cls);
   }
 
   /// Returns an iterable over the directly instantiated classes that extend
   /// [cls] possibly including [cls] itself, if it is live.
   Iterable<ClassElement> subclassesOf(ClassElement cls) {
     assert(isClosed);
     ClassHierarchyNode hierarchy = _classHierarchyNodes[cls.declaration];
     if (hierarchy == null) return const <ClassElement>[];
     return hierarchy
         .subclassesByMask(ClassHierarchyNode.EXPLICITLY_INSTANTIATED);
@@ skipping 200 matching lines @@
         if (link.head.asInstanceOf(cls) == null) {
           continue OUTER;
         }
       }
       commonSupertypes.add(cls);
     }
     commonSupertypes.add(coreClasses.objectClass);
     return commonSupertypes;
   }
 
-  /// Returns an iterable over all mixin applications that mixin [cls].
-  Iterable<MixinApplicationElement> allMixinUsesOf(ClassElement cls) {
-    Iterable<MixinApplicationElement> uses = _mixinUses[cls];
-    return uses != null ? uses : const <MixinApplicationElement>[];
-  }
-
   /// Returns an iterable over the live mixin applications that mixin [cls].
   Iterable<MixinApplicationElement> mixinUsesOf(ClassElement cls) {
     assert(isClosed);
     if (_liveMixinUses == null) {
       _liveMixinUses = new Map<ClassElement, List<MixinApplicationElement>>();
       for (ClassElement mixin in _mixinUses.keys) {
         List<MixinApplicationElement> uses = <MixinApplicationElement>[];
 
         void addLiveUse(MixinApplicationElement mixinApplication) {
           if (isInstantiated(mixinApplication)) {
@@ skipping 64 matching lines @@
     Map<ClassElement, bool> secondMap =
         _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 = typesImplementedBySubclassesOf(superclass);
+
+    Set<ClassElement> 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);
     return result == null
@@ skipping 67 matching lines @@
       return subclassesNeedNoSuchMethod(node);
     } else {
       if (subclassesNeedNoSuchMethod(node)) return true;
       for (ClassHierarchyNode subtypeNode in classSet.subtypeNodes) {
         if (subclassesNeedNoSuchMethod(subtypeNode)) return true;
       }
       return false;
     }
   }
 
-  final JavaScriptBackend _backend;
-  BackendClasses get backendClasses => _backend.backendClasses;
-  FunctionSet _allFunctions;
-  final Set<Element> functionsCalledInLoop = new Set<Element>();
-  final Map<Element, SideEffects> sideEffects = new Map<Element, SideEffects>();
-
-  final Set<TypedefElement> _allTypedefs = new Set<TypedefElement>();
-
-  final Map<ClassElement, Set<MixinApplicationElement>> _mixinUses =
-      new Map<ClassElement, Set<MixinApplicationElement>>();
-  Map<ClassElement, List<MixinApplicationElement>> _liveMixinUses;
-
-  final Map<ClassElement, Set<ClassElement>> _typesImplementedBySubclasses =
-      new Map<ClassElement, Set<ClassElement>>();
-
-  // We keep track of subtype and subclass relationships in four
-  // distinct sets to make class hierarchy analysis faster.
-  final Map<ClassElement, ClassHierarchyNode> _classHierarchyNodes =
-      <ClassElement, ClassHierarchyNode>{};
-  final Map<ClassElement, ClassSet> _classSets = <ClassElement, ClassSet>{};
-
-  final Map<ClassElement, Map<ClassElement, bool>> _subtypeCoveredByCache =
-      <ClassElement, Map<ClassElement, bool>>{};
-
-  final Set<Element> sideEffectsFreeElements = new Set<Element>();
-
-  final Set<Element> elementsThatCannotThrow = new Set<Element>();
-
-  final Set<Element> functionsThatMightBePassedToApply =
-      new Set<FunctionElement>();
-
-  final Set<Element> alreadyPopulated;
-
-  CommonMasks _commonMasks;
-
-  final CommonElements commonElements;
-
-  final CoreTypes coreTypes;
-
-  final CacheStrategy cacheStrategy;
-
-  final ResolutionWorldBuilder resolverWorld;
-
-  bool get isClosed => _closed;
-
-  Set<ClassElement> typesImplementedBySubclassesOf(ClassElement cls) {
-    return _typesImplementedBySubclasses[cls.declaration];
-  }
-
-  WorldImpl(this.resolverWorld, this._backend, this.commonElements,
-      this.coreTypes, CacheStrategy cacheStrategy)
-      : this.cacheStrategy = cacheStrategy,
-        alreadyPopulated = cacheStrategy.newSet() {
-    _allFunctions = new FunctionSet(this);
-  }
-
-  FunctionSet get allFunctions => _allFunctions;
-
-  CommonMasks get commonMasks {
-    assert(isClosed);
-    return _commonMasks;
-  }
-
-  CoreClasses get coreClasses => commonElements;
-
-  ConstantSystem get constantSystem => _backend.constantSystem;
-
-  /// 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) => _registerClass(cls);
-
-  void registerClosureClass(ClassElement cls) {
-    _registerClass(cls, isDirectlyInstantiated: true);
-  }
-
-  void _registerClass(ClassElement cls, {bool isDirectlyInstantiated: false}) {
-    _ensureClassSet(cls);
-    if (isDirectlyInstantiated) {
-      _updateClassHierarchyNodeForClass(cls, directlyInstantiated: true);
-    }
-  }
-
-  void registerTypedef(TypedefElement typdef) {
-    _allTypedefs.add(typdef);
-  }
-
-  Iterable<TypedefElement> get allTypedefs => _allTypedefs;
-
   /// Returns [ClassHierarchyNode] for [cls] used to model the class hierarchies
   /// of known classes.
   ///
   /// This method is only provided for testing. For queries on classes, use the
   /// methods defined in [ClosedWorld].
   ClassHierarchyNode getClassHierarchyNode(ClassElement cls) {
     return _classHierarchyNodes[cls.declaration];
   }
 
-  ClassHierarchyNode _ensureClassHierarchyNode(ClassElement cls) {
-    cls = cls.declaration;
-    return _classHierarchyNodes.putIfAbsent(cls, () {
-      ClassHierarchyNode parentNode;
-      if (cls.superclass != null) {
-        parentNode = _ensureClassHierarchyNode(cls.superclass);
-      }
-      return new ClassHierarchyNode(parentNode, cls);
-    });
-  }
-
   /// 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(ClassElement cls) {
     return _classSets[cls.declaration];
   }
 
-  ClassSet _ensureClassSet(ClassElement cls) {
-    cls = cls.declaration;
-    return _classSets.putIfAbsent(cls, () {
-      ClassHierarchyNode node = _ensureClassHierarchyNode(cls);
-      ClassSet classSet = new ClassSet(node);
-
-      for (InterfaceType type in cls.allSupertypes) {
-        // TODO(johnniwinther): Optimization: Avoid adding [cls] to
-        // superclasses.
-        ClassSet subtypeSet = _ensureClassSet(type.element);
-        subtypeSet.addSubtype(node);
-      }
-      if (cls.isMixinApplication) {
-        // TODO(johnniwinther): Store this in the [ClassSet].
-        MixinApplicationElement mixinApplication = cls;
-        if (mixinApplication.mixin != null) {
-          // If [mixinApplication] is malformed [mixin] is `null`.
-          registerMixinUse(mixinApplication, mixinApplication.mixin);
-        }
-      }
-
-      return classSet;
-    });
+  void registerClosureClass(ClosureClassElement cls) {
+    ClassHierarchyNode parentNode = getClassHierarchyNode(cls.superclass);
+    ClassHierarchyNode node =
+        _classHierarchyNodes[cls] = new ClassHierarchyNode(parentNode, cls);
+    for (InterfaceType type in cls.allSupertypes) {
+      ClassSet subtypeSet = getClassSet(type.element);
+      subtypeSet.addSubtype(node);
+    }
+    _classSets[cls] = new ClassSet(node);
+    _updateSuperClassHierarchyNodeForClass(node);
+    node.isDirectlyInstantiated = true;
   }
 
   void _updateSuperClassHierarchyNodeForClass(ClassHierarchyNode node) {
     // Ensure that classes implicitly implementing `Function` are in its
     // subtype set.
     ClassElement cls = node.cls;
-    if (cls != coreClasses.functionClass &&
-        cls.implementsFunction(coreClasses)) {
-      ClassSet subtypeSet = _ensureClassSet(coreClasses.functionClass);
+    if (cls != commonElements.functionClass &&
+        cls.implementsFunction(commonElements)) {
+      ClassSet subtypeSet = getClassSet(commonElements.functionClass);
       subtypeSet.addSubtype(node);
     }
     if (!node.isInstantiated && node.parentNode != null) {
       _updateSuperClassHierarchyNodeForClass(node.parentNode);
     }
   }
 
-  void _updateClassHierarchyNodeForClass(ClassElement cls,
-      {bool directlyInstantiated: false, bool abstractlyInstantiated: false}) {
-    ClassHierarchyNode node = _ensureClassHierarchyNode(cls);
-    _updateSuperClassHierarchyNodeForClass(node);
-    if (directlyInstantiated) {
-      node.isDirectlyInstantiated = true;
-    }
-    if (abstractlyInstantiated) {
-      node.isAbstractlyInstantiated = true;
-    }
-  }
-
-  ClosedWorld closeWorld(DiagnosticReporter reporter) {
-    /// Updates the `isDirectlyInstantiated` and `isIndirectlyInstantiated`
-    /// properties of the [ClassHierarchyNode] for [cls].
-
-    void addSubtypes(ClassElement cls, InstantiationInfo info) {
-      if (!info.hasInstantiation) {
-        return;
-      }
-      if (cacheStrategy.hasIncrementalSupport && !alreadyPopulated.add(cls)) {
-        return;
-      }
-      assert(cls.isDeclaration);
-      if (!cls.isResolved) {
-        reporter.internalError(cls, 'Class "${cls.name}" is not resolved.');
-      }
-
-      _updateClassHierarchyNodeForClass(cls,
-          directlyInstantiated: info.isDirectlyInstantiated,
-          abstractlyInstantiated: info.isAbstractlyInstantiated);
-
-      // Walk through the superclasses, and record the types
-      // implemented by that type on the superclasses.
-      ClassElement superclass = cls.superclass;
-      while (superclass != null) {
-        Set<Element> typesImplementedBySubclassesOfCls =
-            _typesImplementedBySubclasses.putIfAbsent(
-                superclass, () => new Set<ClassElement>());
-        for (DartType current in cls.allSupertypes) {
-          typesImplementedBySubclassesOfCls.add(current.element);
-        }
-        superclass = superclass.superclass;
-      }
-    }
-
-    // Use the [:seenClasses:] set to include non-instantiated
-    // classes: if the superclass of these classes require RTI, then
-    // they also need RTI, so that a constructor passes the type
-    // variables to the super constructor.
-    resolverWorld.forEachInstantiatedClass(addSubtypes);
-
-    _closed = true;
-    _commonMasks = new CommonMasks(this);
-    return this;
-  }
+  Iterable<TypedefElement> get allTypedefs => _allTypedefs;
 
   @override
   String dump([ClassElement cls]) {
     StringBuffer sb = new StringBuffer();
     if (cls != null) {
       sb.write("Classes in the closed world related to $cls:\n");
     } else {
       sb.write("Instantiated classes in the closed world:\n");
     }
     getClassHierarchyNode(coreClasses.objectClass)
         .printOn(sb, ' ', instantiatedOnly: cls == null, withRespectTo: cls);
     return sb.toString();
   }
 
-  void registerMixinUse(
-      MixinApplicationElement mixinApplication, ClassElement mixin) {
-    // TODO(johnniwinther): Add map restricted to live classes.
-    // We don't support patch classes as mixin.
-    assert(mixin.isDeclaration);
-    Set<MixinApplicationElement> users =
-        _mixinUses.putIfAbsent(mixin, () => new Set<MixinApplicationElement>());
-    users.add(mixinApplication);
-  }
-
   bool hasAnyUserDefinedGetter(Selector selector, TypeMask mask) {
     return allFunctions.filter(selector, mask).any((each) => each.isGetter);
   }
 
-  void registerUsedElement(Element element) {
-    if (element.isInstanceMember && !element.isAbstract) {
-      allFunctions.add(element);
-    }
-  }
-
   FieldElement locateSingleField(Selector selector, TypeMask mask) {
     Element result = locateSingleElement(selector, mask);
     return (result != null && result.isField) ? result : null;
   }
 
   Element locateSingleElement(Selector selector, TypeMask mask) {
     assert(isClosed);
     mask ??= commonMasks.dynamicType;
     return mask.locateSingleElement(selector, this);
   }
@@ skipping 23 matching lines @@
       // E.g. node.firstChild depends on parentNode.removeBefore(n1, n2).
       // TODO(sra): Refine the effect classification so that native effects are
       // distinct from ordinary Dart effects.
       return false;
     }
 
     if (element.isFinal || element.isConst) {
       return true;
     }
     if (element.isInstanceMember) {
-      return !resolverWorld.hasInvokedSetter(element) &&
-          !resolverWorld.fieldSetters.contains(element);
+      return !_resolverWorld.hasInvokedSetter(element) &&
+          !_resolverWorld.fieldSetters.contains(element);
     }
     return false;
   }
 
   SideEffects getSideEffectsOfElement(Element element) {
     // The type inferrer (where the side effects are being computed),
     // does not see generative constructor bodies because they are
     // created by the backend. Also, it does not make any distinction
     // between a constructor and its body for side effects. This
     // implies that currently, the side effects of a constructor body
@@ skipping 67 matching lines @@
       return getMightBePassedToApply(element.expression);
     }
     return functionsThatMightBePassedToApply.contains(element);
   }
 
   @override
   bool getCurrentlyKnownMightBePassedToApply(Element element) {
     return getMightBePassedToApply(element);
   }
 }
-
-/// 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,
-}