Extract ClosedWorldBase from ClosedWorldImpl

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';
 import 'common_elements.dart' show CommonElements;
 import 'elements/entities.dart';
 import 'elements/elements.dart'
     show
         ClassElement,
         Element,
         FunctionElement,
         MemberElement,
         MixinApplicationElement,
-        TypedefElement,
-        FieldElement;
+        TypedefElement;
 import 'elements/resolution_types.dart';
 import 'js_backend/backend.dart' show JavaScriptBackend;
 import 'js_backend/interceptor_data.dart' show InterceptorData;
 import 'js_backend/native_data.dart' show NativeData;
 import 'ordered_typeset.dart';
 import 'types/masks.dart' show CommonMasks, FlatTypeMask, TypeMask;
 import 'universe/class_set.dart';
 import 'universe/function_set.dart' show FunctionSet, FunctionSetBuilder;
 import 'universe/selector.dart' show Selector;
 import 'universe/side_effects.dart' show SideEffects;
@@ skipping 82 matching lines @@
   /// itself.
   void forEachStrictSubclassOf(
       ClassEntity cls, IterationStep f(ClassEntity cls));
 
   /// Returns `true` if [predicate] applies to any live class that extend [cls]
   /// _not_ including [cls] itself.
   bool anyStrictSubclassOf(ClassEntity cls, bool predicate(ClassEntity cls));
 
   /// Returns an iterable over the directly instantiated that implement [cls]
   /// possibly including [cls] itself, if it is live.
-  Iterable<ClassElement> subtypesOf(ClassEntity cls);
+  Iterable<ClassEntity> subtypesOf(ClassEntity cls);
 
   /// Returns an iterable over the live classes that implement [cls] _not_
   /// including [cls] if it is live.
-  Iterable<ClassElement> strictSubtypesOf(ClassEntity cls);
+  Iterable<ClassEntity> strictSubtypesOf(ClassEntity cls);
 
   /// Returns the number of live classes that implement [cls] _not_
   /// including [cls] itself.
   int strictSubtypeCount(ClassEntity cls);
 
   /// Applies [f] to each live class that implements [cls] _not_ including [cls]
   /// itself.
   void forEachStrictSubtypeOf(
       ClassEntity cls, IterationStep f(ClassEntity cls));
 
@@ skipping 37 matching lines @@
   ///     class A {}
   ///     class B {}
   ///     class C implements A, B {}
   ///     class D extends C {}
   ///
   /// the query
   ///
   ///     commonSubclasses(A, ClassQuery.SUBTYPE, B, ClassQuery.SUBTYPE)
   ///
   /// return the set {C} because [D] is implied by [C].
-  Iterable<ClassEntity> commonSubclasses(ClassElement cls1, ClassQuery query1,
-      ClassElement cls2, ClassQuery query2);
+  Iterable<ClassEntity> commonSubclasses(
+      ClassEntity cls1, ClassQuery query1, ClassEntity cls2, ClassQuery query2);
 
   /// Returns an iterable over the live mixin applications that mixin [cls].
   Iterable<ClassEntity> mixinUsesOf(ClassEntity cls);
 
   /// Returns `true` if [cls] is mixed into a live class.
   bool isUsedAsMixin(ClassEntity cls);
 
   /// Returns `true` if any live class that mixes in [cls] implements [type].
   bool hasAnySubclassOfMixinUseThatImplements(
       ClassEntity cls, ClassEntity type);
