Remove unused API.

dart/sdk/lib/_internal/compiler/implementation/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.
 
 part of dart2js;
 
 class World {
   final Compiler compiler;
   final FunctionSet allFunctions;
   final Set<Element> functionsCalledInLoop = new Set<Element>();
   final Map<Element, SideEffects> sideEffects = new Map<Element, SideEffects>();
 
   final Map<ClassElement, Set<MixinApplicationElement>> mixinUses =
       new Map<ClassElement, Set<MixinApplicationElement>>();
 
   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, Set<ClassElement>> _subclasses =
       new Map<ClassElement, Set<ClassElement>>();
-  final Map<ClassElement, Set<ClassElement>> _superclasses =
-      new Map<ClassElement, Set<ClassElement>>();
   final Map<ClassElement, Set<ClassElement>> _subtypes =
       new Map<ClassElement, Set<ClassElement>>();
   final Map<ClassElement, Set<ClassElement>> _supertypes =
       new Map<ClassElement, Set<ClassElement>>();
 
   final Set<Element> sideEffectsFreeElements = new Set<Element>();
 
   final Set<Element> elementsThatCannotThrow = new Set<Element>();
 
   Set<ClassElement> subclassesOf(ClassElement cls) {
     return _subclasses[cls.declaration];
   }
 
   Set<ClassElement> subtypesOf(ClassElement cls) {
     return _subtypes[cls.declaration];
   }
 
-  Set<ClassElement> superclassesOf(ClassElement cls) {
-    return _superclasses[cls.declaration];
-  }
-
   Set<ClassElement> supertypesOf(ClassElement cls) {
     return _supertypes[cls.declaration];
   }
 
   Set<ClassElement> typesImplementedBySubclassesOf(ClassElement cls) {
     return _typesImplementedBySubclasses[cls.declaration];
   }
 
   bool hasSubclasses(ClassElement cls) {
     Set<ClassElement> subclasses = compiler.world.subclassesOf(cls);
@@ skipping 18 matching lines @@
         Set<Element> subtypesOfSupertype =
             _subtypes.putIfAbsent(type.element, () => new Set<ClassElement>());
         supertypesOfClass.add(type.element);
         subtypesOfSupertype.add(cls);
       }
 
       // Walk through the superclasses, and record the types
       // implemented by that type on the superclasses.
       DartType type = cls.supertype;
       while (type != null) {
-        Set<Element> superclassesOfClass =
-            _superclasses.putIfAbsent(cls, () => new Set<ClassElement>());
         Set<Element> subclassesOfSuperclass =
             _subclasses.putIfAbsent(type.element, () => new Set<ClassElement>());
-        superclassesOfClass.add(type.element);
         subclassesOfSuperclass.add(cls);
 
         Set<Element> typesImplementedBySubclassesOfCls =
             _typesImplementedBySubclasses.putIfAbsent(
                 type.element, () => new Set<ClassElement>());
         for (DartType current in cls.allSupertypes) {
           typesImplementedBySubclassesOfCls.add(current.element);
         }
         ClassElement classElement = type.element;
         type = classElement.supertype;
@@ skipping 45 matching lines @@
 
   bool hasAnySubtype(ClassElement cls) {
     Set<ClassElement> classes = subtypesOf(cls);
     return classes != null && !classes.isEmpty;
   }
 
   bool hasAnyUserDefinedGetter(Selector selector) {
     return allFunctions.filter(selector).any((each) => each.isGetter());
   }
 
-  bool hasAnyUserDefinedSetter(Selector selector) {
-     return allFunctions.filter(selector).any((each) => each.isSetter());
-  }
-
   // Returns whether a subclass of [superclass] implements [type].
   bool hasAnySubclassThatImplements(ClassElement superclass,
                                     ClassElement type) {
     Set<ClassElement> subclasses = typesImplementedBySubclassesOf(superclass);
     if (subclasses == null) return false;
     return subclasses.contains(type);
   }
 
   // Returns whether a subclass of any mixin application of [cls] implements
   // [type].
@@ skipping 33 matching lines @@
     return (result != null && result.isField()) ? result : null;
   }
 
   Element locateSingleElement(Selector selector) {
     ti.TypeMask mask = selector.mask == null
         ? new ti.TypeMask.subclass(compiler.objectClass)
         : selector.mask;
     return mask.locateSingleElement(selector, compiler);
   }
 
-  bool hasSingleMatch(Selector selector) {
-    Iterable<Element> targets = allFunctions.filter(selector);
-    return targets.length == 1;
-  }
-
-  Iterable<ClassElement> locateNoSuchMethodHolders(Selector selector) {
-    Selector noSuchMethodSelector = compiler.noSuchMethodSelector;
-    ti.TypeMask mask = selector.mask;
-    if (mask != null) {
-      noSuchMethodSelector = new TypedSelector(mask, noSuchMethodSelector);
-    }
-    ClassElement objectClass = compiler.objectClass;
-    return allFunctions
-        .filter(noSuchMethodSelector)
-        .map((Element member) => member.getEnclosingClass())
-        .where((ClassElement holder) => !identical(holder, objectClass));
-  }
-
   void addFunctionCalledInLoop(Element element) {
     functionsCalledInLoop.add(element.declaration);
   }
 
   bool isCalledInLoop(Element element) {
     return functionsCalledInLoop.contains(element.declaration);
   }
 
   bool fieldNeverChanges(Element element) {
     if (!element.isField()) return false;
@@ skipping 60 matching lines @@
   }
 
   void registerCannotThrow(Element element) {
     elementsThatCannotThrow.add(element);
   }
 
   bool getCannotThrow(Element element) {
     return elementsThatCannotThrow.contains(element);
   }
 }