Add synthetic module-infos for runtime dependencies to compile classpath

jjohannes · jjohannes · commit 9577b7c59f72 · 2022-11-01T14:07:29.000+01:00
To keep code with 'requires /*runtime*/' directives compiling, we
add a synthetic (empty) module descriptor for all of these dependencies
directly to the classpath of the corresponding JavaCompile task.
diff --git a/src/main/java/org/gradlex/javamodule/dependencies/JavaModuleDependenciesPlugin.java b/src/main/java/org/gradlex/javamodule/dependencies/JavaModuleDependenciesPlugin.java
@@ -16,11 +16,6 @@
 
 package org.gradlex.javamodule.dependencies;
 
-import org.gradlex.javamodule.dependencies.internal.bridges.ExtraJavaModuleInfoBridge;
-import org.gradlex.javamodule.dependencies.internal.utils.ModuleInfo;
-import org.gradlex.javamodule.dependencies.tasks.ModuleInfoGeneration;
-import org.gradlex.javamodule.dependencies.tasks.ModuleVersionRecommendation;
-import org.gradlex.javamodule.dependencies.tasks.ModulePathAnalysis;
 import org.gradle.api.GradleException;
 import org.gradle.api.NonNullApi;
 import org.gradle.api.Plugin;
@@ -38,11 +33,19 @@
 import org.gradle.api.tasks.SourceSet;
 import org.gradle.api.tasks.SourceSetContainer;
 import org.gradle.api.tasks.TaskProvider;
+import org.gradle.api.tasks.compile.JavaCompile;
 import org.gradle.util.GradleVersion;
+import org.gradlex.javamodule.dependencies.internal.bridges.ExtraJavaModuleInfoBridge;
+import org.gradlex.javamodule.dependencies.internal.compile.AddSyntheticModulesToCompileClasspathAction;
+import org.gradlex.javamodule.dependencies.internal.utils.ModuleInfo;
+import org.gradlex.javamodule.dependencies.tasks.ModuleInfoGeneration;
+import org.gradlex.javamodule.dependencies.tasks.ModulePathAnalysis;
+import org.gradlex.javamodule.dependencies.tasks.ModuleVersionRecommendation;
 
 import javax.annotation.Nullable;
 import java.io.File;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.stream.Collectors;
@@ -84,6 +87,15 @@ private void setupForJavaProject(Project project, JavaModuleDependenciesExtensio
             process(ModuleInfo.Directive.REQUIRES_TRANSITIVE, sourceSet.getApiConfigurationName(), sourceSet, project, javaModuleDependencies);
             process(ModuleInfo.Directive.REQUIRES_STATIC_TRANSITIVE, sourceSet.getCompileOnlyApiConfigurationName(), sourceSet, project, javaModuleDependencies);
             process(ModuleInfo.Directive.REQUIRES_RUNTIME, sourceSet.getRuntimeOnlyConfigurationName(), sourceSet, project, javaModuleDependencies);
+
+            project.getTasks().named(sourceSet.getCompileJavaTaskName(), JavaCompile.class, javaCompile -> {
+                ModuleInfo moduleInfo = findModuleInfoInSourceSet(sourceSet, project);
+                List<String> requiresRuntime = moduleInfo.get(ModuleInfo.Directive.REQUIRES_RUNTIME);
+                if (!requiresRuntime.isEmpty()) {
+                    javaCompile.doFirst(project.getObjects().newInstance(AddSyntheticModulesToCompileClasspathAction.class,
+                            project.getLayout().getBuildDirectory().dir("tmp").get().getAsFile(), requiresRuntime));
+                }
+            });
         });
         setupReportTasks(project, javaModuleDependencies);
         setupMigrationTasks(project, javaModuleDependencies);