@@ skipping 183 matching lines @@
   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 {
+abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   final JavaScriptBackend _backend;
   BackendClasses get backendClasses => _backend.backendClasses;
   InterceptorData get interceptorData => _backend.interceptorData;
   FunctionSet _allFunctions;
 
   final Iterable<TypedefElement> _allTypedefs;
 
   final Map<ClassEntity, Set<ClassEntity>> _mixinUses;
   Map<ClassEntity, List<ClassEntity>> _liveMixinUses;
 
@@ skipping 16 matching lines @@
 
   final Set<Element> functionsThatMightBePassedToApply =
       new Set<FunctionElement>();
 
   CommonMasks _commonMasks;
 
   final CommonElements commonElements;
 
   final ResolutionWorldBuilder _resolverWorld;
 
-  ClosedWorldImpl(
+  ClosedWorldBase(
       {JavaScriptBackend backend,
       this.commonElements,
       ResolutionWorldBuilder resolutionWorldBuilder,
       FunctionSetBuilder functionSetBuilder,
       Iterable<TypedefElement> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets})
       : this._backend = backend,
@@ skipping 24 matching lines @@
   }
 
   ConstantSystem get constantSystem => _backend.constantSystem;
 
   TypeMask getCachedMask(ClassEntity base, int flags, TypeMask createMask()) {
     Map<ClassEntity, TypeMask> cachedMasks =
         _canonicalizedTypeMasks[flags] ??= <ClassEntity, TypeMask>{};
     return cachedMasks.putIfAbsent(base, createMask);
   }
 
-  bool _checkClass(ClassElement cls) => cls.isDeclaration;
-
-  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.'))*/
-        ;
-  }
-
-  /// Returns `true` if [x] is a subtype of [y], that is, if [x] implements an
-  /// instance of [y].
-  bool isSubtypeOf(ClassElement x, ClassElement y) {
-    assert(checkInvariants(x));
-    assert(checkInvariants(y, mustBeInstantiated: false));
-
-    if (y == commonElements.objectClass) return true;
-    if (x == commonElements.objectClass) return false;
-    if (x.asInstanceOf(y) != null) return true;
-    if (y != commonElements.functionClass) return false;
-    return x.callType != null;
-  }
-
-  /// Return `true` if [x] is a (non-strict) subclass of [y].
-  bool isSubclassOf(ClassElement x, ClassElement y) {
-    assert(checkInvariants(x));
-    assert(checkInvariants(y));
-
-    if (y == commonElements.objectClass) return true;
-    if (x == commonElements.objectClass) return false;
-    while (x != null && x.hierarchyDepth >= y.hierarchyDepth) {
-      if (x == y) return true;
-      x = x.superclass;
-    }
-    return false;
-  }
+  bool _checkClass(ClassEntity cls);
 
   @override
   bool isInstantiated(ClassEntity cls) {
     assert(_checkClass(cls));
     ClassHierarchyNode node = _classHierarchyNodes[cls];
     return node != null && node.isInstantiated;
   }
 
   @override
   bool isDirectlyInstantiated(ClassEntity cls) {
@@ skipping 201 matching lines @@
   @override
   ClassEntity getLubOfInstantiatedSubtypes(ClassEntity cls) {
     assert(_checkClass(cls));
     if (nativeData.isJsInteropClass(cls)) {
       return _backend.helpers.jsJavaScriptObjectClass;
     }
     ClassSet classSet = _classSets[cls];
     return classSet != null ? classSet.getLubOfInstantiatedSubtypes() : null;
   }
 
+  Set<ClassEntity> _commonContainedClasses(ClassEntity cls1, ClassQuery query1,
+      ClassEntity cls2, ClassQuery query2) {
+    Iterable<ClassEntity> xSubset = _containedSubset(cls1, query1);
+    if (xSubset == null) return null;
+    Iterable<ClassEntity> ySubset = _containedSubset(cls2, query2);
+    if (ySubset == null) return null;
+    return xSubset.toSet().intersection(ySubset.toSet());
+  }
+
+  Iterable<ClassEntity> _containedSubset(ClassEntity cls, ClassQuery query) {
+    switch (query) {
+      case ClassQuery.EXACT:
+        return null;
+      case ClassQuery.SUBCLASS:
+        return strictSubclassesOf(cls);
+      case ClassQuery.SUBTYPE:
+        return strictSubtypesOf(cls);
+    }
+    throw new ArgumentError('Unexpected query: $query.');
+  }
+
+  /// Returns `true` if [cls] is mixed into a live class.
+  bool isUsedAsMixin(ClassEntity cls) {
+    return !mixinUsesOf(cls).isEmpty;
+  }
+
+  /// Returns `true` if any live class that mixes in [cls] implements [type].
+  bool hasAnySubclassOfMixinUseThatImplements(
+      ClassEntity cls, ClassEntity type) {
+    return mixinUsesOf(cls)
+        .any((use) => hasAnySubclassThatImplements(use, type));
+  }
+
+  /// Returns `true` if every subtype of [x] is a subclass of [y] or a subclass
+  /// of a mixin application of [y].
+  bool everySubtypeIsSubclassOfOrMixinUseOf(ClassEntity x, ClassEntity y) {
+    assert(_checkClass(x));
+    assert(_checkClass(y));
+    Map<ClassEntity, bool> secondMap =
+        _subtypeCoveredByCache[x] ??= <ClassEntity, bool>{};
+    return secondMap[y] ??= subtypesOf(x).every((ClassEntity cls) =>
+        isSubclassOf(cls, y) || isSubclassOfMixinUseOf(cls, y));
+  }
+
+  /// Returns `true` if any subclass of [superclass] implements [type].
+  bool hasAnySubclassThatImplements(ClassEntity superclass, ClassEntity type) {
+    assert(_checkClass(superclass));
+    Set<ClassEntity> subclasses = _typesImplementedBySubclasses[superclass];
+    if (subclasses == null) return false;
+    return subclasses.contains(type);
+  }
+
+  /// Returns whether a [selector] call on an instance of [cls]
+  /// will hit a method at runtime, and not go through [noSuchMethod].
+  bool hasConcreteMatch(ClassEntity cls, Selector selector,
+      {ClassEntity stopAtSuperclass});
+
+  @override
+  bool needsNoSuchMethod(
+      ClassEntity base, Selector selector, ClassQuery query) {
+    /// Returns `true` if subclasses in the [rootNode] tree needs noSuchMethod
+    /// handling.
+    bool subclassesNeedNoSuchMethod(ClassHierarchyNode rootNode) {
+      if (!rootNode.isInstantiated) {
+        // No subclass needs noSuchMethod handling since they are all
+        // uninstantiated.
+        return false;
+      }
+      ClassEntity rootClass = rootNode.cls;
+      if (hasConcreteMatch(rootClass, selector)) {
+        // The root subclass has a concrete implementation so no subclass needs
+        // noSuchMethod handling.
+        return false;
+      } else if (rootNode.isExplicitlyInstantiated) {
+        // The root class need noSuchMethod handling.
+        return true;
+      }
+      IterationStep result = rootNode.forEachSubclass((ClassEntity subclass) {
+        if (hasConcreteMatch(subclass, selector, stopAtSuperclass: rootClass)) {
+          // Found a match - skip all subclasses.
+          return IterationStep.SKIP_SUBCLASSES;
+        } else {
+          // Stop fast - we found a need for noSuchMethod handling.
+          return IterationStep.STOP;
+        }
+      }, ClassHierarchyNode.EXPLICITLY_INSTANTIATED, strict: true);
+      // We stopped fast so we need noSuchMethod handling.
+      return result == IterationStep.STOP;
+    }
+
+    ClassSet classSet = getClassSet(base);
+    ClassHierarchyNode node = classSet.node;
+    if (query == ClassQuery.EXACT) {
+      return node.isExplicitlyInstantiated && !hasConcreteMatch(base, selector);
+    } else if (query == ClassQuery.SUBCLASS) {
+      return subclassesNeedNoSuchMethod(node);
+    } else {
+      if (subclassesNeedNoSuchMethod(node)) return true;
+      for (ClassHierarchyNode subtypeNode in classSet.subtypeNodes) {
+        if (subclassesNeedNoSuchMethod(subtypeNode)) return true;
+      }
+      return false;
+    }
+  }
+
+  /// 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(ClassEntity cls) {
+    assert(_checkClass(cls));
+    return _classHierarchyNodes[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(ClassEntity cls) {
+    assert(_checkClass(cls));
+    return _classSets[cls];
+  }
+
+  Iterable<TypedefElement> get allTypedefs => _allTypedefs;
+
+  bool hasAnyUserDefinedGetter(Selector selector, TypeMask mask) {
+    return allFunctions.filter(selector, mask).any((each) => each.isGetter);
+  }
+
+  FieldEntity locateSingleField(Selector selector, TypeMask mask) {
+    MemberEntity result = locateSingleElement(selector, mask);
+    return (result != null && result.isField) ? result : null;
+  }
+
+  MemberEntity locateSingleElement(Selector selector, TypeMask mask) {
+    mask ??= commonMasks.dynamicType;
+    return mask.locateSingleElement(selector, this);
+  }
+
+  TypeMask extendMaskIfReachesAll(Selector selector, TypeMask mask) {
+    bool canReachAll = true;
+    if (mask != null) {
+      canReachAll = _backend.backendUsage.isInvokeOnUsed &&
+          mask.needsNoSuchMethodHandling(selector, this);
+    }
+    return canReachAll ? commonMasks.dynamicType : mask;
+  }
+
+  bool fieldNeverChanges(MemberEntity element) {
+    if (!element.isField) return false;
+    if (nativeData.isNativeMember(element)) {
+      // Some native fields are views of data that may be changed by operations.
+      // 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.isAssignable) {
+      return true;
+    }
+    if (element.isInstanceMember) {
+      return !_resolverWorld.hasInvokedSetter(element) &&
+          !_resolverWorld.fieldSetters.contains(element);
+    }
+    return false;
+  }
+
+  SideEffects getSideEffectsOfSelector(Selector selector, TypeMask mask) {
+    // We're not tracking side effects of closures.
+    if (selector.isClosureCall) return new SideEffects();
+    SideEffects sideEffects = new SideEffects.empty();
+    for (MemberElement e in allFunctions.filter(selector, mask)) {
+      if (e.isField) {
+        if (selector.isGetter) {
+          if (!fieldNeverChanges(e)) {
+            sideEffects.setDependsOnInstancePropertyStore();
+          }
+        } else if (selector.isSetter) {
+          sideEffects.setChangesInstanceProperty();
+        } else {
+          assert(selector.isCall);
+          sideEffects.setAllSideEffects();
+          sideEffects.setDependsOnSomething();
+        }
+      } else {
+        sideEffects.add(getSideEffectsOfElement(e));
+      }
+    }
+    return sideEffects;
+  }
+}
+
+class ClosedWorldImpl extends ClosedWorldBase {
+  ClosedWorldImpl(
+      {JavaScriptBackend backend,
+      CommonElements commonElements,
+      ResolutionWorldBuilder resolutionWorldBuilder,
+      FunctionSetBuilder functionSetBuilder,
+      Iterable<TypedefElement> allTypedefs,
+      Map<ClassEntity, Set<ClassEntity>> mixinUses,
+      Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
+      Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
+      Map<ClassEntity, ClassSet> classSets})
+      : super(
+            backend: backend,
+            commonElements: commonElements,
+            resolutionWorldBuilder: resolutionWorldBuilder,
+            functionSetBuilder: functionSetBuilder,
+            allTypedefs: allTypedefs,
+            mixinUses: mixinUses,
+            typesImplementedBySubclasses: typesImplementedBySubclasses,
+            classHierarchyNodes: classHierarchyNodes,
+            classSets: classSets);
+
+  bool _checkClass(ClassElement cls) => cls.isDeclaration;
+
+  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. Currently
+      // various call sites use uninstantiated classes for isSubtypeOf or
+      // isSubclassOf. Some are valid, some are not. Work out better invariants
+      // to catch the latter.
+      (!mustBeInstantiated ||
+       invariant(cls, isInstantiated(cls),
+                 message: '$cls is not instantiated.'))*/
+        ;
+  }
+
+  /// Returns `true` if [x] is a subtype of [y], that is, if [x] implements an
+  /// instance of [y].
+  bool isSubtypeOf(ClassElement x, ClassElement y) {
+    assert(_checkInvariants(x));
+    assert(_checkInvariants(y, mustBeInstantiated: false));
+
+    if (y == commonElements.objectClass) return true;
+    if (x == commonElements.objectClass) return false;
+    if (x.asInstanceOf(y) != null) return true;
+    if (y != commonElements.functionClass) return false;
+    return x.callType != null;
+  }
+
+  /// Return `true` if [x] is a (non-strict) subclass of [y].
+  bool isSubclassOf(ClassElement x, ClassElement y) {
+    assert(_checkInvariants(x));
+    assert(_checkInvariants(y));
+
+    if (y == commonElements.objectClass) return true;
+    if (x == commonElements.objectClass) return false;
+    while (x != null && x.hierarchyDepth >= y.hierarchyDepth) {
+      if (x == y) return true;
+      x = x.superclass;
+    }
+    return false;
+  }
+
   /// Returns an iterable over the common supertypes of the [classes].
   Iterable<ClassElement> commonSupertypesOf(Iterable<ClassElement> classes) {
     Iterator<ClassElement> iterator = classes.iterator;
     if (!iterator.moveNext()) return const <ClassElement>[];
 
     ClassElement cls = iterator.current;
-    assert(checkInvariants(cls));
+    assert(_checkInvariants(cls));
     OrderedTypeSet typeSet = cls.allSupertypesAndSelf;
     if (!iterator.moveNext()) return typeSet.types.map((type) => type.element);
 
     int depth = typeSet.maxDepth;
     Link<OrderedTypeSet> otherTypeSets = const Link<OrderedTypeSet>();
     do {
       ClassElement otherClass = iterator.current;
-      assert(checkInvariants(otherClass));
+      assert(_checkInvariants(otherClass));
       OrderedTypeSet otherTypeSet = otherClass.allSupertypesAndSelf;
       otherTypeSets = otherTypeSets.prepend(otherTypeSet);
       if (otherTypeSet.maxDepth < depth) {
         depth = otherTypeSet.maxDepth;
       }
     } while (iterator.moveNext());
 
     List<ClassElement> commonSupertypes = <ClassElement>[];
     OUTER:
     for (Link<ResolutionDartType> link = typeSet[depth];
@@ skipping 37 matching lines @@
       // Run through the direct supertypes of the class. If the common
       // set contains the direct supertype of the class, we ignore the
       // the class because the supertype is a better candidate.
       for (Link link = each.interfaces; !link.isEmpty; link = link.tail) {
         if (common.contains(link.head.element)) return false;
       }
       return true;
     });
   }
 
