Use getParameterCount instead of getParameterTypes (#4821)

snuyanzin · dblock · web-flow · commit 763ef13ad42c · 2022-11-01T09:03:46.000-04:00
* Use getParameterCount instead of getParameterTypes

Signed-off-by: Sergey Nuyanzin &lt;snuyanzin@gmail.com&gt;

* Update changelog

Signed-off-by: Sergey Nuyanzin &lt;snuyanzin@gmail.com&gt;

* Apply spotless

Signed-off-by: Sergey Nuyanzin &lt;snuyanzin@gmail.com&gt;

* Address feedback

Signed-off-by: Sergey Nuyanzin &lt;snuyanzin@gmail.com&gt;

* Address feedback

Signed-off-by: Sergey Nuyanzin &lt;snuyanzin@gmail.com&gt;

Signed-off-by: Sergey Nuyanzin &lt;snuyanzin@gmail.com&gt;
Co-authored-by: Daniel (dB.) Doubrovkine &lt;dblock@amazon.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -48,6 +48,7 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 - Added resource usage trackers for in-flight cancellation of SearchShardTask ([#4805](https://github.com/opensearch-project/OpenSearch/pull/4805))
 - Renamed flaky tests ([#4912](https://github.com/opensearch-project/OpenSearch/pull/4912))
 - Update previous release bwc version to 2.5.0 ([#5003](https://github.com/opensearch-project/OpenSearch/pull/5003))
+- Use getParameterCount instead of getParameterTypes ([#4821](https://github.com/opensearch-project/OpenSearch/pull/4821))
 
 ### Dependencies
 - Bumps `log4j-core` from 2.18.0 to 2.19.0
diff --git a/buildSrc/src/testFixtures/java/org/opensearch/gradle/test/JUnit3MethodProvider.java b/buildSrc/src/testFixtures/java/org/opensearch/gradle/test/JUnit3MethodProvider.java
@@ -59,7 +59,7 @@ public Collection<Method> getTestMethods(Class<?> suiteClass, ClassModel classMo
             if (m.getName().startsWith("test")
                 && Modifier.isPublic(m.getModifiers())
                 && !Modifier.isStatic(m.getModifiers())
-                && m.getParameterTypes().length == 0) {
+                && m.getParameterCount() == 0) {
                 result.add(m);
             }
         }
diff --git a/client/rest-high-level/src/test/java/org/opensearch/client/RestHighLevelClientTests.java b/client/rest-high-level/src/test/java/org/opensearch/client/RestHighLevelClientTests.java
@@ -1005,37 +1005,34 @@ private static void assertSyncMethod(Method method, String apiName, List<String>
         }
 
         assertEquals("incorrect number of exceptions for method [" + method + "]", 1, method.getExceptionTypes().length);
+        final Class<?>[] parameterTypes = method.getParameterTypes();
         // a few methods don't accept a request object as argument
         if (APIS_WITHOUT_REQUEST_OBJECT.contains(apiName)) {
-            assertEquals("incorrect number of arguments for method [" + method + "]", 1, method.getParameterTypes().length);
-            assertThat(
-                "the parameter to method [" + method + "] is the wrong type",
-                method.getParameterTypes()[0],
-                equalTo(RequestOptions.class)
-            );
+            assertEquals("incorrect number of arguments for method [" + method + "]", 1, method.getParameterCount());
+            assertThat("the parameter to method [" + method + "] is the wrong type", parameterTypes[0], equalTo(RequestOptions.class));
         } else {
-            assertEquals("incorrect number of arguments for method [" + method + "]", 2, method.getParameterTypes().length);
+            assertEquals("incorrect number of arguments for method [" + method + "]", 2, method.getParameterCount());
             // This is no longer true for all methods. Some methods can contain these 2 args backwards because of deprecation
-            if (method.getParameterTypes()[0].equals(RequestOptions.class)) {
+            if (parameterTypes[0].equals(RequestOptions.class)) {
                 assertThat(
                     "the first parameter to method [" + method + "] is the wrong type",
-                    method.getParameterTypes()[0],
+                    parameterTypes[0],
                     equalTo(RequestOptions.class)
                 );
                 assertThat(
                     "the second parameter to method [" + method + "] is the wrong type",
-                    method.getParameterTypes()[1].getSimpleName(),
+                    parameterTypes[1].getSimpleName(),
                     endsWith("Request")
                 );
             } else {
                 assertThat(
                     "the first parameter to method [" + method + "] is the wrong type",
-                    method.getParameterTypes()[0].getSimpleName(),
+                    parameterTypes[0].getSimpleName(),
                     endsWith("Request")
                 );
                 assertThat(
                     "the second parameter to method [" + method + "] is the wrong type",
-                    method.getParameterTypes()[1],
+                    parameterTypes[1],
                     equalTo(RequestOptions.class)
                 );
             }
@@ -1049,39 +1046,40 @@ private static void assertAsyncMethod(Map<String, Set<Method>> methods, Method m
         );
         assertThat("async method [" + method + "] should return Cancellable", method.getReturnType(), equalTo(Cancellable.class));
         assertEquals("async method [" + method + "] should not throw any exceptions", 0, method.getExceptionTypes().length);
+        final Class<?>[] parameterTypes = method.getParameterTypes();
         if (APIS_WITHOUT_REQUEST_OBJECT.contains(apiName.replaceAll("_async$", ""))) {
-            assertEquals(2, method.getParameterTypes().length);
-            assertThat(method.getParameterTypes()[0], equalTo(RequestOptions.class));
-            assertThat(method.getParameterTypes()[1], equalTo(ActionListener.class));
+            assertEquals(2, parameterTypes.length);
+            assertThat(parameterTypes[0], equalTo(RequestOptions.class));
+            assertThat(parameterTypes[1], equalTo(ActionListener.class));
         } else {
-            assertEquals("async method [" + method + "] has the wrong number of arguments", 3, method.getParameterTypes().length);
+            assertEquals("async method [" + method + "] has the wrong number of arguments", 3, method.getParameterCount());
             // This is no longer true for all methods. Some methods can contain these 2 args backwards because of deprecation
-            if (method.getParameterTypes()[0].equals(RequestOptions.class)) {
+            if (parameterTypes[0].equals(RequestOptions.class)) {
                 assertThat(
                     "the first parameter to async method [" + method + "] should be a request type",
-                    method.getParameterTypes()[0],
+                    parameterTypes[0],
                     equalTo(RequestOptions.class)
                 );
                 assertThat(
                     "the second parameter to async method [" + method + "] is the wrong type",
-                    method.getParameterTypes()[1].getSimpleName(),
+                    parameterTypes[1].getSimpleName(),
                     endsWith("Request")
                 );
             } else {
                 assertThat(
                     "the first parameter to async method [" + method + "] should be a request type",
-                    method.getParameterTypes()[0].getSimpleName(),
+                    parameterTypes[0].getSimpleName(),
                     endsWith("Request")
                 );
                 assertThat(
                     "the second parameter to async method [" + method + "] is the wrong type",
-                    method.getParameterTypes()[1],
+                    parameterTypes[1],
                     equalTo(RequestOptions.class)
                 );
             }
             assertThat(
                 "the third parameter to async method [" + method + "] is the wrong type",
-                method.getParameterTypes()[2],
+                parameterTypes[2],
                 equalTo(ActionListener.class)
             );
         }
@@ -1094,16 +1092,17 @@ private static void assertSubmitTaskMethod(
         ClientYamlSuiteRestSpec restSpec
     ) {
         String methodName = extractMethodName(apiName);
+        final Class<?>[] parameterTypes = method.getParameterTypes();
         assertTrue("submit task method [" + method.getName() + "] doesn't have corresponding sync method", methods.containsKey(methodName));
-        assertEquals("submit task method [" + method + "] has the wrong number of arguments", 2, method.getParameterTypes().length);
+        assertEquals("submit task method [" + method + "] has the wrong number of arguments", 2, method.getParameterCount());
         assertThat(
             "the first parameter to submit task method [" + method + "] is the wrong type",
-            method.getParameterTypes()[0].getSimpleName(),
+            parameterTypes[0].getSimpleName(),
             endsWith("Request")
         );
         assertThat(
             "the second parameter to submit task method [" + method + "] is the wrong type",
-            method.getParameterTypes()[1],
+            parameterTypes[1],
             equalTo(RequestOptions.class)
         );
 
diff --git a/modules/lang-painless/src/main/java/org/opensearch/painless/Compiler.java b/modules/lang-painless/src/main/java/org/opensearch/painless/Compiler.java
@@ -212,8 +212,9 @@ private static void addFactoryMethod(Map<String, Class<?>> additionalClasses, Cl
         }
 
         additionalClasses.put(factoryClass.getName(), factoryClass);
-        for (int i = 0; i < factoryMethod.getParameterTypes().length; ++i) {
-            Class<?> parameterClazz = factoryMethod.getParameterTypes()[i];
+        final Class<?>[] parameterTypes = factoryMethod.getParameterTypes();
+        for (int i = 0; i < parameterTypes.length; ++i) {
+            Class<?> parameterClazz = parameterTypes[i];
             additionalClasses.put(parameterClazz.getName(), parameterClazz);
         }
     }
diff --git a/modules/lang-painless/src/main/java/org/opensearch/painless/PainlessScriptEngine.java b/modules/lang-painless/src/main/java/org/opensearch/painless/PainlessScriptEngine.java
@@ -195,11 +195,12 @@ private <T> Type generateStatefulFactory(Loader loader, ScriptContext<T> context
             }
         }
 
-        for (int count = 0; count < newFactory.getParameterTypes().length; ++count) {
+        final Class<?>[] parameterTypes = newFactory.getParameterTypes();
+        for (int count = 0; count < parameterTypes.length; ++count) {
             writer.visitField(
                 Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL,
                 "$arg" + count,
-                Type.getType(newFactory.getParameterTypes()[count]).getDescriptor(),
+                Type.getType(parameterTypes[count]).getDescriptor(),
                 null,
                 null
             ).visitEnd();
@@ -211,7 +212,7 @@ private <T> Type generateStatefulFactory(Loader loader, ScriptContext<T> context
         );
         org.objectweb.asm.commons.Method init = new org.objectweb.asm.commons.Method(
             "<init>",
-            MethodType.methodType(void.class, newFactory.getParameterTypes()).toMethodDescriptorString()
+            MethodType.methodType(void.class, parameterTypes).toMethodDescriptorString()
         );
 
         GeneratorAdapter constructor = new GeneratorAdapter(
@@ -223,10 +224,10 @@ private <T> Type generateStatefulFactory(Loader loader, ScriptContext<T> context
         constructor.loadThis();
         constructor.invokeConstructor(OBJECT_TYPE, base);
 
-        for (int count = 0; count < newFactory.getParameterTypes().length; ++count) {
+        for (int count = 0; count < parameterTypes.length; ++count) {
             constructor.loadThis();
             constructor.loadArg(count);
-            constructor.putField(Type.getType("L" + className + ";"), "$arg" + count, Type.getType(newFactory.getParameterTypes()[count]));
+            constructor.putField(Type.getType("L" + className + ";"), "$arg" + count, Type.getType(parameterTypes[count]));
         }
 
         constructor.returnValue();
@@ -247,7 +248,7 @@ private <T> Type generateStatefulFactory(Loader loader, ScriptContext<T> context
             MethodType.methodType(newInstance.getReturnType(), newInstance.getParameterTypes()).toMethodDescriptorString()
         );
 
-        List<Class<?>> parameters = new ArrayList<>(Arrays.asList(newFactory.getParameterTypes()));
+        List<Class<?>> parameters = new ArrayList<>(Arrays.asList(parameterTypes));
         parameters.addAll(Arrays.asList(newInstance.getParameterTypes()));
 
         org.objectweb.asm.commons.Method constru = new org.objectweb.asm.commons.Method(
@@ -264,9 +265,9 @@ private <T> Type generateStatefulFactory(Loader loader, ScriptContext<T> context
         adapter.newInstance(WriterConstants.CLASS_TYPE);
         adapter.dup();
 
-        for (int count = 0; count < newFactory.getParameterTypes().length; ++count) {
+        for (int count = 0; count < parameterTypes.length; ++count) {
             adapter.loadThis();
-            adapter.getField(Type.getType("L" + className + ";"), "$arg" + count, Type.getType(newFactory.getParameterTypes()[count]));
+            adapter.getField(Type.getType("L" + className + ";"), "$arg" + count, Type.getType(parameterTypes[count]));
         }
 
         adapter.loadArgs();
@@ -334,13 +335,14 @@ private <T> T generateFactory(Loader loader, ScriptContext<T> context, Type clas
             }
         }
 
+        final Class<?>[] parameterTypes = reflect.getParameterTypes();
         org.objectweb.asm.commons.Method instance = new org.objectweb.asm.commons.Method(
             reflect.getName(),
-            MethodType.methodType(reflect.getReturnType(), reflect.getParameterTypes()).toMethodDescriptorString()
+            MethodType.methodType(reflect.getReturnType(), parameterTypes).toMethodDescriptorString()
         );
         org.objectweb.asm.commons.Method constru = new org.objectweb.asm.commons.Method(
             "<init>",
-            MethodType.methodType(void.class, reflect.getParameterTypes()).toMethodDescriptorString()
+            MethodType.methodType(void.class, parameterTypes).toMethodDescriptorString()
         );
 
         GeneratorAdapter adapter = new GeneratorAdapter(
@@ -421,9 +423,7 @@ private <T> T generateFactory(Loader loader, ScriptContext<T> context, Type clas
 
     private void writeNeedsMethods(Class<?> clazz, ClassWriter writer, Set<String> extractedVariables) {
         for (Method method : clazz.getMethods()) {
-            if (method.getName().startsWith("needs")
-                && method.getReturnType().equals(boolean.class)
-                && method.getParameterTypes().length == 0) {
+            if (method.getName().startsWith("needs") && method.getReturnType().equals(boolean.class) && method.getParameterCount() == 0) {
                 String name = method.getName();
                 name = name.substring(5);
                 name = Character.toLowerCase(name.charAt(0)) + name.substring(1);
diff --git a/modules/lang-painless/src/main/java/org/opensearch/painless/ScriptClassInfo.java b/modules/lang-painless/src/main/java/org/opensearch/painless/ScriptClassInfo.java
@@ -88,7 +88,7 @@ public ScriptClassInfo(PainlessLookup painlessLookup, Class<?> baseClass) {
                             + "] has more than one."
                     );
                 }
-            } else if (m.getName().startsWith("needs") && m.getReturnType() == boolean.class && m.getParameterTypes().length == 0) {
+            } else if (m.getName().startsWith("needs") && m.getReturnType() == boolean.class && m.getParameterCount() == 0) {
                 needsMethods.add(new org.objectweb.asm.commons.Method(m.getName(), NEEDS_PARAMETER_METHOD_TYPE.toMethodDescriptorString()));
             } else if (m.getName().startsWith("get")
                 && m.getName().equals("getClass") == false
@@ -124,7 +124,7 @@ public ScriptClassInfo(PainlessLookup painlessLookup, Class<?> baseClass) {
         FunctionTable.LocalFunction defConverter = null;
         for (java.lang.reflect.Method m : baseClass.getMethods()) {
             if (m.getName().startsWith("convertFrom")
-                && m.getParameterTypes().length == 1
+                && m.getParameterCount() == 1
                 && m.getReturnType() == returnType
                 && Modifier.isStatic(m.getModifiers())) {
 
diff --git a/modules/lang-painless/src/main/java/org/opensearch/painless/lookup/PainlessLookupBuilder.java b/modules/lang-painless/src/main/java/org/opensearch/painless/lookup/PainlessLookupBuilder.java
@@ -2168,9 +2168,10 @@ private void generateBridgeMethod(PainlessClassBuilder painlessClassBuilder, Pai
                 bridgeMethodWriter.loadArg(0);
             }
 
-            for (int typeParameterCount = 0; typeParameterCount < javaMethod.getParameterTypes().length; ++typeParameterCount) {
+            final Class<?>[] typeParameters = javaMethod.getParameterTypes();
+            for (int typeParameterCount = 0; typeParameterCount < typeParameters.length; ++typeParameterCount) {
                 bridgeMethodWriter.loadArg(typeParameterCount + bridgeTypeParameterOffset);
-                Class<?> typeParameter = javaMethod.getParameterTypes()[typeParameterCount];
+                Class<?> typeParameter = typeParameters[typeParameterCount];
 
                 if (typeParameter == Byte.class) bridgeMethodWriter.invokeStatic(DEF_UTIL_TYPE, DEF_TO_B_BYTE_IMPLICIT);
                 else if (typeParameter == Short.class) bridgeMethodWriter.invokeStatic(DEF_UTIL_TYPE, DEF_TO_B_SHORT_IMPLICIT);
diff --git a/test/logger-usage/src/test/java/org/opensearch/test/loggerusage/OpenSearchLoggerUsageTests.java b/test/logger-usage/src/test/java/org/opensearch/test/loggerusage/OpenSearchLoggerUsageTests.java

Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ public Collection<Method> getTestMethods(Class<?> suiteClass, ClassModel classMo`
`59`	`59`	`if (m.getName().startsWith("test")`
`60`	`60`	`&& Modifier.isPublic(m.getModifiers())`
`61`	`61`	`&& !Modifier.isStatic(m.getModifiers())`
`62`		`- && m.getParameterTypes().length == 0) {`
	`62`	`+ && m.getParameterCount() == 0) {`
`63`	`63`	`result.add(m);`
`64`	`64`	`}`
`65`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -212,8 +212,9 @@ private static void addFactoryMethod(Map<String, Class<?>> additionalClasses, Cl`
`212`	`212`	`}`
`213`	`213`
`214`	`214`	`additionalClasses.put(factoryClass.getName(), factoryClass);`
`215`		`- for (int i = 0; i < factoryMethod.getParameterTypes().length; ++i) {`
`216`		`- Class<?> parameterClazz = factoryMethod.getParameterTypes()[i];`
	`215`	`+ final Class<?>[] parameterTypes = factoryMethod.getParameterTypes();`
	`216`	`+ for (int i = 0; i < parameterTypes.length; ++i) {`
	`217`	`+ Class<?> parameterClazz = parameterTypes[i];`
`217`	`218`	`additionalClasses.put(parameterClazz.getName(), parameterClazz);`
`218`	`219`	`}`
`219`	`220`	`}`