GROOVY-5359: check super class static method before callable property

src/main/java/groovy/lang/MetaClassImpl.java

@@ -1437,132 +1437,109 @@ public Constructor retrieveConstructor(Class[] arguments) {
         return null;
     }
 
-    public MetaMethod retrieveStaticMethod(String methodName, Object[] arguments) {
-        final MetaMethodIndex.Cache e = metaMethodIndex.getMethods(theClass, methodName);
-        MetaMethodIndex.MetaMethodCache cacheEntry;
+    public MetaMethod getMethodWithoutCaching(Class sender, String methodName, Class[] arguments, boolean isCallToSuper) {
+        MetaMethod method = null;
+        Object methods = getMethods(sender, methodName, isCallToSuper);
+        if (methods != null) {
+            method = (MetaMethod) chooseMethod(methodName, methods, arguments);
+        }
+        return method;
+    }
+
+    public MetaMethod retrieveStaticMethod(final String methodName, final Object[] arguments) {
+        MetaMethodIndex.Cache e = metaMethodIndex.getMethods(theClass, methodName);
         if (e != null) {
-            cacheEntry = e.cachedStaticMethod;
+            MetaMethodIndex.MetaMethodCache cacheEntry = e.cachedStaticMethod;
 
-            if (cacheEntry != null &&
-                    MetaClassHelper.sameClasses(cacheEntry.params, arguments, e.staticMethods instanceof MetaMethod)) {
+            if (cacheEntry != null && MetaClassHelper.sameClasses(cacheEntry.params, arguments, e.staticMethods instanceof MetaMethod)) {
                 return cacheEntry.method;
             }
 
-            final Class[] classes = MetaClassHelper.convertToTypeArray(arguments);
+            Class<?>[] classes = MetaClassHelper.convertToTypeArray(arguments);
             cacheEntry = new MetaMethodIndex.MetaMethodCache(classes, pickStaticMethod(methodName, classes));
 
             e.cachedStaticMethod = cacheEntry;
 
             return cacheEntry.method;
         }
-        return pickStaticMethod(methodName, MetaClassHelper.convertToTypeArray(arguments));
-    }
 
-    public MetaMethod getMethodWithoutCaching(Class sender, String methodName, Class[] arguments, boolean isCallToSuper) {
-        MetaMethod method = null;
-        Object methods = getMethods(sender, methodName, isCallToSuper);
-        if (methods != null) {
-            method = (MetaMethod) chooseMethod(methodName, methods, arguments);
-        }
-        return method;
+        return pickStaticMethod(methodName, MetaClassHelper.convertToTypeArray(arguments));
     }
 
     @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);
-        }
-        Object prop = null;
-        try {
-            prop = getProperty(theClass, theClass, methodName, false, false);
-        } catch (MissingPropertyException mpe) {
-            // ignore
+            MetaClassHelper.unwrap(nonNullArguments);
+            return method.doMethodInvoke(object, nonNullArguments);
         }
 
-        if (prop instanceof Closure) {
-            return invokeStaticClosureProperty(arguments, prop);
-        }
+        Class<?>[] argumentTypes = MetaClassHelper.convertToTypeArray(nonNullArguments);
+        MetaClassHelper.unwrap(nonNullArguments);
 
-        Object[] originalArguments = arguments.clone();
-        MetaClassHelper.unwrap(arguments);
-
-        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);
+        Object propertyValue = null; // GROOVY-3284, GROOVY-3422, GROOVY-9779
+        try {
+            propertyValue = getProperty(theClass, theClass, methodName, false, false);
+        } catch (MissingPropertyException ignore) {
+        }
+        if (propertyValue != null) {
+            if (propertyValue instanceof Closure closure) {
+                return closure.getMetaClass().invokeMethod(theClass, closure, DO_CALL_METHOD, arguments, false, false);
+            } else {
+                return registry.getMetaClass(propertyValue.getClass()).invokeMethod(propertyValue, CALL_METHOD, arguments);
+            }
         }
 
-        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) {
+    private Object invokeStaticMissingMethod(final Class<?> sender, final String methodName, final Object[] arguments) {
         MetaMethod metaMethod = getStaticMetaMethod(STATIC_METHOD_MISSING, METHOD_MISSING_ARGS);
         if (metaMethod != null) {
             return metaMethod.invoke(sender, new Object[]{methodName, arguments});
         }
         throw new MissingMethodException(methodName, sender, arguments, true);
     }
 
-    private MetaMethod pickStaticMethod(String methodName, Class[] arguments) throws MethodSelectionException {
+    private MetaMethod pickStaticMethod(final String methodName, final Class<?>[] argumentTypes) throws MethodSelectionException {
         MetaMethod method = null;
         MethodSelectionException mse = null;
         Object methods = getStaticMethods(theClass, methodName);
 
         if (!(methods instanceof FastArray) || !((FastArray) methods).isEmpty()) {
             try {
-                method = (MetaMethod) chooseMethod(methodName, methods, arguments);
+                method = (MetaMethod) chooseMethod(methodName, methods, argumentTypes);
             } catch (MethodSelectionException msex) {
                 mse = msex;
             }
         }
         if (method == null && theClass != Class.class) {
             MetaClass cmc = registry.getMetaClass(Class.class);
-            method = cmc.pickMethod(methodName, arguments);
+            method = cmc.pickMethod(methodName, argumentTypes);
         }
         if (method == null) {
-            method = (MetaMethod) chooseMethod(methodName, methods, arguments);
+            method = (MetaMethod) chooseMethod(methodName, methods, argumentTypes);
         }
 
         if (method == null && mse != null) {

src/test/groovy/bugs/Groovy5359.groovy

@@ -0,0 +1,64 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package bugs
+
+import org.codehaus.groovy.runtime.metaclass.MissingPropertyExceptionNoStack
+import org.junit.jupiter.api.Test
+
+final class Groovy5359 {
+
+    static class A {
+        static method() { 'A' }
+    }
+
+    static class B extends A {
+    }
+
+    static class C extends A {
+    }
+
+    @groovy.transform.CompileStatic
+    private long measure(Number count, Closure block) {
+        long t0 = System.currentTimeMillis()
+        count.times(block)
+        System.currentTimeMillis() - t0
+    }
+
+    @Test
+    void testStaticMethodOfSuperClass() {
+        ExpandoMetaClass.enableGlobally()
+        try {
+            int count = 0
+            C.metaClass.static.propertyMissing = { name ->
+                count += 1
+                throw new MissingPropertyExceptionNoStack('static property missing', getDelegate())
+            }
+
+            assert B.method() == 'A'
+            assert C.method() == 'A'
+            assert count == 0
+
+            assert measure(1e6) { B.method() } < 1500 // was ~26000 with property check
+            assert measure(1e6) { C.method() } < 1500 // was ~26000 with property check
+            assert count == 0
+        } finally {
+            ExpandoMetaClass.disableGlobally()
+        }
+    }
+}