-  Set<ClassEntity> _commonContainedClasses(ClassEntity cls1, ClassQuery query1,
-      ClassEntity cls2, ClassQuery query2) {
-    Iterable<ClassEntity> xSubset = _containedSubset(cls1, query1);
-    if (xSubset == null) return null;
-    Iterable<ClassEntity> ySubset = _containedSubset(cls2, query2);
-    if (ySubset == null) return null;
-    return xSubset.toSet().intersection(ySubset.toSet());
-  }
-
-  Iterable<ClassEntity> _containedSubset(ClassEntity cls, ClassQuery query) {
-    switch (query) {
-      case ClassQuery.EXACT:
-        return null;
-      case ClassQuery.SUBCLASS:
-        return strictSubclassesOf(cls);
-      case ClassQuery.SUBTYPE:
-        return strictSubtypesOf(cls);
-    }
-    throw new ArgumentError('Unexpected query: $query.');
-  }
-
   /// Returns an iterable over the live mixin applications that mixin [cls].
   Iterable<ClassEntity> mixinUsesOf(ClassEntity cls) {
     if (_liveMixinUses == null) {
       _liveMixinUses = new Map<ClassEntity, List<ClassEntity>>();
       for (ClassElement mixin in _mixinUses.keys) {
         List<ClassEntity> uses = <ClassEntity>[];
 
         void addLiveUse(MixinApplicationElement mixinApplication) {
           if (isInstantiated(mixinApplication)) {
             uses.add(mixinApplication);
           } else if (mixinApplication.isNamedMixinApplication) {
             Set<ClassEntity> next = _mixinUses[mixinApplication];
             if (next != null) {
               next.forEach(addLiveUse);
             }
           }
         }
 
         _mixinUses[mixin].forEach(addLiveUse);
         if (uses.isNotEmpty) {
           _liveMixinUses[mixin] = uses;
         }
       }
     }
     Iterable<ClassEntity> uses = _liveMixinUses[cls];
     return uses != null ? uses : const <ClassEntity>[];
   }
 
