Fix signature computation for vararg generic type parameters; added related test case (#139)

Signed-off-by: Saurabh Sinha <sinha108@gmail.com>

Author: sinha108

src/main/java/com/ibm/cldk/SymbolTable.java

@@ -593,7 +593,7 @@ private static String getTypeErasureSignature(CallableDeclaration callableDecl)
                 Parameter parameter = (Parameter) param;
                 ResolvedType resolvedType = parameter.getType().resolve();
                 if (parameter.isVarArgs()) {
-                    erasureParameterTypes.add(resolvedType.describe() + "[]");
+                    erasureParameterTypes.add(resolvedType.erasure().describe() + "[]");
                 } else {
                     erasureParameterTypes.add(resolvedType.erasure().describe());
                 }

src/test/java/com/ibm/cldk/SymbolTableTest.java

@@ -26,7 +26,7 @@ private String getJavaCodeForTestResource(String resourcePath) {
     }
 
     @Test
-    public void testExtractSingleGenricsDuplicateSignature() throws IOException {
+    public void testExtractSingleGenricsDuplicateSignature_Validate() throws IOException {
         String javaCode = getJavaCodeForTestResource("test-applications/generics-varargs-duplicate-signature-test/Validate.java");
         Map<String, JavaCompilationUnit> symbolTable = SymbolTable.extractSingle(javaCode).getLeft();
         Assertions.assertEquals(1, symbolTable.size());
@@ -36,6 +36,17 @@ public void testExtractSingleGenricsDuplicateSignature() throws IOException {
         Assertions.assertEquals(17, callables.size());
     }
 
+    @Test
+    public void testExtractSingleGenricsDuplicateSignature_FunctorUtils() throws IOException {
+        String javaCode = getJavaCodeForTestResource("test-applications/generics-varargs-duplicate-signature-test/FunctorUtils.java");
+        Map<String, JavaCompilationUnit> symbolTable = SymbolTable.extractSingle(javaCode).getLeft();
+        Assertions.assertEquals(1, symbolTable.size());
+        Map<String, Type> typeDeclaration = symbolTable.values().iterator().next().getTypeDeclarations();
+        Assertions.assertEquals(1, typeDeclaration.size());
+        Map<String, Callable> callables = typeDeclaration.values().iterator().next().getCallableDeclarations();
+        Assertions.assertEquals(10, callables.size());
+    }
+
     @Test
     public void testCallSiteArgumentExpression() throws IOException {
         String javaCode = getJavaCodeForTestResource("test-applications/generics-varargs-duplicate-signature-test/Validate.java");

src/test/resources/test-applications/generics-varargs-duplicate-signature-test/FunctorUtils.java

@@ -0,0 +1,76 @@
+import java.util.Collection;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import org.apache.commons.collections4.Predicate;
+
+final class FunctorUtils {
+
+    private static <T> T[] clone(final T... array) {
+        return array != null ? array.clone() : null;
+    }
+
+    static <R extends java.util.function.Predicate<T>, P extends java.util.function.Predicate<? super T>, T> R coerce(final P predicate) {
+        return (R) predicate;
+    }
+
+    static <R extends Function<I, O>, P extends Function<? super I, ? extends O>, I, O> R coerce(final P transformer) {
+        return (R) transformer;
+    }
+
+    static <T extends Consumer<?>> T[] copy(final T... consumers) {
+        return clone(consumers);
+    }
+
+    static <T extends java.util.function.Predicate<?>> T[] copy(final T... predicates) {
+        return clone(predicates);
+    }
+
+    static <T extends Function<?, ?>> T[] copy(final T... transformers) {
+        return clone(transformers);
+    }
+
+    static <T> Predicate<? super T>[] validate(final Collection<? extends java.util.function.Predicate<? super T>> predicates) {
+        Objects.requireNonNull(predicates, "predicates");
+        // convert to array like this to guarantee iterator() ordering
+        @SuppressWarnings("unchecked") // OK
+        final Predicate<? super T>[] preds = new Predicate[predicates.size()];
+        int i = 0;
+        for (final java.util.function.Predicate<? super T> predicate : predicates) {
+            preds[i] = (Predicate<? super T>) predicate;
+            if (preds[i] == null) {
+                throw new NullPointerException("predicates[" + i + "]");
+            }
+            i++;
+        }
+        return preds;
+    }
+
+    static void validate(final Consumer<?>... consumers) {
+        Objects.requireNonNull(consumers, "consumers");
+        for (int i = 0; i < consumers.length; i++) {
+            if (consumers[i] == null) {
+                throw new NullPointerException("closures[" + i + "]");
+            }
+        }
+    }
+
+    static void validate(final Function<?, ?>... functions) {
+        Objects.requireNonNull(functions, "functions");
+        for (int i = 0; i < functions.length; i++) {
+            if (functions[i] == null) {
+                throw new NullPointerException("functions[" + i + "]");
+            }
+        }
+    }
+
+    static void validate(final java.util.function.Predicate<?>... predicates) {
+        Objects.requireNonNull(predicates, "predicates");
+        for (int i = 0; i < predicates.length; i++) {
+            if (predicates[i] == null) {
+                throw new NullPointerException("predicates[" + i + "]");
+            }
+        }
+    }
+
+}