Merge pull request #1423 from daanschipper/master

SourceRoot implementation for JSS

9 files changed, 226 insertions, 0 deletions

diff --git a/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/utils/SymbolSolverQuickSetup.java b/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/utils/SymbolSolverQuickSetup.java
new file mode 100644
index 000000000..e6d3d530b
--- /dev/null
+++ b/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/utils/SymbolSolverQuickSetup.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) 2007-2010 Júlio Vilmar Gesser.
+ * Copyright (C) 2011, 2013-2018 The JavaParser Team.
+ *
+ * This file is part of JavaParser.
+ *
+ * JavaParser can be used either under the terms of
+ * a) the GNU Lesser General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * b) the terms of the Apache License
+ *
+ * You should have received a copy of both licenses in LICENCE.LGPL and
+ * LICENCE.APACHE. Please refer to those files for details.
+ *
+ * JavaParser is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ */
+
+package com.github.javaparser.symbolsolver.utils;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ParseProblemException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JarTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import com.github.javaparser.utils.Log;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.nio.file.*;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+
+import static com.github.javaparser.utils.Utils.assertNotNull;
+import static java.nio.file.FileVisitResult.*;
+
+/**
+ * Utility class to add all jars and roots of java files of the provided path to a TypeSolver instance.
+ * It traverses the file directory tree and adds all files ending in either .java or .jar.
+ */
+public class SymbolSolverQuickSetup {
+
+    public interface DirFilter {
+        boolean filter(Path path);
+    }
+
+    private final Path root;
+    private CombinedTypeSolver typeSolver = new CombinedTypeSolver(new ReflectionTypeSolver(false));
+    private DirFilter dirFilter = path -> false;
+
+    public SymbolSolverQuickSetup(Path root) {
+        assertNotNull(root);
+        if (!Files.isDirectory(root)) {
+            throw new IllegalArgumentException("Only directories are allowed as root path!");
+        }
+        this.root = root.normalize();
+        Log.info("New symbol source root at \"%s\"", this.root);
+    }
+
+    public SymbolSolverQuickSetup(Path root, DirFilter dirFilter) {
+        this(root);
+        this.dirFilter = dirFilter;
+    }
+
+    public TypeSolver walk() throws IOException {
+        Files.walkFileTree(root, new JavaSymbolSolverWalker());
+        Files.walkFileTree(root, new JarVisitor());
+        return typeSolver;
+    }
+
+    public Optional<TypeSolver> tryToWalk() {
+        try {
+            return Optional.of(walk());
+        } catch (IOException e) {
+            Log.error(e, "Unable to walk root " + root);
+            return Optional.empty();
+        }
+    }
+
+    public TypeSolver getTypeSolver() {
+        return typeSolver;
+    }
+
+    /**
+     * The path that was passed in the constructor.
+     */
+    public Path getRoot() {
+        return root;
+    }
+
+    /**
+     * Walks the directory and adds the roots of the java files to the TypeSolver
+     */
+    private class JavaSymbolSolverWalker extends SimpleFileVisitor<Path> {
+
+        private final Set<Path> roots = new HashSet<>();
+
+        @Override
+        public FileVisitResult visitFile(Path file, BasicFileAttributes attr) throws FileNotFoundException {
+            if (attr.isRegularFile()) {
+                PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:**.java");
+                if (matcher.matches(file)) {
+                    try {
+                        Optional<Path> root = JavaParser.parse(file.toFile()).getStorage()
+                                .map(CompilationUnit.Storage::getSourceRoot);
+                        if (root.isPresent()) {
+                            typeSolver.add(new JavaParserTypeSolver(root.get().toFile()));
+                            if (roots.add(root.get())) {
+                                Log.trace("Added dir " + root.get() + " to the TypeSolver");
+                                return SKIP_SIBLINGS;
+                            }
+                        }
+                    } catch (ParseProblemException e) {
+                        Log.error(e, "Unable to parse file " + file);
+                    }
+                }
+            }
+            return CONTINUE;
+        }
+
+        @Override
+        public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
+            if (Files.isHidden(dir) || dirFilter.filter(dir) || roots.stream().anyMatch(dir::startsWith)) {
+                return SKIP_SUBTREE;
+            }
+            return CONTINUE;
+        }
+    }
+
+    private class JarVisitor extends SimpleFileVisitor<Path> {
+
+        @Override
+        public FileVisitResult visitFile(Path file, BasicFileAttributes attr) throws IOException {
+            if (attr.isRegularFile()) {
+                PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:**.jar");
+                if (matcher.matches(file)) {
+                    typeSolver.add(new JarTypeSolver(file.toString()));
+                }
+            }
+            return CONTINUE;
+        }
+    }
+}
+
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/utils/SymbolSolverQuickSetupTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/utils/SymbolSolverQuickSetupTest.java
new file mode 100644
index 000000000..ddc1bc622
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/utils/SymbolSolverQuickSetupTest.java
@@ -0,0 +1,50 @@
+package com.github.javaparser.symbolsolver.utils;
+
+import com.github.javaparser.ParserConfiguration;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.symbolsolver.JavaSymbolSolver;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.utils.SourceRoot;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+
+/**
+ * Try to resolve all the ClassOrInterfaceDeclaration and MethodCallExpr in some resources folder. If it fails to do
+ * so, an IllegalStateException is thrown.
+ */
+public class SymbolSolverQuickSetupTest {
+
+    private Path root = Paths.get("src/test/resources/symbolsolver_quicksetup");
+    private ParserConfiguration parserConfiguration = new ParserConfiguration();
+
+    @Before
+    public void setUp() throws IOException {
+        SymbolSolverQuickSetup ssr = new SymbolSolverQuickSetup(root);
+        TypeSolver typeSolver = ssr.walk();
+
+        parserConfiguration.setSymbolResolver(new JavaSymbolSolver(typeSolver));
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void notResolve() throws IOException {
+        SourceRoot sourceRoot = new SourceRoot(root);
+        sourceRoot.tryToParse();
+        // try to resolve, this will fail
+        sourceRoot.getCompilationUnits().forEach(compilationUnit ->
+                compilationUnit.findAll(ClassOrInterfaceDeclaration.class).forEach(ClassOrInterfaceDeclaration::resolve));
+    }
+
+    @Test
+    public void resolve() throws IOException {
+        SourceRoot sourceRoot = new SourceRoot(root, parserConfiguration);
+        sourceRoot.tryToParse();
+        // try to resolve, this should succeed
+        sourceRoot.getCompilationUnits().forEach(compilationUnit ->
+                compilationUnit.findAll(ClassOrInterfaceDeclaration.class).forEach(ClassOrInterfaceDeclaration::resolve));
+    }
+}
\ No newline at end of file
diff --git a/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/a/src/a.java b/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/a/src/a.java
new file mode 100644
index 000000000..909044a81
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/a/src/a.java
@@ -0,0 +1,2 @@
+public class a {
+}
diff --git a/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/a/src/package_a/a.java b/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/a/src/package_a/a.java
new file mode 100644
index 000000000..198c2e4c8
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/a/src/package_a/a.java
@@ -0,0 +1,4 @@
+package package_a;
+
+public class a {
+}
diff --git a/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/b/src/b.java b/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/b/src/b.java
new file mode 100644
index 000000000..9d113aad0
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/b/src/b.java
@@ -0,0 +1,2 @@
+public class b {
+}
diff --git a/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/b/src/package_b/b.java b/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/b/src/package_b/b.java
new file mode 100644
index 000000000..6b0c60797
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/b/src/package_b/b.java
@@ -0,0 +1,4 @@
+package package_b;
+
+public class b {
+}
diff --git a/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/c/src/c.java b/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/c/src/c.java
new file mode 100644
index 000000000..c8745a1b2
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/c/src/c.java
@@ -0,0 +1,2 @@
+public class c {
+}
diff --git a/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/c/src/package_c/c.java b/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/c/src/package_c/c.java
new file mode 100644
index 000000000..4eb584993
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/c/src/package_c/c.java
@@ -0,0 +1,4 @@
+package package_c;
+
+public class c {
+}
diff --git a/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/src/Main.java b/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/src/Main.java
new file mode 100644
index 000000000..a0428dacd
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/resources/symbolsolver_quicksetup/src/Main.java
@@ -0,0 +1,6 @@
+public class Main {
+
+    public static void main(String[] args) {
+        System.out.println("Hello World!");
+    }
+}