-  /// Returns `true` if [cls] is mixed into a live class.
-  bool isUsedAsMixin(ClassEntity cls) {
-    return !mixinUsesOf(cls).isEmpty;
-  }
-
-  /// Returns `true` if any live class that mixes in [cls] implements [type].
-  bool hasAnySubclassOfMixinUseThatImplements(
-      ClassEntity cls, ClassEntity type) {
-    return mixinUsesOf(cls)
-        .any((use) => hasAnySubclassThatImplements(use, type));
-  }
-
   /// Returns `true` if any live class that mixes in [mixin] is also a subclass
   /// of [superclass].
   bool hasAnySubclassThatMixes(ClassEntity superclass, ClassEntity mixin) {
     return mixinUsesOf(mixin).any((ClassElement each) {
       return each.isSubclassOf(superclass);
     });
   }
 
   /// Returns `true` if [cls] or any superclass mixes in [mixin].
   bool isSubclassOfMixinUseOf(ClassEntity cls, ClassEntity mixin) {
     assert(_checkClass(cls));
     assert(_checkClass(mixin));
     if (isUsedAsMixin(mixin)) {
       ClassElement current = cls;
       while (current != null) {
         if (current.isMixinApplication) {
           MixinApplicationElement application = current;
           if (application.mixin == mixin) return true;
         }
         current = current.superclass;
       }
     }
     return false;
   }
 
