Probably compatible for newer versions

build.gradle

@@ -4,13 +4,13 @@ plugins {
 }
 
 apply plugin: 'maven-publish'
-version = "all-${mod_version}"
+version = project.mod_version
 group = 'me.fengming.vaultpatcher'
 
 println "Java: ${System.getProperty 'java.version'}, JVM: ${System.getProperty 'java.vm.version'} (${System.getProperty 'java.vendor'}), Arch: ${System.getProperty 'os.arch'}"
 
 jar {
-    baseName 'vaultpatcher'
+    archiveBaseName.set 'vaultpatcher'
 
     manifest {
         attributes([
@@ -25,16 +25,26 @@ jar {
         into 'META-INF/jars'
     }
 
-    filesMatching("fabric.mod.json") {
-        expand "version": mod_version
+    Map<String, Object> prop = [
+            version: project.mod_version,
+            description: project.mod_description,
+            license: project.mod_license,
+            repo: project.mod_repo,
+            homepage: project.mod_homepage,
+    ]
+
+    inputs.properties prop
+
+    filesMatching(["fabric.mod.json", "META-INF/neoforge.mods.toml"]) {
+        expand prop
     }
 
-    exclude "cpw"
+    archiveAppendix = 'all'
 }
 
 java {
     toolchain {
-        languageVersion.set(JavaLanguageVersion.of(8))
+        languageVersion.set(JavaLanguageVersion.of(21))
     }
     disableAutoTargetJvm()
 }
@@ -60,18 +70,52 @@ repositories {
     maven {
         url 'https://jitpack.io/'
     }
+    maven {
+        url 'https://maven.neoforged.net/releases'
+    }
+}
+
+sourceSets.register('java21') {
+//    java { srcDir 'src/java21/java' }
+    compileClasspath += sourceSets.main.output
+    runtimeClasspath += sourceSets.main.output
+}
+
+configurations {
+    named('java21Implementation') {
+        extendsFrom implementation
+    }
+}
+
+compileJava {
+    options.release = 8
+}
+
+tasks.named('compileJava21Java', JavaCompile.class) {
+    options.release = 21
+}
+
+jar {
+    from sourceSets.java21.output
 }
 
 dependencies {
     compileOnly 'org.jetbrains:annotations:23.0.0'
+    compileOnly project(':stub-lib')
 
     implementation 'com.google.code.gson:gson:2.2.4'
     implementation 'it.unimi.dsi:fastutil:7.0.10'
 
     implementation 'net.fabricmc:fabric-loader:0.14.12'
     implementation 'cpw.mods:modlauncher:8.1.3'
     implementation 'net.minecraft:launchwrapper:1.12'
+    java21Implementation ('net.neoforged.fancymodloader:loader:10.0.32') {
+        transitive = false
+    }
+    java21Implementation 'net.neoforged:mergetool:2.0.0:api'
 
     implementation 'com.github.Chocohead:Fabric-ASM:2.3'
 }
 
+
+

gradle.properties

@@ -1,4 +1,8 @@
 org.gradle.jvmargs=-Xmx3G
 org.gradle.daemon=false
 
-mod_version=1.4.6+2
+mod_version=1.4.7-alpha+6
+mod_description=Let the hard coded strings change into localization strings in some mods.
+mod_license=GPL-3.0
+mod_repo=https://github.com/3093FengMing/VaultPatcher
+mod_homepage=https://modrinth.com/mod/vault-patcher

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https://mirrors.cloud.tencent.com/gradle/gradle-7.5.1-bin.zip
+distributionUrl=https://mirrors.cloud.tencent.com/gradle/gradle-9.2.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

settings.gradle

@@ -4,3 +4,5 @@ pluginManagement {
         mavenCentral()
     }
 }
+
+include 'stub-lib'

src/java21/java/me/fengming/vaultpatcher_asm/loader/fancymodloader/ClassPatchProcessor.java

@@ -0,0 +1,31 @@
+package me.fengming.vaultpatcher_asm.loader.fancymodloader;
+
+import me.fengming.vaultpatcher_asm.core.patch.ClassPatcher;
+import me.fengming.vaultpatcher_asm.core.utils.Utils;
+import net.neoforged.neoforgespi.transformation.ProcessorName;
+import net.neoforged.neoforgespi.transformation.SimpleClassProcessor;
+import net.neoforged.neoforgespi.transformation.SimpleTransformationContext;
+import org.objectweb.asm.tree.ClassNode;
+
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public final class ClassPatchProcessor extends SimpleClassProcessor {
+    private static final ProcessorName NAME = VPClassProcessorProvider.processorName("class_patch");
+
+    @Override
+    public void transform(ClassNode input, SimpleTransformationContext context) {
+        ClassNode output = ClassPatcher.patch(input);
+        Utils.deepCopyClass(/*target=*/input, /*source=*/output);
+    }
+
+    @Override
+    public Set<Target> targets() {
+        return ClassPatcher.getPatches().keySet().stream().map(Target::new).collect(Collectors.toSet());
+    }
+
+    @Override
+    public ProcessorName name() {
+        return NAME;
+    }
+}

src/java21/java/me/fengming/vaultpatcher_asm/loader/fancymodloader/ExpandedClassProcessor.java

@@ -0,0 +1,36 @@
+package me.fengming.vaultpatcher_asm.loader.fancymodloader;
+
+import me.fengming.vaultpatcher_asm.config.VaultPatcherConfig;
+import me.fengming.vaultpatcher_asm.core.transformers.VPClassTransformer;
+import me.fengming.vaultpatcher_asm.core.utils.ModClassDiscovery;
+import me.fengming.vaultpatcher_asm.core.utils.StringUtils;
+import net.neoforged.neoforgespi.transformation.ProcessorName;
+import net.neoforged.neoforgespi.transformation.SimpleClassProcessor;
+import net.neoforged.neoforgespi.transformation.SimpleTransformationContext;
+import org.objectweb.asm.tree.ClassNode;
+
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+public final class ExpandedClassProcessor extends SimpleClassProcessor {
+    private static final ProcessorName NAME = VPClassProcessorProvider.processorName("mod");
+
+    @Override
+    public ProcessorName name() {
+        return NAME;
+    }
+
+    @Override
+    public void transform(ClassNode input, SimpleTransformationContext context) {
+        new VPClassTransformer(null).accept(input);
+    }
+
+    @Override
+    public Set<Target> targets() {
+        var set = new LinkedHashSet<Target>();
+        ModClassDiscovery.getApplyClassNames().map(Target::new).forEach(set::add);
+        VaultPatcherConfig.getClasses().stream().map(StringUtils::dotPackage).map(Target::new).forEach(set::add);
+
+        return set;
+    }
+}

src/java21/java/me/fengming/vaultpatcher_asm/loader/fancymodloader/TargetedClassProcessor.java

@@ -0,0 +1,43 @@
+package me.fengming.vaultpatcher_asm.loader.fancymodloader;
+
+import me.fengming.vaultpatcher_asm.config.TranslationInfo;
+import me.fengming.vaultpatcher_asm.core.transformers.VPClassTransformer;
+import me.fengming.vaultpatcher_asm.core.utils.StringUtils;
+import net.neoforged.neoforgespi.transformation.ProcessorName;
+import net.neoforged.neoforgespi.transformation.SimpleClassProcessor;
+import net.neoforged.neoforgespi.transformation.SimpleTransformationContext;
+import org.objectweb.asm.tree.ClassNode;
+
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public final class TargetedClassProcessor extends SimpleClassProcessor {
+    private static final ProcessorName NAME = VPClassProcessorProvider.processorName("targeted");
+    private final Set<TranslationInfo> translationInfos;
+
+    public TargetedClassProcessor(Set<TranslationInfo> translationInfos) {
+        Objects.requireNonNull(translationInfos);
+        this.translationInfos = translationInfos;
+    }
+
+    @Override
+    public void transform(ClassNode input, SimpleTransformationContext context) {
+        new VPClassTransformer(translationInfos).accept(input);
+    }
+
+    @Override
+    public Set<Target> targets() {
+        return translationInfos.stream()
+                .map(TranslationInfo::getTargetClass)
+                .filter(String::isBlank)
+                .map(StringUtils::dotPackage)
+                .map(Target::new)
+                .collect(Collectors.toSet());
+    }
+
+    @Override
+    public ProcessorName name() {
+        return NAME;
+    }
+}

src/java21/java/me/fengming/vaultpatcher_asm/loader/fancymodloader/VPClassProcessorProvider.java

@@ -0,0 +1,50 @@
+package me.fengming.vaultpatcher_asm.loader.fancymodloader;
+
+import me.fengming.vaultpatcher_asm.VaultPatcher;
+import me.fengming.vaultpatcher_asm.config.TranslationInfo;
+import me.fengming.vaultpatcher_asm.config.VaultPatcherConfig;
+import me.fengming.vaultpatcher_asm.core.utils.Platform;
+import me.fengming.vaultpatcher_asm.core.utils.Utils;
+import net.neoforged.api.distmarker.Dist;
+import net.neoforged.fml.loading.FMLEnvironment;
+import net.neoforged.fml.loading.FMLLoader;
+import net.neoforged.neoforgespi.transformation.ClassProcessorProvider;
+import net.neoforged.neoforgespi.transformation.ProcessorName;
+
+import java.util.Set;
+
+/**
+ * Register transformer for NeoForge 1.21.9+.
+ * @author teddyxlandlee
+ */
+public final class VPClassProcessorProvider implements ClassProcessorProvider {
+    public VPClassProcessorProvider() {
+        var loader = FMLLoader.getCurrent();
+
+        VaultPatcher.isClient = FMLEnvironment.getDist() == Dist.CLIENT;
+        VaultPatcher.platform = Platform.Neo21_9;   // Shall we get rid of the enum Platform?
+
+        VaultPatcher.init(loader.getGameDir(), loader.getVersionInfo().mcVersion());
+    }
+
+    @Override
+    public void createProcessors(Context context, Collector collector) {
+        // ClassPatch
+        if (VaultPatcherConfig.isEnableClassPatch()) {
+            collector.add(new ClassPatchProcessor());
+        }
+        // Dynamic
+        collector.add(new VanillaClassProcessor());
+        // Targeted
+        for (Set<TranslationInfo> translationInfos : Utils.translationInfoMap.values()) {
+            collector.add(new TargetedClassProcessor(translationInfos));
+        }
+
+        // Expanded
+        collector.add(new ExpandedClassProcessor());
+    }
+
+    static ProcessorName processorName(String name) {
+        return new ProcessorName("vaultpatcher", name);
+    }
+}

src/java21/java/me/fengming/vaultpatcher_asm/loader/fancymodloader/VanillaClassProcessor.java

@@ -0,0 +1,33 @@
+package me.fengming.vaultpatcher_asm.loader.fancymodloader;
+
+import me.fengming.vaultpatcher_asm.core.transformers.VPMinecraftTransformer;
+import net.neoforged.neoforgespi.transformation.ProcessorName;
+import net.neoforged.neoforgespi.transformation.SimpleClassProcessor;
+import net.neoforged.neoforgespi.transformation.SimpleTransformationContext;
+import org.objectweb.asm.tree.ClassNode;
+
+import java.util.Set;
+
+public final class VanillaClassProcessor extends SimpleClassProcessor {
+    private static final ProcessorName NAME = VPClassProcessorProvider.processorName("vanilla");
+
+    @Override
+    public void transform(ClassNode input, SimpleTransformationContext context) {
+        new VPMinecraftTransformer().accept(input);
+    }
+
+    @Override
+    public Set<Target> targets() {
+        return Set.of(
+                // Font, does it work in 1.21.6+?
+                new Target("net.minecraft.client.gui.Font"),
+                // TextComponent, 1.20.3+
+                new Target("net.minecraft.network.chat.contents.PlainTextContents$LiteralContents")
+        );
+    }
+
+    @Override
+    public ProcessorName name() {
+        return NAME;
+    }
+}

src/java21/resources/META-INF/services/net.neoforged.neoforgespi.transformation.ClassProcessorProvider

@@ -0,0 +1 @@
+me.fengming.vaultpatcher_asm.loader.fancymodloader.VPClassProcessorProvider

src/main/java/me/fengming/vaultpatcher_asm/VaultPatcher.java

@@ -28,6 +28,7 @@ public class VaultPatcher {
     public static List<VaultPatcherPlugin> plugins = new ArrayList<>();
     public static Path mcPath = null;
     public static String mcVersion = null;
+    @Deprecated
     public static Platform javaVersion = Platform.getJavaVersion(System.getProperty("java.specification.version"));
     public static Platform platform = Platform.UNDEFINED;
     public static boolean isClient = false;

src/main/java/me/fengming/vaultpatcher_asm/core/cache/Caches.java

@@ -3,7 +3,6 @@
 import me.fengming.vaultpatcher_asm.core.utils.Utils;
 import org.objectweb.asm.tree.ClassNode;
 
-import java.io.File;
 import java.io.IOException;
 import java.nio.file.FileVisitResult;
 import java.nio.file.Files;
@@ -18,10 +17,7 @@ public class Caches {
 
     public static void init(Path path) throws IOException {
         if (!Utils.debug.isUseCache()) return;
-        File file = path.toFile();
-        if (Files.notExists(path)) {
-            file.mkdirs();
-        }
+        Files.createDirectories(path);
         traverse(path);
     }
 
@@ -43,9 +39,9 @@ public static ClassCache getClassCache(String className) {
     }
 
     public static void addClassCache(String className, ClassNode node) {
-        File classFile = Utils.exportClass(node, Utils.getVpPath().resolve("cache"));
+        Path classFile = Utils.exportClass(node, Utils.getVpPath().resolve("cache"));
         try {
-            ClassCache cache = new ClassCache(classFile.getParentFile().toPath().resolve(classFile.getName() + ".sha256"), classFile.toPath());
+            ClassCache cache = new ClassCache(classFile.getParent().resolve(classFile.getFileName() + ".sha256"), classFile);
             cache.create(Utils.nodeToBytes(node));
             cacheMap.put(className, cache);
         } catch (IOException e) {

src/main/java/me/fengming/vaultpatcher_asm/core/misc/CommonSuperClassWriter.java

@@ -12,6 +12,12 @@ public CommonSuperClassWriter() {
 
     @Override
     protected String getCommonSuperClass(String type1, String type2) {
+        if (type1.equals(type2)) return type1;
+        if (type1.startsWith("java/") && type2.startsWith("java/")) {
+            // jdk platform types
+            return super.getCommonSuperClass(type1, type2);
+        }
+        // Prevent loading
         return "java/lang/Object";
     }
 }