Restructured Project

.gitignore

@@ -1,5 +1,5 @@
 .gradle
-/build
+build
 !gradle/wrapper/gradle-wrapper.jar
 !**/src/main/**/build/
 !**/src/test/**/build/

api/build.gradle

@@ -0,0 +1,11 @@
+plugins {
+    id 'java-library'
+}
+
+group = 'net.neoforged.jst'
+
+dependencies {
+    api "com.jetbrains.intellij.java:java-psi-impl:$intellij_version"
+    api "info.picocli:picocli:$picocli_version"
+    compileOnly "org.jetbrains:annotations:$jetbrains_annotations_version"
+}

src/main/java/PsiHelper.java → api/src/main/java/net/neoforged/jst/api/PsiHelper.java

@@ -1,4 +1,5 @@
-import com.intellij.openapi.util.Key;
+package net.neoforged.jst.api;
+
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiLambdaExpression;
 import com.intellij.psi.PsiMethod;
@@ -11,65 +12,12 @@
 import com.intellij.psi.util.ClassUtil;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.containers.ObjectIntHashMap;
-import namesanddocs.NamesAndDocsDatabase;
-import namesanddocs.NamesAndDocsForClass;
-import namesanddocs.NamesAndDocsForMethod;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 import java.util.Objects;
 import java.util.Optional;
 
 public final class PsiHelper {
-    // Keys for attaching mapping data to a PsiClass. Used to prevent multiple lookups for the same class/method.
-    private static final Key<Optional<NamesAndDocsForClass>> CLASS_DATA_KEY = Key.create("names_and_docs_for_class");
-    private static final Key<Optional<NamesAndDocsForMethod>> METHOD_DATA_KEY = Key.create("names_and_docs_for_method");
-
-    @SuppressWarnings("OptionalAssignedToNull")
-    @Nullable
-    public static NamesAndDocsForClass getClassData(NamesAndDocsDatabase namesAndDocs, @Nullable PsiClass psiClass) {
-        if (psiClass == null) {
-            return null;
-        }
-        var classData = psiClass.getUserData(CLASS_DATA_KEY);
-        if (classData != null) {
-            return classData.orElse(null);
-        } else {
-            var sb = new StringBuilder();
-            getBinaryClassName(psiClass, sb);
-            if (sb.isEmpty()) {
-                classData = Optional.empty();
-            } else {
-                classData = Optional.ofNullable(namesAndDocs.getClass(sb.toString()));
-            }
-            psiClass.putUserData(CLASS_DATA_KEY, classData);
-            return classData.orElse(null);
-        }
-    }
-
-    @SuppressWarnings("OptionalAssignedToNull")
-    @Nullable
-    public static NamesAndDocsForMethod getMethodData(NamesAndDocsDatabase namesAndDocs, @Nullable PsiMethod psiMethod) {
-        if (psiMethod == null) {
-            return null;
-        }
-        var methodData = psiMethod.getUserData(METHOD_DATA_KEY);
-        if (methodData != null) {
-            return methodData.orElse(null);
-        } else {
-            methodData = Optional.empty();
-            var classData = getClassData(namesAndDocs, psiMethod.getContainingClass());
-            if (classData != null) {
-                var methodName = getBinaryMethodName(psiMethod);
-                var methodSignature = getBinaryMethodSignature(psiMethod);
-                methodData = Optional.ofNullable(classData.getMethod(methodName, methodSignature));
-            }
-
-            psiMethod.putUserData(METHOD_DATA_KEY, methodData);
-            return methodData.orElse(null);
-        }
-    }
-
     public static String getBinaryMethodName(PsiMethod psiMethod) {
         return psiMethod.isConstructor() ? "<init>" : psiMethod.getName();
     }

api/src/main/java/net/neoforged/jst/api/Replacement.java

@@ -0,0 +1,11 @@
+package net.neoforged.jst.api;
+
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiElement;
+
+import java.util.Comparator;
+
+public record Replacement(TextRange range, String newText) {
+
+    public static final Comparator<Replacement> COMPARATOR = Comparator.comparingInt(replacement -> replacement.range.getStartOffset());
+}

api/src/main/java/net/neoforged/jst/api/Replacements.java

@@ -0,0 +1,73 @@
+package net.neoforged.jst.api;
+
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiElement;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public final class Replacements {
+    private final List<Replacement> replacements = new ArrayList<>();
+
+    public boolean isEmpty() {
+        return replacements.isEmpty();
+    }
+
+    public void replace(PsiElement element, String newText) {
+        add(new Replacement(element.getTextRange(), newText));
+    }
+
+    public void insertBefore(PsiElement element, String newText) {
+        var startOffset = element.getTextRange().getStartOffset();
+        add(new Replacement(new TextRange(
+                startOffset,
+                startOffset
+        ), newText));
+    }
+
+    public void insertAfter(PsiElement element, String newText) {
+        var endOffset = element.getTextRange().getEndOffset();
+        add(new Replacement(new TextRange(
+                endOffset,
+                endOffset
+        ), newText));
+    }
+
+    public void add(Replacement replacement) {
+        replacements.add(replacement);
+    }
+
+    public String apply(CharSequence originalContent) {
+        // We will assemble the resulting file by iterating all ranges (replaced or not)
+        // For this to work, the replacement ranges need to be in ascending order and non-overlapping
+        replacements.sort(Replacement.COMPARATOR);
+
+        var writer = new StringBuilder();
+        // Copy up until the first replacement
+
+        writer.append(originalContent, 0, replacements.get(0).range().getStartOffset());
+        for (int i = 0; i < replacements.size(); i++) {
+            var replacement = replacements.get(i);
+            var range = replacement.range();
+            if (i > 0) {
+                // Copy between previous and current replacement verbatim
+                var previousReplacement = replacements.get(i - 1);
+                // validate that replacement ranges are non-overlapping
+                if (previousReplacement.range().getEndOffset() > range.getStartOffset()) {
+                    throw new IllegalStateException("Trying to replace overlapping ranges: "
+                            + replacement + " and " + previousReplacement);
+                }
+
+                writer.append(
+                        originalContent,
+                        previousReplacement.range().getEndOffset(),
+                        range.getStartOffset()
+                );
+            }
+            writer.append(replacement.newText());
+        }
+        writer.append(originalContent, replacements.get(replacements.size() - 1).range().getEndOffset(), originalContent.length());
+        return writer.toString();
+    }
+
+}

api/src/main/java/net/neoforged/jst/api/SourceTransformer.java

@@ -0,0 +1,13 @@
+package net.neoforged.jst.api;
+
+import com.intellij.psi.PsiFile;
+
+public interface SourceTransformer {
+    default void beforeRun() {
+    }
+
+    default void afterRun() {
+    }
+
+    void visitFile(PsiFile psiFile, Replacements replacements);
+}

api/src/main/java/net/neoforged/jst/api/SourceTransformerPlugin.java

@@ -0,0 +1,19 @@
+package net.neoforged.jst.api;
+
+/**
+ * Accessed via {@link java.util.ServiceLoader}.
+ */
+public interface SourceTransformerPlugin {
+
+    /**
+     * Unique name used in command-line options to enable this plugin.
+     */
+    String getName();
+
+    /**
+     * Creates a new transformer to be applied to source code.
+     */
+    SourceTransformer createTransformer();
+
+}
+

build.gradle

@@ -1,68 +1,12 @@
 plugins {
-    id 'java'
     id 'maven-publish'
-    id 'com.github.johnrengelman.shadow'
     id 'net.neoforged.gradleutils'
 }
 
 group = "net.neoforged"
 project.version = gradleutils.version
 
-jar {
-    manifest {
-        attributes 'Main-Class': 'ApplyParchmentToSourceJar'
-    }
+subprojects {
+    group = rootProject.group
+    version = rootProject.version
 }
-
-repositories {
-    mavenCentral()
-    maven {
-        url "https://www.jetbrains.com/intellij-repository/releases/"
-    }
-    maven {
-        url "https://cache-redirector.jetbrains.com/intellij-dependencies/"
-    }
-    maven {
-        url "https://maven.parchmentmc.org/"
-    }
-}
-
-dependencies {
-    implementation 'com.jetbrains.intellij.java:java-psi-impl:233.11799.300'
-
-    implementation 'org.parchmentmc.feather:io-gson:1.1.0'
-    implementation 'net.fabricmc:mapping-io:0.5.1'
-
-    testImplementation platform('org.junit:junit-bom:5.9.1')
-    testImplementation 'org.junit.jupiter:junit-jupiter'
-}
-
-test {
-    useJUnitPlatform()
-}
-
-assemble.configure {
-    dependsOn shadowJar
-}
-
-// This skips the shadowjar from being published as part of the normal publication
-components.java.withVariantsFromConfiguration(configurations.shadowRuntimeElements) {
-    skip()
-}
-
-publishing {
-    publications {
-        // This publication only contains the unshaded jar with dependencies in the pom.xml
-        plain(MavenPublication) {
-            artifactId = 'apply-parchment'
-
-            from components.java
-        }
-        // This publication only contains the shaded standalone jar
-        bundle(MavenPublication) {
-            artifactId = 'apply-parchment-bundle'
-
-            project.shadow.component(bundle)
-        }
-    }
-}

cli/build.gradle

@@ -0,0 +1,51 @@
+plugins {
+    id 'java'
+    id 'com.github.johnrengelman.shadow'
+}
+
+group = 'net.neoforged.jst'
+
+jar {
+    manifest {
+        attributes 'Main-Class': 'net.neoforged.jst.cli.Main'
+    }
+}
+
+dependencies {
+    implementation project(":api")
+    implementation "info.picocli:picocli:$picocli_version"
+    implementation project(":parchment")
+
+    testImplementation platform("org.junit:junit-bom:$junit_version")
+    testImplementation 'org.junit.jupiter:junit-jupiter'
+}
+
+test {
+    useJUnitPlatform()
+}
+
+assemble.configure {
+    dependsOn shadowJar
+}
+
+// This skips the shadowjar from being published as part of the normal publication
+components.java.withVariantsFromConfiguration(configurations.shadowRuntimeElements) {
+    skip()
+}
+
+publishing {
+    publications {
+        // This publication only contains the unshaded jar with dependencies in the pom.xml
+        plain(MavenPublication) {
+            artifactId = 'jst-cli'
+
+            from components.java
+        }
+        // This publication only contains the shaded standalone jar
+        bundle(MavenPublication) {
+            artifactId = 'jst-cli-bundle'
+
+            project.shadow.component(bundle)
+        }
+    }
+}