-  /// Returns `true` if every subtype of [x] is a subclass of [y] or a subclass
-  /// of a mixin application of [y].
-  bool everySubtypeIsSubclassOfOrMixinUseOf(ClassEntity x, ClassEntity y) {
-    assert(_checkClass(x));
-    assert(_checkClass(y));
-    Map<ClassEntity, bool> secondMap =
-        _subtypeCoveredByCache[x] ??= <ClassEntity, bool>{};
-    return secondMap[y] ??= subtypesOf(x).every((ClassEntity cls) =>
-        isSubclassOf(cls, y) || isSubclassOfMixinUseOf(cls, y));
-  }
-
-  /// Returns `true` if any subclass of [superclass] implements [type].
-  bool hasAnySubclassThatImplements(ClassEntity superclass, ClassEntity type) {
-    assert(_checkClass(superclass));
-    Set<ClassEntity> subclasses = _typesImplementedBySubclasses[superclass];
-    if (subclasses == null) return false;
-    return subclasses.contains(type);
-  }
-
   @override
   bool hasElementIn(ClassEntity cls, Selector selector, Element element) {
     // Use [:implementation:] of [element]
     // because our function set only stores declarations.
     Element result = findMatchIn(cls, selector);
     return result == null
         ? false
         : result.implementation == element.implementation;
   }
 
