add provides dependency type, add accesswidener processing, jij mod loading

build.gradle.kts

@@ -23,13 +23,15 @@ repositories {
 }
 
 dependencies {
-    implementation(libs.remapper)
+    implementation(libs.remapper){
+        isTransitive = false
+    }
     compileOnly("org.apache.logging.log4j:log4j-slf4j2-impl:3.0.0-beta2")
     compileOnly("org.apache.logging.log4j:log4j-api:3.0.0-beta2")
     compileOnly("org.apache.logging.log4j:log4j-core:3.0.0-beta2")
 
     api(libs.mixin)
-    api(libs.nightconfig)
+    implementation(libs.nightconfig)
     api(libs.annotations)
 }
 

minecraft/build.gradle.kts

@@ -21,5 +21,9 @@ minecraft("1.20.6")
 
 dependencies {
     implementation(project(":"))
-    annotationProcessor(libs.mixin)
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_21
+    targetCompatibility = JavaVersion.VERSION_21
 }

src/main/java/org/ecorous/esnesnon/nonsense/loader/api/extensions/PreLaunchExtension.java

@@ -1,11 +1,13 @@
 package org.ecorous.esnesnon.nonsense.loader.api.extensions;
 
+import org.ecorous.esnesnon.nonsense.loader.impl.mod.BuiltinExtensions;
+
 /**
  * The Pre-Launch Extension.
  * <p>This Extension is run right before the game is launched. (provided the used plugin supports it :) )</p>
  */
 public interface PreLaunchExtension {
-	String ID = "pre_launch";
+	String ID = BuiltinExtensions.PRE_LAUNCH;
 
 	void onPreLaunch();
 }

src/main/java/org/ecorous/esnesnon/nonsense/loader/api/mod/License.java

@@ -31,6 +31,8 @@ public final class License {
 		} catch (Exception e){
 			LoggerFactory.getLogger(License.class).warn("Failed to load license list!", e);
 		}
