Merge pull request #331 from ftomassetti/testingIntegration

[Draft] Completing and testing JavaSymbolSolver

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

@@ -2,16 +2,18 @@
 
 import com.github.javaparser.ast.CompilationUnit;
 import com.github.javaparser.ast.Node;
-import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
-import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.body.*;
 import com.github.javaparser.ast.expr.Expression;
 import com.github.javaparser.ast.type.ArrayType;
 import com.github.javaparser.ast.type.Type;
 import com.github.javaparser.resolution.SymbolResolver;
-import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration;
+import com.github.javaparser.resolution.declarations.*;
 import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
 import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
 import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFactory;
+import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserConstructorDeclaration;
+import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserFieldDeclaration;
 import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserMethodDeclaration;
 import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
 
@@ -46,9 +48,73 @@ public <T> T resolveDeclaration(Node node, Class<T> resultClass) {
             return resultClass.cast(new JavaParserMethodDeclaration((MethodDeclaration)node, typeSolver));
         }
         if (node instanceof ClassOrInterfaceDeclaration) {
-            ResolvedReferenceTypeDeclaration resolvedReferenceTypeDeclaration = JavaParserFactory.toTypeDeclaration(node, typeSolver);
-            if (resultClass.isInstance(resolvedReferenceTypeDeclaration)) {
-                return resultClass.cast(resolvedReferenceTypeDeclaration);
+            ResolvedReferenceTypeDeclaration resolved = JavaParserFactory.toTypeDeclaration(node, typeSolver);
+            if (resultClass.isInstance(resolved)) {
+                return resultClass.cast(resolved);
+            }
+        }
+        if (node instanceof EnumDeclaration) {
+            ResolvedReferenceTypeDeclaration resolved = JavaParserFactory.toTypeDeclaration(node, typeSolver);
+            if (resultClass.isInstance(resolved)) {
+                return resultClass.cast(resolved);
+            }
+        }
+        if (node instanceof EnumConstantDeclaration) {
+            ResolvedEnumDeclaration enumDeclaration = Navigator.findAncestor(node, EnumDeclaration.class).get().resolve().asEnum();
+            // TODO look among the members
+            throw new UnsupportedOperationException();
+        }
+        if (node instanceof ConstructorDeclaration) {
+            ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration)node;
+            ClassOrInterfaceDeclaration classOrInterfaceDeclaration = (ClassOrInterfaceDeclaration)node.getParentNode().get();
+            ResolvedClassDeclaration resolvedClass = resolveDeclaration(classOrInterfaceDeclaration, ResolvedClassDeclaration.class).asClass();
+            ResolvedConstructorDeclaration resolved =  resolvedClass.getConstructors().stream().filter(c -> ((JavaParserConstructorDeclaration)c).getWrappedNode() == constructorDeclaration).findFirst().get();
+            if (resultClass.isInstance(resolved)) {
+                return resultClass.cast(resolved);
+            }
+        }
+        if (node instanceof AnnotationDeclaration) {
+            ResolvedReferenceTypeDeclaration resolved = JavaParserFactory.toTypeDeclaration(node, typeSolver);
+            if (resultClass.isInstance(resolved)) {
+                return resultClass.cast(resolved);
+            }
+        }
+        if (node instanceof AnnotationMemberDeclaration) {
+            ResolvedAnnotationDeclaration annotationDeclaration = Navigator.findAncestor(node, AnnotationDeclaration.class).get().resolve();
+            // TODO look among the members
+            throw new UnsupportedOperationException();
+        }
+        if (node instanceof FieldDeclaration) {
+            FieldDeclaration fieldDeclaration = (FieldDeclaration)node;
+            if (fieldDeclaration.getVariables().size() != 1) {
+                throw new RuntimeException("Cannot resolve a Field Declaration including multiple variable declarators. Resolve the single variable declarators");
+            }
+            ResolvedFieldDeclaration resolved = new JavaParserFieldDeclaration(fieldDeclaration.getVariable(0), typeSolver);
+            if (resultClass.isInstance(resolved)) {
+                return resultClass.cast(resolved);
+            }
+        }
+        if (node instanceof VariableDeclarator) {
+            ResolvedFieldDeclaration resolved = new JavaParserFieldDeclaration((VariableDeclarator)node, typeSolver);
+            if (resultClass.isInstance(resolved)) {
+                return resultClass.cast(resolved);
+            }
+        }
+        if (node instanceof Parameter) {
+            if (ResolvedParameterDeclaration.class.equals(resultClass)) {
+                Parameter parameter = (Parameter)node;
+                CallableDeclaration callableDeclaration = Navigator.findAncestor(node, CallableDeclaration.class).get();
+                ResolvedMethodLikeDeclaration resolvedMethodLikeDeclaration;
+                if (callableDeclaration.isConstructorDeclaration()) {
+                    resolvedMethodLikeDeclaration = callableDeclaration.asConstructorDeclaration().resolve();
+                } else {
+                    resolvedMethodLikeDeclaration = callableDeclaration.asMethodDeclaration().resolve();
+                }
+                for (int i=0;i<resolvedMethodLikeDeclaration.getNumberOfParams();i++) {
+                    if (resolvedMethodLikeDeclaration.getParam(i).getName().equals(parameter.getNameAsString())) {
+                        return resultClass.cast(resolvedMethodLikeDeclaration.getParam(i));
+                    }
+                }
             }
         }
         throw new UnsupportedOperationException("Unable to find the declaration of type " + resultClass.getSimpleName()

java-symbol-solver-model/build.gradle

@@ -1,6 +1,6 @@
 description = ''
 dependencies {
-    compile group: 'com.github.javaparser', name: 'javaparser-core', version: '3.5.0'
+    compile group: 'com.github.javaparser', name: 'javaparser-core', version: '3.5.2'
     compile group: 'org.javassist', name: 'javassist', version: '3.19.0-GA'
     compile group: 'com.google.guava', name: 'guava', version: '21.0'
     compile group: 'io.javaslang', name: 'javaslang', version: '2.0.3'

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

@@ -28,7 +28,7 @@ protected static File adaptPath(File path) {
             if (underJavaParserCore.exists()) {
                 return underJavaParserCore;
             } else {
-                throw new IllegalArgumentException();
+                throw new IllegalArgumentException("I cannot adapt the path " + path.getAbsolutePath());
             }
         }
     }

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

@@ -0,0 +1,158 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ParseStart;
+import com.github.javaparser.ParserConfiguration;
+import com.github.javaparser.StreamProvider;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.*;
+import com.github.javaparser.resolution.declarations.*;
+import com.github.javaparser.resolution.types.ResolvedReferenceType;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import com.google.common.collect.ImmutableList;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class JavaParserAPIIntegrationTest extends AbstractTest {
+
+    private TypeSolver typeSolver;
+    private ResolvedReferenceType string;
+    private ResolvedReferenceType listOfBoolean;
+
+    @Before
+    public void setup() {
+        File src = adaptPath(new File("src/test/resources/javaparser_new_src/javaparser-core"));
+        CombinedTypeSolver combinedTypeSolverNewCode = new CombinedTypeSolver();
+        combinedTypeSolverNewCode.add(new ReflectionTypeSolver());
+        combinedTypeSolverNewCode.add(new JavaParserTypeSolver(src));
+        combinedTypeSolverNewCode.add(new JavaParserTypeSolver(adaptPath(new File("src/test/resources/javaparser_new_src/javaparser-generated-sources"))));
+        typeSolver = combinedTypeSolverNewCode;
+
+        TypeSolver ts = new ReflectionTypeSolver();
+        string = new ReferenceTypeImpl(ts.solveType(String.class.getCanonicalName()), ts);
+        ResolvedReferenceType booleanC = new ReferenceTypeImpl(ts.solveType(Boolean.class.getCanonicalName()), ts);
+        listOfBoolean = new ReferenceTypeImpl(ts.solveType(List.class.getCanonicalName()), ImmutableList.of(booleanC), ts);
+    }
+
+    @Test
+    public void annotationDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/resources/Annotations.java.txt"));
+        CompilationUnit cu = parseWithSymbolResolution(f);
+        AnnotationDeclaration declaration = (AnnotationDeclaration)cu.getType(0);
+        assertEquals("MyAnnotation", declaration.getNameAsString());
+        ResolvedAnnotationDeclaration resolvedDeclaration = declaration.resolve();
+    }
+
+//    @Test
+//    public void annotationMemberDeclarationResolve() throws IOException {
+//        File f = adaptPath(new File("src/test/resources/Annotations.java.txt"));
+//        ParserConfiguration parserConfiguration = new ParserConfiguration();
+//        parserConfiguration.setSymbolResolver(new JavaSymbolSolver(typeSolver));
+//        CompilationUnit cu = new JavaParser(parserConfiguration).parse(ParseStart.COMPILATION_UNIT, new StreamProvider(new FileInputStream(f))).getResult().get();
+//        AnnotationDeclaration declaration = (AnnotationDeclaration)cu.getType(2);
+//        assertEquals("MyAnnotationWithFields", declaration.getNameAsString());
+//        AnnotationMemberDeclaration memberDeclaration = (AnnotationMemberDeclaration)declaration.getMember(0);
+//        ResolvedAnnotationMemberDeclaration resolvedDeclaration = memberDeclaration.resolve();
+//    }
+
+    @Test
+    public void classDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/resources/javaparser_new_src/javaparser-core/com/github/javaparser/ast/CompilationUnit.java"));
+        CompilationUnit cu = parseWithSymbolResolution(f);
+        ClassOrInterfaceDeclaration declaration = (ClassOrInterfaceDeclaration)cu.getType(0);
+        declaration.resolve();
+    }
+
+    @Test
+    public void interfaceDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/resources/MethodTypeParams.java.txt"));
+        CompilationUnit cu = parseWithSymbolResolution(f);
+        ClassOrInterfaceDeclaration declaration = (ClassOrInterfaceDeclaration)cu.getType(1);
+        assertEquals("VoidVisitor", declaration.getNameAsString());
+        assertEquals(true, declaration.isInterface());
+        declaration.resolve();
+    }
+
+    private CompilationUnit parseWithSymbolResolution(File f) throws IOException {
+        ParserConfiguration parserConfiguration = new ParserConfiguration();
+        parserConfiguration.setSymbolResolver(new JavaSymbolSolver(typeSolver));
+        return new JavaParser(parserConfiguration).parse(ParseStart.COMPILATION_UNIT, new StreamProvider(new FileInputStream(f))).getResult().get();
+    }
+
+    @Test
+    public void constructorDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/resources/javaparser_new_src/javaparser-core/com/github/javaparser/ast/CompilationUnit.java"));
+        CompilationUnit cu = parseWithSymbolResolution(f);
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = (ClassOrInterfaceDeclaration)cu.getType(0);
+        ConstructorDeclaration constructorDeclaration = classOrInterfaceDeclaration.getDefaultConstructor().get();
+        ResolvedConstructorDeclaration resolvedConstructorDeclaration = constructorDeclaration.resolve();
+    }
+    @Test
+    public void enumDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/resources/javaparser_new_src/javaparser-core/com/github/javaparser/ast/AccessSpecifier.java"));
+        CompilationUnit cu = parseWithSymbolResolution(f);
+        EnumDeclaration declaration = (EnumDeclaration) cu.getType(0);
+        assertEquals("AccessSpecifier", declaration.getNameAsString());
+        ResolvedEnumDeclaration resolvedDeclaration = declaration.resolve();
+    }
+
+//    @Test
+//    public void enumConstantDeclarationResolve() throws IOException {
+//        File f = adaptPath(new File("src/test/resources/javaparser_new_src/javaparser-core/com/github/javaparser/ast/AccessSpecifier.java"));
+//        CompilationUnit cu = parseWithSymbolResolution(f);
+//        EnumDeclaration enumDeclaration = (EnumDeclaration) cu.getType(0);
+//        assertEquals("AccessSpecifier", enumDeclaration.getNameAsString());
+//        EnumConstantDeclaration declaration = enumDeclaration.getEntry(0);
+//        assertEquals("PUBLIC", declaration.getNameAsString());
+//        ResolvedEnumConstantDeclaration resolvedDeclaration = declaration.resolve();
+//    }
+
+    @Test
+    public void fieldDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/resources/javaparser_new_src/javaparser-core/com/github/javaparser/ast/CompilationUnit.java"));
+        CompilationUnit cu = parseWithSymbolResolution(f);
+        ClassOrInterfaceDeclaration classDeclaration = (ClassOrInterfaceDeclaration) cu.getType(0);
+        assertEquals("CompilationUnit", classDeclaration.getNameAsString());
+        FieldDeclaration declaration = classDeclaration.getFields().get(0);
+        ResolvedFieldDeclaration resolvedDeclaration = declaration.resolve();
+    }
+
+    // TODO make VariableDeclarator resolvable
+
+    @Test
+    public void methodDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/resources/javaparser_new_src/javaparser-core/com/github/javaparser/ast/CompilationUnit.java"));
+        CompilationUnit cu = parseWithSymbolResolution(f);
+        ClassOrInterfaceDeclaration classDeclaration = (ClassOrInterfaceDeclaration) cu.getType(0);
+        assertEquals("CompilationUnit", classDeclaration.getNameAsString());
+        MethodDeclaration declaration = classDeclaration.getMethodsByName("getComments").get(0);
+        ResolvedMethodDeclaration resolvedDeclaration = declaration.resolve();
+        assertEquals("getComments", resolvedDeclaration.getName());
+        assertEquals(0, resolvedDeclaration.getNumberOfParams());
+    }
+
+    @Test
+    public void parameterDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/resources/javaparser_new_src/javaparser-core/com/github/javaparser/ast/CompilationUnit.java"));
+        ParserConfiguration parserConfiguration = new ParserConfiguration();
+        parserConfiguration.setSymbolResolver(new JavaSymbolSolver(typeSolver));
+        CompilationUnit cu = new JavaParser(parserConfiguration).parse(ParseStart.COMPILATION_UNIT, new StreamProvider(new FileInputStream(f))).getResult().get();
+        ClassOrInterfaceDeclaration classDeclaration = (ClassOrInterfaceDeclaration) cu.getType(0);
+        assertEquals("CompilationUnit", classDeclaration.getNameAsString());
+        MethodDeclaration methodDeclaration = classDeclaration.getMethodsByName("setComments").get(0);
+        Parameter declaration = methodDeclaration.getParameter(0);
+        ResolvedParameterDeclaration resolvedDeclaration = declaration.resolve();
+    }
+
+}

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

