Merge branch 'master' of https://github.com/ponder-lab/Java-8-Stream-Refactoring

Author: khatchad

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

@@ -37,4 +37,10 @@ private PreconditionFailure(int code) {
 	public int getCode() {
 		return code;
 	}
+
+	public static void main(String[] args) {
+		System.out.println("code,name");
+		for (PreconditionFailure failure : PreconditionFailure.values())
+			System.out.println(failure.getCode() + "," + failure);
+	}
 }

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

@@ -4,6 +4,7 @@
 
 import java.io.IOException;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Map;
@@ -23,6 +24,7 @@
 import com.ibm.safe.internal.exceptions.PropertiesException;
 import com.ibm.wala.ipa.callgraph.AnalysisOptions;
 import com.ibm.wala.ipa.callgraph.AnalysisOptions.ReflectionOptions;
+import com.ibm.wala.ipa.callgraph.CallGraph;
 import com.ibm.wala.ipa.callgraph.CallGraphBuilderCancelException;
 import com.ibm.wala.ipa.callgraph.Entrypoint;
 import com.ibm.wala.ipa.callgraph.propagation.InstanceKey;
@@ -46,7 +48,12 @@ private static void addImplicitEntryPoints(Collection<Entrypoint> target, Iterab
 				LOGGER.info(() -> "Adding implicit entry point: " + implicitEntryPoint);
 	}
 
-	private Set<EclipseProjectAnalysisEngine<InstanceKey>> enginesWithBuiltCallGraphs = new HashSet<>();
+	/**
+	 * Map from {@link EclipseProjectAnalysisEngine}s that have their
+	 * {@link CallGraph}s built to the {@link Entrypoint}s that were used to build
+	 * the graph.
+	 */
+	private Map<EclipseProjectAnalysisEngine<InstanceKey>, Collection<Entrypoint>> enginesWithBuiltCallGraphsToEntrypointsUsed = new HashMap<>();
 
 	private boolean findImplicitEntryPoints = true;
 
@@ -72,7 +79,14 @@ public StreamAnalyzer(boolean visitDocTags, boolean findImplicitEntryPoints, boo
 		this.findImplicitTestEntryPoints = findImplicitTestEntryPoints;
 	}
 
-	public void analyze() throws CoreException {
+	/**
+	 * Analyzes this {@link StreamAnalyzer}'s streams.
+	 *
+	 * @return {@link Map} of project's analyzed along with the entry points used.
+	 */
+	public Map<IJavaProject, Collection<Entrypoint>> analyze() throws CoreException {
+		Map<IJavaProject, Collection<Entrypoint>> ret = new HashMap<>();
+
 		// collect the projects to be analyzed.
 		Map<IJavaProject, Set<Stream>> projectToStreams = this.getStreamSet().stream().filter(s -> s.getStatus().isOK())
 				.collect(Collectors.groupingBy(Stream::getCreationJavaProject, Collectors.toSet()));
@@ -90,21 +104,24 @@ public void analyze() throws CoreException {
 			}
 
 			// build the call graph for the project.
+			Collection<Entrypoint> entryPoints = null;
 			try {
-				this.buildCallGraph(engine);
-			} catch (NoEntryPointException e) {
-				LOGGER.log(Level.WARNING,
-						"No entry point exception caught while processing: " + engine.getProject().getElementName(), e);
+				entryPoints = this.buildCallGraph(engine);
+			} catch (IOException | CoreException | CancelException e) {
+				LOGGER.log(Level.SEVERE,
+						"Exception encountered while building call graph for: " + project.getElementName() + ".", e);
+				throw new RuntimeException(e);
+			}
+
+			// save the entry points.
+			ret.put(project, entryPoints);
 
+			if (entryPoints.isEmpty()) {
 				// add a status entry for each stream in the project
 				for (Stream stream : projectToStreams.get(project))
 					stream.addStatusEntry(PreconditionFailure.NO_ENTRY_POINT,
 							"Project: " + engine.getProject().getElementName() + " has no entry points.");
-				return;
-			} catch (IOException | CoreException | CancelException e) {
-				LOGGER.log(Level.SEVERE,
-						"Exception encountered while building call graph for: " + project.getElementName() + ".", e);
-				throw new RuntimeException(e);
+				return ret;
 			}
 
 			OrderingInference orderingInference = new OrderingInference(engine.getClassHierarchy());
@@ -147,12 +164,23 @@ public void analyze() throws CoreException {
 					.collect(Collectors.toSet()))
 				stream.check();
 		} // end for each stream.
+
+		return ret;
 	}
 
-	protected void buildCallGraph(EclipseProjectAnalysisEngine<InstanceKey> engine)
-			throws IOException, CoreException, CallGraphBuilderCancelException, CancelException, NoEntryPointException {
+	/**
+	 * Builds the call graph that is part of the
+	 * {@link EclipseProjectAnalysisEngine}.
+	 *
+	 * @param engine
+	 *            The EclipseProjectAnalysisEngine for which to build the call
+	 *            graph.
+	 * @return The {@link Entrypoint}s used in building the {@link CallGraph}.
+	 */
+	protected Collection<Entrypoint> buildCallGraph(EclipseProjectAnalysisEngine<InstanceKey> engine)
+			throws IOException, CoreException, CallGraphBuilderCancelException, CancelException {
 		// if we haven't built the call graph yet.
-		if (!this.enginesWithBuiltCallGraphs.contains(engine)) {
+		if (!this.enginesWithBuiltCallGraphsToEntrypointsUsed.keySet().contains(engine)) {
 			// find explicit entry points.
 			Set<Entrypoint> entryPoints = Util.findEntryPoints(engine.getClassHierarchy());
 			entryPoints.forEach(ep -> LOGGER.info(() -> "Adding explicit entry point: " + ep));
@@ -175,8 +203,7 @@ protected void buildCallGraph(EclipseProjectAnalysisEngine<InstanceKey> engine)
 			}
 
 			if (entryPoints.isEmpty())
-				throw new NoEntryPointException(
-						"Project: " + engine.getProject().getElementName() + " has no entry points.");
+				LOGGER.warning(() -> "Project: " + engine.getProject().getElementName() + " has no entry points.");
 
 			// set options.
 			AnalysisOptions options = engine.getDefaultOptions(entryPoints);
@@ -193,8 +220,9 @@ protected void buildCallGraph(EclipseProjectAnalysisEngine<InstanceKey> engine)
 			}
 			// TODO: Can I slice the graph so that only nodes relevant to the
 			// instance in question are present?
-			this.enginesWithBuiltCallGraphs.add(engine);
+			this.enginesWithBuiltCallGraphsToEntrypointsUsed.put(engine, entryPoints);
 		}
+		return this.enginesWithBuiltCallGraphsToEntrypointsUsed.get(engine);
 	}
 
 	public Set<Stream> getStreamSet() {