@@ -150,34 +162,43 @@ private void setupMigrationTasks(Project project, JavaModuleDependenciesExtensio
     private void process(ModuleInfo.Directive moduleDirective, String gradleConfiguration, SourceSet sourceSet, Project project, JavaModuleDependenciesExtension javaModuleDependenciesExtension) {
         Configuration conf = project.getConfigurations().findByName(gradleConfiguration);
         if (conf != null) {
-            conf.withDependencies(d -> findAndReadModuleInfo(moduleDirective, sourceSet, project, conf, javaModuleDependenciesExtension));
+            conf.withDependencies(d -> readModuleInfo(moduleDirective, sourceSet, project, conf, javaModuleDependenciesExtension));
         } else {
             project.getConfigurations().whenObjectAdded(lateAddedConf -> {
                 if (gradleConfiguration.equals(lateAddedConf.getName())) {
-                    lateAddedConf.withDependencies(d -> findAndReadModuleInfo(moduleDirective, sourceSet, project, lateAddedConf, javaModuleDependenciesExtension));
+                    lateAddedConf.withDependencies(d -> readModuleInfo(moduleDirective, sourceSet, project, lateAddedConf, javaModuleDependenciesExtension));
                 }
             });
         }
     }
 
-    private void findAndReadModuleInfo(ModuleInfo.Directive moduleDirective, SourceSet sourceSet, Project project, Configuration configuration, JavaModuleDependenciesExtension javaModuleDependenciesExtension) {
+    private void readModuleInfo(ModuleInfo.Directive moduleDirective, SourceSet sourceSet, Project project, Configuration configuration, JavaModuleDependenciesExtension javaModuleDependenciesExtension) {
+        ModuleInfo moduleInfo = findModuleInfoInSourceSet(sourceSet, project);
+        String ownModuleNamesPrefix = moduleInfo.moduleNamePrefix(project.getName(), sourceSet.getName());
+        for (String moduleName : moduleInfo.get(moduleDirective)) {
+            declareDependency(moduleName, ownModuleNamesPrefix, moduleInfo.getFilePath(), project, configuration, javaModuleDependenciesExtension);
+        }
+    }
+
+    /**
+     * Returns the module-info.java for the given SourceSet. If the SourceSet has multiple source folders with multiple
+     * module-info files (which is usually a broken setup) the first file found is returned.
+     */
+    private ModuleInfo findModuleInfoInSourceSet(SourceSet sourceSet, Project project) {
         for (File folder : sourceSet.getJava().getSrcDirs()) {
             Provider<RegularFile> moduleInfoFile = project.getLayout().file(project.provider(() -> new File(folder, "module-info.java")));
             Provider<String> moduleInfoContent = project.getProviders().fileContents(moduleInfoFile).getAsText();
             if (moduleInfoContent.isPresent()) {
-                if (!this.moduleInfo.containsKey(folder)) {
-                    this.moduleInfo.put(folder, new ModuleInfo(moduleInfoContent.get()));
-                }
-                ModuleInfo moduleInfo = this.moduleInfo.get(folder);
-                String ownModuleNamesPrefix = moduleInfo.moduleNamePrefix(project.getName(), sourceSet.getName());
-                for (String moduleName : moduleInfo.get(moduleDirective)) {
-                    declareDependency(moduleName, ownModuleNamesPrefix, moduleInfoFile, project, configuration, javaModuleDependenciesExtension);
+                if (!moduleInfo.containsKey(folder)) {
+                    moduleInfo.put(folder, new ModuleInfo(moduleInfoContent.get(), moduleInfoFile.get().getAsFile()));
                 }
+                return moduleInfo.get(folder);
             }
         }
+        return ModuleInfo.EMPTY;
     }
 
-    private void declareDependency(String moduleName, @Nullable String ownModuleNamesPrefix, Provider<RegularFile> moduleInfoFile, Project project, Configuration configuration, JavaModuleDependenciesExtension javaModuleDependencies) {
+    private void declareDependency(String moduleName, @Nullable String ownModuleNamesPrefix, File moduleInfoFile, Project project, Configuration configuration, JavaModuleDependenciesExtension javaModuleDependencies) {
         if (JDKInfo.MODULES.contains(moduleName)) {
             // The module is part of the JDK, no dependency required
             return;
@@ -241,17 +262,17 @@ private void declareDependency(String moduleName, @Nullable String ownModuleName
         }
     }
 
-    private void warnVersionMissing(String moduleName, Map<String, Object> ga, Provider<RegularFile> moduleInfoFile, Project project, JavaModuleDependenciesExtension javaModuleDependencies) {
+    private void warnVersionMissing(String moduleName, Map<String, Object> ga, File moduleInfoFile, Project project, JavaModuleDependenciesExtension javaModuleDependencies) {
         if (javaModuleDependencies.getWarnForMissingVersions().get()) {
             project.getLogger().warn("[WARN] [Java Module Dependencies] No version defined in catalog - " + ga.get(GAV.GROUP) + ":" + ga.get(GAV.ARTIFACT) + " - "
                     + moduleDebugInfo(moduleName.replace('.', '_'), moduleInfoFile, project.getRootDir()));
         }
     }
 
-    private String moduleDebugInfo(String moduleName, Provider<RegularFile> moduleInfoFile, File rootDir) {
+    private String moduleDebugInfo(String moduleName, File moduleInfoFile, File rootDir) {
         return moduleName
                 + " (required in "
-                + moduleInfoFile.get().getAsFile().getAbsolutePath().substring(rootDir.getAbsolutePath().length() + 1)
+                + moduleInfoFile.getAbsolutePath().substring(rootDir.getAbsolutePath().length() + 1)
                 + ")";
     }
 
diff --git a/src/main/java/org/gradlex/javamodule/dependencies/internal/compile/AddSyntheticModulesToCompileClasspathAction.java b/src/main/java/org/gradlex/javamodule/dependencies/internal/compile/AddSyntheticModulesToCompileClasspathAction.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2022 the GradleX team.
+ *
+ * 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
+ *
+ *     http://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.gradlex.javamodule.dependencies.internal.compile;
+
+import org.gradle.api.Action;
+import org.gradle.api.NonNullApi;
+import org.gradle.api.Task;
+import org.gradle.api.file.ConfigurableFileCollection;
+import org.gradle.api.model.ObjectFactory;
+import org.gradle.api.tasks.compile.JavaCompile;
+import org.gradlex.javamodule.dependencies.internal.utils.ModuleInfoClassCreator;
+
+import javax.inject.Inject;
+import java.io.File;
+import java.util.List;
+
+@NonNullApi
+public abstract class AddSyntheticModulesToCompileClasspathAction implements Action<Task> {
+
+    private final File tmpFolder;
+    private final List<String> moduleDependencies;
+    private final ObjectFactory objects;
+
+    @Inject
+    public AddSyntheticModulesToCompileClasspathAction(File tmpFolder, List<String> moduleDependencies, ObjectFactory objects) {
+        this.tmpFolder = tmpFolder;
+        this.moduleDependencies = moduleDependencies;
+        this.objects = objects;
+    }
+
+    @Override
+    public void execute(Task task) {
+        if (moduleDependencies.isEmpty()) {
+            return;
+        }
+
+        JavaCompile javaCompile = (JavaCompile) task;
+
+        ConfigurableFileCollection syntheticModuleInfoFolders = objects.fileCollection();
+        for (String moduleName : moduleDependencies) {
+            File dir = new File(tmpFolder, "java-module-dependencies/" + moduleName + "-synthetic");
+            ModuleInfoClassCreator.createEmpty(moduleName, dir);
+            syntheticModuleInfoFolders.from(dir);
+        }
+
+        javaCompile.setClasspath(javaCompile.getClasspath().plus(syntheticModuleInfoFolders));
+    }
+}
diff --git a/src/main/java/org/gradlex/javamodule/dependencies/internal/utils/ModuleInfo.java b/src/main/java/org/gradlex/javamodule/dependencies/internal/utils/ModuleInfo.java
@@ -17,6 +17,7 @@
 package org.gradlex.javamodule.dependencies.internal.utils;
 
 import javax.annotation.Nullable;
+import java.io.File;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -41,14 +42,19 @@ public String literal() {
 
     public static final String RUNTIME_KEYWORD = "/*runtime*/";
 
-    private String moduleName;
+    public static final ModuleInfo EMPTY = new ModuleInfo("", new File(""));
+
+    private String moduleName = "";
     private final List<String> requires = new ArrayList<>();
     private final List<String> requiresTransitive = new ArrayList<>();
     private final List<String> requiresStatic = new ArrayList<>();
     private final List<String> requiresStaticTransitive = new ArrayList<>();
     private final List<String> requiresRuntime = new ArrayList<>();
 
-    public ModuleInfo(String moduleInfoFileContent) {
+    private final File filePath;
+
+    public ModuleInfo(String moduleInfoFileContent, File filePath) {
+        this.filePath = filePath;
         boolean insideComment = false;
         for(String line: moduleInfoFileContent.split("\n")) {
             insideComment = parse(line, insideComment);
@@ -90,6 +96,10 @@ public String moduleNamePrefix(String projectName, String sourceSetName) {
         return null;
     }
 
+    public File getFilePath() {
+        return filePath;
+    }
+
     /**
      * @return true, if we are inside a multi-line comment after this line
      */
diff --git a/src/main/java/org/gradlex/javamodule/dependencies/internal/utils/ModuleInfoClassCreator.java b/src/main/java/org/gradlex/javamodule/dependencies/internal/utils/ModuleInfoClassCreator.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2022 the GradleX team.
+ *
+ * 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
+ *
+ *     http://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.gradlex.javamodule.dependencies.internal.utils;
+
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.ModuleVisitor;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+import static org.objectweb.asm.Opcodes.ACC_MANDATED;
+import static org.objectweb.asm.Opcodes.ACC_MODULE;
+import static org.objectweb.asm.Opcodes.ACC_SYNTHETIC;
+
+public class ModuleInfoClassCreator {
+
+    public static void createEmpty(String moduleName, File targetFolder) {
+        //noinspection ResultOfMethodCallIgnored
+        targetFolder.mkdirs();
+
+        ClassWriter cw = new ClassWriter(0);
+        cw.visit(53, ACC_MODULE, "module-info", null, null, null);
+        ModuleVisitor moduleVisitor = cw.visitModule(moduleName, ACC_SYNTHETIC, null);
+        moduleVisitor.visitRequire("java.base", ACC_MANDATED, null);
+        cw.visitEnd();
+        try (FileOutputStream s = new FileOutputStream(new File(targetFolder, "module-info.class"))) {
+            s.write(cw.toByteArray());
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}
diff --git a/src/main/java/org/gradlex/javamodule/dependencies/tasks/ModulePathAnalysis.java b/src/main/java/org/gradlex/javamodule/dependencies/tasks/ModulePathAnalysis.java
@@ -90,7 +90,7 @@ public void report() throws IOException {
             if (file.exists()) {
                 try(Stream<String> lines = Files.lines(file.toPath())) {
                     String fileContent = lines.collect(Collectors.joining("\n"));
-                    ownModuleNamesPrefix = new ModuleInfo(fileContent).moduleNamePrefix(projectName, main.getName());
+                    ownModuleNamesPrefix = new ModuleInfo(fileContent, file).moduleNamePrefix(projectName, main.getName());
                 }
                 break;
             }
diff --git a/src/test/groovy/org/gradlex/javamodule/dependencies/test/ModuleInfoParseTest.groovy b/src/test/groovy/org/gradlex/javamodule/dependencies/test/ModuleInfoParseTest.groovy
@@ -18,7 +18,7 @@ class ModuleInfoParseTest extends Specification {
                 // requires com.bla.blub;
                 requires transitive foo.bar.la;
             }
-        ''')
+        ''', new File(''))
 
         expect:
         moduleInfo.moduleNamePrefix("thing", "main") == "some"
@@ -35,7 +35,7 @@ class ModuleInfoParseTest extends Specification {
             module some.thing { // module some.thing.else
                 requires transitive foo.bar.la;
             }
-        ''')
+        ''', new File(''))
 
         expect:
         moduleInfo.moduleNamePrefix("thing", "main") == "some"
@@ -55,7 +55,7 @@ class ModuleInfoParseTest extends Specification {
                 */
                 requires static foo.bar.la;
             }
-        ''')
+        ''', new File(''))
 
         expect:
         moduleInfo.get(REQUIRES) == []
@@ -75,7 +75,7 @@ class ModuleInfoParseTest extends Specification {
                     requires only.a.comment
                 */
             }
-        ''')
+        ''', new File(''))
 
         expect:
         moduleInfo.get(REQUIRES) == ["foo.bar.li"]
@@ -91,7 +91,7 @@ class ModuleInfoParseTest extends Specification {
             module some.thing {
                 requires /*runtime*/ foo.bar.lo;
             }
-        ''')
+        ''', new File(''))
 
         expect:
         moduleInfo.get(REQUIRES) == []
diff --git a/src/test/groovy/org/gradlex/javamodule/dependencies/test/RequiresRuntimeTest.groovy b/src/test/groovy/org/gradlex/javamodule/dependencies/test/RequiresRuntimeTest.groovy
@@ -77,4 +77,42 @@ class RequiresRuntimeTest extends Specification {
         then:
         result.output.contains("[main] INFO org.gradlex.test.app.Main - Running application...")
     }
+
+    def "runtime only dependencies are not visible at compile time"() {
+        given:
+        appBuildFile << '''
+            dependencies.constraints {
+                javaModuleDependencies {
+                    implementation(gav("org.slf4j", "2.0.3"))
+                }
+            }
+        '''
+        appModuleInfoFile << '''
+            module org.gradlex.test.app {
+                requires /*runtime*/ org.slf4j;
+                
+                exports org.gradlex.test.app;
+            }
+        '''
+        file("app/src/main/java/org/gradlex/test/app/Main.java") << """
+            package org.gradlex.test.app;
+            
+            import org.slf4j.Logger;
+            import org.slf4j.LoggerFactory;
+            
+            public class Main {
+                private static final Logger LOGGER = LoggerFactory.getLogger(Main.class);
+                
+                public static void main(String[] args) {
+                    LOGGER.info("Running application...");
+                }
+            }
+        """
+
+        when:
+        def result = fail()
+
+        then:
+        result.output.contains("error: package org.slf4j does not exist")
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -90,7 +90,7 @@ public void report() throws IOException {`
`90`	`90`	`if (file.exists()) {`
`91`	`91`	`try(Stream<String> lines = Files.lines(file.toPath())) {`
`92`	`92`	`String fileContent = lines.collect(Collectors.joining("\n"));`
`93`		`- ownModuleNamesPrefix = new ModuleInfo(fileContent).moduleNamePrefix(projectName, main.getName());`
	`93`	`+ ownModuleNamesPrefix = new ModuleInfo(fileContent, file).moduleNamePrefix(projectName, main.getName());`
`94`	`94`	`}`
`95`	`95`	`break;`
`96`	`96`	`}`