Fixed cardinality problem with project and entrypoints.

Author: khatchad

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,15 +48,18 @@ 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;
 
 	private boolean findImplicitTestEntryPoints;
 
 	private Set<Stream> streamSet = new HashSet<>();
-	
-	private Set<Entrypoint> entryPoints = new HashSet<>();
 
 	public StreamAnalyzer() {
 		this(false);
@@ -74,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()));
@@ -92,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());
@@ -149,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));
@@ -177,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);
@@ -195,10 +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);
-
-			setEntryPoints(entryPoints);
+			this.enginesWithBuiltCallGraphsToEntrypointsUsed.put(engine, entryPoints);
 		}
+		return this.enginesWithBuiltCallGraphsToEntrypointsUsed.get(engine);
 	}
 
 	public Set<Stream> getStreamSet() {
@@ -252,13 +276,4 @@ public boolean visit(MethodInvocation node) {
 
 		return super.visit(node);
 	}
-
-	protected void setEntryPoints(Set<Entrypoint> entryPoints) {
-		this.entryPoints = entryPoints;
-	}
-	
-	public Set<Entrypoint> getEntryPoints() {
-		return this.entryPoints;
-	}
-
 }

edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/refactorings/ConvertToParallelStreamRefactoringProcessor.java

@@ -4,8 +4,9 @@
 import static org.eclipse.jdt.ui.JavaElementLabels.getElementLabel;
 
 import java.text.MessageFormat;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
@@ -132,8 +133,8 @@ public static void setLoggingLevel(int level) {
 	private IJavaProject[] javaProjects;
 
 	private Set<Stream> streamSet;
-	
-	private Set<Entrypoint> entryPoints = new HashSet<>();
+
+	private Map<IJavaProject, Collection<Entrypoint>> projectToEntryPoints;
 
 	private boolean useImplicitEntrypoints = true;
 
@@ -208,14 +209,18 @@ public RefactoringStatus checkFinalConditions(final IProgressMonitor monitor, fi
 				}
 			}
 
-			analyzer.analyze();
+			// analyze and set entry points.
+			projectToEntryPoints = analyzer.analyze();
+			
+			// map empty set to unprocessed projects.
+			for (IJavaProject project : this.getJavaProjects())
+				this.projectToEntryPoints.computeIfAbsent(project, p -> Collections.emptySet());
+				
 
+			// get the status of each stream.
 			RefactoringStatus collectedStatus = getStreamSet().stream().map(Stream::getStatus)
 					.collect(() -> new RefactoringStatus(), (a, b) -> a.merge(b), (a, b) -> a.merge(b));
 			status.merge(collectedStatus);
-			
-			// set entry points
-		    setEntryPoints(analyzer.getEntryPoints());
 
 			// if there are no fatal errors.
 			if (!status.hasFatalError()) {
@@ -240,12 +245,8 @@ public RefactoringStatus checkFinalConditions(final IProgressMonitor monitor, fi
 		}
 	}
 
-	private void setEntryPoints(Set<Entrypoint> entryPoints) {
-		this.entryPoints = entryPoints;
-	}
-	
-	public Set<Entrypoint> getEntryPoints() {
-		return this.entryPoints;
+	public Collection<Entrypoint> getEntryPoints(IJavaProject javaProject) {
+		return this.projectToEntryPoints.get(javaProject);
 	}
 
 	private boolean getUseImplicitEntrypoints() {

edu.cuny.hunter.streamrefactoring.eval/META-INF/MANIFEST.MF

@@ -24,6 +24,7 @@ Export-Package: edu.cuny.hunter.streamrefactoring.eval.handlers,
 Import-Package: com.google.common.io,
  com.ibm.wala.classLoader,
  com.ibm.wala.ipa.callgraph,
+ com.ibm.wala.types,
  edu.cuny.hunter.streamrefactoring.core.analysis,
  edu.cuny.hunter.streamrefactoring.core.refactorings,
  edu.cuny.hunter.streamrefactoring.core.utils,

edu.cuny.hunter.streamrefactoring.eval/src/edu/cuny/hunter/streamrefactoring/eval/handlers/EvaluateConvertToParallelStreamRefactoringHandler.java

@@ -246,14 +246,15 @@ public Object execute(ExecutionEvent event) throws ExecutionException {
 					RefactoringStatus status = new ProcessorBasedRefactoring(processor)
 							.checkAllConditions(new NullProgressMonitor());
 					resultsTimeCollector.stop();
-					
-					// print entry points
-					Set<Entrypoint> entryPoints = processor.getEntryPoints();
-					resultsPrinter.print(entryPoints.size());
+
+					// print entry points.
+					Collection<Entrypoint> entryPoints = getProjectEntryPoints(javaProject, processor);
+					resultsPrinter.print(entryPoints.size()); // number.
 
 					for (Entrypoint entryPoint : entryPoints) {
-						entryPointsPrinter.printRecord(javaProject.getElementName(),
-								entryPoint.getMethod().getSignature(), "! not implement now");
+						com.ibm.wala.classLoader.IMethod method = entryPoint.getMethod();
+						entryPointsPrinter.printRecord(javaProject.getElementName(), method.getSignature(),
+								method.getDeclaringClass().getName());
 					}
 
 					// #streams.
@@ -448,6 +449,11 @@ public Object execute(ExecutionEvent event) throws ExecutionException {
 		return null;
 	}
 
+	private static Collection<Entrypoint> getProjectEntryPoints(IJavaProject javaProject,
+			ConvertToParallelStreamRefactoringProcessor processor) {
+		return processor.getEntryPoints(javaProject);
+	}
+
 	private Set<SearchMatch> findReferences(Set<? extends IJavaElement> elements) throws CoreException {
 		Set<SearchMatch> ret = new HashSet<>();
 		for (IJavaElement elem : elements)