Iterate over return types.

Author: khatchad

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

@@ -374,98 +374,100 @@ public static Collection<TypeAbstraction> getPossibleTypesInterprocedurally(CGNo
 				// Find the return type of the instruction.
 				TypeInference inference = TypeInference.make(node.getIR(), false);
 				Collection<TypeAbstraction> returnTypes = Util.getPossibleTypes(valueNumber, inference);
-				assert returnTypes.size() == 1 : "Not expecting more than one return type.";
-				TypeAbstraction rType = returnTypes.iterator().next();
 
-				PointType concreteType = new PointType(concreteClass);
-
-				if (rType.getType().getReference().equals(TypeReference.JavaLangObject)) {
-					IR ir = node.getIR();
-					IMethod method = ir.getMethod();
-					IBytecodeMethod bytecodeMethod = (IBytecodeMethod) method;
-
-					// get the definition instruction.
-					SSAInvokeInstruction def = (SSAInvokeInstruction) node.getDU().getDef(valueNumber);
-
-					// which index is it into the instruction array?
-					int instructionIndex = Util.indexOf(ir.getInstructions(), def);
-
-					// get the bytecode index.
-					int bytecodeIndex;
-					try {
-						bytecodeIndex = bytecodeMethod.getBytecodeIndex(instructionIndex);
-					} catch (InvalidClassFileException e) {
-						throw new IllegalArgumentException(
-								"Value number: " + valueNumber + " does not have a definition (" + instructionIndex
-										+ ") corresponding to a bytecode index.",
-								e);
-					}
+				// for each return type.
+				for (TypeAbstraction rType : returnTypes) {
+					PointType concreteType = new PointType(concreteClass);
+
+					if (rType.getType().getReference().equals(TypeReference.JavaLangObject)) {
+						IR ir = node.getIR();
+						IMethod method = ir.getMethod();
+						IBytecodeMethod bytecodeMethod = (IBytecodeMethod) method;
+
+						// get the definition instruction.
+						SSAInvokeInstruction def = (SSAInvokeInstruction) node.getDU().getDef(valueNumber);
+
+						// which index is it into the instruction array?
+						int instructionIndex = Util.indexOf(ir.getInstructions(), def);
+
+						// get the bytecode index.
+						int bytecodeIndex;
+						try {
+							bytecodeIndex = bytecodeMethod.getBytecodeIndex(instructionIndex);
+						} catch (InvalidClassFileException e) {
+							throw new IllegalArgumentException(
+									"Value number: " + valueNumber + " does not have a definition (" + instructionIndex
+											+ ") corresponding to a bytecode index.",
+									e);
+						}
 
-					// get the source information
-					SourcePosition sourcePosition;
-					try {
-						sourcePosition = method.getSourcePosition(bytecodeIndex);
-					} catch (InvalidClassFileException e) {
-						throw new IllegalArgumentException(
-								"Value number: " + valueNumber + " does not have bytecode index (" + bytecodeIndex
-										+ ") corresponding to a bytecode index.",
-								e);
-					}
+						// get the source information
+						SourcePosition sourcePosition;
+						try {
+							sourcePosition = method.getSourcePosition(bytecodeIndex);
+						} catch (InvalidClassFileException e) {
+							throw new IllegalArgumentException(
+									"Value number: " + valueNumber + " does not have bytecode index (" + bytecodeIndex
+											+ ") corresponding to a bytecode index.",
+									e);
+						}
 
-					// let's assume that the source file is in the same project.
-					IJavaProject enclosingProject = engine.getProject();
-
-					String fqn = method.getDeclaringClass().getName().getPackage().toUnicodeString() + "."
-							+ method.getDeclaringClass().getName().getClassName().toUnicodeString();
-					IType type = enclosingProject.findType(fqn.replace('/', '.'));
-					// FIXME: Need to (i) exclude from result timer and (ii) use the cache in
-					// ConvertToParallelStreamRefactoringProcessor #141.
-					CompilationUnit unit = RefactoringASTParser.parseWithASTProvider(type.getTypeRoot(), true, null);
-
-					// We have the CompilationUnit corresponding to the instruction's file. Can we
-					// correlate the instruction to the method invocation in the AST?
-					MethodInvocation correspondingInvocation = findCorrespondingMethodInvocation(unit, sourcePosition,
-							def.getCallSite().getDeclaredTarget());
-
-					// what does the method return?
-					ITypeBinding genericReturnType = correspondingInvocation.resolveMethodBinding().getReturnType();
-
-					// Is it compatible with the concrete type we got from WALA? But first, we'll
-					// need to translate the Eclipse JDT type over to a IClass.
-					TypeReference genericTypeRef = getJDTIdentifyMapper(correspondingInvocation)
-							.getTypeRef(genericReturnType);
-					IClass genericClass = node.getClassHierarchy().lookupClass(genericTypeRef);
-
-					boolean assignableFrom = node.getClassHierarchy().isAssignableFrom(genericClass, concreteClass);
-
-					// if it's assignable.
-					if (assignableFrom)
-						// would the ordering be consistent?
-						if (wouldOrderingBeConsistent(Collections.unmodifiableCollection(ret), concreteType,
-								orderingInference)) {
-							// if so, add it.
-							LOGGER.fine("Add type straight up: " + concreteType);
-							ret.add(concreteType);
-						} else {
-							// otherwise, would the generic type cause the
-							// ordering to be inconsistent?
-							PointType genericType = new PointType(genericClass);
-
-							if (wouldOrderingBeConsistent(Collections.unmodifiableCollection(ret), genericType,
+						// let's assume that the source file is in the same project.
+						IJavaProject enclosingProject = engine.getProject();
+
+						String fqn = method.getDeclaringClass().getName().getPackage().toUnicodeString() + "."
+								+ method.getDeclaringClass().getName().getClassName().toUnicodeString();
+						IType type = enclosingProject.findType(fqn.replace('/', '.'));
+						// FIXME: Need to (i) exclude from result timer and (ii) use the cache in
+						// ConvertToParallelStreamRefactoringProcessor #141.
+						CompilationUnit unit = RefactoringASTParser.parseWithASTProvider(type.getTypeRoot(), true,
+								null);
+
+						// We have the CompilationUnit corresponding to the instruction's file. Can we
+						// correlate the instruction to the method invocation in the AST?
+						MethodInvocation correspondingInvocation = findCorrespondingMethodInvocation(unit,
+								sourcePosition, def.getCallSite().getDeclaredTarget());
+
+						// what does the method return?
+						ITypeBinding genericReturnType = correspondingInvocation.resolveMethodBinding().getReturnType();
+
+						// Is it compatible with the concrete type we got from WALA? But first, we'll
+						// need to translate the Eclipse JDT type over to a IClass.
+						TypeReference genericTypeRef = getJDTIdentifyMapper(correspondingInvocation)
+								.getTypeRef(genericReturnType);
+						IClass genericClass = node.getClassHierarchy().lookupClass(genericTypeRef);
+
+						boolean assignableFrom = node.getClassHierarchy().isAssignableFrom(genericClass, concreteClass);
+
+						// if it's assignable.
+						if (assignableFrom)
+							// would the ordering be consistent?
+							if (wouldOrderingBeConsistent(Collections.unmodifiableCollection(ret), concreteType,
 									orderingInference)) {
-								LOGGER.fine("Defaulting to generic type: " + genericType);
-								ret.add(genericType);
-							} else {
-								// fall back to the concrete type.
-								LOGGER.fine(
-										"Defaulting to concrete type eventhough it isn't consistent: " + concreteType);
+								// if so, add it.
+								LOGGER.fine("Add type straight up: " + concreteType);
 								ret.add(concreteType);
+							} else {
+								// otherwise, would the generic type cause the
+								// ordering to be inconsistent?
+								PointType genericType = new PointType(genericClass);
+
+								if (wouldOrderingBeConsistent(Collections.unmodifiableCollection(ret), genericType,
+										orderingInference)) {
+									LOGGER.fine("Defaulting to generic type: " + genericType);
+									ret.add(genericType);
+								} else {
+									// fall back to the concrete type.
+									LOGGER.fine("Defaulting to concrete type eventhough it isn't consistent: "
+											+ concreteType);
+									ret.add(concreteType);
+								}
 							}
-						}
-				} else {
-					// just add it.
-					LOGGER.fine("Add type straight up: " + concreteType);
-					ret.add(concreteType);
+					} else {
+						// just add it.
+						LOGGER.fine("Add type straight up: " + concreteType);
+						ret.add(concreteType);
+					}
 				}
 			}
 		}