This is an automated email from the ASF dual-hosted git repository. borinquenkid pushed a commit to branch test/document-datamapping-core-transformers in repository https://gitbox.apache.org/repos/asf/grails-core.git
commit 0e9f36645d8c7bf29aea62f24909abbdd97cd437 Author: Walter Duque de Estrada <[email protected]> AuthorDate: Thu Aug 13 13:49:25 2026 -0500 Fix IntelliJ warnings on DirtyCheckingTransformer Cleanup pass addressing IntelliJ's inspection warnings, all semantic-preserving: - Unused catch parameter renamed to 'ignored'. - 11 unnecessary qualified references removed (Modifier.PUBLIC, GeneralUtils.*, and AstUtils.isDomainClass were all already available via existing static imports; the fully-qualified org.codehaus.groovy.transform.trait.TraitComposer reference was replaced with a proper import). The now-unused plain imports for Modifier, GeneralUtils, and AstUtils were removed. - 8 helper methods that don't touch instance state made static (isDefinedInTransientsNode, resolvePropertyReturnType, isAnnotatedWithJavaValidationApi, getGetterAndSetterForPropertyName, isSetter, isGetter, weaveIntoExistingSetter, createMarkDirtyMethodCall). The nested GetterAndSetter class was also made static since it never referenced the enclosing instance - required once its factory method became static. - isDefinedInTransientsNode given an explicit `return false` for the branch that previously fell through with no return value on a boolean-returning method. - 6 .equals() calls on Groovy value types replaced with ==, which is equivalent here (Groovy's == is equals()-based with added null-safety, not Java reference equality). Verified via a full, unfiltered module test suite run - no test changes were needed since none of this altered behavior. Co-Authored-By: Claude Sonnet 5 <[email protected]> --- .../compiler/gorm/DirtyCheckingTransformer.groovy | 54 +++++++++++----------- 1 file changed, 26 insertions(+), 28 deletions(-) diff --git a/grails-datamapping-core/src/main/groovy/org/grails/compiler/gorm/DirtyCheckingTransformer.groovy b/grails-datamapping-core/src/main/groovy/org/grails/compiler/gorm/DirtyCheckingTransformer.groovy index 687e7862a4..40e3019d04 100644 --- a/grails-datamapping-core/src/main/groovy/org/grails/compiler/gorm/DirtyCheckingTransformer.groovy +++ b/grails-datamapping-core/src/main/groovy/org/grails/compiler/gorm/DirtyCheckingTransformer.groovy @@ -19,8 +19,6 @@ package org.grails.compiler.gorm -import java.lang.reflect.Modifier - import groovy.transform.CompilationUnitAware import groovy.transform.CompileStatic import org.codehaus.groovy.ast.AnnotationNode @@ -36,11 +34,11 @@ import org.codehaus.groovy.ast.expr.ConstantExpression import org.codehaus.groovy.ast.expr.ListExpression import org.codehaus.groovy.ast.expr.MethodCallExpression import org.codehaus.groovy.ast.stmt.BlockStatement -import org.codehaus.groovy.ast.tools.GeneralUtils import org.codehaus.groovy.classgen.GeneratorContext import org.codehaus.groovy.control.CompilationUnit import org.codehaus.groovy.control.SourceUnit import org.codehaus.groovy.transform.sc.StaticCompilationVisitor +import org.codehaus.groovy.transform.trait.TraitComposer import org.springframework.validation.annotation.Validated @@ -48,7 +46,6 @@ import grails.gorm.dirty.checking.DirtyCheck import grails.gorm.dirty.checking.DirtyCheckedProperty import org.grails.datastore.mapping.dirty.checking.DirtyCheckable import org.grails.datastore.mapping.model.config.GormProperties -import org.grails.datastore.mapping.reflect.AstUtils import org.grails.datastore.mapping.reflect.ClassUtils import org.grails.datastore.mapping.reflect.NameUtils import org.grails.datastore.mapping.reflect.ReflectionUtils @@ -99,7 +96,7 @@ class DirtyCheckingTransformer implements CompilationUnitAware { if (ClassUtils.isPresent('jakarta.validation.Constraint')) { try { VALIDATION_CONSTRAINT_NODE = ClassHelper.make(Class.forName('jakarta.validation.Constraint')) - } catch (Throwable e) { + } catch (Throwable ignored) { VALIDATION_CONSTRAINT_NODE = null } } @@ -124,7 +121,7 @@ class DirtyCheckingTransformer implements CompilationUnitAware { final MethodNode markDirtyMethodNode = changeTrackableClassNode.getMethod(METHOD_NAME_MARK_DIRTY, new Parameter(ClassHelper.STRING_TYPE, 'propertyName'), new Parameter(ClassHelper.OBJECT_TYPE, 'newValue')) ClassNode superClass = classNode.getSuperClass() - boolean shouldWeave = superClass.equals(OBJECT_CLASS_NODE) + boolean shouldWeave = superClass == OBJECT_CLASS_NODE ClassNode dirtyCheckableTrait = ClassHelper.make(traitToInject).getPlainNodeReference() if (traitToInject != DirtyCheckable) { @@ -136,7 +133,7 @@ class DirtyCheckingTransformer implements CompilationUnitAware { break } superClass = superClass.getSuperClass() - if (superClass == null || superClass.equals(OBJECT_CLASS_NODE)) { + if (superClass == null || superClass == OBJECT_CLASS_NODE) { shouldWeave = true break } @@ -146,7 +143,7 @@ class DirtyCheckingTransformer implements CompilationUnitAware { classNode.addInterface(dirtyCheckableTrait) if (compilationUnit != null) { - org.codehaus.groovy.transform.trait.TraitComposer.doExtendTraits(classNode, source, compilationUnit) + TraitComposer.doExtendTraits(classNode, source, compilationUnit) } } @@ -206,16 +203,16 @@ class DirtyCheckingTransformer implements CompilationUnitAware { } if (hasAnnotation(allAnnotationNodes, GormEntityTransformation.JPA_ID_ANNOTATION_NODE)) { - if (!propertyName.equals(GormProperties.IDENTITY)) { + if (propertyName != GormProperties.IDENTITY) { // if the property is a JPA @Id but the property name is not id add a transient getter to retrieve the id called getId if (classNode.getField(GormProperties.IDENTITY) == null && gettersAndSetters[GormProperties.IDENTITY] == null) { def getIdMethod = new MethodNode( 'getId', - Modifier.PUBLIC, + PUBLIC, pn.type.plainNodeReference, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, - GeneralUtils.returnS(GeneralUtils.varX(propertyField)) + returnS(varX(propertyField)) ) markAsGenerated(classNode, getIdMethod) classNode.addMethod(getIdMethod) @@ -232,11 +229,11 @@ class DirtyCheckingTransformer implements CompilationUnitAware { if (classNode.getField(GormProperties.VERSION) == null && gettersAndSetters[GormProperties.VERSION] == null) { def getVersionMethod = new MethodNode( 'getVersion', - Modifier.PUBLIC, + PUBLIC, pn.type.plainNodeReference, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, - GeneralUtils.returnS(GeneralUtils.varX(propertyField)) + returnS(varX(propertyField)) ) markAsGenerated(classNode, getVersionMethod) classNode.addMethod(getVersionMethod) @@ -256,7 +253,7 @@ class DirtyCheckingTransformer implements CompilationUnitAware { // first add the getter ClassNode returnType = resolvePropertyReturnType(pn, classNode) - boolean booleanProperty = ClassHelper.boolean_TYPE.getName().equals(returnType.getName()) || ClassHelper.Boolean_TYPE.getName().equals(returnType.getName()) + boolean booleanProperty = ClassHelper.boolean_TYPE.getName() == returnType.getName() || ClassHelper.Boolean_TYPE.getName() == returnType.getName() String fieldName = propertyField.getName() String getterName = NameUtils.getGetterName(propertyName, false) @@ -307,11 +304,11 @@ class DirtyCheckingTransformer implements CompilationUnitAware { // if the entity is a JPA and has no version property then add a transient one as a stub, this is more to satisfy Grails def getVersionMethod = new MethodNode( 'getVersion', - Modifier.PUBLIC, + PUBLIC, ClassHelper.make(Long), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, - GeneralUtils.returnS(GeneralUtils.constX(0)) + returnS(constX(0)) ) markAsGenerated(classNode, getVersionMethod) classNode.addMethod(getVersionMethod) @@ -333,18 +330,19 @@ class DirtyCheckingTransformer implements CompilationUnitAware { * @param transientPropertyNode The property node representing static transients * @return If the property is transient */ - private boolean isDefinedInTransientsNode(String propertyName, PropertyNode transientPropertyNode) { + private static boolean isDefinedInTransientsNode(String propertyName, PropertyNode transientPropertyNode) { if (transientPropertyNode) { - transientPropertyNode.isStatic() && + return transientPropertyNode.isStatic() && transientPropertyNode.initialExpression instanceof ListExpression && ((ListExpression) transientPropertyNode.initialExpression).expressions.find { it instanceof ConstantExpression && it.value == propertyName } } + return false } - private ClassNode resolvePropertyReturnType(PropertyNode pn, ClassNode classNode) { + private static ClassNode resolvePropertyReturnType(PropertyNode pn, ClassNode classNode) { ClassNode originalReturnType = pn.getType() ClassNode returnType - if (!originalReturnType.getNameWithoutPackage().equals(VOID)) { + if (originalReturnType.getNameWithoutPackage() != VOID) { if (ClassHelper.isPrimitiveType(originalReturnType.redirect())) { returnType = originalReturnType.getPlainNodeReference() } else { @@ -375,7 +373,7 @@ class DirtyCheckingTransformer implements CompilationUnitAware { } } - protected boolean isAnnotatedWithJavaValidationApi(List<AnnotationNode> annotationNodes) { + protected static boolean isAnnotatedWithJavaValidationApi(List<AnnotationNode> annotationNodes) { VALIDATION_CONSTRAINT_NODE != null && annotationNodes.any { AnnotationNode an -> an.classNode.getAnnotations(VALIDATION_CONSTRAINT_NODE) } } @@ -390,7 +388,7 @@ class DirtyCheckingTransformer implements CompilationUnitAware { } boolean shouldInject(URL url) { - return AstUtils.isDomainClass(url) + return isDomainClass(url) } void performInjectionOnAnnotatedEntity(ClassNode classNode) { @@ -423,7 +421,7 @@ class DirtyCheckingTransformer implements CompilationUnitAware { } return copiedReturnType } - protected void weaveIntoExistingSetter(String propertyName, GetterAndSetter getterAndSetter, MethodNode markDirtyMethodNode) { + protected static void weaveIntoExistingSetter(String propertyName, GetterAndSetter getterAndSetter, MethodNode markDirtyMethodNode) { final MethodNode setterMethod = getterAndSetter.setter if (setterMethod.annotations.any { AnnotationNode an -> an.classNode.name == 'grails.persistence.PersistenceMethod' }) return @@ -448,14 +446,14 @@ class DirtyCheckingTransformer implements CompilationUnitAware { setterMethod.code = newBody } - protected MethodCallExpression createMarkDirtyMethodCall(MethodNode markDirtyMethodNode, String propertyName, Variable value) { + protected static MethodCallExpression createMarkDirtyMethodCall(MethodNode markDirtyMethodNode, String propertyName, Variable value) { def args = args(constX(propertyName), varX(value)) final markDirtyMethodCall = callX(varX('this'), markDirtyMethodNode.name, args) markDirtyMethodCall.methodTarget = markDirtyMethodNode return markDirtyMethodCall } - protected GetterAndSetter getGetterAndSetterForPropertyName(LinkedHashMap<String, GetterAndSetter> gettersAndSetters, String propertyName) { + protected static GetterAndSetter getGetterAndSetterForPropertyName(LinkedHashMap<String, GetterAndSetter> gettersAndSetters, String propertyName) { def getterAndSetter = gettersAndSetters[propertyName] if (getterAndSetter == null) { getterAndSetter = new GetterAndSetter() @@ -464,11 +462,11 @@ class DirtyCheckingTransformer implements CompilationUnitAware { return getterAndSetter } - private boolean isSetter(String methodName, MethodNode declaredMethod) { + private static boolean isSetter(String methodName, MethodNode declaredMethod) { return declaredMethod.getParameters().length == 1 && ReflectionUtils.isSetter(methodName, OBJECT_CLASS_ARG) } - private boolean isGetter(String methodName, MethodNode declaredMethod) { + private static boolean isGetter(String methodName, MethodNode declaredMethod) { return declaredMethod.getParameters().length == 0 && ReflectionUtils.isGetter(methodName, EMPTY_JAVA_CLASS_ARRAY) } @@ -477,7 +475,7 @@ class DirtyCheckingTransformer implements CompilationUnitAware { } @CompileStatic - class GetterAndSetter { + static class GetterAndSetter { MethodNode getter MethodNode setter
