if (missingClassList.isEmpty()) {  return isSubtype; } else {     if (isSubtype) return true; else throw new ClassNotFoundException("Class not found: " + missingClassList); }
return cachedResult.isSupertype(supertype);
	public boolean isSubtype(ObjectType subtype, ObjectType supertype) throws ClassNotFoundException {		if (Debug.VERIFY_INTEGRITY) {			if (!inheritanceGraph.containsVertex(subtype))				throw new IllegalStateException("Inheritance graph does not contain node " +					subtype.getSignature());			if (!inheritanceGraph.containsVertex(supertype))				throw new IllegalStateException("Inheritance graph does not contain node " +					supertype.getSignature());		}		// TODO: precompute subtypes and store in a table of bit vectors		// based on type ids.  That would be really fast.		// For now, we do a slow traversal of the inheritance graph.		// Breadth first search through superinterfaces		// and interfaces implemented by superclasses		// TODO: cache the result as a bit vector of type ids.		// Work queue		LinkedList<ObjectType> work = new LinkedList<ObjectType>();		work.add(subtype);		// Keep track of where we've been		HashSet<ObjectType> visited = new HashSet<ObjectType>();		// Keep track of missing classes		LinkedList<String> missingClassList = new LinkedList<String>();		boolean isSubtype = false;		// Until we have examined all supertypes...		while (!work.isEmpty()) {			ObjectType type = work.removeFirst();			if (!visited.add(type))				continue;			if (type.equals(supertype)) {				isSubtype = true;				// NOTE: we keep going finding all supertypes,				// in order that when we finished we have enumerated				// the complete set of supertypes, which could				// then be cached.			}			try {				// Resolve the type so we know its supertypes.				resolveObjectType(type);				// Add all supertypes to work queue.				for (Iterator<ObjectType> i = inheritanceGraph.successorIterator(type); i.hasNext(); )					work.add(i.next());			} catch (ClassNotFoundException e) {				String missingClassName = ClassNotFoundExceptionParser.getMissingClassName(e);				if (missingClassName == null)					missingClassName = "<unknown class>";				missingClassList.add(missingClassName);			}		}		// Search terminated without finding the superinterface.		// If no part of the class hierarchy was unknown,		// then we have a definitive answer.  Otherwise,		// throw an exception.		if (missingClassList.isEmpty()) {			// TODO: cache bit vector of known supertypes			return isSubtype;		} else {			// There were missing classes.  However, an answer of			// "true" is still definitive.  We just won't cache the			// result.  FIXME: need to hook in a missing class			// reporter so caller still knows about the problem.			if (isSubtype)				return true;			else				throw new ClassNotFoundException("Class not found: " + missingClassList);		}	}