@@ -347,7 +347,8 @@ public void testGetInterfacesWithoutParameters() {
                 "com.github.javaparser.ast.nodeTypes.NodeWithConstructors",
                 "com.github.javaparser.ast.nodeTypes.NodeWithImplements",
                 "com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAbstractModifier",
-                "com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters"),
+                "com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters",
+                "com.github.javaparser.resolution.Resolvable"),
                 coid.getInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
     }
 
@@ -425,7 +426,8 @@ public void testGetAllInterfacesWithoutParameters() {
                 "com.github.javaparser.ast.nodeTypes.modifiers.NodeWithStrictfpModifier",
                 "com.github.javaparser.ast.nodeTypes.NodeWithRange",
                 "com.github.javaparser.ast.nodeTypes.NodeWithTokenRange",
-                "com.github.javaparser.ast.nodeTypes.NodeWithConstructors"), coid.getAllInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+                "com.github.javaparser.ast.nodeTypes.NodeWithConstructors",
+                "com.github.javaparser.resolution.Resolvable"), coid.getAllInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
     }
 
     @Test

java-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/LambdaExprContextResolutionTest.java

@@ -81,7 +81,7 @@ public void solveParameterOfLambdaInFieldDecl() throws ParseException {
         File src = new File("src/test/resources");
         CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
         combinedTypeSolver.add(new ReflectionTypeSolver());
-        combinedTypeSolver.add(new JavaParserTypeSolver(src));
+        combinedTypeSolver.add(new JavaParserTypeSolver(adaptPath(src)));
 
         Context context = new LambdaExprContext(lambdaExpr, combinedTypeSolver);
 
@@ -99,7 +99,7 @@ public void solveParameterOfLambdaInVarDecl() throws ParseException {
         VariableDeclarator varDecl = Navigator.demandVariableDeclaration(method, "a");
         LambdaExpr lambdaExpr = (LambdaExpr) varDecl.getInitializer().get();
 
-        File src = new File("src/test/resources");
+        File src = adaptPath(new File("src/test/resources"));
         CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
         combinedTypeSolver.add(new ReflectionTypeSolver());
         combinedTypeSolver.add(new JavaParserTypeSolver(src));

java-symbol-solver-testing/src/test/resources/Annotations.java.txt

@@ -6,6 +6,10 @@ public @interface MyAnnotation {
 public @interface MyAnnotation2 {
 }
 
+public @interface MyAnnotationWithFields {
+    int field();
+}
+
 @MyAnnotation
 class CA {