Merge branch 'main' into feature/better-versioning

Author: Machine-Maker

.github/workflows/build.yml

@@ -18,13 +18,12 @@ jobs:
       fail-fast: true
     steps:
       - uses: actions/checkout@v4
-      - uses: gradle/actions/wrapper-validation@v3
       - name: JDK ${{ matrix.java }}
         uses: actions/setup-java@v4
         with:
           java-version: ${{ matrix.java }}
           distribution: 'temurin'
-      - uses: gradle/actions/setup-gradle@v3
+      - uses: gradle/actions/setup-gradle@v4
       - name: Build
         run: ./gradlew build --stacktrace
       - name: Determine Status

reflection-rewriter/rewriter/src/main/java/io/papermc/reflectionrewriter/DefineClassRule.java

@@ -40,6 +40,11 @@ private DefineClassRule(final String proxyClassName, final boolean assumeClassLo
         this.assumeClassLoader = assumeClassLoader;
     }
 
+    @Override
+    public boolean shouldProcess(final ClassProcessingContext context, final int opcode, final String owner, final String name, final String descriptor, final boolean isInterface, final boolean isInvokeDynamic) {
+        return true; // see comment below
+    }
+
     // We could split this into multiple rules and return false for shouldProcess when the processing class doesn't
     // extend (S)CL. However since the MethodHandles.Lookup portion always needs to run, the actual benefit would
     // be beyond minute (if not actually worse).

src/main/java/io/papermc/asm/rules/builder/RuleFactory.java

@@ -1,7 +1,7 @@
 package io.papermc.asm.rules.builder;
 
 import io.papermc.asm.rules.RewriteRule;
-import io.papermc.asm.rules.builder.matcher.field.FieldMatcher;
+import io.papermc.asm.rules.builder.matcher.field.FieldMatcherBuilder;
 import io.papermc.asm.rules.builder.matcher.method.MethodMatcher;
 import io.papermc.asm.rules.builder.matcher.method.targeted.TargetedMethodMatcher;
 import java.lang.constant.ClassDesc;
