Counting occurrences and test case for inner loop.

Author: dvmarcilio

src/lang/java/refactoring/forloop/EnhancedForLoopRefactorer.rsc

@@ -36,79 +36,76 @@ public void forLoopToFunctional(list[loc] locs, set[str] checkedExceptions) {
 }
 
 // Losing formatting after a method is refactored.
-public CompilationUnit refactorEnhancedForStatements(CompilationUnit unit) {
+public tuple[CompilationUnit unit, int occurrences]  refactorEnhancedForStatements(CompilationUnit unit) {
+	int occurrences = 0;
 	alreadyComputedClassFields = false;
 	CompilationUnit refactoredUnit = visit(unit) {
 		case (MethodDeclaration) `<MethodModifier* mds> <MethodHeader methodHeader> <MethodBody mBody>`: {
 			MethodBody refactoredMethodBody = visit(mBody) {
-				case MethodBody methodBody: insert refactorEnhancedForStatementsInMethodBody(unit, methodHeader, methodBody); 	  		
+				case MethodBody methodBody: {
+					refactored = refactorEnhancedForStatementsInMethodBody(unit, methodHeader, methodBody);
+					occurrences += refactored.occurrences;
+					insert refactored.body; 	  				
+				}
 			};
 
 			insert((MethodDeclaration) `<MethodModifier* mds> <MethodHeader methodHeader> <MethodBody refactoredMethodBody>`);
 		}
 	};
 
-	return refactoredUnit;
+	return <refactoredUnit, occurrences>;
 }
 
 // TODO What happens when two for statements are refactored inside the same method?
-public MethodBody refactorEnhancedForStatementsInMethodBody(CompilationUnit unit, MethodHeader methodHeader, MethodBody methodBody) {
+public tuple[MethodBody body, int occurrences] refactorEnhancedForStatementsInMethodBody(CompilationUnit unit, MethodHeader methodHeader, MethodBody methodBody) {
 	set[MethodVar] availableVars = {};
 	alreadyComputedCurrentMethodAvailableVars = false;
+	occurrences = 0;
+	
 	MethodBody refactoredMethodBody = methodBody; 
 
 	top-down visit(methodBody) {
-		case EnhancedForStatement forStmt: {
-			if(PRINT_DEBUG) {
-				println("for");
-				println(forStmt);
-				println();
-			}
-			
-			if(!alreadyComputedClassFields) {
-				currentClassFields = findClassFields(unit);
-				alreadyComputedClassFields = true;
-			}
-			
-			if(!alreadyComputedCurrentMethodAvailableVars) { 
-				methodVars = findLocalVariables(methodHeader, methodBody);
-				availableVars = retainLocalVariablesIfDuplicates(currentClassFields, methodVars);
-				alreadyComputedAvailableVars = true;
-			}
+		case EnhancedForStatement enhancedForStmt: 
+			visit(enhancedForStmt) {
 
-			top-down visit(forStmt) {
-				case EnhancedForStatement enhancedForStmt: {
-					visit(enhancedForStmt) {
-						case (EnhancedForStatement) `for ( <VariableModifier* _> <UnannType _> <VariableDeclaratorId iteratedVarName>: <Expression collectionId> ) <Statement loopBody>`: {
-							
-							if(isLoopRefactorable(availableVars, collectionId, loopBody)) {
-							
-								try {
-									refactoredMethodBody = refactorEnhancedToFunctional(availableVars, enhancedForStmt, methodBody, iteratedVarName, collectionId);
-									refactoredCount += 1;
+				case (EnhancedForStatement) `for ( <VariableModifier* _> <UnannType _> <VariableDeclaratorId iteratedVarName>: <Expression collectionId> ) <Statement loopBody>`: {
+					
+					if(!alreadyComputedClassFields) {
+						currentClassFields = findClassFields(unit);
+						alreadyComputedClassFields = true;
+					}
+					
+					if(!alreadyComputedCurrentMethodAvailableVars) { 
+						methodVars = findLocalVariables(methodHeader, methodBody);
+						availableVars = retainLocalVariablesIfDuplicates(currentClassFields, methodVars);
+						alreadyComputedAvailableVars = true;
+					}
 
-									if(PRINT_DEBUG) {
-										println("refactored: " + toString(refactoredCount));
-										println(enhancedForStmt);
-										println("---");
-										println(refactoredMethodBody);
-										println();
-									}
-								} catch:
-									continue;
-								
+					if(isLoopRefactorable(availableVars, collectionId, loopBody)) {
+					
+						try {
+							refactoredMethodBody = refactorEnhancedToFunctional(availableVars, enhancedForStmt, methodBody, iteratedVarName, collectionId);
+							occurrences += 1;
+							
+							if(PRINT_DEBUG) {
+								println("refactored: " + toString(occurrences));
+								println(enhancedForStmt);
+								println("---");
+								println(refactoredMethodBody);
+								println();
 							}
-						}
+						} catch: 
+							continue;
 					}
 				}
+				
 			}
-		}
 
 		case (EnhancedForStatementNoShortIf) `for ( <VariableModifier* _> <UnannType _> <VariableDeclaratorId _> : <Expression _> ) <StatementNoShortIf stmt>`:
 			println("TODO");
 	}
 
-	return refactoredMethodBody;
+	return <refactoredMethodBody, occurrences>;
 }
 
 private bool isLoopRefactorable(set[MethodVar] availableVariables, Expression collectionId, Statement loopBody) {

src/lang/java/refactoring/forloop/test/EnhancedForLoopRefactorerTest.rsc

@@ -1,15 +1,17 @@
 module lang::java::refactoring::forloop::\test::EnhancedForLoopRefactorerTest
 
+import IO;
 import lang::java::refactoring::forloop::EnhancedForLoopRefactorer;
 import lang::java::refactoring::forloop::\test::resources::RefactorerTestResources;
 
-// comparing an entire file is not that practical
+// comparing an entire file is not that practical	
 // comparing methods then
 // but definitely should automate test for entire compilation unit 
 public test bool shouldRefactorInnerLoopButNoutOuterLoop() {
 	refactorable = innerLoopButNotOuterLoop();
 
 	refactored = refactorEnhancedForStatementsInMethodBody(refactorable.unit, refactorable.header, refactorable.body);
 
-	return refactored == refactorable.refactored;
+	return refactored.body == refactorable.refactored &&
+		refactored.occurrences == 1;
 }

src/lang/java/refactoring/forloop/test/resources/RefactorerTestResources.rsc

@@ -0,0 +1,18 @@
+module lang::java::refactoring::forloop::\test::resources::RefactorerTestResources
+
+import IO;
+import ParseTree;
+import lang::java::\syntax::Java18;
+
+public data RefactorableFor = refactorableFor(CompilationUnit unit, MethodHeader header, MethodBody body, MethodBody refactored);
+
+public RefactorableFor innerLoopButNotOuterLoop() {
+	classLoc = |project://rascal-Java8//testes/forloop/Refactorer/ServletComponentRegisteringPostProcessor.java|;
+	unit = parse(#CompilationUnit, readFile(classLoc));
+	header = parse(#MethodHeader, "void scanPackage(\r\n\t\t\tClassPathScanningCandidateComponentProvider componentProvider,\r\n\t\t\tString packageToScan)"); 
+	body = parse(#MethodBody, "{\r\n\t\tfor (BeanDefinition candidate : componentProvider\r\n\t\t\t\t.findCandidateComponents(packageToScan)) {\r\n\t\t\tif (candidate instanceof ScannedGenericBeanDefinition) {\r\n\t\t\t\tfor (ServletComponentHandler handler : HANDLERS) {\r\n\t\t\t\t\thandler.handle(((ScannedGenericBeanDefinition) candidate),\r\n\t\t\t\t\t\t\t(BeanDefinitionRegistry) this.applicationContext);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}");
+	
+	refactored = parse(#MethodBody, "{\r\n\t\tfor (BeanDefinition candidate : componentProvider\r\n\t\t\t\t.findCandidateComponents(packageToScan)) {\r\n\t\t\tif (candidate instanceof ScannedGenericBeanDefinition) {\r\n\t\t\t\tHANDLERS.forEach(handler -\> {\nhandler.handle(((ScannedGenericBeanDefinition) candidate),\r\n\t\t\t\t\t\t\t(BeanDefinitionRegistry) this.applicationContext);\n});\r\n\t\t\t}\r\n\t\t}\r\n\t}");
+	
+	return refactorableFor(unit, header, body, refactored);
+}