add javac plugin

build.gradle.kts

@@ -148,6 +148,8 @@ java {
 
 tasks.jar {
     from(sourceSets["main"].output, sourceSets["shared"].output)
+    from(project("javac-plugin").sourceSets["main"].output)
+
     from(rootDir.resolve("LICENSE.md"))
     from(rootDir.resolve("license")) {
         into("license")
@@ -171,6 +173,7 @@ tasks.jar {
 
 tasks.getByName<Jar>("sourcesJar") {
     from(sourceSets["shared"].allSource)
+    from(project("javac-plugin").sourceSets["main"].allSource)
     from(rootDir.resolve("LGPLv2.1.md"))
 
     isPreserveFileTimestamps = false
@@ -185,6 +188,7 @@ project.evaluationDependsOnChildren()
 
 val shadowJar by tasks.registering(ShadowJar::class) {
     from(sourceSets["main"].output, sourceSets["shared"].output)
+    from(project("javac-plugin").sourceSets["main"].output)
     from(rootDir.resolve("LGPLv2.1.md"))
 
     isPreserveFileTimestamps = false

java-api/build.gradle.kts

@@ -134,6 +134,7 @@ tasks.getByName<JavaCompile>("compileCoverageJava") {
 
 val genCtSym by tasks.registering(GenerateCtSymTask::class) {
     group = "jvmdg"
+    lowerVersion = fromVersion
     upperVersion = toVersion - 1
 }
 

javac-plugin/build.gradle.kts

@@ -0,0 +1,37 @@
+import org.gradle.internal.os.OperatingSystem
+
+java {
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(8))
+    }
+}
+
+dependencies {
+    compileOnly(rootProject.sourceSets["main"].output)
+    compileOnly(rootProject.sourceSets["shared"].output)
+
+    // macos doesn't link tools.jar by default for some reason
+    val javaHome = javaToolchains.compilerFor { languageVersion.set(JavaLanguageVersion.of(8)) }.get().metadata.installationPath
+    implementation(files("$javaHome/lib/tools.jar"))
+
+    testImplementation("org.junit.jupiter:junit-jupiter:5.10.2")
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+}
+
+tasks.compileTestJava {
+    classpath += rootProject.tasks["shadowJar"].outputs.files
+
+    javaCompiler = javaToolchains.compilerFor {
+        languageVersion.set(JavaLanguageVersion.of(17))
+    }
+
+    options.compilerArgs.add("-Xplugin:jvmdg target=8 log=info")
+}
+
+tasks.test {
+    useJUnitPlatform()
+
+    javaLauncher = javaToolchains.launcherFor {
+        languageVersion.set(JavaLanguageVersion.of(8))
+    }
+}

javac-plugin/src/main/java/xyz/wagyourtail/jvmdg/javac/JvmdgJavacPlugin.java

@@ -0,0 +1,170 @@
+package xyz.wagyourtail.jvmdg.javac;
+
+import com.sun.source.util.Plugin;
+import com.sun.source.util.JavacTask;
+import com.sun.tools.javac.api.BasicJavacTask;
+import com.sun.tools.javac.main.JavaCompiler;
+import xyz.wagyourtail.jvmdg.ClassDowngrader;
+import xyz.wagyourtail.jvmdg.cli.Flags;
+import xyz.wagyourtail.jvmdg.compile.PathDowngrader;
+import xyz.wagyourtail.jvmdg.logging.Logger;
+import xyz.wagyourtail.jvmdg.util.Utils;
+
+import javax.tools.JavaFileManager;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardLocation;
+import java.io.Closeable;
+import java.io.File;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.*;
+
+@SuppressWarnings("UrlHashCode")
+public class JvmdgJavacPlugin implements Plugin, Closeable {
+    private BasicJavacTask task;
+    private Flags flags;
+    private final Set<URL> classpathURLs = new HashSet<>();
+
+    @Override
+    public String getName() {
+        return "jvmdg";
+    }
+
+    static {
+        int vmVersion = Utils.classVersionToMajorVersion(Utils.getCurrentClassVersion());
+        if(vmVersion > 8) {
+            try {
+                Method getModule = Class.class.getDeclaredMethod("getModule");
+                openModule(getModule.invoke(JavacTask.class));
+            } catch (Throwable t) {
+                Utils.sneakyThrow(t);
+            }
+        }
+    }
+
+    @Override
+    public void init(JavacTask t, String... args) {
+        this.task = (BasicJavacTask) t;
+
+        JavaCompiler compiler = JavaCompiler.instance(task.getContext());
+        compiler.closeables = compiler.closeables.prepend(this);
+
+        this.flags = new Flags();
+        flags.api = flags.findJavaApi();
+
+        final String p = "[" + File.separator + "]";
+
+        for(String arg : args) {
+            if(arg.contains("=")) {
+                String[] split = arg.split("=", 2);
+                switch(split[0]) {
+                    case "api":
+                        if(flags.api == null) {
+                            flags.api = new ArrayList<>();
+                        }
+                        for(String s : split[1].split(p)) {
+                            flags.api.add(new File(s));
+                        }
+                        break;
+                    case "logLevel":
+                    case "log":
+                        flags.logLevel = Logger.Level.valueOf(split[1].toUpperCase(Locale.ROOT));
+                        break;
+                    case "skipStubs":
+                        for(String s : split[1].split(",")) {
+                            flags.debugSkipStubs.add(Integer.parseInt(s));
+                        }
+                        break;
+                    case "target":
+                        flags.classVersion = Utils.majorVersionToClassVersion(Integer.parseInt(split[1]));
+                        break;
+                    case "classpath":
+                    case "cp":
+                        for(String s : split[1].split(p)) {
+                            try {
+                                classpathURLs.add(new File(s).toURI().toURL());
+                            } catch (Throwable t1) {
+                                Utils.sneakyThrow(t1);
+                            }
+                        }
+                        break;
+                }
+            }
+        }
+    }
+
+    @Override
+    public void close() {
+        try {
+            runDowngrade();
+        } catch (Throwable t) {
+            Utils.sneakyThrow(t);
+        }
+    }
+
+    private void runDowngrade() throws Throwable {
+        final JavaFileManager fileManager = task.getContext().get(JavaFileManager.class);
+
+        File root = new File(
+            fileManager.getJavaFileForOutput(
+                StandardLocation.CLASS_OUTPUT,
+                "", JavaFileObject.Kind.CLASS, null
+            ).toUri()
+        ).getParentFile();
+
+        // must be mutable, since GradleStandardJavaFileManager calls remove
+        Set<JavaFileObject.Kind> kindSet = new HashSet<>();
+        kindSet.add(JavaFileObject.Kind.CLASS);
+
+        for(JavaFileObject jfo : fileManager.list(StandardLocation.CLASS_PATH, "", kindSet, true)) {
+            classpathURLs.add(jfo.toUri().toURL());
+        }
+
+        Path tempOutput = Files.createTempDirectory("downgrade");
+        tempOutput.toFile().deleteOnExit();
+
+        try(ClassDowngrader cd = ClassDowngrader.downgradeTo(flags)) {
+            cd.logger.debug("classpath: " + classpathURLs);
+
+            PathDowngrader.downgradePaths(
+                cd,
+                Collections.singletonList(root.toPath()),
+                Collections.singletonList(tempOutput),
+                classpathURLs
+            );
+        }
+
+        Files.walk(tempOutput)
+            .filter(Files::isRegularFile)
+            .forEach(p -> {
+                try {
+                    Path target = root.toPath().resolve(tempOutput.relativize(p));
+                    Files.createDirectories(target.getParent());
+                    Files.move(p, target, StandardCopyOption.REPLACE_EXISTING);
+                } catch (Throwable t) {
+                    Utils.sneakyThrow(t);
+                }
+            });
+    }
+
+    public static void openModule(Object o) throws Throwable {
+        Class<?> moduleClass = o.getClass();
+        if(!moduleClass.getName().equals("java.lang.Module")) {
+            throw new IllegalArgumentException("Not a module: " + o);
+        }
+        MethodHandle implAddOpens = Utils.getImplLookup().findVirtual(moduleClass, "implAddOpens",
+            MethodType.methodType(void.class, String.class));
+
+        @SuppressWarnings("unchecked")
+        Set<String> packages = (Set<String>) moduleClass.getDeclaredMethod("getPackages").invoke(o);
+
+        for(String pn : packages) {
+            implAddOpens.invoke(o, pn);
+        }
+    }
+}

javac-plugin/src/main/resources/META-INF/services/com.sun.source.util.Plugin

@@ -0,0 +1 @@
+xyz.wagyourtail.jvmdg.javac.JvmdgJavacPlugin

javac-plugin/src/test/java/TheTest.java

@@ -0,0 +1,18 @@
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TheTest {
+    @Test
+    public void test() {
+        // if this class loads, the plugin is working
+
+        // just make sure we're running on Java 8
+        assertTrue(System.getProperty("java.version").startsWith("1.8"));
+
+        String h = """
+        Hello World!
+        """;
+        assertEquals("Hello World!\n", h);
+    }
+}

settings.gradle.kts

@@ -13,6 +13,7 @@ plugins {
 include("gradle-plugin")
 include("java-api")
 include("site")
+include("javac-plugin")
 
 include("testing")
 include("testing:downgrade")