@@ -28,6 +28,8 @@ static RuleFactory.Factory combine(final RuleFactory.Factory... factories) {
 
     void plainStaticRewrite(ClassDesc newOwner, MethodMatcher methodMatcher);
 
+    void plainStaticRewrite(ClassDesc newOwner, MethodMatcher methodMatcher, String staticMethodName);
+
     default void changeParamToSuper(final Class<?> oldParamType, final Class<?> newParamType, final MethodMatcher methodMatcher) {
         if (!newParamType.isAssignableFrom(oldParamType)) {
             throw new IllegalArgumentException(newParamType + " is not a superclass of " + oldParamType);
@@ -70,7 +72,7 @@ default void changeReturnTypeDirectWithContext(final Class<?> newReturnType, fin
 
     void changeReturnTypeDirectWithContext(ClassDesc newReturnType, Method staticHandler, TargetedMethodMatcher targetedMethodMatcher);
 
-    void changeFieldToMethod(@Nullable String getterName, @Nullable String setterName, boolean isInterfaceMethod, Consumer<? super FieldMatcher.Builder> builderConsumer);
+    void changeFieldToMethod(@Nullable String getterName, @Nullable String setterName, boolean isInterfaceMethod, Consumer<? super FieldMatcherBuilder> builderConsumer);
 
     default void moveInstanceMethod(final Class<?> newOwner, final String newMethodName, final MethodMatcher methodMatcher) {
         this.moveInstanceMethod(desc(newOwner), newMethodName, methodMatcher);

src/main/java/io/papermc/asm/rules/builder/RuleFactoryImpl.java

@@ -2,6 +2,7 @@
 
 import io.papermc.asm.rules.RewriteRule;
 import io.papermc.asm.rules.builder.matcher.field.FieldMatcher;
+import io.papermc.asm.rules.builder.matcher.field.FieldMatcherBuilder;
 import io.papermc.asm.rules.builder.matcher.method.MethodMatcher;
 import io.papermc.asm.rules.builder.matcher.method.targeted.TargetedMethodMatcher;
 import io.papermc.asm.rules.field.FieldToMethodRewrite;
@@ -43,6 +44,11 @@ public void plainStaticRewrite(final ClassDesc newOwner, final MethodMatcher met
         this.addRule(new DirectStaticRewrite(this.owners, methodMatcher, newOwner));
     }
 
+    @Override
+    public void plainStaticRewrite(final ClassDesc newOwner, final MethodMatcher methodMatcher, final String staticMethodName) {
+        this.addRule(new DirectStaticRewrite(this.owners, staticMethodName, methodMatcher, newOwner));
+    }
+
     @Override
     public void changeParamToSuper(final ClassDesc legacyParamType, final ClassDesc newParamType, final MethodMatcher methodMatcher) {
         this.addRule(new SuperTypeParamRewrite(this.owners, methodMatcher, legacyParamType, newParamType));
@@ -78,7 +84,7 @@ private void changeReturnTypeDirect(final ClassDesc newReturnType, final Method
     }
 
     @Override
-    public void changeFieldToMethod(final @Nullable String getterName, final @Nullable String setterName, final boolean isInterfaceMethod, final Consumer<? super FieldMatcher.Builder> builderConsumer) {
+    public void changeFieldToMethod(final @Nullable String getterName, final @Nullable String setterName, final boolean isInterfaceMethod, final Consumer<? super FieldMatcherBuilder> builderConsumer) {
         this.addRule(new FieldToMethodRewrite(this.owners, build(builderConsumer, FieldMatcher::builder), getterName, setterName, isInterfaceMethod));
     }
 

src/main/java/io/papermc/asm/rules/builder/matcher/field/FieldMatcher.java

@@ -1,51 +1,16 @@
 package io.papermc.asm.rules.builder.matcher.field;
 
-import java.lang.constant.ClassDesc;
-import java.util.Collection;
-import java.util.List;
-import java.util.function.Predicate;
-
-import static java.util.function.Predicate.isEqual;
-
+@FunctionalInterface
 public interface FieldMatcher {
 
-    boolean matchesName(String name);
+    static FieldMatcherBuilderImpl builder() {
+        return new FieldMatcherBuilderImpl();
+    }
 
     boolean matches(String name, String descriptor);
 
-    static Builder builder() {
-        return new Builder();
+    default FieldMatcher or(final FieldMatcher other) {
+        return (name, descriptor) -> this.matches(name, descriptor) || other.matches(name, descriptor);
     }
 
-    final class Builder implements io.papermc.asm.util.Builder<FieldMatcher> {
-
-        private Predicate<String> byName = $ -> false;
-        private Predicate<? super ClassDesc> byType = $ -> true;
-
-        private Builder() {
-        }
-
-        public Builder names(final String... names) {
-            return this.names(List.of(names));
-        }
-
-        public Builder names(final Collection<String> names) {
-            this.byName = this.byName.or(names::contains);
-            return this;
-        }
-
-        public Builder desc(final ClassDesc desc) {
-            return this.desc(isEqual(desc));
-        }
-
-        public Builder desc(final Predicate<? super ClassDesc> predicate) {
-            this.byType = predicate;
-            return this;
-        }
-
-        @Override
-        public FieldMatcher build() {
-            return new FieldMatcherImpl(this.byName, this.byType);
-        }
-    }
 }

src/main/java/io/papermc/asm/rules/builder/matcher/field/FieldMatcherBuilder.java

@@ -0,0 +1,47 @@
+package io.papermc.asm.rules.builder.matcher.field;
+
+import io.papermc.asm.util.Builder;
+import java.lang.constant.ClassDesc;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Predicate;
+
+import static java.util.function.Predicate.isEqual;
+
+public interface FieldMatcherBuilder extends Builder<FieldMatcher> {
+
+    default FieldMatcherBuilder match(final String fieldName) {
+        return this.match(fieldName, $ -> true);
+    }
+
+    default FieldMatcherBuilder match(final String fieldName, final ClassDesc fieldDesc) {
+        return this.match(fieldName, isEqual(fieldDesc));
+    }
+
+    default FieldMatcherBuilder match(final String fieldName, final Predicate<ClassDesc> fieldDescPredicate) {
+        return this.match(isEqual(fieldName), fieldDescPredicate);
+    }
+
+    default FieldMatcherBuilder match(final Collection<String> fieldNames) {
+        return this.match(fieldNames, $ -> true);
+    }
+
+    default FieldMatcherBuilder match(final Collection<String> fieldNames, final ClassDesc fieldDesc) {
+        return this.match(fieldNames, isEqual(fieldDesc));
+    }
+
+    default FieldMatcherBuilder match(final Collection<String> fieldNames, final Predicate<ClassDesc> fieldDescPredicate) {
+        final List<String> copy = List.copyOf(fieldNames);
+        return this.match(copy::contains, fieldDescPredicate);
+    }
+
+    default FieldMatcherBuilder match(final Predicate<String> fieldNamePredicate) {
+        return this.match(fieldNamePredicate, $ -> true);
+    }
+
+    default FieldMatcherBuilder match(final Predicate<String> fieldNamePredicate, final ClassDesc fieldDesc) {
+        return this.match(fieldNamePredicate, isEqual(fieldDesc));
+    }
+
+    FieldMatcherBuilder match(Predicate<String> fieldNamePredicate, Predicate<ClassDesc> fieldDescPredicate);
+}

src/main/java/io/papermc/asm/rules/builder/matcher/field/FieldMatcherBuilderImpl.java

@@ -0,0 +1,23 @@
+package io.papermc.asm.rules.builder.matcher.field;
+
+import java.lang.constant.ClassDesc;
+import java.util.function.Predicate;
+
+public final class FieldMatcherBuilderImpl implements FieldMatcherBuilder {
+
+    private FieldMatcher matcher = (name, descriptor) -> false;
+
+    FieldMatcherBuilderImpl() {
+    }
+
+    @Override
+    public FieldMatcherBuilder match(final Predicate<String> fieldNamePredicate, final Predicate<ClassDesc> fieldDescPredicate) {
+        this.matcher = this.matcher.or((name, descriptor) -> fieldNamePredicate.test(name) && fieldDescPredicate.test(ClassDesc.ofDescriptor(descriptor)));
+        return this;
+    }
+
+    @Override
+    public FieldMatcher build() {
+        return this.matcher;
+    }
+}

src/main/java/io/papermc/asm/rules/builder/matcher/field/FieldMatcherImpl.java

@@ -15,11 +15,6 @@ public FieldMatcherImpl(final Predicate<? super String> byName, final Predicate<
         this.byDesc = byDesc;
     }
 
-    @Override
-    public boolean matchesName(final String name) {
-        return this.byName.test(name);
-    }
-
     @Override
     public boolean matches(final String name, final String descriptor) {
         return this.byName.test(name) && this.byDesc.test(classDesc(descriptor));

src/main/java/io/papermc/asm/rules/builder/matcher/method/MethodMatcher.java

@@ -1,6 +1,7 @@
 package io.papermc.asm.rules.builder.matcher.method;
 
 import java.lang.constant.MethodTypeDesc;
+import java.util.function.Consumer;
 import java.util.function.Predicate;
 
 @FunctionalInterface
@@ -10,6 +11,10 @@ static MethodMatcherBuilder builder() {
         return new MethodMatcherBuilderImpl();
     }
 
+    static MethodMatcher single(final String name, final Consumer<MethodMatcherBuilder.MatchBuilder> matchBuilderConsumer) {
+        return builder().match(name, matchBuilderConsumer).build();
+    }
+
     boolean matches(int opcode, boolean isInvokeDynamic, String name, String descriptor);
 
     default boolean matches(final int opcode, final boolean isInvokeDynamic, final String name, final MethodTypeDesc descriptor) {

src/main/java/io/papermc/asm/rules/classes/EnumToInterfaceRule.java

@@ -71,7 +71,7 @@ private static MethodMatcher createStaticMatcher(final ClassDesc legacyEnumType)
             .build();
     }
 
-    final class EnumVirtualMethods implements GeneratedStaticRewrite {
+    final class EnumVirtualMethods implements GeneratedStaticRewrite, OwnableMethodRewriteRule.Filtered {
 
         @Override
         public MethodMatcher methodMatcher() {