@@ skipping 14 matching lines @@
     MemberElement element = findMatchIn(cls, selector);
     if (element == null) return false;
 
     if (element.isAbstract) {
       ClassElement enclosingClass = element.enclosingClass;
       return hasConcreteMatch(enclosingClass.superclass, selector);
     }
     return selector.appliesUntyped(element);
   }
 
-  @override
-  bool needsNoSuchMethod(
-      ClassElement base, Selector selector, ClassQuery query) {
-    /// Returns `true` if subclasses in the [rootNode] tree needs noSuchMethod
-    /// handling.
-    bool subclassesNeedNoSuchMethod(ClassHierarchyNode rootNode) {
-      if (!rootNode.isInstantiated) {
-        // No subclass needs noSuchMethod handling since they are all
-        // uninstantiated.
-        return false;
-      }
-      ClassElement rootClass = rootNode.cls;
-      if (hasConcreteMatch(rootClass, selector)) {
-        // The root subclass has a concrete implementation so no subclass needs
-        // noSuchMethod handling.
-        return false;
-      } else if (rootNode.isExplicitlyInstantiated) {
-        // The root class need noSuchMethod handling.
-        return true;
-      }
-      IterationStep result = rootNode.forEachSubclass((ClassElement subclass) {
-        if (hasConcreteMatch(subclass, selector, stopAtSuperclass: rootClass)) {
-          // Found a match - skip all subclasses.
-          return IterationStep.SKIP_SUBCLASSES;
-        } else {
-          // Stop fast - we found a need for noSuchMethod handling.
-          return IterationStep.STOP;
-        }
-      }, ClassHierarchyNode.EXPLICITLY_INSTANTIATED, strict: true);
-      // We stopped fast so we need noSuchMethod handling.
-      return result == IterationStep.STOP;
-    }
-
-    ClassSet classSet = getClassSet(base);
-    ClassHierarchyNode node = classSet.node;
-    if (query == ClassQuery.EXACT) {
-      return node.isExplicitlyInstantiated && !hasConcreteMatch(base, selector);
-    } else if (query == ClassQuery.SUBCLASS) {
-      return subclassesNeedNoSuchMethod(node);
-    } else {
-      if (subclassesNeedNoSuchMethod(node)) return true;
-      for (ClassHierarchyNode subtypeNode in classSet.subtypeNodes) {
-        if (subclassesNeedNoSuchMethod(subtypeNode)) return true;
-      }
-      return false;
-    }
-  }
-
-  /// 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(ClassEntity cls) {
-    assert(_checkClass(cls));
-    return _classHierarchyNodes[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(ClassEntity cls) {
-    assert(_checkClass(cls));
-    return _classSets[cls];
-  }
-
   void registerClosureClass(ClosureClassElement cls) {
     ClassHierarchyNode parentNode = getClassHierarchyNode(cls.superclass);
     ClassHierarchyNode node = _classHierarchyNodes[cls] =
         new ClassHierarchyNode(parentNode, cls, cls.hierarchyDepth);
     for (ResolutionInterfaceType 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 != commonElements.functionClass &&
         cls.implementsFunction(commonElements)) {
       ClassSet subtypeSet = getClassSet(commonElements.functionClass);
       subtypeSet.addSubtype(node);
     }
     if (!node.isInstantiated && node.parentNode != null) {
       _updateSuperClassHierarchyNodeForClass(node.parentNode);
     }
   }
 
-  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(commonElements.objectClass)
         .printOn(sb, ' ', instantiatedOnly: cls == null, withRespectTo: cls);
     return sb.toString();
   }
 
