protected void computeEdgeAndThreadNo() {
Iterator it = iterator();
int numberOfEdge = 0;
while (it.hasNext()) {
List succList = (List) getSuccsOf(it.next());
numberOfEdge = numberOfEdge + succList.size();
}
numberOfEdge = numberOfEdge + startToThread.size();
System.err.println("**number of edges: " + numberOfEdge);
System.err.println("**number of threads: " + (startToThread.size() + 1));
/* Set keySet = startToThread.keySet();
Iterator keyIt = keySet.iterator();
while (keyIt.hasNext()){
List list = (List)startToThread.get(keyIt.next());
System.out.println("********start thread:");
Iterator itit = list.iterator();
while (itit.hasNext()){
System.out.println(it.next());
}
}
*/
}
/**
* given a DelayabilityAnalysis and the computations of each unit, calculates the latest
* computation-point for each expression.<br>
* the <code>equivRhsMap</code> could be calculated on the fly, but it is <b>very</b> likely that
* it already exists (as similar maps are used for calculating Earliestness, Delayed,...<br>
* the shared set allows more efficient set-operations, when they the computation is merged with
* other analyses/computations.
*
* @param dg a ExceptionalUnitGraph
* @param delayed the delayability-analysis of the same graph.
* @param equivRhsMap all computations of the graph
* @param set the shared flowSet
*/
public LatestComputation(
UnitGraph unitGraph, DelayabilityAnalysis delayed, Map equivRhsMap, BoundedFlowSet set) {
unitToLatest = new HashMap<Unit, FlowSet>(unitGraph.size() + 1, 0.7f);
Iterator unitIt = unitGraph.iterator();
while (unitIt.hasNext()) {
/* create a new Earliest-list for each unit */
Unit currentUnit = (Unit) unitIt.next();
/* basically the latest-set is:
* (delayed) INTERSECT (comp UNION (UNION_successors ~Delayed)) =
* (delayed) MINUS ((INTERSECTION_successors Delayed) MINUS comp).
*/
FlowSet delaySet = (FlowSet) delayed.getFlowBefore(currentUnit);
/* Calculate (INTERSECTION_successors Delayed) */
FlowSet succCompSet = (FlowSet) set.topSet();
List succList = unitGraph.getSuccsOf(currentUnit);
Iterator succIt = succList.iterator();
while (succIt.hasNext()) {
Unit successor = (Unit) succIt.next();
succCompSet.intersection((FlowSet) delayed.getFlowBefore(successor), succCompSet);
}
/* remove the computation of this set: succCompSet is then:
* ((INTERSECTION_successors Delayed) MINUS comp) */
if (equivRhsMap.get(currentUnit) != null) succCompSet.remove(equivRhsMap.get(currentUnit));
/* make the difference: */
FlowSet latest = (FlowSet) delaySet.emptySet();
delaySet.difference(succCompSet, latest);
unitToLatest.put(currentUnit, latest);
}
}
public StronglyConnectedComponentsBV(BitVector typeVariableList, TypeResolverBV resolver)
throws TypeException {
this.resolver = resolver;
variables = typeVariableList;
black = new TreeSet();
finished = new LinkedList();
for (BitSetIterator i = variables.iterator(); i.hasNext(); ) {
TypeVariableBV var = resolver.typeVariableForId(i.next());
if (!black.contains(var)) {
black.add(var);
dfsg_visit(var);
}
}
black = new TreeSet();
for (Iterator i = finished.iterator(); i.hasNext(); ) {
TypeVariableBV var = (TypeVariableBV) i.next();
if (!black.contains(var)) {
current_tree = new LinkedList();
forest.add(current_tree);
black.add(var);
dfsgt_visit(var);
}
}
for (Iterator i = forest.iterator(); i.hasNext(); ) {
LinkedList list = (LinkedList) i.next();
TypeVariableBV previous = null;
StringBuffer s = null;
if (DEBUG) {
s = new StringBuffer("scc:\n");
}
for (Iterator j = list.iterator(); j.hasNext(); ) {
TypeVariableBV current = (TypeVariableBV) j.next();
if (DEBUG) {
s.append(" " + current + "\n");
}
if (previous == null) {
previous = current;
} else {
try {
previous = previous.union(current);
} catch (TypeException e) {
if (DEBUG) {
G.v().out.println(s);
}
throw e;
}
}
}
}
}
/**
* Indicates whether this ThrowableSet includes some exception that might be caught by a handler
* argument of the type <code>catcher</code>.
*
* @param catcher type of the handler parameter to be tested.
* @return <code>true</code> if this set contains an exception type that might be caught by <code>
* catcher</code>, false if it does not.
*/
public boolean catchableAs(RefType catcher) {
if (INSTRUMENTING) {
Manager.v().catchableAsQueries++;
}
FastHierarchy h = Scene.v().getOrMakeFastHierarchy();
if (exceptionsExcluded.size() > 0) {
if (INSTRUMENTING) {
Manager.v().catchableAsFromSearch++;
}
for (Iterator i = exceptionsExcluded.iterator(); i.hasNext(); ) {
AnySubType exclusion = (AnySubType) i.next();
if (h.canStoreType(catcher, exclusion.getBase())) {
return false;
}
}
}
if (exceptionsIncluded.contains(catcher)) {
if (INSTRUMENTING) {
if (exceptionsExcluded.size() == 0) {
Manager.v().catchableAsFromMap++;
} else {
Manager.v().catchableAsFromSearch++;
}
}
return true;
} else {
if (INSTRUMENTING) {
if (exceptionsExcluded.size() == 0) {
Manager.v().catchableAsFromSearch++;
}
}
for (Iterator i = exceptionsIncluded.iterator(); i.hasNext(); ) {
RefLikeType thrownType = (RefLikeType) i.next();
if (thrownType instanceof RefType) {
if (thrownType == catcher) {
// assertion failure.
throw new IllegalStateException(
"ThrowableSet.catchableAs(RefType): exceptions.contains() failed to match contained RefType "
+ catcher);
} else if (h.canStoreType(thrownType, catcher)) {
return true;
}
} else {
RefType thrownBase = ((AnySubType) thrownType).getBase();
// At runtime, thrownType might be instantiated by any
// of thrownBase's subtypes, so:
if (h.canStoreType(thrownBase, catcher) || h.canStoreType(catcher, thrownBase)) {
return true;
}
}
}
return false;
}
}
public void computeMonitorObjs() {
Set maps = monitor.entrySet();
for (Iterator iter = maps.iterator(); iter.hasNext(); ) {
Map.Entry entry = (Map.Entry) iter.next();
FlowSet fs = (FlowSet) entry.getValue();
Iterator it = fs.iterator();
while (it.hasNext()) {
Object obj = it.next();
if (!monitorObjs.contains(obj)) monitorObjs.add(obj);
}
}
}
private void iterateAllMethods() {
// Find methods
Iterator<SootClass> getClassesIt = Scene.v().getApplicationClasses().iterator();
while (getClassesIt.hasNext()) {
SootClass appClass = getClassesIt.next();
Iterator<SootMethod> getMethodsIt = appClass.getMethods().iterator();
while (getMethodsIt.hasNext()) {
SootMethod method = getMethodsIt.next();
analyzeMethod(method);
}
}
}
private void createWorkList(LinkedList<Object> changedUnits, HashSet<Object> changedUnitsSet) {
createWorkList(changedUnits, changedUnitsSet, g.getMainPegChain());
Set maps = g.getStartToThread().entrySet();
for (Iterator iter = maps.iterator(); iter.hasNext(); ) {
Map.Entry entry = (Map.Entry) iter.next();
List runMethodChainList = (List) entry.getValue();
Iterator it = runMethodChainList.iterator();
while (it.hasNext()) {
PegChain chain = (PegChain) it.next();
createWorkList(changedUnits, changedUnitsSet, chain);
}
}
}
protected void buildPreds() {
buildPredecessor(mainPegChain);
Set maps = getStartToThread().entrySet();
for (Iterator iter = maps.iterator(); iter.hasNext(); ) {
Map.Entry entry = (Map.Entry) iter.next();
List runMethodChainList = (List) entry.getValue();
Iterator it = runMethodChainList.iterator();
while (it.hasNext()) {
Chain chain = (Chain) it.next();
// System.out.println("chain is null: "+(chain == null));
buildPredecessor(chain);
}
}
}
/** Returns a string representation of this <code>ThrowableSet</code>. */
public String toString() {
StringBuffer buffer = new StringBuffer(this.toBriefString());
buffer.append(":\n ");
for (Iterator i = exceptionsIncluded.iterator(); i.hasNext(); ) {
buffer.append('+');
Object o = i.next();
buffer.append(o == null ? "null" : o.toString());
// buffer.append(i.next().toString());
}
for (Iterator i = exceptionsExcluded.iterator(); i.hasNext(); ) {
buffer.append('-');
buffer.append(i.next().toString());
}
return buffer.toString();
}
protected void testPegChain(Chain chain) {
System.out.println("******** chain********");
Iterator it = chain.iterator();
while (it.hasNext()) {
/*Object o = it.next();
System.out.println(o);
if (!(o instanceof JPegStmt)) System.out.println("not instanceof JPegStmt: "+o);
JPegStmt s = (JPegStmt)o;
*/
JPegStmt stmt = (JPegStmt) it.next();
System.out.println(stmt.toString());
/*if (stmt.getName().equals("start")){
System.out.println("find start method in : " + stmt.toString() );
List list =(List)startToThread.get(stmt);
Iterator chainIt = list.iterator();
while (chainIt.hasNext()){
Chain chain = (Chain)chainIt.next();
Iterator subit = chain.iterator();
while (subit.hasNext()){
System.out.println("**" + ((JPegStmt)subit.next()).toString());
}
}
System.out.println("$$$$$$returing to main chain");
}
*/
}
}
public void go() {
Iterator methods = cg.sourceMethods();
while (methods.hasNext()) {
SootMethod m = (SootMethod) methods.next();
dfsVisit(m);
}
}
/**
* Returns a <code>ThrowableSet</code> representing the set of exceptions included in <code>
* include</code> minus the set of exceptions included in <code>exclude</code>. Creates a new
* <code>ThrowableSet</code> only if there was not already one whose contents correspond to
* <code>include</code> - <code>exclude</code>.
*
* @param include A set of {@link RefLikeType} objects representing exception types included in
* the result; may be <code>null</code> if there are no included types.
* @param exclude A set of {@link AnySubType} objects representing exception types excluded from
* the result; may be <code>null</code> if there are no excluded types.
* @return a <code>ThrowableSet</code> representing the set of exceptions corresponding to
* <code>include</code> - <code>exclude</code>.
*/
private ThrowableSet registerSetIfNew(Set include, Set exclude) {
if (INSTRUMENTING) {
registrationCalls++;
}
if (include == null) {
include = Collections.EMPTY_SET;
}
if (exclude == null) {
exclude = Collections.EMPTY_SET;
}
int size = include.size() + exclude.size();
Integer sizeKey = new Integer(size);
List sizeList = (List) sizeToSets.get(sizeKey);
if (sizeList == null) {
sizeList = new LinkedList();
sizeToSets.put(sizeKey, sizeList);
}
for (Iterator i = sizeList.iterator(); i.hasNext(); ) {
ThrowableSet set = (ThrowableSet) i.next();
if (set.exceptionsIncluded.equals(include) && set.exceptionsExcluded.equals(exclude)) {
return set;
}
}
if (INSTRUMENTING) {
registeredSets++;
}
ThrowableSet result = new ThrowableSet(include, exclude);
sizeList.add(result);
return result;
}
private void insertAfter(JPegStmt node, JPegStmt after) {
// System.out.println("node: "+node);
// System.out.println("after: "+after);
// System.out.println("succs of node: "+getSuccsOf(node));
// this must be done first because the succs of node will be chanaged lately
List succOfAfter = new ArrayList();
succOfAfter.addAll(getSuccsOf(node));
unitToSuccs.put(after, succOfAfter);
Iterator succsIt = getSuccsOf(node).iterator();
while (succsIt.hasNext()) {
Object succ = succsIt.next();
List pred = getPredsOf(succ);
pred.remove(node);
pred.add(after);
}
List succOfNode = new ArrayList();
succOfNode.add(after);
unitToSuccs.put(node, succOfNode);
List predOfAfter = new ArrayList();
predOfAfter.add(node);
unitToPreds.put(after, predOfAfter);
// buildPredecessor(Chain pegChain);
}
/**
* Utility method used in the construction of {@link UnitGraph}s, to be called only after the
* unitToPreds and unitToSuccs maps have been built.
*
* <p><code>UnitGraph</code> provides an implementation of <code>buildHeadsAndTails()</code> which
* defines the graph's set of heads to include the first {@link Unit} in the graph's body,
* together with any other <tt>Unit</tt> which has no predecessors. It defines the graph's set of
* tails to include all <tt>Unit</tt>s with no successors. Subclasses of <code>UnitGraph</code>
* may override this method to change the criteria for classifying a node as a head or tail.
*/
protected void buildHeadsAndTails() {
List tailList = new ArrayList();
List headList = new ArrayList();
for (Iterator unitIt = unitChain.iterator(); unitIt.hasNext(); ) {
Unit s = (Unit) unitIt.next();
List succs = (List) unitToSuccs.get(s);
if (succs.size() == 0) {
tailList.add(s);
}
List preds = (List) unitToPreds.get(s);
if (preds.size() == 0) {
headList.add(s);
}
}
// Add the first Unit, even if it is the target of
// a branch.
Unit entryPoint = (Unit) unitChain.getFirst();
if (!headList.contains(entryPoint)) {
headList.add(entryPoint);
}
tails = Collections.unmodifiableList(tailList);
heads = Collections.unmodifiableList(headList);
}
protected void testList(List list) {
// System.out.println("test list");
Iterator listIt = list.iterator();
while (listIt.hasNext()) {
System.out.println(listIt.next());
}
}
protected int processModifiers(List l) {
int modifier = 0;
Iterator it = l.iterator();
while (it.hasNext()) {
Object t = it.next();
if (t instanceof AAbstractModifier) modifier |= Modifier.ABSTRACT;
else if (t instanceof AFinalModifier) modifier |= Modifier.FINAL;
else if (t instanceof ANativeModifier) modifier |= Modifier.NATIVE;
else if (t instanceof APublicModifier) modifier |= Modifier.PUBLIC;
else if (t instanceof AProtectedModifier) modifier |= Modifier.PROTECTED;
else if (t instanceof APrivateModifier) modifier |= Modifier.PRIVATE;
else if (t instanceof AStaticModifier) modifier |= Modifier.STATIC;
else if (t instanceof ASynchronizedModifier) modifier |= Modifier.SYNCHRONIZED;
else if (t instanceof ATransientModifier) modifier |= Modifier.TRANSIENT;
else if (t instanceof AVolatileModifier) modifier |= Modifier.VOLATILE;
else if (t instanceof AEnumModifier) modifier |= Modifier.ENUM;
else if (t instanceof AAnnotationModifier) modifier |= Modifier.ANNOTATION;
else
throw new RuntimeException(
"Impossible: modifier unknown - Have you added a new modifier and not updated this file?");
}
return modifier;
}
protected void testStartToThread() {
System.out.println("=====test startToThread ");
Set maps = startToThread.entrySet();
for (Iterator iter = maps.iterator(); iter.hasNext(); ) {
Map.Entry entry = (Map.Entry) iter.next();
JPegStmt key = (JPegStmt) entry.getKey();
Tag tag = (Tag) key.getTags().get(0);
System.out.println("---key= " + tag + " " + key);
/* List list = (List)entry.getValue();
if (list.size()>0){
System.out.println("**thread set:");
Iterator it = list.iterator();
while (it.hasNext()){
Chain chain =(Chain)it.next();
Iterator chainIt = chain.iterator();
System.out.println("the size of chain is: "+chain.size());
while (chainIt.hasNext()){
JPegStmt stmt = (JPegStmt)chainIt.next();
System.out.println(stmt);
}
}
}
*/
}
System.out.println("=========startToThread--ends--------");
}
/**
* Utility method that produces a new map from the {@link Unit}s of this graph's body to the union
* of the values stored in the two argument {@link Map}s, used to combine the maps of exceptional
* and unexceptional predecessors and successors into maps of all predecessors and successors. The
* values stored in both argument maps must be {@link List}s of {@link Unit}s, which are assumed
* not to contain any duplicate <tt>Unit</tt>s.
*
* @param mapA The first map to be combined.
* @param mapB The second map to be combined.
*/
protected Map combineMapValues(Map mapA, Map mapB) {
// The duplicate screen
Map result = new HashMap(mapA.size() * 2 + 1, 0.7f);
for (Iterator chainIt = unitChain.iterator(); chainIt.hasNext(); ) {
Unit unit = (Unit) chainIt.next();
List listA = (List) mapA.get(unit);
if (listA == null) {
listA = Collections.EMPTY_LIST;
}
List listB = (List) mapB.get(unit);
if (listB == null) {
listB = Collections.EMPTY_LIST;
}
int resultSize = listA.size() + listB.size();
if (resultSize == 0) {
result.put(unit, Collections.EMPTY_LIST);
} else {
List resultList = new ArrayList(resultSize);
Iterator listIt = null;
// As a minor optimization of the duplicate screening,
// copy the longer list first.
if (listA.size() >= listB.size()) {
resultList.addAll(listA);
listIt = listB.iterator();
} else {
resultList.addAll(listB);
listIt = listA.iterator();
}
while (listIt.hasNext()) {
Object element = listIt.next();
// It is possible for there to be both an exceptional
// and an unexceptional edge connecting two Units
// (though probably not in a class generated by
// javac), so we need to screen for duplicates. On the
// other hand, we expect most of these lists to have
// only one or two elements, so it doesn't seem worth
// the cost to build a Set to do the screening.
if (!resultList.contains(element)) {
resultList.add(element);
}
}
result.put(unit, Collections.unmodifiableList(resultList));
}
}
return result;
}
public void convertToBaf(JimpleToBafContext context, List<Unit> out) {
Unit u = Baf.v().newLoadInst(getType(), context.getBafLocalOfJimpleLocal(this));
out.add(u);
Iterator it = context.getCurrentUnit().getTags().iterator();
while (it.hasNext()) {
u.addTag((Tag) it.next());
}
}
public boolean isEmpty() {
if (subsets == null) return true;
for (Iterator subsetIt = subsets.iterator(); subsetIt.hasNext(); ) {
final PointsToSet subset = (PointsToSet) subsetIt.next();
if (!subset.isEmpty()) return false;
}
return true;
}
public void internalTransform(String phaseName, Map opts) {
Iterator it = Scene.v().getApplicationClasses().iterator();
while (it.hasNext()) {
SootClass sc = (SootClass) it.next();
// make map of first line to each method
HashMap<Integer, SootMethod> lineToMeth = new HashMap<Integer, SootMethod>();
Iterator methIt = sc.getMethods().iterator();
while (methIt.hasNext()) {
SootMethod meth = (SootMethod) methIt.next();
if (!meth.isConcrete()) continue;
Body body = meth.retrieveActiveBody();
Stmt s = (Stmt) body.getUnits().getFirst();
while (s instanceof IdentityStmt) {
s = (Stmt) body.getUnits().getSuccOf(s);
}
if (s.hasTag("LineNumberTag")) {
LineNumberTag tag = (LineNumberTag) s.getTag("LineNumberTag");
lineToMeth.put(new Integer(tag.getLineNumber()), meth);
}
}
Iterator methIt2 = sc.getMethods().iterator();
while (methIt2.hasNext()) {
SootMethod meth = (SootMethod) methIt2.next();
if (!meth.isConcrete()) continue;
Body body = meth.retrieveActiveBody();
Stmt s = (Stmt) body.getUnits().getFirst();
while (s instanceof IdentityStmt) {
s = (Stmt) body.getUnits().getSuccOf(s);
}
if (s.hasTag("LineNumberTag")) {
LineNumberTag tag = (LineNumberTag) s.getTag("LineNumberTag");
int line_num = tag.getLineNumber() - 1;
// already taken
if (lineToMeth.containsKey(new Integer(line_num))) {
meth.addTag(new LineNumberTag(line_num + 1));
}
// still available - so use it for this meth
else {
meth.addTag(new LineNumberTag(line_num));
}
}
}
}
}
// helper function
protected void testIterator() {
System.out.println("********begin test iterator*******");
Iterator testIt = iterator();
while (testIt.hasNext()) {
System.out.println(testIt.next());
}
System.out.println("********end test iterator*******");
System.out.println("=======size is: " + size());
}
public void convertToBaf(JimpleToBafContext context, List out) {
Unit u = Baf.v().newStaticGetInst(fieldRef);
out.add(u);
Iterator it = context.getCurrentUnit().getTags().iterator();
while (it.hasNext()) {
u.addTag((Tag) it.next());
}
}
protected void testSet(Set set, String name) {
System.out.println("$test set " + name);
Iterator setIt = set.iterator();
while (setIt.hasNext()) {
Object s = setIt.next();
// JPegStmt s = (JPegStmt)setIt.next();
// Tag tag = (Tag)s.getTags().get(0);
System.out.println(s);
}
}
private void dfsVisit(SootMethod m) {
if (visited.contains(m)) return;
visited.add(m);
Iterator targets = new Targets(cg.edgesOutOf(m));
while (targets.hasNext()) {
SootMethod target = (SootMethod) targets.next();
dfsVisit(target);
}
order.add(m);
}
/**
* Utility method for <tt>UnitGraph</tt> constructors. It computes the edges corresponding to
* unexceptional control flow.
*
* @param unitToSuccs A {@link Map} from {@link Unit}s to {@link List}s of {@link Unit}s. This is
* an ``out parameter''; callers must pass an empty {@link Map}.
* <tt>buildUnexceptionalEdges</tt> will add a mapping for every <tt>Unit</tt> in the body to
* a list of its unexceptional successors.
* @param unitToPreds A {@link Map} from {@link Unit}s to {@link List}s of {@link Unit}s. This is
* an ``out parameter''; callers must pass an empty {@link Map}.
* <tt>buildUnexceptionalEdges</tt> will add a mapping for every <tt>Unit</tt> in the body to
* a list of its unexceptional predecessors.
*/
protected void buildUnexceptionalEdges(Map unitToSuccs, Map unitToPreds) {
// Initialize the predecessor sets to empty
for (Iterator unitIt = unitChain.iterator(); unitIt.hasNext(); ) {
unitToPreds.put(unitIt.next(), new ArrayList());
}
Iterator unitIt = unitChain.iterator();
Unit currentUnit, nextUnit;
nextUnit = unitIt.hasNext() ? (Unit) unitIt.next() : null;
while (nextUnit != null) {
currentUnit = nextUnit;
nextUnit = unitIt.hasNext() ? (Unit) unitIt.next() : null;
List successors = new ArrayList();
if (currentUnit.fallsThrough()) {
// Add the next unit as the successor
if (nextUnit != null) {
successors.add(nextUnit);
((List) unitToPreds.get(nextUnit)).add(currentUnit);
}
}
if (currentUnit.branches()) {
for (Iterator targetIt = currentUnit.getUnitBoxes().iterator(); targetIt.hasNext(); ) {
Unit target = ((UnitBox) targetIt.next()).getUnit();
// Arbitrary bytecode can branch to the same
// target it falls through to, so we screen for duplicates:
if (!successors.contains(target)) {
successors.add(target);
((List) unitToPreds.get(target)).add(currentUnit);
}
}
}
// Store away successors
unitToSuccs.put(currentUnit, successors);
}
}
public void computeSynchNodes() {
int num = 0;
Set maps = monitor.entrySet();
for (Iterator iter = maps.iterator(); iter.hasNext(); ) {
Map.Entry entry = (Map.Entry) iter.next();
FlowSet fs = (FlowSet) entry.getValue();
num += fs.size();
}
System.err.println("synch objects: " + num);
}
public String toString() {
Iterator it = unitChain.iterator();
StringBuffer buf = new StringBuffer();
while (it.hasNext()) {
Unit u = (Unit) it.next();
buf.append("// preds: " + getPredsOf(u) + "\n");
buf.append(u.toString() + '\n');
buf.append("// succs " + getSuccsOf(u) + "\n");
}
return buf.toString();
}
/**
* Utility method that replaces the values of a {@link Map}, which must be instances of {@link
* List}, with unmodifiable equivalents.
*
* @param map The map whose values are to be made unmodifiable.
*/
protected static void makeMappedListsUnmodifiable(Map map) {
for (Iterator it = map.entrySet().iterator(); it.hasNext(); ) {
Map.Entry entry = (Map.Entry) it.next();
List value = (List) entry.getValue();
if (value.size() == 0) {
entry.setValue(Collections.EMPTY_LIST);
} else {
entry.setValue(Collections.unmodifiableList(value));
}
}
}
public Set possibleTypes() {
if (subsets == null) {
return Collections.EMPTY_SET;
}
HashSet ret = new HashSet();
for (Iterator subsetIt = subsets.iterator(); subsetIt.hasNext(); ) {
final PointsToSet subset = (PointsToSet) subsetIt.next();
ret.addAll(subset.possibleTypes());
}
return ret;
}