+		idToName.put("ARR", "All rights reserved");
+		idToName.put("", "Unknown License");
 	}
 
 	public static License fromId(String id){

src/main/java/org/ecorous/esnesnon/nonsense/loader/api/mod/ModDependencies.java

@@ -6,10 +6,11 @@ public final class ModDependencies {
 
 	private final Map<Type, Collection<Entry>> entries = new HashMap<>();
 
-	public ModDependencies(Collection<Entry> depends, Collection<Entry> breaks, Collection<Entry> suggests) {
+	public ModDependencies(Collection<Entry> depends, Collection<Entry> breaks, Collection<Entry> suggests, Collection<Entry> provides) {
 		entries.put(Type.DEPEND, depends);
 		entries.put(Type.BREAK, breaks);
 		entries.put(Type.SUGGEST, suggests);
+		entries.put(Type.PROVIDE, provides);
 	}
 
 	public Collection<Entry> getForType(Type type) {
@@ -51,6 +52,6 @@ public final class ModDependencies {
 	}
 
 	public enum Type {
-		DEPEND, BREAK, SUGGEST
+		DEPEND, BREAK, SUGGEST, PROVIDE
 	}
 }

src/main/java/org/ecorous/esnesnon/nonsense/loader/impl/mod/BuiltinExtensions.java

@@ -0,0 +1,11 @@
+package org.ecorous.esnesnon.nonsense.loader.impl.mod;
+
+import lombok.experimental.UtilityClass;
+
+@UtilityClass
+public class BuiltinExtensions {
+	public final String MIXIN_CONFIG = "mixin_config";
+	public final String INCLUDED_JARS = "included_jars";
+	public final String PRE_LAUNCH = "pre_launch";
+	public final String ACCESSWIDENER = "frog_aw";
+}

src/main/java/org/ecorous/esnesnon/nonsense/loader/impl/mod/ModPropertiesReader.java

@@ -61,6 +61,10 @@ public class ModPropertiesReader {
 			String version = config.get("frog.mod.version");
 			String license = config.get("frog.mod.license");
 
+			if (license == null){
+				license = "";
+			}
+
 			List<UnmodifiableConfig> creditsList = config.get("frog.mod.credits");
 			Map<String, Collection<String>> credits = new HashMap<>();
 			if (creditsList != null) {
@@ -68,8 +72,21 @@ public class ModPropertiesReader {
 			}
 
 			Collection<ModDependencies.Entry> depends = config.get("frog.dependencies.depends");
+			if (depends == null){
+				depends = Collections.emptySet();
+			}
 			Collection<ModDependencies.Entry> breaks = config.get("frog.dependencies.breaks");
+			if (breaks == null){
+				breaks = Collections.emptySet();
+			}
 			Collection<ModDependencies.Entry> suggests = config.get("frog.dependencies.suggests");
+			if (suggests == null){
+				suggests = Collections.emptySet();
+			}
+			Collection<ModDependencies.Entry> provides = config.get("frog.dependencies.provides");
+			if (provides == null){
+				provides = Collections.emptySet();
+			}
 
 			UnmodifiableConfig extensionsConfig = config.get("frog.extensions");
 			Map<String, Object> extensions = new HashMap<>();
@@ -77,7 +94,7 @@ public class ModPropertiesReader {
 				extensionsConfig.entrySet().forEach(entry -> extensions.put(entry.getKey(), entry.getValue()));
 			}
 
-			return new ModPropertiesImpl(id, name, SemVerImpl.parse(version), License.fromId(license), ModCredits.of(credits), new ModDependencies(depends, breaks, suggests), ModExtensions.of(extensions));
+			return new ModPropertiesImpl(id, name, SemVerImpl.parse(version), License.fromId(license), ModCredits.of(credits), new ModDependencies(depends, breaks, suggests, provides), ModExtensions.of(extensions));
 		});
 
 		private final String version;

src/main/java/org/ecorous/esnesnon/nonsense/loader/impl/plugin/game/minecraft/AWProcessor.java

@@ -0,0 +1,208 @@
+package org.ecorous.esnesnon.nonsense.loader.impl.plugin.game.minecraft;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.file.*;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.*;
+import java.util.function.Predicate;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import lombok.AllArgsConstructor;
+import org.ecorous.esnesnon.nonsense.loader.api.mod.ModProperties;
+import org.ecorous.esnesnon.nonsense.loader.impl.mod.BuiltinExtensions;
+import org.objectweb.asm.*;
+
+/**
+ * Minimal implementation of accesswideners.
+ * (Untested)
+ */
+
+class AWProcessor {
+
+	private static final String AW_EXTENSION_NAME = BuiltinExtensions.ACCESSWIDENER;
+	private static final Predicate<String> HEADER = Pattern.compile("accessWidener\\s+v[12]").asMatchPredicate();
+	private static final Predicate<String> COMMENT = Pattern.compile("^#.*").asMatchPredicate();
+	private static final Pattern SEPARATOR = Pattern.compile("[\\t ]+");
+
+	static void apply(Collection<ModProperties> mods, Path input, Path output) throws IOException {
+		List<Entry> entries = mods.parallelStream().map(ModProperties::extensions).map(e -> (String) e.get(AW_EXTENSION_NAME))
+				.filter(Objects::nonNull).map(AWProcessor.class::getResourceAsStream).filter(Objects::nonNull)
+				.map(InputStreamReader::new).map(BufferedReader::new).flatMap(BufferedReader::lines)
+				.filter(l -> !l.isBlank()).filter(l -> !COMMENT.test(l)).filter(l -> !HEADER.test(l)).distinct()
+				.map(l -> l.replace("transitive-", "")) // ignore all transitive declarations (just make them normal) as they're only relevant for dev envs
+				.map(SEPARATOR::matcher).filter(Matcher::matches).map(Entry::new).toList();
+
+		Map<String, Entry> classMap = new HashMap<>();
+		Map<String, Map<String, Entry>> methods = new HashMap<>();
+		Map<String, Map<String, Entry>> fields = new HashMap<>();
+		Map<String, Map<String, Entry>> mutations = new HashMap<>();
+		entries.forEach(e -> {
+			if ("class".equals(e.targetType)) {
+				if (e.type == AccessType.MUTABLE){
+					throw new IllegalArgumentException("aw format error: classes can not have a 'mutable' modifier (at: "+e+")");
+				}
+				if (!classMap.containsKey(e.className)) {
+					classMap.put(e.className, e);
+				} else {
+					var other = classMap.get(e.className);
+					if (e.isAccessGreaterThan(other)) {
+						classMap.put(e.className, e);
+					}
+				}
+			} else if ("method".equals(e.targetType)) {
+				if (e.type == AccessType.MUTABLE){
+					throw new IllegalArgumentException("aw format error: methods can not have a 'mutable' modifier (at: "+e+")");
+				}
+				var map = methods.computeIfAbsent(e.className, s -> new HashMap<>());
+				var id = e.name + e.descriptor;
+				if (!map.containsKey(id)) {
+					map.put(id, e);
+				} else {
+					var other = map.get(id);
+					if (e.isAccessGreaterThan(other)) {
+						classMap.put(id, e);
+					}
+				}
+			} else if ("field".equals(e.targetType)) {
+				if (e.type == AccessType.EXTENDABLE){
+					throw new IllegalArgumentException("aw format error: fields can not have a 'extendable' modifier (at: "+e+")");
+				}
+				var map = fields.computeIfAbsent(e.className, s -> new HashMap<>());
+				var id = e.name + e.descriptor;
+				if (e.type == AccessType.MUTABLE){
+					mutations.computeIfAbsent(e.className, s -> new HashMap<>()).putIfAbsent(id, e);
+					return;
+				}
+
+				if (!map.containsKey(id)) {
+					map.put(id, e);
+				} else {
+					var other = map.get(id);
+					if (e.isAccessGreaterThan(other)) {
+						classMap.put(id, e);
+					}
+				}
+			}
+		});
+
+		Files.deleteIfExists(output);
+
+		try (FileSystem in = FileSystems.newFileSystem(input.toAbsolutePath());
+			 FileSystem out = FileSystems.newFileSystem(output, Map.of("create", "true"))) {
+
+			Files.walkFileTree(in.getPath("/"), new SimpleFileVisitor<>() {
+				@Override
+				public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+					Path output = out.getPath(file.toString());
+					Files.createDirectories(output.getParent());
+					if (file.getFileName().toString().endsWith(".class")) {
+
+						var className = file.toString().substring(0, file.toString().length() - 6);
+						ClassReader reader = new ClassReader(Files.newInputStream(file));
+						ClassWriter writer = new ClassWriter(0);
+						ClassVisitor mapper = new ClassVisitor(Opcodes.ASM9, writer) {
+							@Override
+							public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+								Entry e = classMap.get(className);
+								if (e != null) {
+									access = ~(Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED | Opcodes.ACC_PUBLIC);
+									access |= e.type.access;
+								} else if (fields.containsKey(className) || methods.containsKey(className) || mutations.containsKey(className)) { // make all classes with modifications public as well
+									access = ~(Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED | Opcodes.ACC_PUBLIC);
+									access |= Opcodes.ACC_PUBLIC;
+								}
+								super.visit(version, access, name, signature, superName, interfaces);
+							}
+
+							@Override
+							public FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value) {
+								Map<String, Entry> map = fields.get(className);
+								if (map != null) {
+									Entry e = map.get(name + descriptor);
+									if (e != null) {
+										access = ~(Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED | Opcodes.ACC_PUBLIC); // remove all access modifiers
+										access |= e.type.access; // re-add the new one
+									}
+								}
+								if ((map = mutations.get(className)) != null){
+									var e = map.get(name+descriptor);
+									if (e != null) {
+										access |= ~Opcodes.ACC_FINAL; // always AccessType.MUTABLE
+									}
+								}
+								return super.visitField(access, name, descriptor, signature, value);
+							}
+
+							@Override
+							public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
+								Map<String, Entry> map = methods.get(className);
+								if (map != null) {
+									Entry e = map.get(name + descriptor);
+									if (e != null) {
+										access = ~(Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED | Opcodes.ACC_PUBLIC);
+										access |= e.type.access;
+									}
+								}
+								return super.visitMethod(access, name, descriptor, signature, exceptions);
+							}
+						};
+
+						reader.accept(mapper, 0);
+
+						Files.write(output, writer.toByteArray());
+					} else {
+						Files.copy(file, output);
+					}
+					return FileVisitResult.CONTINUE;
+				}
+			});
+		}
+	}
+
+	private record Entry(AccessType type, String targetType, String className, String name, String descriptor) {
+
+		public Entry(Matcher line) {
+			this(AccessType.of(line.group(1)), line.group(2), line.group(3), line.group(4), line.group(5));
+		}
+
+		public boolean isAccessGreaterThan(Entry other) {
+			return Access.of(type().access).index < Access.of(other.type.access).index;
+		}
+	}
+
+	@AllArgsConstructor
+	private enum AccessType {
+		ACCESSIBLE("accessible", Opcodes.ACC_PUBLIC),
+		EXTENDABLE("extendable", Opcodes.ACC_PROTECTED),
+		MUTABLE("mutable", ~Opcodes.ACC_FINAL)
+		;
+		private final String id;
+		private final int access;
+
+		public static AccessType of(String name) {
+			return Arrays.stream(values()).filter(a -> a.id.equals(name)).findFirst().orElseThrow(() -> new IllegalStateException("Unknown access type: " + name));
+		}
+	}
+
+	@AllArgsConstructor
+	private enum Access {
+		PUBLIC(1), PROTECTED(2), PACKAGE_PRIVATE(3), PRIVATE(4);
+		private final int index;
+
+		public static Access of(int access) {
+			if ((access & Opcodes.ACC_PUBLIC) != 0) {
+				return PUBLIC;
+			}
+			if ((access & Opcodes.ACC_PROTECTED) != 0) {
+				return PROTECTED;
+			}
+			if ((access & Opcodes.ACC_PRIVATE) != 0) {
+				return PRIVATE;
+			}
+			return PACKAGE_PRIVATE;
+		}
+	}
+}

