fix issue 2951

javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistUtils.java

@@ -140,7 +140,7 @@ private static ResolvedType objectTypeArgumentToType(SignatureAttribute.ObjectTy
         if (typeArgument instanceof SignatureAttribute.ClassType) {
             return signatureTypeToType(typeArgument, typeSolver, typeParametrizable);
         } else if (typeArgument instanceof SignatureAttribute.ArrayType) {
-            return signatureTypeToType(((SignatureAttribute.ArrayType) typeArgument).getComponentType(), typeSolver, typeParametrizable);
+            return new ResolvedArrayType(signatureTypeToType(((SignatureAttribute.ArrayType) typeArgument).getComponentType(), typeSolver, typeParametrizable));
         } else {
             String typeName = typeArgument.jvmTypeName();
             return getGenericParameterByName(typeName, typeParametrizable, typeSolver);

javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue2951Test.java

@@ -0,0 +1,85 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.ParserConfiguration;
+import com.github.javaparser.StaticJavaParser;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.body.TypeDeclaration;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.stmt.Statement;
+import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration;
+import com.github.javaparser.resolution.types.ResolvedArrayType;
+import com.github.javaparser.resolution.types.ResolvedReferenceType;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.resolution.types.parametrization.ResolvedTypeParametersMap;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JarTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class Issue2951Test {
+    @Test
+    public void testResolveListOfByteArray() throws IOException {
+        ParserConfiguration config = new ParserConfiguration();
+        CombinedTypeSolver typeResolver = new CombinedTypeSolver(new ReflectionTypeSolver(false));
+        typeResolver.add(new JarTypeSolver("src/test/resources/issue2951/a.jar"));
+        config.setSymbolResolver(new JavaSymbolSolver(typeResolver));
+        StaticJavaParser.setConfiguration(config);
+
+        ResolvedReferenceTypeDeclaration clazzA = typeResolver.solveType("foo.A");
+        Optional<ResolvedMethodDeclaration> optionalMethod = clazzA.getDeclaredMethods().stream().filter(m -> m.getName().equals("get")).findFirst();
+        assertTrue(optionalMethod.isPresent());
+
+        ResolvedMethodDeclaration method = optionalMethod.get();
+        ResolvedType paramType = method.getParam(0).getType();
+        assertTrue(paramType.isReferenceType());
+        ResolvedReferenceType referenceType = paramType.asReferenceType();
+        ResolvedTypeParametersMap typeParametersMap = referenceType.typeParametersMap();
+        ResolvedType type = typeParametersMap.getTypes().get(0);
+        assertTrue(type instanceof ResolvedArrayType);
+    }
+
+    @Test
+    public void testIssue2951() throws IOException {
+        ParserConfiguration config = new ParserConfiguration();
+        CombinedTypeSolver typeResolver = new CombinedTypeSolver(new ReflectionTypeSolver(false));
+        typeResolver.add(new JarTypeSolver("src/test/resources/issue2951/a.jar"));
+        config.setSymbolResolver(new JavaSymbolSolver(typeResolver));
+        StaticJavaParser.setConfiguration(config);
+
+        String code = "package foo;\n"
+                + "import java.util.List;\n"
+                + "import foo.A;\n"
+                + "public class Test {\n"
+                + "    public void foo() {\n"
+                + "        List<byte[]> keys = new ArrayList<>();\n"
+                + "        A a = new A();\n"
+                + "        a.get(keys);\n"
+                + "    }\n"
+                + "}";
+        CompilationUnit cu = StaticJavaParser.parse(code);
+
+        for (TypeDeclaration<?> type : cu.getTypes()) {
+            type.ifClassOrInterfaceDeclaration(classDecl -> {
+                for (MethodDeclaration method : classDecl.getMethods()) {
+                    method.getBody().ifPresent(body -> {
+                        for (Statement stmt : body.getStatements()) {
+                            for (MethodCallExpr methodCallExpr : stmt.findAll(MethodCallExpr.class)) {
+                                ResolvedMethodDeclaration resolvedMethodCall = methodCallExpr.resolve();
+                                String methodSig = resolvedMethodCall.getQualifiedSignature();
+                                assertEquals("foo.A.get(java.util.List<byte[]>)", methodSig);
+                            }
+                        }
+                    });
+                }
+            });
+        }
+    }
+}

javaparser-symbol-solver-testing/src/test/resources/issue2951/foo/A.java

@@ -0,0 +1,5 @@
+package foo;
+import java.util.List;
+class A {
+    public void get(List<byte[]> b) {}
+}