small refactor for pre-configured RuleFactory

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

@@ -11,14 +11,13 @@
 
 public interface ConfiguredRuleFactory extends RuleFactory {
 
-    static ConfiguredRuleFactory create(final Set<Class<?>> owners, final ClassDesc delegateOwner, final ClassDesc generatedDelegateOwner) {
-        return new ConfiguredRuleFactoryImpl(owners, delegateOwner, generatedDelegateOwner);
+    static ConfiguredRuleFactory create(final Set<Class<?>> owners, final RuleFactoryConfiguration config) {
+        return new ConfiguredRuleFactoryImpl(owners, config);
     }
 
-    @SafeVarargs
-    static Consumer<? super ConfiguredRuleFactory> combine(final Consumer<? super ConfiguredRuleFactory>... factories) {
+    static ConfiguredRuleFactory.Factory combine(final ConfiguredRuleFactory.Factory... factories) {
         return r -> {
-            for (final Consumer<? super ConfiguredRuleFactory> factory : factories) {
+            for (final ConfiguredRuleFactory.Factory factory : factories) {
                 factory.accept(r);
             }
         };
@@ -61,4 +60,11 @@ default void changeReturnTypeDirectWithContext(final Class<?> newReturnType, fin
     }
 
     void changeReturnTypeDirectWithContext(ClassDesc newReturnType, Method staticHandler, Consumer<? super TargetedMethodMatcher.Builder> builderConsumer);
+
+    @FunctionalInterface
+    interface Factory extends Consumer<ConfiguredRuleFactory> {
+
+        @Override
+        void accept(ConfiguredRuleFactory factory);
+    }
 }

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

@@ -9,47 +9,45 @@
 
 public class ConfiguredRuleFactoryImpl extends RuleFactoryImpl implements ConfiguredRuleFactory {
 
-    private final ClassDesc delegateOwner;
-    private final ClassDesc generatedDelegateOwner;
+    private final RuleFactoryConfiguration config;
 
-    ConfiguredRuleFactoryImpl(final Set<Class<?>> owners, final ClassDesc delegateOwner, final ClassDesc generatedDelegateOwner) {
+    ConfiguredRuleFactoryImpl(final Set<Class<?>> owners, final RuleFactoryConfiguration config) {
         super(owners);
-        this.delegateOwner = delegateOwner;
-        this.generatedDelegateOwner = generatedDelegateOwner;
+        this.config = config;
     }
 
     @Override
     public void plainStaticRewrite(final Consumer<? super MethodMatcher.Builder> builderConsumer) {
-        this.plainStaticRewrite(this.delegateOwner, builderConsumer);
+        this.plainStaticRewrite(this.config.delegateOwner(), builderConsumer);
     }
 
     @Override
     public void changeParamFuzzy(final ClassDesc newParamType, final Method staticHandler, final Consumer<? super TargetedMethodMatcher.Builder> builderConsumer) {
-        this.changeParamFuzzy(this.generatedDelegateOwner, newParamType, staticHandler, builderConsumer);
+        this.changeParamFuzzy(this.config.generatedDelegateOwner(), newParamType, staticHandler, builderConsumer);
     }
 
     @Override
     public void changeParamDirect(final ClassDesc newParamType, final Method staticHandler, final Consumer<? super TargetedMethodMatcher.Builder> builderConsumer) {
-        this.changeParamDirect(this.generatedDelegateOwner, newParamType, staticHandler, builderConsumer);
+        this.changeParamDirect(this.config.generatedDelegateOwner(), newParamType, staticHandler, builderConsumer);
     }
 
     @Override
     public void changeReturnTypeFuzzy(final ClassDesc newReturnType, final Method staticHandler, final Consumer<? super TargetedMethodMatcher.Builder> builderConsumer) {
-        this.changeReturnTypeFuzzy(this.generatedDelegateOwner, newReturnType, staticHandler, builderConsumer);
+        this.changeReturnTypeFuzzy(this.config.generatedDelegateOwner(), newReturnType, staticHandler, builderConsumer);
     }
 
     @Override
     public void changeReturnTypeDirect(final ClassDesc newReturnType, final Method staticHandler, final Consumer<? super TargetedMethodMatcher.Builder> builderConsumer) {
-        this.changeReturnTypeDirect(this.generatedDelegateOwner, newReturnType, staticHandler, builderConsumer);
+        this.changeReturnTypeDirect(this.config.generatedDelegateOwner(), newReturnType, staticHandler, builderConsumer);
     }
 
     @Override
     public void changeReturnTypeFuzzyWithContext(final ClassDesc newReturnType, final Method staticHandler, final Consumer<? super TargetedMethodMatcher.Builder> builderConsumer) {
-        this.changeReturnTypeFuzzyWithContext(this.generatedDelegateOwner, newReturnType, staticHandler, builderConsumer);
+        this.changeReturnTypeFuzzyWithContext(this.config.generatedDelegateOwner(), newReturnType, staticHandler, builderConsumer);
     }
 
     @Override
     public void changeReturnTypeDirectWithContext(final ClassDesc newReturnType, final Method staticHandler, final Consumer<? super TargetedMethodMatcher.Builder> builderConsumer) {
-        this.changeReturnTypeDirectWithContext(this.generatedDelegateOwner, newReturnType, staticHandler, builderConsumer);
+        this.changeReturnTypeDirectWithContext(this.config.generatedDelegateOwner(), newReturnType, staticHandler, builderConsumer);
     }
 }

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

@@ -17,10 +17,9 @@ static RuleFactory create(final Set<Class<?>> owners) {
         return new RuleFactoryImpl(owners);
     }
 
-    @SafeVarargs
-    static Consumer<? super RuleFactory> combine(final Consumer<? super RuleFactory>... factories) {
+    static RuleFactory.Factory combine(final RuleFactory.Factory... factories) {
         return r -> {
-            for (final Consumer<? super RuleFactory> factory : factories) {
+            for (final RuleFactory.Factory factory : factories) {
                 factory.accept(r);
             }
         };
@@ -87,4 +86,11 @@ default void changeReturnTypeDirectWithContext(final ClassDesc newOwner, final C
     void addRule(RewriteRule rule);
 
     RewriteRule build();
+
+    @FunctionalInterface
+    interface Factory extends Consumer<RuleFactory> {
+
+        @Override
+        void accept(RuleFactory factory);
+    }
 }

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

@@ -0,0 +1,36 @@
+package io.papermc.asm.rules.builder;
+
+import io.papermc.asm.rules.RewriteRule;
+import java.lang.constant.ClassDesc;
+import java.util.Collections;
+import java.util.Set;
+import java.util.function.Consumer;
+
+public interface RuleFactoryConfiguration {
+
+    static RuleFactoryConfiguration create(final ClassDesc delegateOwner, final ClassDesc generatedDelegateOwner) {
+        return new RuleFactoryConfigurationImpl(delegateOwner, generatedDelegateOwner);
+    }
+
+    ClassDesc delegateOwner();
+
+    ClassDesc generatedDelegateOwner();
+
+    interface Holder {
+
+        RuleFactoryConfiguration configuration();
+
+        default RewriteRule forOwner(final Class<?> owner, final ConfiguredRuleFactory.Factory firstFactoryConsumer, final ConfiguredRuleFactory.Factory ...factoryConsumers) {
+            return this.forOwners(Collections.singleton(owner), firstFactoryConsumer, factoryConsumers);
+        }
+
+        default RewriteRule forOwners(final Set<Class<?>> owners, final ConfiguredRuleFactory.Factory firstFactoryConsumer, final ConfiguredRuleFactory.Factory ...factoryConsumers) {
+            final ConfiguredRuleFactory factory = ConfiguredRuleFactory.create(owners, this.configuration());
+            firstFactoryConsumer.accept(factory);
+            for (final ConfiguredRuleFactory.Factory factoryConsumer : factoryConsumers) {
+                factoryConsumer.accept(factory);
+            }
+            return factory.build();
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+package io.papermc.asm.rules.builder;
+
+import java.lang.constant.ClassDesc;
+
+record RuleFactoryConfigurationImpl(ClassDesc delegateOwner, ClassDesc generatedDelegateOwner) implements RuleFactoryConfiguration {
+}