src/main/java/org/ecorous/esnesnon/nonsense/loader/impl/plugin/game/minecraft/Minecraft.java

@@ -1,18 +1,5 @@
 package org.ecorous.esnesnon.nonsense.loader.impl.plugin.game.minecraft;
 
-import com.google.gson.JsonObject;
-import org.ecorous.esnesnon.nonsense.loader.api.extensions.PreLaunchExtension;
-import org.ecorous.esnesnon.nonsense.loader.api.mod.*;
-import org.ecorous.esnesnon.nonsense.loader.impl.Discovery;
-import org.ecorous.esnesnon.nonsense.loader.impl.LoaderImpl;
-import org.ecorous.esnesnon.nonsense.loader.impl.mod.ModPropertiesImpl;
-import org.ecorous.esnesnon.nonsense.loader.impl.mod.ModPropertiesReader;
-import org.ecorous.esnesnon.nonsense.loader.impl.plugin.NonsensePlugin;
-import org.ecorous.esnesnon.nonsense_remapper.NonsenseRemapper;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.spongepowered.asm.mixin.Mixins;
-
 import java.io.File;
 import java.io.IOException;
 import java.lang.invoke.MethodHandle;
@@ -23,6 +10,20 @@ import java.net.URL;
 import java.nio.file.*;
 import java.util.*;
 
