Fix #108

* slicing

* add comments

* add comments

* visitor

* delete test output

* requested changes

* Some changes to @saledouble's code #196.

* Forgot uses for #196.

* Revert "Add bundle to build."

This reverts commit 5cc28ac.

* move to a class

* streamOp?

* merge

* Forgot uses for #196.

* delete

* fix casting

* add null checker

* fix infinite calls

* fix format

* fix ilegal argument

* check class

* improve

* improve

* fix logic

* delete unused code

* use pruned callgraph

* Revert "use pruned callgraph"

This reverts commit 335c21e.

* Remove space.

* Re-add space.

* improve

* improve

* revert if condition

* clear

* implement base stream

* rename

* rename

* make private

Author: Grace Tang

edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/StreamAnalyzer.java

@@ -405,8 +405,6 @@ protected Collection<Entrypoint> buildCallGraph(EclipseProjectAnalysisEngine<Ins
 						+ engine.getProject().getElementName());
 				throw e;
 			}
-			// TODO: Can I slice the graph so that only nodes relevant to the
-			// instance in question are present?
 			this.enginesWithBuiltCallGraphsToEntrypointsUsed.put(engine, entryPoints);
 		}
 		return this.enginesWithBuiltCallGraphsToEntrypointsUsed.get(engine);

edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/StreamFindingVisitor.java

@@ -0,0 +1,107 @@
+package edu.cuny.hunter.streamrefactoring.core.analysis;
+
+import java.util.Arrays;
+
+import com.ibm.wala.ipa.cha.IClassHierarchy;
+import com.ibm.wala.ssa.SSAArrayLoadInstruction;
+import com.ibm.wala.ssa.SSAArrayStoreInstruction;
+import com.ibm.wala.ssa.SSACheckCastInstruction;
+import com.ibm.wala.ssa.SSAConditionalBranchInstruction;
+import com.ibm.wala.ssa.SSAConversionInstruction;
+import com.ibm.wala.ssa.SSAGetCaughtExceptionInstruction;
+import com.ibm.wala.ssa.SSAGetInstruction;
+import com.ibm.wala.ssa.SSAInstanceofInstruction;
+import com.ibm.wala.ssa.SSAInstruction.Visitor;
+import com.ibm.wala.ssa.SSAInvokeInstruction;
+import com.ibm.wala.ssa.SSALoadMetadataInstruction;
+import com.ibm.wala.ssa.SSANewInstruction;
+import com.ibm.wala.ssa.SSAPutInstruction;
+import com.ibm.wala.types.TypeReference;
+
+public class StreamFindingVisitor extends Visitor {
+
+	private IClassHierarchy classHierarchy;
+
+	private boolean foundStream = false;
+
+	public StreamFindingVisitor(IClassHierarchy classHierarchy) {
+		this.classHierarchy = classHierarchy;
+	}
+
+	protected IClassHierarchy getClassHierarchy() {
+		return this.classHierarchy;
+	}
+
+	public boolean hasFoundStream() {
+		return this.foundStream;
+	}
+
+	private void processType(TypeReference type) {
+		if (Util.implementsBaseStream(type, this.getClassHierarchy()))
+			this.setFoundStream(true);
+	}
+
+	protected void setFoundStream(boolean foundStream) {
+		this.foundStream = foundStream;
+	}
+
+	@Override
+	public void visitArrayLoad(SSAArrayLoadInstruction instruction) {
+		this.processType(instruction.getElementType());
+	}
+
+	@Override
+	public void visitArrayStore(SSAArrayStoreInstruction instruction) {
+		this.processType(instruction.getElementType());
+	}
+
+	@Override
+	public void visitCheckCast(SSACheckCastInstruction instruction) {
+		Arrays.stream(instruction.getDeclaredResultTypes()).forEach(this::processType);
+	}
+
+	@Override
+	public void visitConditionalBranch(SSAConditionalBranchInstruction instruction) {
+		this.processType(instruction.getType());
+	}
+
+	@Override
+	public void visitConversion(SSAConversionInstruction instruction) {
+		this.processType(instruction.getToType());
+		this.processType(instruction.getFromType());
+	}
+
+	@Override
+	public void visitGet(SSAGetInstruction instruction) {
+		this.processType(instruction.getDeclaredFieldType());
+	}
+
+	@Override
+	public void visitGetCaughtException(SSAGetCaughtExceptionInstruction instruction) {
+	}
+
+	@Override
+	public void visitInstanceof(SSAInstanceofInstruction instruction) {
+		this.processType(instruction.getCheckedType());
+	}
+
+	@Override
+	public void visitInvoke(SSAInvokeInstruction instruction) {
+		this.processType(instruction.getDeclaredResultType());
+	}
+
+	@Override
+	public void visitLoadMetadata(SSALoadMetadataInstruction instruction) {
+		this.processType(instruction.getType());
+	}
+
+	@Override
+	public void visitNew(SSANewInstruction instruction) {
+		this.processType(instruction.getConcreteType());
+	}
+
+	@Override
+	public void visitPut(SSAPutInstruction instruction) {
+		this.processType(instruction.getDeclaredFieldType());
+	}
+}

edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/StreamStateMachine.java

@@ -58,6 +58,7 @@
 import com.ibm.wala.ipa.callgraph.propagation.InstanceKey;
 import com.ibm.wala.ipa.callgraph.propagation.NormalAllocationInNode;
 import com.ibm.wala.ipa.callgraph.propagation.PointerKey;
+import com.ibm.wala.ipa.callgraph.pruned.PrunedCallGraph;
 import com.ibm.wala.ipa.cfg.BasicBlockInContext;
 import com.ibm.wala.ipa.cha.IClassHierarchy;
 import com.ibm.wala.ipa.modref.ModRef;
@@ -982,7 +983,8 @@ public Map<TypestateRule, Statistics> start(Set<Stream> streamSet, EclipseProjec
 		SubMonitor subMonitor = SubMonitor.convert(monitor, "Performing typestate analysis (may take a while)", 100);
 		Map<TypestateRule, Statistics> ret = new HashMap<>();
 
-		BenignOracle ora = new ModifiedBenignOracle(engine.getCallGraph(), engine.getPointerAnalysis());
+		CallGraph prunedCallGraph = pruneCallGraph(engine.getCallGraph(), engine.getClassHierarchy());
+		BenignOracle ora = new ModifiedBenignOracle(prunedCallGraph, engine.getPointerAnalysis());
 
 		PropertiesManager manager = PropertiesManager.initFromMap(Collections.emptyMap());
 		PropertiesManager.registerProperties(
@@ -1006,7 +1008,7 @@ public Map<TypestateRule, Statistics> start(Set<Stream> streamSet, EclipseProjec
 
 			// this gets a solver that tracks all streams.
 			LOGGER.info(() -> "Starting " + rule.getName() + " solver for: " + engine.getProject().getElementName());
-			ISafeSolver solver = TypestateSolverFactory.getSolver(engine.getOptions(), engine.getCallGraph(),
+			ISafeSolver solver = TypestateSolverFactory.getSolver(engine.getOptions(), prunedCallGraph,
 					engine.getPointerAnalysis(), engine.getHeapGraph(), dfa, ora, typeStateOptions, null, null, null);
 
 			AggregateSolverResult result;
@@ -1043,7 +1045,7 @@ public Map<TypestateRule, Statistics> start(Set<Stream> streamSet, EclipseProjec
 				// TODO: Can this be somehow rewritten to get blocks corresponding to terminal
 				// operations?
 				// for each call graph node in the call graph.
-				for (CGNode cgNode : engine.getCallGraph())
+				for (CGNode cgNode : prunedCallGraph)
 					// separating client from library code, improving performance #103.
 					if (cgNode.getMethod().getDeclaringClass().getClassLoader().getReference()
 							.equals(ClassLoaderReference.Application)) {
@@ -1228,7 +1230,7 @@ public Map<TypestateRule, Statistics> start(Set<Stream> streamSet, EclipseProjec
 
 		// discover whether any stateful intermediate operations are
 		// present.
-		this.discoverPossibleStatefulIntermediateOperations(engine.getClassHierarchy(), engine.getCallGraph(),
+		this.discoverPossibleStatefulIntermediateOperations(engine.getClassHierarchy(), prunedCallGraph,
 				subMonitor.split(5, SubMonitor.SUPPRESS_NONE));
 
 		// does reduction order matter?
@@ -1291,4 +1293,30 @@ public Map<TypestateRule, Statistics> start(Set<Stream> streamSet, EclipseProjec
 		}
 		return ret;
 	}
+
+	/**
+	 * This method is used to prune call graph. For each CGNode in the callGraph, it
+	 * check whether it is a stream node. If it is, then keep it. If it not, then
+	 * remove it.
+	 * 
+	 * @param callGraph
+	 * @param classHierarchy
+	 * @return A pruned callGraph
+	 */
+	private static CallGraph pruneCallGraph(CallGraph callGraph, IClassHierarchy classHierarchy) {
+		int numberOfNodesInCallGraph = callGraph.getNumberOfNodes();
+		LOGGER.info("The number of nodes in the call graph: " + numberOfNodesInCallGraph);
+		HashSet<CGNode> keep = new HashSet<>();
+		for (CGNode node : callGraph) {
+			if (Util.isStreamNode(node, classHierarchy))
+				keep.add(node);
+		}
+		
+		PrunedCallGraph prunedCallGraph = new PrunedCallGraph(callGraph, keep);
+		int numberOfNodesInPrunedCallGraph = prunedCallGraph.getNumberOfNodes();
+		LOGGER.info("The number of nodes in partial graph: " + numberOfNodesInPrunedCallGraph
+				+ ". The number of saved nodes: " + (numberOfNodesInCallGraph - numberOfNodesInPrunedCallGraph));
+		
+		return prunedCallGraph;
+	}
 }

edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/Util.java

@@ -17,6 +17,8 @@
 import java.util.logging.Logger;
 import java.util.stream.BaseStream;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
 
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.IType;
@@ -407,21 +409,46 @@ static int getLineNumberFromIR(IBytecodeMethod method, SSAInstruction instructio
 		return lineNumberFromIR;
 	}
 
+	/**
+	 * This set is used to store visited values. Without this set, the method
+	 * getPossibleTypes could be infinitely recursively called and would never
+	 * return. So adding this set means to add a base case.
+	 */
+	static private HashSet<Value> seenValues = new HashSet<>();
+
 	static Collection<TypeAbstraction> getPossibleTypes(int valueNumber, TypeInference inference) {
+		seenValues.clear();
+		return getPossibleTypesInternal(valueNumber, inference);
+	}
+
+	static private Collection<TypeAbstraction> getPossibleTypesInternal(int valueNumber, TypeInference inference) {
 		Set<TypeAbstraction> ret = new HashSet<>();
-		Value value = inference.getIR().getSymbolTable().getValue(valueNumber);
+		Value value;
+		try {
+			value = inference.getIR().getSymbolTable().getValue(valueNumber);
+		} catch (IllegalArgumentException exception) {
+			LOGGER.info("The value number is invalid for getting possible types.");
+			return ret;
+		}
 
 		// TODO: Should really be using a pointer analysis here rather than
 		// re-implementing one using PhiValue.
 		if (value instanceof PhiValue) {
+
+			// avoid infinite recursion here
+			if (seenValues.contains(value))
+				return ret;
+			else
+				seenValues.add(value);
+
 			// multiple possible types.
 			PhiValue phiValue = (PhiValue) value;
 			SSAPhiInstruction phiInstruction = phiValue.getPhiInstruction();
 			int numberOfUses = phiInstruction.getNumberOfUses();
 			// get the possible types for each use.
 			for (int i = 0; i < numberOfUses; i++) {
 				int use = phiInstruction.getUse(i);
-				Collection<TypeAbstraction> possibleTypes = getPossibleTypes(use, inference);
+				Collection<TypeAbstraction> possibleTypes = getPossibleTypesInternal(use, inference);
 				ret.addAll(possibleTypes);
 			}
 		} else
@@ -458,6 +485,7 @@ public static Collection<TypeAbstraction> getPossibleTypesInterprocedurally(Coll
 					// type is java.lang.Object.
 					// Find the return type of the instruction.
 					TypeInference inference = TypeInference.make(node.getIR(), false);
+					// Get all possible types
 					Collection<TypeAbstraction> returnTypes = Util.getPossibleTypes(valueNumber, inference);
 
 					// for each return type.
@@ -611,6 +639,9 @@ public static boolean implementsIterable(TypeReference reference, IClassHierarch
 
 	public static boolean implementsType(TypeReference typeReference, IClassHierarchy classHierarchy,
 			Predicate<IClass> predicate) {
+		if (typeReference == null)
+			return false;
+
 		IClass clazz = classHierarchy.lookupClass(typeReference);
 
 		if (clazz == null)
@@ -761,4 +792,63 @@ private static boolean wouldOrderingBeConsistent(final Collection<TypeAbstractio
 
 	private Util() {
 	}
+
+	/**
+	 * This method is used to check whether the CGNode is a "stream node". It checks
+	 * each instruction in the node. If the type of instruction could implement base
+	 * stream, then it is a stream node.
+	 * 
+	 * @param node:
+	 *            CGNode
+	 * @param classHierarchy
+	 */
+	public static boolean isStreamNode(CGNode node, IClassHierarchy classHierarchy) {
+		if (isDeclaredStreamClass(node, classHierarchy))
+			return true;
+
+		IR ir = node.getIR();
+
+		if (ir == null || ir.isEmptyIR())
+			return true;
+
+		for (SSAInstruction instruction : ir.getInstructions()) {
+			if (instruction == null)
+				continue;
+
+			// Most of instruction APIs provide the methods to get the return types.
+			StreamFindingVisitor visitor = new StreamFindingVisitor(classHierarchy);
+			instruction.visit(visitor);
+
+			if (visitor.hasFoundStream())
+				return true;
+
+			// otherwise, let's check the defs and uses.
+			TypeInference inference = TypeInference.make(ir, false);
+
+			Stream<TypeAbstraction> defs = IntStream.range(0, instruction.getNumberOfDefs())
+					.mapToObj(i -> instruction.getDef(i)).flatMap(d -> getPossibleTypes(d, inference).stream());
+
+			Stream<TypeAbstraction> uses = IntStream.range(0, instruction.getNumberOfUses())
+					.mapToObj(i -> instruction.getUse(i)).flatMap(u -> getPossibleTypes(u, inference).stream());
+
+			if (Stream.concat(defs, uses).anyMatch(t -> implementsBaseStream(t.getTypeReference(), classHierarchy)))
+				return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Check declared class for CGNode
+	 * 
+	 * @param node:
+	 *            CGNode in the CallGraph
+	 */
+	private static boolean isDeclaredStreamClass(CGNode node, IClassHierarchy classHierarchy) {
+		IMethod method = node.getMethod();
+		if (implementsBaseStream(method.getDeclaringClass().getReference(), classHierarchy))
+			return true;
+		else
+			return false;
+	}
 }