if (thrownExceptionSet.isEmpty()) return thrownExceptionSet;
	private ExceptionSet computeEdgeExceptionSet(Edge edge, ExceptionSet thrownExceptionSet) {		ExceptionSet result = exceptionSetFactory.createExceptionSet();		if (edge.getType() == UNHANDLED_EXCEPTION_EDGE) {			// The unhandled exception edge always comes			// after all of the handled exception edges.			result.addAll(thrownExceptionSet);			thrownExceptionSet.clear();			return result;		}		BasicBlock handlerBlock = edge.getTarget();		CodeExceptionGen handler = handlerBlock.getExceptionGen();		ObjectType catchType = handler.getCatchType();		if (Hierarchy.isUniversalExceptionHandler(catchType)) {			result.addAll(thrownExceptionSet);			thrownExceptionSet.clear();		} else {			// Go through the set of thrown exceptions.			// Any that will DEFINITELY be caught be this handler, remove.			// Any that MIGHT be caught, but won't definitely be caught,			// remain.			for (ExceptionSet.ThrownExceptionIterator i = thrownExceptionSet.iterator(); i.hasNext();) {				//ThrownException thrownException = i.next();				ObjectType thrownType = i.next();				boolean explicit = i.isExplicit();				if (DEBUG)					System.out.println("\texception type " + thrownType +					        ", catch type " + catchType);				try {					if (Hierarchy.isSubtype(thrownType, catchType)) {						// Exception can be thrown along this edge						result.add(thrownType, explicit);							// And it will definitely be caught						i.remove();						if (DEBUG)							System.out.println("\tException is subtype of catch type: " +							        "will definitely catch");					} else if (Hierarchy.isSubtype(catchType, thrownType)) {						// Exception possibly thrown along this edge						result.add(thrownType, explicit);						if (DEBUG)							System.out.println("\tException is supertype of catch type: " +							        "might catch");					}				} catch (ClassNotFoundException e) {					// As a special case, if a class hierarchy lookup					// fails, then we will conservatively assume that the					// exception in question CAN, but WON'T NECESSARILY					// be caught by the handler.					AnalysisContext.reportMissingClass(e);					result.add(thrownType, explicit);				}			}		}		return result;	}