anchor.diff:      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) {
  
positive.code:     });
    }
  
    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) {
  
negative.code:   SUBTYPE,
  }
  
  abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
    final JavaScriptBackend _backend;
    BackendClasses get backendClasses => _backend.backendClasses;
    InterceptorData get interceptorData => _backend.interceptorData;
  