Allow parsing a non-leaf module in a reactor build

sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ClasspathExtractor.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2021 - 2023 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.sbm.parsers;
+
+import lombok.RequiredArgsConstructor;
+import org.openrewrite.maven.tree.MavenResolutionResult;
+import org.openrewrite.maven.tree.ResolvedDependency;
+import org.openrewrite.maven.tree.Scope;
+import org.openrewrite.maven.utilities.MavenArtifactDownloader;
+
+import java.nio.file.Path;
+import java.util.*;
+import java.util.stream.Collectors;
+
+
+/**
+ * @author Fabian Krüger
+ */
+@RequiredArgsConstructor
+public class ClasspathExtractor {
+    private final MavenArtifactDownloader rewriteMavenArtifactDownloader;
+
+    public Set<Path> extractClasspath(MavenResolutionResult pom, Scope scope) {
+        List<ResolvedDependency> resolvedDependencies = pom.getDependencies().get(scope);
+        if (resolvedDependencies != null) {
+            return resolvedDependencies
+                    // FIXME: 945 - deal with dependencies to projects in reactor
+                    //
+                    .stream()
+                    .filter(rd -> rd.getRepository() != null)
+                    .map(rd -> rewriteMavenArtifactDownloader.downloadArtifact(rd))
+                    .filter(Objects::nonNull)
+                    .distinct()
+                    .collect(Collectors.toSet());
+        } else {
+            return new HashSet<>();
+        }
+    }
+}

sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ClasspathRegistry.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2021 - 2023 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.sbm.parsers;
+
+import org.openrewrite.maven.tree.MavenResolutionResult;
+import org.openrewrite.maven.tree.Scope;
+import org.springframework.sbm.scopes.ProjectMetadata;
+
+import java.nio.file.Path;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @author Fabian Krüger
+ */
+public class ClasspathRegistry {
+    private final ClasspathExtractor classpathExtractor;
+    private final Map<Path, MavenResolutionResult> map;
+
+    public ClasspathRegistry(ClasspathExtractor classpathExtractor) {
+        this.map = new HashMap<>();
+        this.classpathExtractor = classpathExtractor;
+    }
+
+    public void registerClasspaths(Map<Path, MavenResolutionResult> map) {
+        this.map.putAll(map);
+    }
+
+    public void registerClasspath(Path buildFilePath, MavenResolutionResult mavenResolutionResult) {
+        this.map.put(buildFilePath, mavenResolutionResult);
+    }
+
+    public void clear() {
+        this.map.clear();
+    }
+
+    public Set<Path> getClasspath(Path buildFileProjectPath, Scope scope) {
+        if(!map.containsKey(buildFileProjectPath)) {
+            throw new IllegalArgumentException("The given pom path '%s' does not define a classpath.".formatted(buildFileProjectPath));
+        }
+        MavenResolutionResult mavenResolutionResult = map.get(buildFileProjectPath);
+        return classpathExtractor.extractClasspath(mavenResolutionResult, scope);
+    }
+}

sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ClasspathRegistryFactory.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2021 - 2023 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.sbm.parsers;
+
+import lombok.RequiredArgsConstructor;
+import org.openrewrite.maven.tree.MavenResolutionResult;
+import org.openrewrite.xml.tree.Xml;
+
+import java.nio.file.Path;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author Fabian Krüger
+ */
+@RequiredArgsConstructor
+public class ClasspathRegistryFactory {
+
+    private final ClasspathExtractor classpathExtractor;
+
+    public ClasspathRegistry create(Path baseDir, List<Xml.Document> parsedBuildFiles) {
+        Map<Path, MavenResolutionResult> map = new HashMap<>();
+        parsedBuildFiles.stream()
+                .forEach(buildFile -> {
+                    Path pomPath = baseDir.resolve(buildFile.getSourcePath()).toAbsolutePath().normalize();
+                    MavenResolutionResult marker = buildFile.getMarkers().findFirst(MavenResolutionResult.class).get();
+                    map.put(pomPath, marker);
+                });
+
+        return new ClasspathRegistry(classpathExtractor);
+    }
+}

sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/JavaParserMarker.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2021 - 2023 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.sbm.parsers;
+
+import lombok.Value;
+import lombok.With;
+import org.openrewrite.java.JavaParser;
+import org.openrewrite.marker.Marker;
+
+import java.util.UUID;
+
+
+/**
+ * Used to keep the stateful {@link JavaParser} for later parsing.
+ *
+ * This is required when (re-)parsing a submodule somewhere (non-leaf) in a reactor build tree.
+ * Then this module requires the JavaParser with types from the last parse where types from lower modules are cached.
+ *
+ * @author Fabian Krüger
+ */
+@Value
+@With
+public class JavaParserMarker implements Marker {
+    private final UUID id;
+    private final JavaParser javaParser;
+}

sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/MavenProject.java

@@ -20,9 +20,7 @@
 import org.apache.maven.model.Model;
 import org.apache.maven.model.Plugin;
 import org.jetbrains.annotations.NotNull;
-import org.openrewrite.SourceFile;
 import org.openrewrite.maven.tree.*;
-import org.openrewrite.maven.utilities.MavenArtifactDownloader;
 import org.openrewrite.xml.tree.Xml;
 import org.springframework.core.io.Resource;
 import org.springframework.sbm.parsers.maven.MavenRuntimeInformation;
@@ -43,20 +41,19 @@ public class MavenProject {
 
     private final Path projectRoot;
     private final Resource pomFile;
-    // FIXME: 945 temporary method, model should nopt come from Maven
     private final Model pomModel;
+    private final List<Resource> resources;
+    private final ClasspathRegistry classpathRegistry;
     private List<MavenProject> collectedProjects = new ArrayList<>();
     private Xml.Document sourceFile;
-    private final MavenArtifactDownloader rewriteMavenArtifactDownloader;
-    private final List<Resource> resources;
     private ProjectId projectId;
 
-    public MavenProject(Path projectRoot, Resource pomFile, Model pomModel, MavenArtifactDownloader rewriteMavenArtifactDownloader, List<Resource> resources) {
+    public MavenProject(Path projectRoot, Resource pomFile, Model pomModel, List<Resource> resources, ClasspathRegistry classpathRegistry) {
         this.projectRoot = projectRoot;
         this.pomFile = pomFile;
         this.pomModel = pomModel;
-        this.rewriteMavenArtifactDownloader = rewriteMavenArtifactDownloader;
         this.resources = resources;
+        this.classpathRegistry = classpathRegistry;
         projectId = new ProjectId(getGroupId(), getArtifactId());
     }
 
@@ -145,32 +142,22 @@ public String getSourceDirectory() {
         return s == null ? ResourceUtil.getPath(pomFile).getParent().resolve("src/main/java").toAbsolutePath().normalize().toString() : s;
     }
 
-    public List<Path> getCompileClasspathElements() {
+
+    /**
+     * Must be called after {@link ParserContext#setParsedBuildFiles(List)}.
+     */
+    public Set<Path> getCompileClasspathElements() {
         Scope scope = Scope.Compile;
         return getClasspathElements(scope);
     }
 
-    public List<Path> getTestClasspathElements() {
+    public Set<Path> getTestClasspathElements() {
         return getClasspathElements(Scope.Test);
     }
 
     @NotNull
-    private List<Path> getClasspathElements(Scope scope) {
-        MavenResolutionResult pom = getSourceFile().getMarkers().findFirst(MavenResolutionResult.class).get();
-        List<ResolvedDependency> resolvedDependencies = pom.getDependencies().get(scope);
-        if(resolvedDependencies != null) {
-            return resolvedDependencies
-                    // FIXME: 945 - deal with dependencies to projects in reactor
-                    //
-                    .stream()
-                    .filter(rd -> rd.getRepository() != null)
-                    .map(rd -> rewriteMavenArtifactDownloader.downloadArtifact(rd))
-                    .filter(Objects::nonNull)
-                    .distinct()
-                    .toList();
-        } else {
-            return new ArrayList<>();
-        }
+    private Set<Path> getClasspathElements(Scope scope) {
+        return classpathRegistry.getClasspath(getPomFilePath(), scope);
     }
 
     public String getTestSourceDirectory() {
@@ -199,7 +186,6 @@ private static Predicate<Resource> whenIn(Path sourceDirectory) {
         return r -> ResourceUtil.getPath(r).toString().startsWith(sourceDirectory.toString());
     }
 
-
     public List<Resource> getJavaSourcesInTarget() {
         return listJavaSources(getResources(), getBasedir().resolve(getBuildDirectory()));
     }

sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ModuleParser.java

@@ -73,7 +73,6 @@ public <T extends SourceFile> UnaryOperator<T> addProvenance(
     public List<SourceFile> processMainSources(
             Path baseDir,
             List<Resource> resources,
-            Xml.Document moduleBuildFile,
             JavaParser.Builder<? extends JavaParser, ?> javaParserBuilder,
             RewriteResourceParser rp,
             List<Marker> provenanceMarkers,
@@ -105,9 +104,9 @@ public List<SourceFile> processMainSources(
         // Or, the classpath must be created from the sources of the project.
 
 
-        List<Path> dependencies = currentProject.getCompileClasspathElements();
+        Set<Path> jarDependencies = currentProject.getCompileClasspathElements();
 
-        javaParserBuilder.classpath(dependencies);
+        javaParserBuilder.classpath(jarDependencies);
 
         JavaTypeCache typeCache = new JavaTypeCache();
         javaParserBuilder.typeCache(typeCache);
@@ -116,13 +115,14 @@ public List<SourceFile> processMainSources(
                 .map(r -> new Parser.Input(ResourceUtil.getPath(r), () -> ResourceUtil.getInputStream(r)))
                 .toList();
 
-        Stream<? extends SourceFile> cus = Stream.of(javaParserBuilder)
-                .map(JavaParser.Builder::build)
-                .flatMap(parser -> parser.parseInputs(inputs, baseDir, executionContext))
+        JavaParser javaParser = javaParserBuilder.build();
+        Stream<? extends SourceFile> cus = javaParser.parseInputs(inputs, baseDir, executionContext)
                 .peek(s -> alreadyParsed.add(baseDir.resolve(s.getSourcePath())));
 
+
         List<Marker> mainProjectProvenance = new ArrayList<>(provenanceMarkers);
-        mainProjectProvenance.add(sourceSet("main", dependencies, typeCache));
+        mainProjectProvenance.add(sourceSet("main", jarDependencies, typeCache));
+        mainProjectProvenance.add(new JavaParserMarker(UUID.randomUUID(), javaParser));
 
         // FIXME: 945 Why target and not all main?
         List<Path> parsedJavaPaths = mainJavaSources.stream().map(ResourceUtil::getPath).toList();
@@ -149,7 +149,7 @@ public List<SourceFile> processMainSources(
     }
 
     @NotNull
-    private static JavaSourceSet sourceSet(String name, List<Path> dependencies, JavaTypeCache typeCache) {
+    private static JavaSourceSet sourceSet(String name, Set<Path> dependencies, JavaTypeCache typeCache) {
         return JavaSourceSet.build(name, dependencies, typeCache, false);
     }
 
@@ -159,7 +159,6 @@ private static JavaSourceSet sourceSet(String name, List<Path> dependencies, Jav
      */
     public List<SourceFile> processTestSources(
             Path baseDir,
-            Xml.Document moduleBuildFile,
             JavaParser.Builder<? extends JavaParser, ?> javaParserBuilder,
             RewriteResourceParser rp,
             List<Marker> provenanceMarkers,
@@ -170,7 +169,7 @@ public List<SourceFile> processTestSources(
     ) {
         log.info("Processing test sources in module '%s'".formatted(currentProject.getProjectId()));
 
-        List<Path> testDependencies = currentProject.getTestClasspathElements();
+        Set<Path> testDependencies = currentProject.getTestClasspathElements();
 
         javaParserBuilder.classpath(testDependencies);
         JavaTypeCache typeCache = new JavaTypeCache();

sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ModuleParsingResult.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2021 - 2023 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.sbm.parsers;
+
+import org.openrewrite.SourceFile;
+
+import java.util.List;
+
+/**
+ * @author Fabian Krüger
+ */
+public record ModuleParsingResult(List<SourceFile> sourceFiles) {
+
+}

sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ParserContext.java

@@ -40,7 +40,7 @@ public class ParserContext {
     private final List<MavenProject> sortedProjects;
     @Getter
     private Map<Path, Xml.Document> pathDocumentMap;
-
+    private ClasspathRegistry classpathRegistry;
 
 
     public List<String> getActiveProfiles() {
@@ -80,4 +80,8 @@ private void addSourceFileToModel(Path baseDir, List<MavenProject> sortedProject
                 .filter(p -> ResourceUtil.getPath(p.getPomFile()).toString().equals(baseDir.resolve(s.getSourcePath()).toString()))
                 .forEach(p -> p.setSourceFile(s));
     }
+
+    public void setClasspathRegistry(ClasspathRegistry classpathRegistry) {
+        this.classpathRegistry = classpathRegistry;
+    }
 }