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>();
@@ skipping 21 matching lines @@
   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];

[Johnni Winther, 2013/12/03 11:52:31]

Is _superclasses needed in itself?

[ahe, 2013/12/04 11:45:43]

Removed.

-  }
-
   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 88 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);
   }
 }