Fix VerifierError with closures in Spock specs with @Rollback - Fixes #9837

Author: graemerocher

grails-core/src/main/groovy/org/grails/transaction/transform/TransactionalTransform.groovy

@@ -20,6 +20,8 @@ import grails.compiler.DelegatingMethod
 import grails.transaction.Rollback
 import groovy.transform.TypeChecked
 import org.codehaus.groovy.ast.stmt.Statement
+import org.codehaus.groovy.classgen.VariableScopeVisitor
+import org.codehaus.groovy.control.ErrorCollector
 import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.beans.factory.annotation.Qualifier
 import org.springframework.transaction.annotation.Propagation
@@ -292,14 +294,26 @@ class TransactionalTransform implements ASTTransformation{
         final transactionStatusParameter = new Parameter(ClassHelper.make(TransactionStatus), "transactionStatus")
         def newParameters = methodNode.getParameters() ? (copyParameters(((methodNode.getParameters() as List) + [transactionStatusParameter]) as Parameter[])) : [transactionStatusParameter] as Parameter[]
 
+
+        def body = methodNode.code
         MethodNode renamedMethodNode = new MethodNode(
                 renamedMethodName,
                 Modifier.PROTECTED, methodNode.getReturnType().getPlainNodeReference(),
                 newParameters,
                 GrailsArtefactClassInjector.EMPTY_CLASS_ARRAY,
-                methodNode.code
+                body
                 );
 
+
+        def newVariableScope = new VariableScope()
+        for(p in newParameters) {
+            newVariableScope.putDeclaredVariable(p)
+        }
+
+        renamedMethodNode.setVariableScope(
+                newVariableScope
+        )
+
         // GrailsCompileStatic and GrailsTypeChecked are not explicitly addressed
         // here but they will be picked up because they are @AnnotationCollector annotations
         // which use CompileStatic and TypeChecked...
@@ -309,14 +323,19 @@ class TransactionalTransform implements ASTTransformation{
         methodNode.setCode(null)
         classNode.addMethod(renamedMethodNode)
 
-        if( !isSpockTest(classNode) ) {
-            processVariableScopes(source, classNode, renamedMethodNode)
+        // Use a dummy source unit to process the variable scopes to avoid the issue where this is run twice producing an error
+        VariableScopeVisitor scopeVisitor = new VariableScopeVisitor(new SourceUnit("dummy", "dummy", source.getConfiguration(), source.getClassLoader(), new ErrorCollector(source.getConfiguration())));
+        if(methodNode == null) {
+            scopeVisitor.visitClass(classNode);
+        } else {
+            scopeVisitor.prepareVisit(classNode);
+            scopeVisitor.visitMethod(renamedMethodNode);
         }
 
         final originalMethodCall = new MethodCallExpression(new VariableExpression("this"), renamedMethodName, new ArgumentListExpression(renamedMethodNode.parameters))
         originalMethodCall.setImplicitThis(false)
         originalMethodCall.setMethodTarget(renamedMethodNode)
-        
+
         originalMethodCall
     }
 

grails-core/src/test/groovy/grails/transaction/TransactionalTransformSpec.groovy

@@ -26,8 +26,41 @@ import javax.sql.DataSource
  */
 class TransactionalTransformSpec extends Specification {
 
+    @Issue('https://github.com/grails/grails-core/issues/9837')
+    void "Test @Rollback when applied to Spock specifications with closures combined with where queries"() {
+        when: "A new instance of a class with a @Transactional method is created that subclasses another transactional class"
+        Class mySpec = new GroovyShell().evaluate('''
+    import grails.transaction.*
+    import spock.lang.Specification
+
+    @Rollback
+    class MySpec extends Specification {
+        void 'test something'() {
+            expect:
+            def someClosure = { println x }
+            x + y == sum
+
+            where:
+            x | y | sum
+            4 | 2 | 6
+        }
+    }
+    MySpec
+    ''')
+
+        then: "It implements TransactionManagerAware"
+        TransactionManagerAware.isAssignableFrom(mySpec)
+        mySpec.getDeclaredMethod('$spock_feature_0_0', Object, Object, Object)
+        mySpec.getDeclaredMethod('$tt__$spock_feature_0_0', Object, Object, Object, TransactionStatus)
+
+        and:"The spec can be called"
+        mySpec.newInstance().'$tt__$spock_feature_0_0'(2,2,4,new DefaultTransactionStatus(new Object(), true, true, false, false, null))
+
+
+    }
+
     @Issue('https://github.com/grails/grails-core/issues/9646')
-    void "Test @Rollback when applied to Spock specifications with closures in there blocks"() {
+    void "Test @Rollback when applied to Spock specifications with closures in then blocks"() {
         when: "A new instance of a class with a @Transactional method is created that subclasses another transactional class"
         Class mySpec = new GroovyShell().evaluate('''
     import grails.transaction.*