From 4827207f64ff7f7f5805a612129f549ace1a3507 Mon Sep 17 00:00:00 2001 From: Mumfrey Date: Mon, 28 Jun 2021 19:58:02 +0100 Subject: [PATCH 1/6] Make compat warnings less spammy but more verbose. Add MAX_SUPPORTED. --- .../asm/mixin/MixinEnvironment.java | 49 ++++++++++-- .../asm/mixin/transformer/MixinConfig.java | 79 ++++++++++++++++--- .../mixin/transformer/MixinTargetContext.java | 7 +- 3 files changed, 111 insertions(+), 24 deletions(-) diff --git a/src/main/java/org/spongepowered/asm/mixin/MixinEnvironment.java b/src/main/java/org/spongepowered/asm/mixin/MixinEnvironment.java index 34bff3bb..69869c3c 100644 --- a/src/main/java/org/spongepowered/asm/mixin/MixinEnvironment.java +++ b/src/main/java/org/spongepowered/asm/mixin/MixinEnvironment.java @@ -663,6 +663,28 @@ public final class MixinEnvironment implements ITokenProvider { */ public static CompatibilityLevel DEFAULT = CompatibilityLevel.JAVA_6; + /** + * Maximum compatibility level actually supported. Other compatibility + * levels might exist but we don't actually have any internal code in + * place which supports those features. This is mainly used to indicate + * that mixin classes compiled with newer JDKs might have bytecode-level + * class features that this version of mixin doesn't understand, even + * when the current ASM or JRE do. + * + *

This is particularly important for the case where a config + * declares a higher version (eg. JAVA_14) which has been added to the + * enum but no code actually exists within Mixin as a library to handle + * language features from that version. In other words adding values to + * this enum doesn't magically add support for language features, and + * this field should point to the highest known supported + * version regardless of other known versions.

+ * + *

This comment mainly added to avoid stuff in the future like + * PR #500 which demonstrates that the nature of compatibility levels + * in mixin are not understood that well.

+ */ + public static CompatibilityLevel MAX_SUPPORTED = CompatibilityLevel.JAVA_11; + private final int ver; private final int classVersion; @@ -808,13 +830,28 @@ public final class MixinEnvironment implements ITokenProvider { static String getSupportedVersions() { StringBuilder sb = new StringBuilder(); boolean comma = false; + int rangeStart = 0, rangeEnd = 0; for (CompatibilityLevel level : CompatibilityLevel.values()) { if (level.isSupported()) { - if (comma) { - sb.append(", "); + if (level.ver == rangeEnd + 1) { + rangeEnd = level.ver; + } else { + if (rangeStart > 0) { + sb.append(comma ? "," : "").append(rangeStart); + if (rangeEnd > rangeStart) { + sb.append(rangeEnd > rangeStart + 1 ? '-' : ',').append(rangeEnd); + } + comma = true; + rangeStart = rangeEnd = level.ver; + } + rangeStart = rangeEnd = level.ver; } - sb.append(level.ver); - comma = true; + } + } + if (rangeStart > 0) { + sb.append(comma ? "," : "").append(rangeStart); + if (rangeEnd > rangeStart) { + sb.append(rangeEnd > rangeStart + 1 ? '-' : ',').append(rangeEnd); } } return sb.toString(); @@ -998,8 +1035,8 @@ public final class MixinEnvironment implements ITokenProvider { printer.add("SpongePowered MIXIN%s", verbose ? " (Verbose debugging enabled)" : "").centre().hr(); printer.kv("Code source", codeSource); printer.kv("Internal Version", version); - printer.kv("Java Versions Supported", CompatibilityLevel.getSupportedVersions()); - printer.kv("Current Compatibility Level", MixinEnvironment.getCompatibilityLevel()); + printer.kv("Java Version", "%s (supports compatibility %s)", JavaVersion.current(), CompatibilityLevel.getSupportedVersions()); + printer.kv("Default Compatibility Level", MixinEnvironment.getCompatibilityLevel()); printer.kv("Detected ASM API Version", ASM.getApiVersionString()); printer.kv("Detected ASM Supports Java", ASM.getClassVersionString()).hr(); printer.kv("Service Name", serviceName); diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java index 204b46e6..913b7e06 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java @@ -370,6 +370,17 @@ final class MixinConfig implements Comparable, IMixinConfig { * Track whether this mixin has been evaluated for selection yet */ private transient boolean visited = false; + + /** + * Compatibility level read from the config (or default if none specified) + */ + private transient CompatibilityLevel compatibilityLevel = CompatibilityLevel.DEFAULT; + + /** + * Only emit the compatibility level warning for any increase in the class + * version, track warned level here + */ + private transient int warnedClassVersion = 0; /** * Spawn via GSON, no public ctor for you @@ -397,6 +408,7 @@ final class MixinConfig implements Comparable, IMixinConfig { // If no parent, initialise config options this.env = this.parseSelector(this.selector, fallbackEnvironment); + this.verboseLogging |= this.env.getOption(Option.DEBUG_VERBOSE); this.required = this.requiredValue != null && this.requiredValue.booleanValue() && !this.env.getOption(Option.IGNORE_REQUIRED); this.initPriority(IMixinConfig.DEFAULT_PRIORITY, IMixinConfig.DEFAULT_PRIORITY); @@ -440,6 +452,7 @@ final class MixinConfig implements Comparable, IMixinConfig { } this.env = this.parseSelector(this.selector, this.parent.env); + this.verboseLogging |= this.env.getOption(Option.DEBUG_VERBOSE); this.required = this.requiredValue == null ? this.parent.required : this.requiredValue.booleanValue() && !this.env.getOption(Option.IGNORE_REQUIRED); @@ -486,31 +499,74 @@ final class MixinConfig implements Comparable, IMixinConfig { @SuppressWarnings("deprecation") private void initCompatibilityLevel() { + this.compatibilityLevel = MixinEnvironment.getCompatibilityLevel(); + if (this.compatibility == null) { return; } - CompatibilityLevel level = CompatibilityLevel.valueOf(this.compatibility.trim().toUpperCase(Locale.ROOT)); - CompatibilityLevel current = MixinEnvironment.getCompatibilityLevel(); + String strCompatibility = this.compatibility.trim().toUpperCase(Locale.ROOT); + try { + this.compatibilityLevel = CompatibilityLevel.valueOf(strCompatibility); + } catch (IllegalArgumentException ex) { + throw new MixinInitialisationError(String.format("Mixin config %s specifies compatibility level %s which is not recognised", + this.name, strCompatibility)); + } - if (level == current) { + CompatibilityLevel currentLevel = MixinEnvironment.getCompatibilityLevel(); + if (this.compatibilityLevel == currentLevel) { return; } // Current level is higher than required but too new to support it - if (current.isAtLeast(level)) { - if (!current.canSupport(level)) { - throw new MixinInitialisationError("Mixin config " + this.name + " requires compatibility level " + level + " which is too old"); - } + if (currentLevel.isAtLeast(this.compatibilityLevel) && !currentLevel.canSupport(this.compatibilityLevel)) { + throw new MixinInitialisationError(String.format("Mixin config %s requires compatibility level %s which is too old", + this.name, this.compatibilityLevel)); } // Current level is lower than required but current level prohibits elevation - if (!current.canElevateTo(level)) { - throw new MixinInitialisationError("Mixin config " + this.name + " requires compatibility level " + level + " which is prohibited by " - + current); + if (!currentLevel.canElevateTo(this.compatibilityLevel)) { + throw new MixinInitialisationError(String.format("Mixin config %s requires compatibility level %s which is prohibited by %s", + this.name, this.compatibilityLevel, currentLevel)); } - MixinEnvironment.setCompatibilityLevel(level); + // Required level is higher than highest version we support, this possibly + // means that a shaded mixin dependency has been usurped by an old version, + // or the mixin author is trying to elevate the compatibility level beyond + // the versions currently supported + if (CompatibilityLevel.MAX_SUPPORTED.isLessThan(this.compatibilityLevel)) { + Level logLevel = this.verboseLogging ? Level.WARN : Level.DEBUG; + this.logger.log(logLevel, + "Compatibility level {} specified by {} is higher than the maximum level supported by this version of mixin ({}).", + this.compatibilityLevel, this, CompatibilityLevel.MAX_SUPPORTED); + } + + MixinEnvironment.setCompatibilityLevel(this.compatibilityLevel); + } + + /** + * Called by MixinTargetContext when class version is elevated, allows us to + * warn devs (or end-users with verbose turned on, for whatever reason) that + * the current compatibility level is too low for the classes being + * processed. The warning is only emitted at WARN for each new class version + * and at DEBUG thereafter. + * + *

The logic here is that we only really care about supported class + * features, but a version of mixin which doesn't actually support newer + * features may well be able to operate with classes *compiled* with a newer + * JDK, but we don't actually know that for sure). + */ + void checkCompatibilityLevel(MixinInfo mixin, int majorVersion, int minorVersion) { + if (majorVersion <= this.compatibilityLevel.getClassMajorVersion()) { + return; + } + + Level logLevel = this.verboseLogging && majorVersion > this.warnedClassVersion ? Level.WARN : Level.DEBUG; + String message = majorVersion > CompatibilityLevel.MAX_SUPPORTED.getClassMajorVersion() + ? "the current version of Mixin" : "the declared compatibility level"; + this.warnedClassVersion = majorVersion; + this.logger.log(logLevel, "{}: Class version {} required is higher than the class version supported by {} ({} supports class version {})", + mixin, majorVersion, message, this.compatibilityLevel, this.compatibilityLevel.getClassMajorVersion()); } // AMS - temp @@ -655,7 +711,6 @@ final class MixinConfig implements Comparable, IMixinConfig { } this.refMapper = ReferenceMapper.read(this.refMapperConfig); - this.verboseLogging |= this.env.getOption(Option.DEBUG_VERBOSE); if (!suppressRefMapWarning && this.refMapper.isDefault() && !this.env.getOption(Option.DISABLE_REFMAP)) { this.logger.warn("Reference map '{}' for {} could not be read. If this is a development environment you can ignore this message", diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTargetContext.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTargetContext.java index 51f2077d..96767c46 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTargetContext.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTargetContext.java @@ -1088,12 +1088,7 @@ public class MixinTargetContext extends ClassContext implements IMixinContext { majorVersion, minorVersion, ASM.getClassVersionString())); } - CompatibilityLevel compatibilityLevel = MixinEnvironment.getCompatibilityLevel(); - if (majorVersion > compatibilityLevel.getClassMajorVersion()) { - MixinTargetContext.logger.warn( - "{}: Class version {}.{} required is higher than the class version supported by the current compatibility level {} ", - this, majorVersion, minorVersion, compatibilityLevel); - } + this.mixin.getParent().checkCompatibilityLevel(this.mixin, majorVersion, minorVersion); } /* (non-Javadoc) From dcc124d48730050e7570a5c3f58bc7dcfda76d3d Mon Sep 17 00:00:00 2001 From: Mumfrey Date: Mon, 28 Jun 2021 20:42:37 +0100 Subject: [PATCH 2/6] Don't crash when config package is null, for empty common parent configs --- .../asm/mixin/transformer/MixinConfig.java | 32 ++++++++++++++----- 1 file changed, 24 insertions(+), 8 deletions(-) diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java index 913b7e06..24edb1d8 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java @@ -693,7 +693,11 @@ final class MixinConfig implements Comparable, IMixinConfig { */ void onSelect() { this.plugin = new PluginHandle(this, this.service, this.pluginClassName); - this.plugin.onLoad(this.mixinPackage); + this.plugin.onLoad(Strings.nullToEmpty(this.mixinPackage)); + + if (Strings.isNullOrEmpty(this.mixinPackage)) { + return; + } if (!this.mixinPackage.endsWith(".")) { this.mixinPackage += "."; @@ -757,14 +761,14 @@ final class MixinConfig implements Comparable, IMixinConfig { } this.prepared = true; - this.prepareMixins(this.mixinClasses, false); + this.prepareMixins("mixins", this.mixinClasses, false); switch (this.env.getSide()) { case CLIENT: - this.prepareMixins(this.mixinClassesClient, false); + this.prepareMixins("client", this.mixinClassesClient, false); break; case SERVER: - this.prepareMixins(this.mixinClassesServer, false); + this.prepareMixins("server", this.mixinClassesServer, false); break; case UNKNOWN: //$FALL-THROUGH$ @@ -777,7 +781,7 @@ final class MixinConfig implements Comparable, IMixinConfig { void postInitialise() { if (this.plugin != null) { List pluginMixins = this.plugin.getMixins(); - this.prepareMixins(pluginMixins, true); + this.prepareMixins("companion plugin", pluginMixins, true); } for (Iterator iter = this.mixins.iterator(); iter.hasNext();) { @@ -809,11 +813,19 @@ final class MixinConfig implements Comparable, IMixinConfig { } } - private void prepareMixins(List mixinClasses, boolean ignorePlugin) { + private void prepareMixins(String collectionName, List mixinClasses, boolean ignorePlugin) { if (mixinClasses == null) { return; } + if (Strings.isNullOrEmpty(this.mixinPackage)) { + if (mixinClasses.size() > 0) { + this.logger.error("{} declares mixin classes in {} but does not specify a package, {} orphaned mixins will not be loaded: {}", + this, collectionName, mixinClasses.size(), mixinClasses); + } + return; + } + for (String mixinClass : mixinClasses) { String fqMixinClass = this.mixinPackage + mixinClass; @@ -917,7 +929,7 @@ final class MixinConfig implements Comparable, IMixinConfig { */ @Override public String getMixinPackage() { - return this.mixinPackage; + return Strings.nullToEmpty(this.mixinPackage); } /** @@ -1022,6 +1034,10 @@ final class MixinConfig implements Comparable, IMixinConfig { */ @SuppressWarnings({"unchecked", "rawtypes"}) public List getClasses() { + if (Strings.isNullOrEmpty(this.mixinPackage)) { + return Collections.emptyList(); + } + Builder list = ImmutableList.builder(); for (List classes : new List[] { this.mixinClasses, this.mixinClassesClient, this.mixinClassesServer} ) { if (classes != null) { @@ -1113,7 +1129,7 @@ final class MixinConfig implements Comparable, IMixinConfig { * package */ public boolean packageMatch(String className) { - return className.startsWith(this.mixinPackage); + return !Strings.isNullOrEmpty(this.mixinPackage) && className.startsWith(this.mixinPackage); } /** From 828f9943f5b3e26fc7a29a600f73c597cc03b941 Mon Sep 17 00:00:00 2001 From: Mumfrey Date: Mon, 28 Jun 2021 20:49:17 +0100 Subject: [PATCH 3/6] Use service ClassProvider instead of Class.forName for refmap wrappers --- .../org/spongepowered/asm/mixin/transformer/MixinConfig.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java index 24edb1d8..71380fca 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java @@ -729,7 +729,7 @@ final class MixinConfig implements Comparable, IMixinConfig { String wrapperName = this.mixinPackage + this.refMapperWrapper; try { @SuppressWarnings("unchecked") - Class wrapperCls = (Class) Class.forName(wrapperName); + Class wrapperCls = (Class) this.service.getClassProvider().findClass(wrapperName, true); Constructor ctr = wrapperCls.getConstructor(MixinEnvironment.class, IReferenceMapper.class); this.refMapper = ctr.newInstance(this.env, this.refMapper); } catch (ClassNotFoundException e) { From dfa5a70fc3d4da7889daa71899d3e3167353171f Mon Sep 17 00:00:00 2001 From: Mumfrey Date: Wed, 30 Jun 2021 18:45:55 +0100 Subject: [PATCH 4/6] Support current fernflower and forgeflower with this one simple trick --- .../transformer/debug/RuntimeDecompiler.java | 36 ++++++++++++++++--- .../extensions/ExtensionClassExporter.java | 4 +-- 2 files changed, 34 insertions(+), 6 deletions(-) diff --git a/src/fernflower/java/org/spongepowered/asm/mixin/transformer/debug/RuntimeDecompiler.java b/src/fernflower/java/org/spongepowered/asm/mixin/transformer/debug/RuntimeDecompiler.java index 931e3ad8..579bfae6 100644 --- a/src/fernflower/java/org/spongepowered/asm/mixin/transformer/debug/RuntimeDecompiler.java +++ b/src/fernflower/java/org/spongepowered/asm/mixin/transformer/debug/RuntimeDecompiler.java @@ -26,6 +26,8 @@ package org.spongepowered.asm.mixin.transformer.debug; import java.io.File; import java.io.IOException; +import java.lang.reflect.Method; +import java.net.URL; import java.util.Map; import java.util.jar.Manifest; @@ -35,6 +37,7 @@ import org.apache.logging.log4j.Logger; import org.jetbrains.java.decompiler.main.Fernflower; import org.jetbrains.java.decompiler.main.extern.IBytecodeProvider; import org.jetbrains.java.decompiler.main.extern.IFernflowerLogger; +import org.jetbrains.java.decompiler.main.extern.IFernflowerPreferences; import org.jetbrains.java.decompiler.main.extern.IResultSaver; import org.jetbrains.java.decompiler.util.InterpreterUtil; import org.spongepowered.asm.mixin.transformer.ext.IDecompiler; @@ -53,8 +56,14 @@ public class RuntimeDecompiler extends IFernflowerLogger implements IDecompiler, private static final Level[] SEVERITY_LEVELS = { Level.TRACE, Level.INFO, Level.WARN, Level.ERROR }; private final Map options = ImmutableMap.builder() - .put("din", "0").put("rbr", "0").put("dgs", "1").put("asc", "1") - .put("den", "1").put("hdc", "1").put("ind", " ").build(); + .put(IFernflowerPreferences.DECOMPILE_INNER, "0") + .put(IFernflowerPreferences.REMOVE_BRIDGE, "0") + .put(IFernflowerPreferences.DECOMPILE_GENERIC_SIGNATURES, "1") + .put(IFernflowerPreferences.ASCII_STRING_CHARACTERS, "1") + .put(IFernflowerPreferences.DECOMPILE_ENUM, "1") + .put(IFernflowerPreferences.HIDE_DEFAULT_CONSTRUCTOR, "1") + .put(IFernflowerPreferences.INDENT_STRING, " ") + .build(); private final File outputPath; @@ -70,6 +79,17 @@ public class RuntimeDecompiler extends IFernflowerLogger implements IDecompiler, } } } + + @Override + public String toString() { + try { + URL codeSource = Fernflower.class.getProtectionDomain().getCodeSource().getLocation(); + File file = new File(codeSource.toURI()); + return file.getName(); + } catch (Exception ex) { + return "unknown source (classpath)"; + } + } @Override public void decompile(final File file) { @@ -88,7 +108,15 @@ public class RuntimeDecompiler extends IFernflowerLogger implements IDecompiler, }, this, this.options, this); - fernflower.getStructContext().addSpace(file, true); + try { + // New fernflower (including forgeflower) + Method mdAddSource = fernflower.getClass().getDeclaredMethod("addSource", File.class); + mdAddSource.invoke(fernflower, file); + } catch (ReflectiveOperationException ex) { + // Old fernflower + fernflower.getStructContext().addSpace(file, true); + } + fernflower.decompileContext(); } catch (Throwable ex) { this.logger.warn("Decompilation error while processing {}", file.getName()); @@ -128,7 +156,7 @@ public class RuntimeDecompiler extends IFernflowerLogger implements IDecompiler, @Override public void writeMessage(String message, Severity severity, Throwable t) { - this.logger.log(RuntimeDecompiler.SEVERITY_LEVELS[severity.ordinal()], message, t); + this.logger.log(RuntimeDecompiler.SEVERITY_LEVELS[severity.ordinal()], message, severity == Severity.ERROR ? t : null); } @Override diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/ext/extensions/ExtensionClassExporter.java b/src/main/java/org/spongepowered/asm/mixin/transformer/ext/extensions/ExtensionClassExporter.java index 2c40ee97..c362ac03 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/ext/extensions/ExtensionClassExporter.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/ext/extensions/ExtensionClassExporter.java @@ -98,8 +98,8 @@ public class ExtensionClassExporter implements IExtension { Class clazz = (Class)Class.forName(className); Constructor ctor = clazz.getDeclaredConstructor(File.class); IDecompiler decompiler = ctor.newInstance(outputPath); - ExtensionClassExporter.logger.info("Fernflower decompiler was successfully initialised, exported classes will be decompiled{}", - as ? " in a separate thread" : ""); + ExtensionClassExporter.logger.info("Fernflower decompiler was successfully initialised from {}, exported classes will be decompiled{}", + decompiler, as ? " in a separate thread" : ""); return decompiler; } catch (Throwable th) { ExtensionClassExporter.logger.info("Fernflower could not be loaded, exported classes will not be decompiled. {}: {}", From 9d4fcbb678203b9615d133a70153d9dd9c055047 Mon Sep 17 00:00:00 2001 From: Mumfrey Date: Wed, 30 Jun 2021 19:13:06 +0100 Subject: [PATCH 5/6] Update checkstyle --- build.gradle | 2 +- checkstyle.xml | 5 ++--- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/build.gradle b/build.gradle index dce3a615..7d0715d3 100644 --- a/build.gradle +++ b/build.gradle @@ -238,7 +238,7 @@ checkstyle { "year" : project.inceptionYear ] configFile = file("checkstyle.xml") - toolVersion = '8.36.1' + toolVersion = '8.43' } // Source compiler configuration diff --git a/checkstyle.xml b/checkstyle.xml index fd6970e0..62145c03 100644 --- a/checkstyle.xml +++ b/checkstyle.xml @@ -90,7 +90,7 @@ - + @@ -100,8 +100,7 @@ - - + From 2046b44ad2fed1255256699f3b0b729bdb674369 Mon Sep 17 00:00:00 2001 From: Mumfrey Date: Thu, 1 Jul 2021 18:15:14 +0100 Subject: [PATCH 6/6] Mixin 0.8.3 RELEASE --- gradle.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle.properties b/gradle.properties index efa97310..fb7a375b 100644 --- a/gradle.properties +++ b/gradle.properties @@ -5,7 +5,7 @@ description=Mixin url=https://www.spongepowered.org organization=SpongePowered buildVersion=0.8.3 -buildType=SNAPSHOT +buildType=RELEASE asmVersion=7.2 legacyForgeAsmVersion=5.0.3 modlauncherAsmVersion=7.2