-  bool hasAnyUserDefinedGetter(Selector selector, TypeMask mask) {
-    return allFunctions.filter(selector, mask).any((each) => each.isGetter);
-  }
-
-  FieldElement locateSingleField(Selector selector, TypeMask mask) {
-    Element result = locateSingleElement(selector, mask);
-    return (result != null && result.isField) ? result : null;
-  }
-
-  MemberElement locateSingleElement(Selector selector, TypeMask mask) {
-    mask ??= commonMasks.dynamicType;
-    return mask.locateSingleElement(selector, this);
-  }
-
-  TypeMask extendMaskIfReachesAll(Selector selector, TypeMask mask) {
-    bool canReachAll = true;
-    if (mask != null) {
-      canReachAll = _backend.backendUsage.isInvokeOnUsed &&
-          mask.needsNoSuchMethodHandling(selector, this);
-    }
-    return canReachAll ? commonMasks.dynamicType : mask;
-  }
-
-  void addFunctionCalledInLoop(Element element) {
-    functionsCalledInLoop.add(element.declaration);
-  }
-
-  bool isCalledInLoop(Element element) {
-    return functionsCalledInLoop.contains(element.declaration);
-  }
-
-  bool fieldNeverChanges(MemberElement element) {
-    if (!element.isField) return false;
-    if (nativeData.isNativeMember(element)) {
-      // Some native fields are views of data that may be changed by operations.
-      // 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 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
     // contain the side effects of the initializers.
     assert(!element.isGenerativeConstructorBody);
     assert(!element.isField);
     return sideEffects.putIfAbsent(element.declaration, () {
       return new SideEffects();
     });
   }
 
   @override
   SideEffects getCurrentlyKnownSideEffects(Element element) {
     return getSideEffectsOfElement(element);
   }
 
   void registerSideEffects(Element element, SideEffects effects) {
     if (sideEffectsFreeElements.contains(element)) return;
     sideEffects[element.declaration] = effects;
   }
 
   void registerSideEffectsFree(Element element) {
     sideEffects[element.declaration] = new SideEffects.empty();
     sideEffectsFreeElements.add(element);
   }
 
-  SideEffects getSideEffectsOfSelector(Selector selector, TypeMask mask) {
-    // We're not tracking side effects of closures.
-    if (selector.isClosureCall) return new SideEffects();
-    SideEffects sideEffects = new SideEffects.empty();
-    for (MemberElement e in allFunctions.filter(selector, mask)) {
-      if (e.isField) {
-        if (selector.isGetter) {
-          if (!fieldNeverChanges(e)) {
-            sideEffects.setDependsOnInstancePropertyStore();
-          }
-        } else if (selector.isSetter) {
-          sideEffects.setChangesInstanceProperty();
-        } else {
-          assert(selector.isCall);
-          sideEffects.setAllSideEffects();
-          sideEffects.setDependsOnSomething();
-        }
-      } else {
-        sideEffects.add(getSideEffectsOfElement(e));
-      }
-    }
-    return sideEffects;
+  void addFunctionCalledInLoop(Element element) {
+    functionsCalledInLoop.add(element.declaration);
+  }
+
+  bool isCalledInLoop(Element element) {
+    return functionsCalledInLoop.contains(element.declaration);
   }
 
   void registerCannotThrow(Element element) {
     elementsThatCannotThrow.add(element);
   }
 
   bool getCannotThrow(Element element) {
     return elementsThatCannotThrow.contains(element);
   }
 
@@ skipping 12 matching lines @@
       return getMightBePassedToApply(element.expression);
     }
     return functionsThatMightBePassedToApply.contains(element);
   }
 
   @override
   bool getCurrentlyKnownMightBePassedToApply(Element element) {
     return getMightBePassedToApply(element);
   }
 }