+import com.google.gson.JsonObject;
+import org.ecorous.esnesnon.nonsense.loader.api.extensions.PreLaunchExtension;
+import org.ecorous.esnesnon.nonsense.loader.api.mod.*;
+import org.ecorous.esnesnon.nonsense.loader.impl.Discovery;
+import org.ecorous.esnesnon.nonsense.loader.impl.LoaderImpl;
+import org.ecorous.esnesnon.nonsense.loader.impl.mod.BuiltinExtensions;
+import org.ecorous.esnesnon.nonsense.loader.impl.mod.ModPropertiesImpl;
+import org.ecorous.esnesnon.nonsense.loader.impl.mod.ModPropertiesReader;
+import org.ecorous.esnesnon.nonsense.loader.impl.plugin.NonsensePlugin;
+import org.ecorous.esnesnon.nonsense_remapper.NonsenseRemapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spongepowered.asm.mixin.Mixins;
+
 public class Minecraft implements NonsensePlugin {
 
 	private static final Logger LOGGER = LoggerFactory.getLogger("Plugin/Minecraft");
@@ -45,9 +46,12 @@ public class Minecraft implements NonsensePlugin {
 
 	@Override
 	public void init(LoaderImpl loader) throws Exception {
+		if (gamePath == null){
+			throw new IllegalStateException("Game not found yet!");
+		}
 		Path remappedGamePath = loader.getGameDir().resolve(".nonsense/remappedJars").resolve(version).resolve("game-" + version + "-remapped.jar");
 
-		if (!Files.exists(remappedGamePath)){
+		if (!Files.exists(remappedGamePath.getParent())) {
 			try {
 				Files.createDirectories(remappedGamePath.getParent());
 			} catch (IOException e) {
@@ -58,14 +62,19 @@ public class Minecraft implements NonsensePlugin {
 		modProperties.add(new ModPropertiesImpl("minecraft", "Minecraft",
 				new MinecraftSemVerImpl(version), License.custom("MC-EULA", "Minecraft EULA"),
 				ModCredits.of(Map.of("Mojang AB", Collections.singleton("Author"))),
-				new ModDependencies(Collections.emptySet(), Collections.emptySet(), Collections.emptySet()),
+				new ModDependencies(Collections.emptySet(), Collections.emptySet(), Collections.emptySet(), Collections.emptySet()),
 				ModExtensions.of(Collections.emptyMap())));
 
 		Collection<Path> mods = Discovery.find(loader.getModsDir(), path ->
 				version.equals(path.getFileName().toString()), path ->
 				path.getFileName().toString().endsWith(LoaderImpl.MOD_FILE_EXTENSION));
-		// TODO add mods found on the classpath
 		Collection<URL> classpathMods = this.getClass().getClassLoader().resources(ModPropertiesReader.PROPERTIES_FILE_NAME).distinct().toList();
+
+		classpathMods.parallelStream().map(ModPropertiesReader::readFile).forEachOrdered(modProperties::add);
+		for (Path mod : new HashSet<>(mods)) {
+			findJiJMods(mod, mods);
+		}
+
 		mods.parallelStream().map(Path::toUri).map(uri -> {
 			try {
 				return uri.toURL();
@@ -74,28 +83,49 @@ public class Minecraft implements NonsensePlugin {
 			}
 		}).forEachOrdered(LoaderImpl.getInstance().getClassloader()::addURL);
 
-		classpathMods.parallelStream().map(ModPropertiesReader::readFile).forEachOrdered(modProperties::add);
+		// TODO respect mod dependencies and display errors appropriately
-		mods.parallelStream().map(ModPropertiesReader::read).forEachOrdered(opt -> opt.ifPresent(modProperties::add));
 
 		modProperties.parallelStream().forEach(props -> {
-			String name = props.extensions().get("mixin_config");
+			String name = props.extensions().get(BuiltinExtensions.MIXIN_CONFIG);
 			if (name != null) {
 				Mixins.addConfiguration(name);
 			}
 		});
 
-		if (!Files.exists(remappedGamePath) && !loader.isDevelopment()){
+		if (!Files.exists(remappedGamePath)) {
-			try {
+			if (!loader.isDevelopment()) {
 				NonsenseRemapper.run(version, gamePath, remappedGamePath, true, false);
-			} catch (Throwable e) {
+			} else {
-				throw new RuntimeException(e);
+				Files.copy(gamePath, remappedGamePath);
 			}
 		}
 
+		Path runtimePath = remappedGamePath.resolveSibling("game-" + version + "-runtime.jar");
+		AWProcessor.apply(modProperties, remappedGamePath, runtimePath);
+		Runtime.getRuntime().addShutdownHook(new Thread(() -> {
 			try {
-			LoaderImpl.getInstance().getClassloader().addURL(remappedGamePath.toUri().toURL());
+				Files.deleteIfExists(runtimePath);
-		} catch (Throwable e) {
+			} catch (IOException ignored) {
-			throw new RuntimeException(e);
+			}
+		}));
+
+
+		LoaderImpl.getInstance().getClassloader().addURL(runtimePath.toUri().toURL());
+	}
+
+	private void findJiJMods(Path mod, Collection<Path> mods) throws IOException {
+		Optional<ModProperties> opt = ModPropertiesReader.read(mod);
+		if (opt.isPresent()) {
+			ModProperties p = opt.get();
+			modProperties.add(p);
+			List<String> jars = p.extensions().getOrDefault(BuiltinExtensions.INCLUDED_JARS, Collections.emptyList());
+			try (FileSystem fs = FileSystems.newFileSystem(mod)){
+				for (String jar : jars) {
+					Path path = fs.getPath(jar);
+					mods.add(path);
+					findJiJMods(path, mods);
+				}
+			}
 		}
 	}