anchor.diff:      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] =
  
positive.code:     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]
  
negative.code:     Link<OrderedTypeSet> otherTypeSets = const Link<OrderedTypeSet>();
      do {
        ClassElement otherClass = iterator.current;
        assert(_checkInvariants(otherClass));
        OrderedTypeSet otherTypeSet = otherClass.allSupertypesAndSelf;
        otherTypeSets = otherTypeSets.prepend(otherTypeSet);
        if (otherTypeSet.maxDepth < depth) {
  