(groovy) 01/01: GROOVY-5359: refactor `MetaClassImpl#invokeStaticMethod`

[emilles]

This is an automated email from the ASF dual-hosted git repository.

emilles pushed a commit to branch GROOVY-5359
in repository https://gitbox.apache.org/repos/asf/groovy.git

commit b7c0edfdb359c378d86667290351ed2089918d55
Author: Eric Milles <eric.mil...@thomsonreuters.com>
AuthorDate: Thu Jan 22 20:54:41 2026 -0600

    GROOVY-5359: refactor `MetaClassImpl#invokeStaticMethod`
---
 src/main/java/groovy/lang/MetaClassImpl.java | 74 ++++++++++------------------
 1 file changed, 27 insertions(+), 47 deletions(-)

diff --git a/src/main/java/groovy/lang/MetaClassImpl.java 
b/src/main/java/groovy/lang/MetaClassImpl.java
index 2dcd9c6ca0..a7e53e6ebb 100644
--- a/src/main/java/groovy/lang/MetaClassImpl.java
+++ b/src/main/java/groovy/lang/MetaClassImpl.java
@@ -1468,73 +1468,53 @@ public class MetaClassImpl implements MetaClass, 
MutableMetaClass {
     }
 
     @Override
-    public Object invokeStaticMethod(Object object, String methodName, 
Object[] arguments) {
+    public Object invokeStaticMethod(final Object object, final String 
methodName, final Object[] arguments) {
         checkInitalised();
 
-        final Class sender = object instanceof Class ? (Class) object : 
object.getClass();
-        if (sender != theClass) {
-            MetaClass mc = registry.getMetaClass(sender);
-            return mc.invokeStaticMethod(sender, methodName, arguments);
-        }
-        if (sender == Class.class) {
-            return invokeMethod(object, methodName, arguments);
+        {
+            var sender = object instanceof Class ? (Class<?>) object : 
object.getClass();
+            if (sender != theClass) { MetaClass mc = 
registry.getMetaClass(sender);
+                return mc.invokeStaticMethod(sender, methodName, arguments);
+            }
+            if (sender == Class.class) {
+                return invokeMethod(object, methodName, arguments);
+            }
         }
 
-        if (arguments == null) arguments = EMPTY_ARGUMENTS;
+        Object[] nonNullArguments = arguments != null ? arguments.clone() : 
EMPTY_ARGUMENTS;
 
-        MetaMethod method = retrieveStaticMethod(methodName, arguments);
         // let's try to use the cache to find the method
-
+        MetaMethod method = retrieveStaticMethod(methodName, nonNullArguments);
         if (method != null) {
-            MetaClassHelper.unwrap(arguments);
-            return method.doMethodInvoke(object, arguments);
+            MetaClassHelper.unwrap(nonNullArguments);
+            return method.doMethodInvoke(object, nonNullArguments);
         }
-        Object prop = null;
+
+        Object propertyValue = null;
         try {
-            prop = getProperty(theClass, theClass, methodName, false, false);
+            propertyValue = getProperty(theClass, theClass, methodName, false, 
false);
         } catch (MissingPropertyException mpe) {
             // ignore
         }
-
-        if (prop instanceof Closure) {
-            return invokeStaticClosureProperty(arguments, prop);
+        if (propertyValue instanceof Closure closure) { // GROOVY-3422
+            return closure.getMetaClass().invokeMethod(theClass, closure, 
DO_CALL_METHOD, arguments, false, false);
         }
 
-        Object[] originalArguments = arguments.clone();
-        MetaClassHelper.unwrap(arguments);
+        Class<?>[] argumentTypes = 
MetaClassHelper.convertToTypeArray(nonNullArguments);
+        MetaClassHelper.unwrap(nonNullArguments);
 
-        Class superClass = sender.getSuperclass();
-        Class[] argClasses = MetaClassHelper.convertToTypeArray(arguments);
-        while (superClass != Object.class && superClass != null) {
+        for (var superClass = theClass.getSuperclass(); superClass != null; 
superClass = superClass.getSuperclass()) {
             MetaClass mc = registry.getMetaClass(superClass);
-            method = mc.getStaticMetaMethod(methodName, argClasses);
-            if (method != null) return method.doMethodInvoke(object, 
arguments);
-
-            try {
-                prop = mc.getProperty(superClass, superClass, methodName, 
false, false);
-            } catch (MissingPropertyException mpe) {
-                // ignore
-            }
-
-            if (prop instanceof Closure) {
-                return invokeStaticClosureProperty(originalArguments, prop);
-            }
-
-            superClass = superClass.getSuperclass();
+            method = mc.getStaticMetaMethod(methodName, argumentTypes);
+            if (method != null) return method.doMethodInvoke(object, 
nonNullArguments);
         }
 
-        if (prop != null) {
-            MetaClass propMC = registry.getMetaClass(prop.getClass());
-            return propMC.invokeMethod(prop, CALL_METHOD, arguments);
+        if (propertyValue != null) { // GROOVY-3284, GROOVY-9779
+            MetaClass mc = registry.getMetaClass(propertyValue.getClass());
+            return mc.invokeMethod(propertyValue, CALL_METHOD, 
nonNullArguments);
         }
 
-        return invokeStaticMissingMethod(sender, methodName, arguments);
-    }
-
-    private static Object invokeStaticClosureProperty(Object[] 
originalArguments, Object prop) {
-        Closure closure = (Closure) prop;
-        MetaClass delegateMetaClass = closure.getMetaClass();
-        return delegateMetaClass.invokeMethod(closure.getClass(), closure, 
DO_CALL_METHOD, originalArguments, false, false);
+        return invokeStaticMissingMethod(theClass, methodName, 
nonNullArguments);
     }
 
     private Object invokeStaticMissingMethod(Class sender, String methodName, 
Object[] arguments) {