From 76ff47b6b358a350f768d1aba6185f692301aea0 Mon Sep 17 00:00:00 2001 From: Rafael Winterhalter Date: Tue, 4 Aug 2015 13:12:07 +0200 Subject: [PATCH] Removed ModifierTransformer and added MethodTransformer that allows for more generic transformation. --- .../main/java/net/bytebuddy/ByteBuddy.java | 33 ++- .../net/bytebuddy/dynamic/DynamicType.java | 102 ++++---- .../bytebuddy/dynamic/MethodTransformer.java | 2 +- .../bytebuddy/dynamic/ModifierResolver.java | 64 ----- .../dynamic/scaffold/MethodRegistry.java | 227 +++++++----------- .../dynamic/scaffold/TypeWriter.java | 115 ++------- .../subclass/ConstructorStrategy.java | 17 +- .../implementation/Implementation.java | 10 +- .../AbstractDynamicTypeBuilderTest.java | 15 +- .../ModifierResolverDesynchronizing.java | 51 ---- .../ModifierResolverRetainingTest.java | 50 ---- .../scaffold/MethodRegistryDefaultTest.java | 61 ++--- .../scaffold/MethodRegistryHandlerTest.java | 20 +- .../TypeWriterMethodPoolRecordTest.java | 65 ++--- .../ConstructorStrategyDefaultTest.java | 19 +- 15 files changed, 277 insertions(+), 574 deletions(-) delete mode 100644 byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/ModifierResolver.java delete mode 100644 byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/ModifierResolverDesynchronizing.java delete mode 100644 byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/ModifierResolverRetainingTest.java diff --git a/byte-buddy-dep/src/main/java/net/bytebuddy/ByteBuddy.java b/byte-buddy-dep/src/main/java/net/bytebuddy/ByteBuddy.java index 44cb372d5df..aab7e6356ae 100644 --- a/byte-buddy-dep/src/main/java/net/bytebuddy/ByteBuddy.java +++ b/byte-buddy-dep/src/main/java/net/bytebuddy/ByteBuddy.java @@ -12,7 +12,7 @@ import net.bytebuddy.description.type.generic.GenericTypeList; import net.bytebuddy.dynamic.ClassFileLocator; import net.bytebuddy.dynamic.DynamicType; -import net.bytebuddy.dynamic.ModifierResolver; +import net.bytebuddy.dynamic.MethodTransformer; import net.bytebuddy.dynamic.TargetType; import net.bytebuddy.dynamic.scaffold.FieldRegistry; import net.bytebuddy.dynamic.scaffold.InstrumentedType; @@ -1420,6 +1420,8 @@ public static class MethodAnnotationTarget extends Proxy { */ protected final MethodAttributeAppender.Factory attributeAppenderFactory; + protected final MethodTransformer methodTransformer; + /** * Creates a new method annotation target. * @@ -1458,7 +1460,8 @@ protected MethodAnnotationTarget(ClassFileVersion classFileVersion, MethodAttributeAppender.Factory defaultMethodAttributeAppenderFactory, LatentMethodMatcher methodMatcher, MethodRegistry.Handler handler, - MethodAttributeAppender.Factory attributeAppenderFactory) { + MethodAttributeAppender.Factory attributeAppenderFactory, + MethodTransformer methodTransformer) { super(classFileVersion, namingStrategy, auxiliaryTypeNamingStrategy, @@ -1474,6 +1477,7 @@ protected MethodAnnotationTarget(ClassFileVersion classFileVersion, this.methodMatcher = methodMatcher; this.handler = handler; this.attributeAppenderFactory = attributeAppenderFactory; + this.methodTransformer = methodTransformer; } /** @@ -1499,7 +1503,8 @@ public MethodAnnotationTarget attribute(MethodAttributeAppender.Factory attribut defaultMethodAttributeAppenderFactory, methodMatcher, handler, - new MethodAttributeAppender.Factory.Compound(this.attributeAppenderFactory, nonNull(attributeAppenderFactory))); + new MethodAttributeAppender.Factory.Compound(this.attributeAppenderFactory, nonNull(attributeAppenderFactory)), + methodTransformer); } /** @@ -1587,7 +1592,7 @@ protected ByteBuddy materialize() { interfaceTypes, ignoredMethods, classVisitorWrapperChain, - methodRegistry.prepend(methodMatcher, handler, attributeAppenderFactory), + methodRegistry.prepend(methodMatcher, handler, attributeAppenderFactory, methodTransformer), modifiers, typeAttributeAppender, methodGraphCompiler, @@ -1607,7 +1612,8 @@ public boolean equals(Object other) { MethodAnnotationTarget that = (MethodAnnotationTarget) other; return attributeAppenderFactory.equals(that.attributeAppenderFactory) && handler.equals(that.handler) - && methodMatcher.equals(that.methodMatcher); + && methodMatcher.equals(that.methodMatcher) + && methodTransformer.equals(that.methodTransformer); } @Override @@ -1616,6 +1622,7 @@ public int hashCode() { result = 31 * result + methodMatcher.hashCode(); result = 31 * result + handler.hashCode(); result = 31 * result + attributeAppenderFactory.hashCode(); + result = 31 * result + methodTransformer.hashCode(); return result; } @@ -1637,6 +1644,7 @@ public String toString() { ", methodMatcher=" + methodMatcher + ", handler=" + handler + ", attributeAppenderFactory=" + attributeAppenderFactory + + ", methodTransformer=" + methodTransformer + '}'; } } @@ -2354,8 +2362,9 @@ public MethodAnnotationTarget intercept(Implementation implementation) { defaultFieldAttributeAppenderFactory, defaultMethodAttributeAppenderFactory, methodMatcher, - new MethodRegistry.Handler.ForImplementation(nonNull(implementation), ModifierResolver.Retaining.INSTANCE), - MethodAttributeAppender.NoOp.INSTANCE); + new MethodRegistry.Handler.ForImplementation(nonNull(implementation)), + MethodAttributeAppender.NoOp.INSTANCE, + MethodTransformer.Retaining.INSTANCE); } @Override @@ -2373,8 +2382,9 @@ public MethodAnnotationTarget withoutCode() { defaultFieldAttributeAppenderFactory, defaultMethodAttributeAppenderFactory, methodMatcher, - new MethodRegistry.Handler.ForAbstractMethod(ModifierResolver.Retaining.INSTANCE), - MethodAttributeAppender.NoOp.INSTANCE); + MethodRegistry.Handler.ForAbstractMethod.INSTANCE, + MethodAttributeAppender.NoOp.INSTANCE, + MethodTransformer.Retaining.INSTANCE); } @Override @@ -2397,8 +2407,9 @@ public MethodAnnotationTarget withDefaultValue(Object value) { defaultFieldAttributeAppenderFactory, defaultMethodAttributeAppenderFactory, methodMatcher, - MethodRegistry.Handler.ForAnnotationValue.of(value, ModifierResolver.Retaining.INSTANCE), - MethodAttributeAppender.NoOp.INSTANCE); + MethodRegistry.Handler.ForAnnotationValue.of(value), + MethodAttributeAppender.NoOp.INSTANCE, + MethodTransformer.Retaining.INSTANCE); } /** diff --git a/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/DynamicType.java b/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/DynamicType.java index 2bb3301adb5..435b0f92b3b 100644 --- a/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/DynamicType.java +++ b/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/DynamicType.java @@ -691,11 +691,10 @@ interface MatchedMethodInterception { /** * Intercepts the currently selected method by a given implementation. * - * @param implementation An implementation to apply to the currently selected method. - * @param modifierResolver The modifier resolver to apply to the instrumented method. + * @param implementation An implementation to apply to the currently selected method. * @return A builder which will intercept the currently selected methods by the given implementation. */ - MethodAnnotationTarget intercept(Implementation implementation, ModifierResolver modifierResolver); + MethodAnnotationTarget intercept(Implementation implementation, MethodTransformer methodTransformer); /** * Implements the currently selected methods as {@code abstract} methods. @@ -707,10 +706,9 @@ interface MatchedMethodInterception { /** * Implements the currently selected methods as {@code abstract} methods. * - * @param modifierResolver The modifier resolver to apply to the instrumented method. * @return A builder which will implement the currently selected methods as {@code abstract} methods. */ - MethodAnnotationTarget withoutCode(ModifierResolver modifierResolver); + MethodAnnotationTarget withoutCode(MethodTransformer methodTransformer); /** * Defines a default annotation value to set for any matched method. @@ -724,12 +722,11 @@ interface MatchedMethodInterception { /** * Defines a default annotation value to set for any matched method. * - * @param value The value that the annotation property should set as a default. - * @param type The type of the annotation property. - * @param modifierResolver The modifier resolver to apply to the instrumented method. + * @param value The value that the annotation property should set as a default. + * @param type The type of the annotation property. * @return A builder which defines the given default value for all matched methods. */ - MethodAnnotationTarget withDefaultValue(Object value, Class type, ModifierResolver modifierResolver); + MethodAnnotationTarget withDefaultValue(Object value, Class type, MethodTransformer methodTransformer); /** * Defines a default annotation value to set for any matched method. The value is to be represented in a wrapper format, @@ -748,11 +745,10 @@ interface MatchedMethodInterception { * instances, annotations as {@link AnnotationDescription} instances and * {@link Class} values as {@link TypeDescription} instances. Other values are handed in their raw format or as their wrapper types. * - * @param value A non-loaded value that the annotation property should set as a default. - * @param modifierResolver The modifier resolver to apply to the instrumented method. + * @param value A non-loaded value that the annotation property should set as a default. * @return A builder which defines the given default value for all matched methods. */ - MethodAnnotationTarget withDefaultValue(Object value, ModifierResolver modifierResolver); + MethodAnnotationTarget withDefaultValue(Object value, MethodTransformer methodTransformer); } /** @@ -2295,53 +2291,55 @@ protected DefaultMatchedMethodInterception(LatentMethodMatcher methodMatcher, Li @Override public MethodAnnotationTarget intercept(Implementation implementation) { - return intercept(implementation, ModifierResolver.Retaining.INSTANCE); + return intercept(implementation, MethodTransformer.Retaining.INSTANCE); } @Override - public MethodAnnotationTarget intercept(Implementation implementation, ModifierResolver modifierResolver) { + public MethodAnnotationTarget intercept(Implementation implementation, MethodTransformer methodTransformer) { return new DefaultMethodAnnotationTarget(methodMatcher, methodTokens, - new MethodRegistry.Handler.ForImplementation(nonNull(implementation), nonNull(modifierResolver)), - defaultMethodAttributeAppenderFactory); + new MethodRegistry.Handler.ForImplementation(nonNull(implementation)), + defaultMethodAttributeAppenderFactory, + nonNull(methodTransformer)); } @Override public MethodAnnotationTarget withoutCode() { - return withoutCode(ModifierResolver.Retaining.INSTANCE); + return withoutCode(MethodTransformer.Retaining.INSTANCE); } @Override - public MethodAnnotationTarget withoutCode(ModifierResolver modifierResolver) { + public MethodAnnotationTarget withoutCode(MethodTransformer methodTransformer) { return new DefaultMethodAnnotationTarget(methodMatcher, methodTokens, - new MethodRegistry.Handler.ForAbstractMethod(nonNull(modifierResolver)), - defaultMethodAttributeAppenderFactory); + MethodRegistry.Handler.ForAbstractMethod.INSTANCE, + defaultMethodAttributeAppenderFactory, + nonNull(methodTransformer)); } @Override public MethodAnnotationTarget withDefaultValue(Object value, Class type) { - return withDefaultValue(value, type, ModifierResolver.Retaining.INSTANCE); + return withDefaultValue(value, type, MethodTransformer.Retaining.INSTANCE); } @Override - public MethodAnnotationTarget withDefaultValue(Object value, Class type, ModifierResolver modifierResolver) { + public MethodAnnotationTarget withDefaultValue(Object value, Class type, MethodTransformer methodTransformer) { return withDefaultValue(AnnotationDescription.ForLoadedAnnotation.describe(nonNull(value), - new TypeDescription.ForLoadedType(nonNull(type))), - nonNull(modifierResolver)); + new TypeDescription.ForLoadedType(nonNull(type))), nonNull(methodTransformer)); } @Override public MethodAnnotationTarget withDefaultValue(Object value) { - return withDefaultValue(value, ModifierResolver.Retaining.INSTANCE); + return withDefaultValue(value, MethodTransformer.Retaining.INSTANCE); } @Override - public MethodAnnotationTarget withDefaultValue(Object value, ModifierResolver modifierResolver) { + public MethodAnnotationTarget withDefaultValue(Object value, MethodTransformer methodTransformer) { return new DefaultMethodAnnotationTarget(methodMatcher, methodTokens, - MethodRegistry.Handler.ForAnnotationValue.of(value, nonNull(modifierResolver)), - MethodAttributeAppender.NoOp.INSTANCE); + MethodRegistry.Handler.ForAnnotationValue.of(value), + MethodAttributeAppender.NoOp.INSTANCE, + nonNull(methodTransformer)); } @Override @@ -2435,8 +2433,8 @@ public MethodAnnotationTarget intercept(Implementation implementation) { } @Override - public MethodAnnotationTarget intercept(Implementation implementation, ModifierResolver modifierResolver) { - return materialize(methodToken).intercept(implementation, modifierResolver); + public MethodAnnotationTarget intercept(Implementation implementation, MethodTransformer methodTransformer) { + return materialize(methodToken).intercept(implementation, methodTransformer); } @Override @@ -2445,8 +2443,8 @@ public MethodAnnotationTarget withoutCode() { } @Override - public MethodAnnotationTarget withoutCode(ModifierResolver modifierResolver) { - return materialize(methodToken).withoutCode(modifierResolver); + public MethodAnnotationTarget withoutCode(MethodTransformer methodTransformer) { + return materialize(methodToken).withoutCode(methodTransformer); } @Override @@ -2455,8 +2453,8 @@ public MethodAnnotationTarget withDefaultValue(Object value, Class type) { } @Override - public MethodAnnotationTarget withDefaultValue(Object value, Class type, ModifierResolver modifierResolver) { - return materialize(methodToken).withDefaultValue(value, type, modifierResolver); + public MethodAnnotationTarget withDefaultValue(Object value, Class type, MethodTransformer methodTransformer) { + return materialize(methodToken).withDefaultValue(value, type, methodTransformer); } @Override @@ -2465,8 +2463,8 @@ public MethodAnnotationTarget withDefaultValue(Object value) { } @Override - public MethodAnnotationTarget withDefaultValue(Object value, ModifierResolver modifierResolver) { - return materialize(methodToken).withDefaultValue(value, modifierResolver); + public MethodAnnotationTarget withDefaultValue(Object value, MethodTransformer methodTransformer) { + return materialize(methodToken).withDefaultValue(value, methodTransformer); } /** @@ -2537,6 +2535,8 @@ protected class DefaultMethodAnnotationTarget extends AbstractDelegatingBuilder< */ private final MethodAttributeAppender.Factory attributeAppenderFactory; + private final MethodTransformer methodTransformer; + /** * Creates a new default method annotation target. * @@ -2548,11 +2548,13 @@ protected class DefaultMethodAnnotationTarget extends AbstractDelegatingBuilder< protected DefaultMethodAnnotationTarget(LatentMethodMatcher methodMatcher, List methodTokens, MethodRegistry.Handler handler, - MethodAttributeAppender.Factory attributeAppenderFactory) { + MethodAttributeAppender.Factory attributeAppenderFactory, + MethodTransformer methodTransformer) { this.methodMatcher = methodMatcher; this.methodTokens = methodTokens; this.handler = handler; this.attributeAppenderFactory = attributeAppenderFactory; + this.methodTransformer = methodTransformer; } @Override @@ -2567,7 +2569,7 @@ protected DynamicType.Builder materialize() { ignoredMethods, classVisitorWrapperChain, fieldRegistry, - methodRegistry.prepend(methodMatcher, handler, attributeAppenderFactory), + methodRegistry.prepend(methodMatcher, handler, attributeAppenderFactory, methodTransformer), methodGraphCompiler, defaultFieldAttributeAppenderFactory, defaultMethodAttributeAppenderFactory, @@ -2581,7 +2583,8 @@ public MethodAnnotationTarget attribute(MethodAttributeAppender.Factory attri methodTokens, handler, new MethodAttributeAppender.Factory.Compound(this.attributeAppenderFactory, - nonNull(attributeAppenderFactory))); + nonNull(attributeAppenderFactory)), + methodTransformer); } @Override @@ -2635,6 +2638,7 @@ public boolean equals(Object other) { return attributeAppenderFactory.equals(that.attributeAppenderFactory) && handler.equals(that.handler) && methodMatcher.equals(that.methodMatcher) + && methodTransformer.equals(that.methodTransformer) && methodTokens.equals(that.methodTokens) && AbstractBase.this.equals(that.getDynamicTypeBuilder()); } @@ -2644,6 +2648,7 @@ public int hashCode() { int result = methodMatcher.hashCode(); result = 31 * result + methodTokens.hashCode(); result = 31 * result + handler.hashCode(); + result = 31 * result + methodTransformer.hashCode(); result = 31 * result + attributeAppenderFactory.hashCode(); result = 31 * result + AbstractBase.this.hashCode(); return result; @@ -2654,9 +2659,10 @@ public String toString() { return "DynamicType.Builder.AbstractBase.DefaultMethodAnnotationTarget{" + "base=" + AbstractBase.this + ", methodMatcher=" + methodMatcher + - ", methodTokens=" + methodTokens + ", handler=" + handler + ", attributeAppenderFactory=" + attributeAppenderFactory + + ", methodTransformer=" + methodTransformer + + ", methodTokens=" + methodTokens + '}'; } @@ -2695,8 +2701,8 @@ public MethodAnnotationTarget intercept(Implementation implementation) { } @Override - public MethodAnnotationTarget intercept(Implementation implementation, ModifierResolver modifierResolver) { - return materialize().method(isDeclaredBy(anyOf(additionalInterfaceTypes))).intercept(implementation, modifierResolver); + public MethodAnnotationTarget intercept(Implementation implementation, MethodTransformer methodTransformer) { + return materialize().method(isDeclaredBy(anyOf(additionalInterfaceTypes))).intercept(implementation, methodTransformer); } @Override @@ -2705,8 +2711,8 @@ public MethodAnnotationTarget withoutCode() { } @Override - public MethodAnnotationTarget withoutCode(ModifierResolver modifierResolver) { - return materialize().method(isDeclaredBy(anyOf(additionalInterfaceTypes))).withoutCode(modifierResolver); + public MethodAnnotationTarget withoutCode(MethodTransformer methodTransformer) { + return materialize().method(isDeclaredBy(anyOf(additionalInterfaceTypes))).withoutCode(methodTransformer); } @Override @@ -2715,8 +2721,8 @@ public MethodAnnotationTarget withDefaultValue(Object value, Class type) { } @Override - public MethodAnnotationTarget withDefaultValue(Object value, Class type, ModifierResolver modifierResolver) { - return materialize().method(isDeclaredBy(anyOf(additionalInterfaceTypes))).withDefaultValue(value, type, modifierResolver); + public MethodAnnotationTarget withDefaultValue(Object value, Class type, MethodTransformer methodTransformer) { + return materialize().method(isDeclaredBy(anyOf(additionalInterfaceTypes))).withDefaultValue(value, type, methodTransformer); } @Override @@ -2725,8 +2731,8 @@ public MethodAnnotationTarget withDefaultValue(Object value) { } @Override - public MethodAnnotationTarget withDefaultValue(Object value, ModifierResolver modifierResolver) { - return materialize().method(isDeclaredBy(anyOf(additionalInterfaceTypes))).withDefaultValue(value, modifierResolver); + public MethodAnnotationTarget withDefaultValue(Object value, MethodTransformer methodTransformer) { + return materialize().method(isDeclaredBy(anyOf(additionalInterfaceTypes))).withDefaultValue(value, methodTransformer); } @Override diff --git a/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/MethodTransformer.java b/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/MethodTransformer.java index 0d4bf693269..c1c9a4faa85 100644 --- a/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/MethodTransformer.java +++ b/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/MethodTransformer.java @@ -35,7 +35,7 @@ public String toString() { class Transforming implements MethodTransformer { - public static MethodTransformer enforce(ModifierContributor.ForMethod... modifierTransformer) { + public static MethodTransformer modifiers(ModifierContributor.ForMethod... modifierTransformer) { return new Transforming(new Transformer.ForModifierTransformation(Arrays.asList(nonNull(modifierTransformer)))); } diff --git a/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/ModifierResolver.java b/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/ModifierResolver.java deleted file mode 100644 index 99c5b20ea2d..00000000000 --- a/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/ModifierResolver.java +++ /dev/null @@ -1,64 +0,0 @@ -package net.bytebuddy.dynamic; - -import net.bytebuddy.description.method.MethodDescription; -import org.objectweb.asm.Opcodes; - -/** - * A modifier resolver allows to define a modifier for a method. That modifier may derive from the original modifier. - * It is the responsibility of the transformer to assure that a transformed modifier is legal. - */ -public interface ModifierResolver { - - /** - * Resolves a modifier for a given method. - * - * @param methodDescription The method for which a modifier is to be resolved. - * @param implemented {@code true} if the method is implemented. - * @return The modifier to be defined for this method. This modifier must be a method's actual modifier which might derive from the value that - * is returned from the reflection API. - * @see MethodDescription#getAdjustedModifiers(boolean) - */ - int transform(MethodDescription methodDescription, boolean implemented); - - /** - * Resolves a modifier as it is defined by the method itself. - */ - enum Retaining implements ModifierResolver { - - /** - * The singleton instance. - */ - INSTANCE; - - @Override - public int transform(MethodDescription methodDescription, boolean implemented) { - return methodDescription.getAdjustedModifiers(implemented); - } - - @Override - public String toString() { - return "ModifierResolver.Retaining." + name(); - } - } - - /** - * Resolves a modifier as it is defined by the method itself but strips any {@code synchronized} modifier. - */ - enum Desynchronizing implements ModifierResolver { - - /** - * The singleton instance. - */ - INSTANCE; - - @Override - public int transform(MethodDescription methodDescription, boolean implemented) { - return methodDescription.getAdjustedModifiers(implemented) & ~Opcodes.ACC_SYNCHRONIZED; - } - - @Override - public String toString() { - return "ModifierResolver.Desynchronizing." + name(); - } - } -} diff --git a/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/scaffold/MethodRegistry.java b/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/scaffold/MethodRegistry.java index 6917c8b6a75..5cd018cbe58 100644 --- a/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/scaffold/MethodRegistry.java +++ b/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/scaffold/MethodRegistry.java @@ -3,7 +3,7 @@ import net.bytebuddy.description.method.MethodDescription; import net.bytebuddy.description.method.MethodList; import net.bytebuddy.description.type.TypeDescription; -import net.bytebuddy.dynamic.ModifierResolver; +import net.bytebuddy.dynamic.MethodTransformer; import net.bytebuddy.implementation.Implementation; import net.bytebuddy.implementation.LoadedTypeInitializer; import net.bytebuddy.implementation.attribute.MethodAttributeAppender; @@ -29,7 +29,10 @@ public interface MethodRegistry { * @param attributeAppenderFactory A method attribute appender to apply to any matched method. * @return A mutated version of this method registry. */ - MethodRegistry prepend(LatentMethodMatcher methodMatcher, Handler handler, MethodAttributeAppender.Factory attributeAppenderFactory); + MethodRegistry prepend(LatentMethodMatcher methodMatcher, + Handler handler, + MethodAttributeAppender.Factory attributeAppenderFactory, + MethodTransformer methodTransformer); /** * Appends the given method definition to this method registry, i.e. this configuration is applied last. @@ -39,7 +42,10 @@ public interface MethodRegistry { * @param attributeAppenderFactory A method attribute appender to apply to any matched method. * @return A mutated version of this method registry. */ - MethodRegistry append(LatentMethodMatcher methodMatcher, Handler handler, MethodAttributeAppender.Factory attributeAppenderFactory); + MethodRegistry append(LatentMethodMatcher methodMatcher, + Handler handler, + MethodAttributeAppender.Factory attributeAppenderFactory, + MethodTransformer methodTransformer); /** * Prepares this method registry. @@ -80,31 +86,19 @@ interface Compiled { /** * Assembles this compiled entry with a method attribute appender. * - * @param attributeAppender The method attribute appender to apply together with this handler. * @param methodDescription The method description to apply with this handler. + * @param attributeAppender The method attribute appender to apply together with this handler. * @return A method pool entry representing this handler and the given attribute appender. */ - TypeWriter.MethodPool.Record assemble(MethodAttributeAppender attributeAppender, MethodDescription methodDescription); + TypeWriter.MethodPool.Record assemble(MethodDescription methodDescription, MethodAttributeAppender attributeAppender); } /** * A handler for defining an abstract or native method. */ - class ForAbstractMethod implements Handler, Compiled { + enum ForAbstractMethod implements Handler, Compiled { - /** - * The transformer to apply to the modifier of this method. - */ - private final ModifierResolver modifierResolver; - - /** - * Creates a new handler for defining an abstract method. - * - * @param modifierResolver The transformer to apply to the modifier of this method. - */ - public ForAbstractMethod(ModifierResolver modifierResolver) { - this.modifierResolver = modifierResolver; - } + INSTANCE; @Override public InstrumentedType prepare(InstrumentedType instrumentedType) { @@ -117,26 +111,13 @@ public Compiled compile(Implementation.Target implementationTarget) { } @Override - public TypeWriter.MethodPool.Record assemble(MethodAttributeAppender attributeAppender, MethodDescription methodDescription) { - return new TypeWriter.MethodPool.Record.ForDefinedMethod.WithoutBody(methodDescription, attributeAppender, modifierResolver); - } - - @Override - public boolean equals(Object other) { - return this == other || !(other == null || getClass() != other.getClass()) - && modifierResolver.equals(((ForAbstractMethod) other).modifierResolver); - } - - @Override - public int hashCode() { - return modifierResolver.hashCode(); + public TypeWriter.MethodPool.Record assemble(MethodDescription methodDescription, MethodAttributeAppender attributeAppender) { + return new TypeWriter.MethodPool.Record.ForDefinedMethod.WithoutBody(methodDescription, attributeAppender); } @Override public String toString() { - return "MethodRegistry.Handler.ForAbstractMethod{" + - "modifierResolver=" + modifierResolver + - '}'; + return "MethodRegistry.Handler.ForAbstractMethod." + name(); } } @@ -150,20 +131,13 @@ class ForImplementation implements Handler { */ private final Implementation implementation; - /** - * The transformer to apply to the modifier of this method. - */ - private final ModifierResolver modifierResolver; - /** * Creates a new handler for implementing a method with byte code. * * @param implementation The implementation to apply. - * @param modifierResolver The transformer to apply to the modifier of this method. */ - public ForImplementation(Implementation implementation, ModifierResolver modifierResolver) { + public ForImplementation(Implementation implementation) { this.implementation = implementation; - this.modifierResolver = modifierResolver; } @Override @@ -173,26 +147,24 @@ public InstrumentedType prepare(InstrumentedType instrumentedType) { @Override public Compiled compile(Implementation.Target implementationTarget) { - return new Compiled(implementation.appender(implementationTarget), modifierResolver); + return new Compiled(implementation.appender(implementationTarget)); } @Override public boolean equals(Object other) { return this == other || !(other == null || getClass() != other.getClass()) - && implementation.equals(((ForImplementation) other).implementation) - && modifierResolver.equals(((ForImplementation) other).modifierResolver); + && implementation.equals(((ForImplementation) other).implementation); } @Override public int hashCode() { - return implementation.hashCode() + 31 * modifierResolver.hashCode(); + return implementation.hashCode(); } @Override public String toString() { return "MethodRegistry.Handler.ForImplementation{" + "implementation=" + implementation + - ", modifierResolver=" + modifierResolver + '}'; } @@ -206,47 +178,35 @@ protected static class Compiled implements Handler.Compiled { */ private final ByteCodeAppender byteCodeAppender; - /** - * The transformer to apply to the modifier of this method. - */ - private final ModifierResolver modifierResolver; - /** * Creates a new compiled handler for a method implementation. * * @param byteCodeAppender The byte code appender to apply. - * @param modifierResolver The transformer to apply to the modifier of this method. */ - protected Compiled(ByteCodeAppender byteCodeAppender, ModifierResolver modifierResolver) { + protected Compiled(ByteCodeAppender byteCodeAppender) { this.byteCodeAppender = byteCodeAppender; - this.modifierResolver = modifierResolver; } @Override - public TypeWriter.MethodPool.Record assemble(MethodAttributeAppender attributeAppender, MethodDescription methodDescription) { - return new TypeWriter.MethodPool.Record.ForDefinedMethod.WithBody(methodDescription, - byteCodeAppender, - attributeAppender, - modifierResolver); + public TypeWriter.MethodPool.Record assemble(MethodDescription methodDescription, MethodAttributeAppender attributeAppender) { + return new TypeWriter.MethodPool.Record.ForDefinedMethod.WithBody(methodDescription, byteCodeAppender, attributeAppender); } @Override public boolean equals(Object other) { return this == other || !(other == null || getClass() != other.getClass()) - && byteCodeAppender.equals(((Compiled) other).byteCodeAppender) - && modifierResolver.equals(((Compiled) other).modifierResolver); + && byteCodeAppender.equals(((Compiled) other).byteCodeAppender); } @Override public int hashCode() { - return byteCodeAppender.hashCode() + 31 * modifierResolver.hashCode(); + return byteCodeAppender.hashCode(); } @Override public String toString() { return "MethodRegistry.Handler.ForImplementation.Compiled{" + "byteCodeAppender=" + byteCodeAppender + - ", modifierResolver=" + modifierResolver + '}'; } } @@ -262,35 +222,27 @@ class ForAnnotationValue implements Handler, Compiled { */ private final Object annotationValue; - /** - * The transformer to apply to the modifier of this method. - */ - private final ModifierResolver modifierResolver; - /** * Creates a handler for defining a default annotation value for a method. * * @param annotationValue The annotation value to set as a default value. - * @param modifierResolver The transformer to apply to the modifier of this method. */ - protected ForAnnotationValue(Object annotationValue, ModifierResolver modifierResolver) { + protected ForAnnotationValue(Object annotationValue) { this.annotationValue = annotationValue; - this.modifierResolver = modifierResolver; } /** * Represents the given value as an annotation default value handler after validating its suitability. * * @param annotationValue The annotation value to represent. - * @param modifierResolver The transformer to apply to the modifier of this method. * @return A handler for setting the given value as a default value for instrumented methods. */ - public static Handler of(Object annotationValue, ModifierResolver modifierResolver) { + public static Handler of(Object annotationValue) { TypeDescription typeDescription = new TypeDescription.ForLoadedType(annotationValue.getClass()); if (!typeDescription.isAnnotationValue() && !typeDescription.isPrimitiveWrapper()) { throw new IllegalArgumentException("Does not describe an annotation value: " + annotationValue); } - return new ForAnnotationValue(annotationValue, modifierResolver); + return new ForAnnotationValue(annotationValue); } @Override @@ -304,30 +256,25 @@ public Compiled compile(Implementation.Target implementationTarget) { } @Override - public TypeWriter.MethodPool.Record assemble(MethodAttributeAppender attributeAppender, MethodDescription methodDescription) { - return new TypeWriter.MethodPool.Record.ForDefinedMethod.WithAnnotationDefaultValue(methodDescription, - annotationValue, - attributeAppender, - modifierResolver); + public TypeWriter.MethodPool.Record assemble(MethodDescription methodDescription, MethodAttributeAppender attributeAppender) { + return new TypeWriter.MethodPool.Record.ForDefinedMethod.WithAnnotationDefaultValue(methodDescription, annotationValue, attributeAppender); } @Override public boolean equals(Object other) { return this == other || !(other == null || getClass() != other.getClass()) - && annotationValue.equals(((ForAnnotationValue) other).annotationValue) - && modifierResolver.equals(((ForAnnotationValue) other).modifierResolver); + && annotationValue.equals(((ForAnnotationValue) other).annotationValue); } @Override public int hashCode() { - return annotationValue.hashCode() + 31 * modifierResolver.hashCode(); + return annotationValue.hashCode(); } @Override public String toString() { return "MethodRegistry.Handler.ForAnnotationValue{" + "annotationValue=" + annotationValue + - ", modifierResolver=" + modifierResolver + '}'; } } @@ -377,7 +324,7 @@ protected Compiled(TypeDescription instrumentedType) { } @Override - public TypeWriter.MethodPool.Record assemble(MethodAttributeAppender attributeAppender, MethodDescription methodDescription) { + public TypeWriter.MethodPool.Record assemble(MethodDescription methodDescription, MethodAttributeAppender attributeAppender) { return TypeWriter.MethodPool.Record.ForDefinedMethod.OfVisibilityBridge.of(instrumentedType, methodDescription, attributeAppender); } @@ -507,15 +454,17 @@ private Default(List entries) { @Override public MethodRegistry prepend(LatentMethodMatcher methodMatcher, Handler handler, - MethodAttributeAppender.Factory attributeAppenderFactory) { - return new Default(join(new Entry(methodMatcher, handler, attributeAppenderFactory), entries)); + MethodAttributeAppender.Factory attributeAppenderFactory, + MethodTransformer methodTransformer) { + return new Default(join(new Entry(methodMatcher, handler, attributeAppenderFactory, methodTransformer), entries)); } @Override public MethodRegistry append(LatentMethodMatcher methodMatcher, Handler handler, - MethodAttributeAppender.Factory attributeAppenderFactory) { - return new Default(join(entries, new Entry(methodMatcher, handler, attributeAppenderFactory))); + MethodAttributeAppender.Factory attributeAppenderFactory, + MethodTransformer methodTransformer) { + return new Default(join(entries, new Entry(methodMatcher, handler, attributeAppenderFactory, methodTransformer))); } @Override @@ -531,7 +480,7 @@ public MethodRegistry.Prepared prepare(InstrumentedType instrumentedType, ElementMatcher handledMethods = noneOf(helperMethods); helperMethods = instrumentedType.getDeclaredMethods(); for (MethodDescription helperMethod : helperMethods.filter(handledMethods)) { - implementations.put(helperMethod, entry.asPreparedEntry(Collections.emptySet())); + implementations.put(helperMethod, entry.asPreparedEntry(helperMethod, Collections.emptySet())); } } } @@ -543,7 +492,7 @@ public MethodRegistry.Prepared prepare(InstrumentedType instrumentedType, if (relevanceMatcher.matches(methodDescription)) { for (Entry entry : entries) { if (entry.resolve(instrumentedType).matches(methodDescription)) { - implementations.put(methodDescription, entry.asPreparedEntry(node.getBridges())); + implementations.put(methodDescription, entry.asPreparedEntry(methodDescription, node.getBridges())); visibilityBridge = false; break; } @@ -562,7 +511,7 @@ public MethodRegistry.Prepared prepare(InstrumentedType instrumentedType, MethodDescription typeInitializer = new MethodDescription.Latent.TypeInitializer(instrumentedType); for (Entry entry : entries) { if (entry.resolve(instrumentedType).matches(typeInitializer)) { - implementations.put(typeInitializer, entry.asPreparedEntry(Collections.emptySet())); + implementations.put(typeInitializer, entry.asPreparedEntry(typeInitializer, Collections.emptySet())); break; } } @@ -612,6 +561,8 @@ protected static class Entry implements LatentMethodMatcher { */ private final MethodAttributeAppender.Factory attributeAppenderFactory; + private final MethodTransformer methodTransformer; + /** * Creates a new entry. * @@ -619,10 +570,14 @@ protected static class Entry implements LatentMethodMatcher { * @param handler The handler to apply to all matched entries. * @param attributeAppenderFactory A method attribute appender factory to apply to all entries. */ - protected Entry(LatentMethodMatcher methodMatcher, Handler handler, MethodAttributeAppender.Factory attributeAppenderFactory) { + protected Entry(LatentMethodMatcher methodMatcher, + Handler handler, + MethodAttributeAppender.Factory attributeAppenderFactory, + MethodTransformer methodTransformer) { this.methodMatcher = methodMatcher; this.handler = handler; this.attributeAppenderFactory = attributeAppenderFactory; + this.methodTransformer = methodTransformer; } /** @@ -631,8 +586,8 @@ protected Entry(LatentMethodMatcher methodMatcher, Handler handler, MethodAttrib * @param bridges The bridges to be appended to this entry. * @return A prepared version of this entry. */ - protected Prepared.Entry asPreparedEntry(Set bridges) { - return new Prepared.Entry(handler, attributeAppenderFactory, bridges); + protected Prepared.Entry asPreparedEntry(MethodDescription methodDescription, Set bridges) { + return new Prepared.Entry(handler, attributeAppenderFactory, methodTransformer.transform(methodDescription), bridges); } /** @@ -656,7 +611,8 @@ public boolean equals(Object other) { Entry entry = (Entry) other; return methodMatcher.equals(entry.methodMatcher) && handler.equals(entry.handler) - && attributeAppenderFactory.equals(entry.attributeAppenderFactory); + && attributeAppenderFactory.equals(entry.attributeAppenderFactory) + && methodTransformer.equals(entry.methodTransformer); } @Override @@ -664,6 +620,7 @@ public int hashCode() { int result = methodMatcher.hashCode(); result = 31 * result + handler.hashCode(); result = 31 * result + attributeAppenderFactory.hashCode(); + result = 31 * result + methodTransformer.hashCode(); return result; } @@ -673,6 +630,7 @@ public String toString() { "methodMatcher=" + methodMatcher + ", handler=" + handler + ", attributeAppenderFactory=" + attributeAppenderFactory + + ", methodTransformer=" + methodTransformer + '}'; } } @@ -765,7 +723,10 @@ public MethodRegistry.Compiled compile(Implementation.Target.Factory implementat cachedAttributeAppender = entry.getValue().getAppenderFactory().make(instrumentedType); attributeAppenderCache.put(entry.getValue().getAppenderFactory(), cachedAttributeAppender); } - entries.put(entry.getKey(), new Compiled.Entry(cachedHandler, cachedAttributeAppender, entry.getValue().getBridges())); + entries.put(entry.getKey(), new Compiled.Entry(cachedHandler, + cachedAttributeAppender, + entry.getValue().getMethodDescription(), + entry.getValue().getBridges())); } return new Compiled(instrumentedType, loadedTypeInitializer, typeInitializer, entries); } @@ -816,7 +777,7 @@ protected static class Entry { * @return An entry representing a visibility bridge. */ protected static Entry forVisibilityBridge(MethodDescription bridgeTarget, Set bridges) { - return new Entry(Handler.ForVisibilityBridge.INSTANCE, new MethodAttributeAppender.ForMethod(bridgeTarget), bridges); + return new Entry(Handler.ForVisibilityBridge.INSTANCE, new MethodAttributeAppender.ForMethod(bridgeTarget), bridgeTarget, bridges); } /** @@ -829,6 +790,8 @@ protected static Entry forVisibilityBridge(MethodDescription bridgeTarget, Set bridges) { + protected Entry(Handler handler, + MethodAttributeAppender.Factory attributeAppenderFactory, + MethodDescription methodDescription, + Set bridges) { this.handler = handler; this.attributeAppenderFactory = attributeAppenderFactory; + this.methodDescription = methodDescription; this.bridges = bridges; } @@ -865,6 +832,10 @@ protected MethodAttributeAppender.Factory getAppenderFactory() { return attributeAppenderFactory; } + protected MethodDescription getMethodDescription() { + return methodDescription; + } + /** * A set of bridges for the implemented method. * @@ -881,6 +852,7 @@ public boolean equals(Object other) { Entry entry = (Entry) other; return handler.equals(entry.handler) && attributeAppenderFactory.equals(entry.attributeAppenderFactory) + && methodDescription.equals(entry.methodDescription) && bridges.equals(entry.bridges); } @@ -888,6 +860,7 @@ public boolean equals(Object other) { public int hashCode() { int result = handler.hashCode(); result = 31 * result + attributeAppenderFactory.hashCode(); + result = 31 * result + methodDescription.hashCode(); result = 31 * result + bridges.hashCode(); return result; } @@ -897,6 +870,7 @@ public String toString() { return "MethodRegistry.Default.Prepared.Entry{" + "handler=" + handler + ", attributeAppenderFactory=" + attributeAppenderFactory + + ", methodDescription=" + methodDescription + ", bridges=" + bridges + '}'; } @@ -971,7 +945,7 @@ public Record target(MethodDescription methodDescription) { Entry entry = implementations.get(methodDescription); return entry == null ? Record.ForNonDefinedMethod.INSTANCE - : entry.bind(methodDescription, instrumentedType); + : entry.bind(instrumentedType); } @Override @@ -1004,48 +978,28 @@ public String toString() { '}'; } - /** - * An entry of a compiled method registry. - */ protected static class Entry { - /** - * The compiled handler to be used for any implemented method. - */ - private final Handler.Compiled compiledHandler; + private final Handler.Compiled handler; - /** - * The attribute appender to be used for any implemented method. - */ private final MethodAttributeAppender attributeAppender; - /** - * The bridges added to any implemented method. - */ + private final MethodDescription methodDescription; + private final Set bridges; - /** - * Creates a new entry of a compiled method registry. - * - * @param compiledHandler The compiled handler to be used for any implemented method. - * @param attributeAppender The attribute appender to be used for any implemented method. - * @param bridges The bridges added to any implemented method. - */ - protected Entry(Handler.Compiled compiledHandler, MethodAttributeAppender attributeAppender, Set bridges) { - this.compiledHandler = compiledHandler; + public Entry(Handler.Compiled handler, + MethodAttributeAppender attributeAppender, + MethodDescription methodDescription, + Set bridges) { + this.handler = handler; this.attributeAppender = attributeAppender; + this.methodDescription = methodDescription; this.bridges = bridges; } - /** - * Binds this entry to the provided method description. - * - * @param methodDescription The method to be bound. - * @param instrumentedType The instrumented type. - * @return A record for implementing the provided method for the instrumented type. - */ - protected Record bind(MethodDescription methodDescription, TypeDescription instrumentedType) { - return Record.AccessBridgeWrapper.of(compiledHandler.assemble(attributeAppender, methodDescription), + protected Record bind(TypeDescription instrumentedType) { + return TypeWriter.MethodPool.Record.AccessBridgeWrapper.of(handler.assemble(methodDescription, attributeAppender), instrumentedType, methodDescription, bridges, @@ -1057,15 +1011,17 @@ public boolean equals(Object other) { if (this == other) return true; if (other == null || getClass() != other.getClass()) return false; Entry entry = (Entry) other; - return compiledHandler.equals(entry.compiledHandler) + return handler.equals(entry.handler) && attributeAppender.equals(entry.attributeAppender) + && methodDescription.equals(entry.methodDescription) && bridges.equals(entry.bridges); } @Override public int hashCode() { - int result = compiledHandler.hashCode(); + int result = handler.hashCode(); result = 31 * result + attributeAppender.hashCode(); + result = 31 * result + methodDescription.hashCode(); result = 31 * result + bridges.hashCode(); return result; } @@ -1073,8 +1029,9 @@ public int hashCode() { @Override public String toString() { return "MethodRegistry.Default.Compiled.Entry{" + - "compiledHandler=" + compiledHandler + + "handler=" + handler + ", attributeAppender=" + attributeAppender + + ", methodDescription=" + methodDescription + ", bridges=" + bridges + '}'; } diff --git a/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/scaffold/TypeWriter.java b/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/scaffold/TypeWriter.java index 6deaf0a468f..7fc4395f1ff 100644 --- a/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/scaffold/TypeWriter.java +++ b/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/scaffold/TypeWriter.java @@ -15,7 +15,6 @@ import net.bytebuddy.description.type.generic.GenericTypeList; import net.bytebuddy.dynamic.ClassFileLocator; import net.bytebuddy.dynamic.DynamicType; -import net.bytebuddy.dynamic.ModifierResolver; import net.bytebuddy.dynamic.scaffold.inline.MethodRebaseResolver; import net.bytebuddy.implementation.Implementation; import net.bytebuddy.implementation.LoadedTypeInitializer; @@ -267,12 +266,7 @@ interface Record { */ Sort getSort(); - /** - * Returns this entry's modifier transformer. - * - * @return The modifier transformer of this entry. - */ - ModifierResolver getModifierResolver(); + MethodDescription getImplementedMethod(); /** * Prepends the given method appender to this entry. @@ -398,8 +392,8 @@ public void applyHead(MethodVisitor methodVisitor) { } @Override - public ModifierResolver getModifierResolver() { - throw new IllegalStateException("Cannot transform modifier for method that should be skipped"); + public MethodDescription getImplementedMethod() { + throw new IllegalStateException("A method that is not defined cannot be extracted"); } @Override @@ -423,16 +417,9 @@ public String toString() { */ abstract class ForDefinedMethod implements Record { - /** - * Returns the method this record implements. - * - * @return The method this record implements. - */ - protected abstract MethodDescription getImplementedMethod(); - @Override public void apply(ClassVisitor classVisitor, Implementation.Context implementationContext) { - MethodVisitor methodVisitor = classVisitor.visitMethod(getModifierResolver().transform(getImplementedMethod(), getSort().isImplemented()), + MethodVisitor methodVisitor = classVisitor.visitMethod(getImplementedMethod().getAdjustedModifiers(getSort().isImplemented()), getImplementedMethod().getInternalName(), getImplementedMethod().getDescriptor(), getImplementedMethod().getGenericSignature(), @@ -468,11 +455,6 @@ public static class WithBody extends ForDefinedMethod { */ private final MethodAttributeAppender methodAttributeAppender; - /** - * The modifier resolver to apply to the implemented method. - */ - private final ModifierResolver modifierResolver; - /** * Creates a new record for an implemented method without attributes or a modifier resolver. * @@ -480,7 +462,7 @@ public static class WithBody extends ForDefinedMethod { * @param byteCodeAppender The byte code appender to apply. */ public WithBody(MethodDescription methodDescription, ByteCodeAppender byteCodeAppender) { - this(methodDescription, byteCodeAppender, MethodAttributeAppender.NoOp.INSTANCE, ModifierResolver.Retaining.INSTANCE); + this(methodDescription, byteCodeAppender, MethodAttributeAppender.NoOp.INSTANCE); } /** @@ -489,20 +471,15 @@ public WithBody(MethodDescription methodDescription, ByteCodeAppender byteCodeAp * @param methodDescription The implemented method. * @param byteCodeAppender The byte code appender to apply. * @param methodAttributeAppender The method attribute appender to apply. - * @param modifierResolver The modifier resolver to apply to the implemented method. */ - public WithBody(MethodDescription methodDescription, - ByteCodeAppender byteCodeAppender, - MethodAttributeAppender methodAttributeAppender, - ModifierResolver modifierResolver) { + public WithBody(MethodDescription methodDescription, ByteCodeAppender byteCodeAppender, MethodAttributeAppender methodAttributeAppender) { this.methodDescription = methodDescription; this.byteCodeAppender = byteCodeAppender; this.methodAttributeAppender = methodAttributeAppender; - this.modifierResolver = modifierResolver; } @Override - protected MethodDescription getImplementedMethod() { + public MethodDescription getImplementedMethod() { return methodDescription; } @@ -511,11 +488,6 @@ public Sort getSort() { return Sort.IMPLEMENTED; } - @Override - public ModifierResolver getModifierResolver() { - return modifierResolver; - } - @Override public void applyHead(MethodVisitor methodVisitor) { /* do nothing */ @@ -531,10 +503,7 @@ public void applyBody(MethodVisitor methodVisitor, Implementation.Context implem @Override public Record prepend(ByteCodeAppender byteCodeAppender) { - return new WithBody(methodDescription, - new ByteCodeAppender.Compound(byteCodeAppender, this.byteCodeAppender), - methodAttributeAppender, - modifierResolver); + return new WithBody(methodDescription, new ByteCodeAppender.Compound(byteCodeAppender, this.byteCodeAppender), methodAttributeAppender); } @Override @@ -544,8 +513,7 @@ public boolean equals(Object other) { WithBody withBody = (WithBody) other; return methodDescription.equals(withBody.methodDescription) && byteCodeAppender.equals(withBody.byteCodeAppender) - && methodAttributeAppender.equals(withBody.methodAttributeAppender) - && modifierResolver.equals(withBody.modifierResolver); + && methodAttributeAppender.equals(withBody.methodAttributeAppender); } @Override @@ -553,7 +521,6 @@ public int hashCode() { int result = methodDescription.hashCode(); result = 31 * result + byteCodeAppender.hashCode(); result = 31 * result + methodAttributeAppender.hashCode(); - result = 31 * result + modifierResolver.hashCode(); return result; } @@ -563,7 +530,6 @@ public String toString() { "methodDescription=" + methodDescription + ", byteCodeAppender=" + byteCodeAppender + ", methodAttributeAppender=" + methodAttributeAppender + - ", modifierResolver=" + modifierResolver + '}'; } } @@ -583,28 +549,19 @@ public static class WithoutBody extends ForDefinedMethod { */ private final MethodAttributeAppender methodAttributeAppender; - /** - * The modifier resolver to apply to the method that is being created. - */ - private final ModifierResolver modifierResolver; - /** * Creates a new entry for a method that is defines but does not append byte code, i.e. is native or abstract. * * @param methodDescription The implemented method. * @param methodAttributeAppender The method attribute appender to apply. - * @param modifierResolver The modifier resolver to apply to the method that is being created. */ - public WithoutBody(MethodDescription methodDescription, - MethodAttributeAppender methodAttributeAppender, - ModifierResolver modifierResolver) { + public WithoutBody(MethodDescription methodDescription, MethodAttributeAppender methodAttributeAppender) { this.methodDescription = methodDescription; this.methodAttributeAppender = methodAttributeAppender; - this.modifierResolver = modifierResolver; } @Override - protected MethodDescription getImplementedMethod() { + public MethodDescription getImplementedMethod() { return methodDescription; } @@ -613,11 +570,6 @@ public Sort getSort() { return Sort.DEFINED; } - @Override - public ModifierResolver getModifierResolver() { - return modifierResolver; - } - @Override public void applyHead(MethodVisitor methodVisitor) { /* do nothing */ @@ -639,15 +591,13 @@ public boolean equals(Object other) { if (other == null || getClass() != other.getClass()) return false; WithoutBody that = (WithoutBody) other; return methodDescription.equals(that.methodDescription) - && methodAttributeAppender.equals(that.methodAttributeAppender) - && modifierResolver.equals(that.modifierResolver); + && methodAttributeAppender.equals(that.methodAttributeAppender); } @Override public int hashCode() { int result = methodDescription.hashCode(); result = 31 * result + methodAttributeAppender.hashCode(); - result = 31 * result + modifierResolver.hashCode(); return result; } @@ -656,7 +606,6 @@ public String toString() { return "TypeWriter.MethodPool.Record.ForDefinedMethod.WithoutBody{" + "methodDescription=" + methodDescription + ", methodAttributeAppender=" + methodAttributeAppender + - ", modifierResolver=" + modifierResolver + '}'; } } @@ -681,31 +630,23 @@ public static class WithAnnotationDefaultValue extends ForDefinedMethod { */ private final MethodAttributeAppender methodAttributeAppender; - /** - * The modifier resolver to apply to the method that is being created. - */ - private final ModifierResolver modifierResolver; - /** * Creates a new entry for defining a method with a default annotation value. * * @param methodDescription The implemented method. * @param annotationValue The annotation value to define. * @param methodAttributeAppender The method attribute appender to apply. - * @param modifierResolver The modifier resolver to apply to the method that is being created. */ public WithAnnotationDefaultValue(MethodDescription methodDescription, Object annotationValue, - MethodAttributeAppender methodAttributeAppender, - ModifierResolver modifierResolver) { + MethodAttributeAppender methodAttributeAppender) { this.methodDescription = methodDescription; this.annotationValue = annotationValue; this.methodAttributeAppender = methodAttributeAppender; - this.modifierResolver = modifierResolver; } @Override - protected MethodDescription getImplementedMethod() { + public MethodDescription getImplementedMethod() { return methodDescription; } @@ -714,11 +655,6 @@ public Sort getSort() { return Sort.DEFINED; } - @Override - public ModifierResolver getModifierResolver() { - return modifierResolver; - } - @Override public void applyHead(MethodVisitor methodVisitor) { if (!methodDescription.isDefaultValue(annotationValue)) { @@ -749,8 +685,7 @@ public boolean equals(Object other) { WithAnnotationDefaultValue that = (WithAnnotationDefaultValue) other; return methodDescription.equals(that.methodDescription) && annotationValue.equals(that.annotationValue) - && methodAttributeAppender.equals(that.methodAttributeAppender) - && modifierResolver.equals(that.modifierResolver); + && methodAttributeAppender.equals(that.methodAttributeAppender); } @Override @@ -758,7 +693,6 @@ public int hashCode() { int result = methodDescription.hashCode(); result = 31 * result + annotationValue.hashCode(); result = 31 * result + methodAttributeAppender.hashCode(); - result = 31 * result + modifierResolver.hashCode(); return result; } @@ -768,7 +702,6 @@ public String toString() { "methodDescription=" + methodDescription + ", annotationValue=" + annotationValue + ", methodAttributeAppender=" + methodAttributeAppender + - ", modifierResolver=" + modifierResolver + '}'; } } @@ -832,7 +765,7 @@ protected OfVisibilityBridge(MethodDescription visibilityBridge, } @Override - protected MethodDescription getImplementedMethod() { + public MethodDescription getImplementedMethod() { return visibilityBridge; } @@ -841,17 +774,9 @@ public Sort getSort() { return Sort.IMPLEMENTED; } - @Override - public ModifierResolver getModifierResolver() { - return ModifierResolver.Retaining.INSTANCE; - } - @Override public Record prepend(ByteCodeAppender byteCodeAppender) { - return new ForDefinedMethod.WithBody(visibilityBridge, - new ByteCodeAppender.Compound(this, byteCodeAppender), - attributeAppender, - ModifierResolver.Retaining.INSTANCE); + return new ForDefinedMethod.WithBody(visibilityBridge, new ByteCodeAppender.Compound(this, byteCodeAppender), attributeAppender); } @Override @@ -1070,8 +995,8 @@ public Sort getSort() { } @Override - public ModifierResolver getModifierResolver() { - return delegate.getModifierResolver(); + public MethodDescription getImplementedMethod() { + return bridgeTarget; } @Override @@ -2162,7 +2087,7 @@ protected MethodVisitor redefine(MethodDescription methodDescription, boolean ab methodDescription.getGenericSignature(), methodDescription.getExceptionTypes().asRawTypes().toInternalNames()); } - MethodVisitor methodVisitor = super.visitMethod(record.getModifierResolver().transform(methodDescription, record.getSort().isImplemented()), + MethodVisitor methodVisitor = super.visitMethod(methodDescription.getAdjustedModifiers(record.getSort().isImplemented()), methodDescription.getInternalName(), methodDescription.getDescriptor(), methodDescription.getGenericSignature(), diff --git a/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/scaffold/subclass/ConstructorStrategy.java b/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/scaffold/subclass/ConstructorStrategy.java index 74b8bc39abc..c0687f7ab77 100644 --- a/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/scaffold/subclass/ConstructorStrategy.java +++ b/byte-buddy-dep/src/main/java/net/bytebuddy/dynamic/scaffold/subclass/ConstructorStrategy.java @@ -4,7 +4,7 @@ import net.bytebuddy.description.method.MethodList; import net.bytebuddy.description.type.TypeDescription; import net.bytebuddy.description.type.generic.GenericTypeDescription; -import net.bytebuddy.dynamic.ModifierResolver; +import net.bytebuddy.dynamic.MethodTransformer; import net.bytebuddy.dynamic.scaffold.MethodRegistry; import net.bytebuddy.implementation.SuperMethodCall; import net.bytebuddy.implementation.attribute.MethodAttributeAppender; @@ -89,8 +89,9 @@ public List extractConstructors(TypeDescription instrum @Override public MethodRegistry inject(MethodRegistry methodRegistry, MethodAttributeAppender.Factory defaultMethodAttributeAppenderFactory) { return methodRegistry.append(new LatentMethodMatcher.Resolved(isConstructor()), - new MethodRegistry.Handler.ForImplementation(SuperMethodCall.INSTANCE, ModifierResolver.Retaining.INSTANCE), - defaultMethodAttributeAppenderFactory); + new MethodRegistry.Handler.ForImplementation(SuperMethodCall.INSTANCE), + defaultMethodAttributeAppenderFactory, + MethodTransformer.Retaining.INSTANCE); } }, @@ -112,8 +113,9 @@ public List extractConstructors(TypeDescription instrum @Override public MethodRegistry inject(MethodRegistry methodRegistry, MethodAttributeAppender.Factory defaultMethodAttributeAppenderFactory) { return methodRegistry.append(new LatentMethodMatcher.Resolved(isConstructor()), - new MethodRegistry.Handler.ForImplementation(SuperMethodCall.INSTANCE, ModifierResolver.Retaining.INSTANCE), - defaultMethodAttributeAppenderFactory); + new MethodRegistry.Handler.ForImplementation(SuperMethodCall.INSTANCE), + defaultMethodAttributeAppenderFactory, + MethodTransformer.Retaining.INSTANCE); } }, @@ -134,8 +136,9 @@ public List extractConstructors(TypeDescription instrum @Override public MethodRegistry inject(MethodRegistry methodRegistry, MethodAttributeAppender.Factory defaultMethodAttributeAppenderFactory) { return methodRegistry.append(new LatentMethodMatcher.Resolved(isConstructor()), - new MethodRegistry.Handler.ForImplementation(SuperMethodCall.INSTANCE, ModifierResolver.Retaining.INSTANCE), - defaultMethodAttributeAppenderFactory); + new MethodRegistry.Handler.ForImplementation(SuperMethodCall.INSTANCE), + defaultMethodAttributeAppenderFactory, + MethodTransformer.Retaining.INSTANCE); } }; diff --git a/byte-buddy-dep/src/main/java/net/bytebuddy/implementation/Implementation.java b/byte-buddy-dep/src/main/java/net/bytebuddy/implementation/Implementation.java index 29730668bad..f4de368b606 100644 --- a/byte-buddy-dep/src/main/java/net/bytebuddy/implementation/Implementation.java +++ b/byte-buddy-dep/src/main/java/net/bytebuddy/implementation/Implementation.java @@ -10,7 +10,6 @@ import net.bytebuddy.description.type.generic.GenericTypeDescription; import net.bytebuddy.description.type.generic.GenericTypeList; import net.bytebuddy.dynamic.DynamicType; -import net.bytebuddy.dynamic.ModifierResolver; import net.bytebuddy.dynamic.scaffold.InstrumentedType; import net.bytebuddy.dynamic.scaffold.MethodGraph; import net.bytebuddy.dynamic.scaffold.TypeWriter; @@ -1107,7 +1106,7 @@ protected AbstractDelegationRecord(MethodDescription methodDescription) { } @Override - protected MethodDescription getImplementedMethod() { + public MethodDescription getImplementedMethod() { return methodDescription; } @@ -1116,11 +1115,6 @@ public Sort getSort() { return Sort.IMPLEMENTED; } - @Override - public ModifierResolver getModifierResolver() { - return ModifierResolver.Retaining.INSTANCE; - } - @Override public void applyHead(MethodVisitor methodVisitor) { /* do nothing */ @@ -1135,7 +1129,7 @@ public void applyBody(MethodVisitor methodVisitor, Context implementationContext @Override public TypeWriter.MethodPool.Record prepend(ByteCodeAppender byteCodeAppender) { - throw new UnsupportedOperationException("Cannot prepend code to a delegator"); + throw new UnsupportedOperationException("Cannot prepend code to a delegation"); } @Override diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/AbstractDynamicTypeBuilderTest.java b/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/AbstractDynamicTypeBuilderTest.java index 3d17f73752d..608dd30bc9a 100644 --- a/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/AbstractDynamicTypeBuilderTest.java +++ b/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/AbstractDynamicTypeBuilderTest.java @@ -1,7 +1,7 @@ package net.bytebuddy.dynamic; -import net.bytebuddy.asm.ClassVisitorWrapper; import net.bytebuddy.description.method.MethodDescription; +import net.bytebuddy.description.modifier.MethodManifestation; import net.bytebuddy.description.modifier.Ownership; import net.bytebuddy.description.modifier.TypeManifestation; import net.bytebuddy.description.modifier.Visibility; @@ -16,8 +16,6 @@ import net.bytebuddy.test.utility.ClassFileExtraction; import org.hamcrest.CoreMatchers; import org.junit.Test; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.MethodVisitor; import org.objectweb.asm.Opcodes; import java.lang.reflect.Constructor; @@ -35,8 +33,6 @@ import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; -import static org.mockito.Mockito.*; - public abstract class AbstractDynamicTypeBuilderTest { @@ -198,19 +194,16 @@ public void testConstructorInvokingMethod() throws Exception { } @Test - public void testModifierTransformation() throws Exception { - ModifierResolver modifierResolver = mock(ModifierResolver.class); - MethodDescription toString = TypeDescription.OBJECT.getDeclaredMethods().filter(named("toString")).getOnly(); - when(modifierResolver.transform(toString, true)).thenReturn(Opcodes.ACC_FINAL | Opcodes.ACC_PUBLIC); + public void testMethodTransformation() throws Exception { Class type = createPlain() .method(named(TO_STRING)) - .intercept(new Implementation.Simple(new TextConstant(FOO), MethodReturn.REFERENCE), modifierResolver) + .intercept(new Implementation.Simple(new TextConstant(FOO), MethodReturn.REFERENCE), + MethodTransformer.Transforming.modifiers(MethodManifestation.FINAL)) .make() .load(new URLClassLoader(new URL[0], null), ClassLoadingStrategy.Default.WRAPPER) .getLoaded(); assertThat(type.newInstance().toString(), is(FOO)); assertThat(type.getDeclaredMethod(TO_STRING).getModifiers(), is(Opcodes.ACC_FINAL | Opcodes.ACC_PUBLIC)); - verify(modifierResolver).transform(toString, true); } @Test diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/ModifierResolverDesynchronizing.java b/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/ModifierResolverDesynchronizing.java deleted file mode 100644 index 0d2a33977ac..00000000000 --- a/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/ModifierResolverDesynchronizing.java +++ /dev/null @@ -1,51 +0,0 @@ -package net.bytebuddy.dynamic; - -import net.bytebuddy.description.method.MethodDescription; -import net.bytebuddy.test.utility.MockitoRule; -import net.bytebuddy.test.utility.ObjectPropertyAssertion; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TestRule; -import org.mockito.Mock; -import org.objectweb.asm.Opcodes; - -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.core.Is.is; -import static org.mockito.Matchers.anyBoolean; -import static org.mockito.Mockito.*; - -public class ModifierResolverDesynchronizing { - - private static final int MODIFIERS = 42; - - @Rule - public TestRule mockitoRule = new MockitoRule(this); - - @Mock - public MethodDescription methodDescription; - - @Before - public void setUp() throws Exception { - when(methodDescription.getAdjustedModifiers(anyBoolean())).thenReturn(MODIFIERS); - } - - @Test - public void testModifierResolutionImplemented() throws Exception { - assertThat(ModifierResolver.Desynchronizing.INSTANCE.transform(methodDescription, true), is(MODIFIERS & ~Opcodes.ACC_SYNCHRONIZED)); - verify(methodDescription).getAdjustedModifiers(true); - verifyNoMoreInteractions(methodDescription); - } - - @Test - public void testModifierResolutionNonImplemented() throws Exception { - assertThat(ModifierResolver.Desynchronizing.INSTANCE.transform(methodDescription, false), is(MODIFIERS & ~Opcodes.ACC_SYNCHRONIZED)); - verify(methodDescription).getAdjustedModifiers(false); - verifyNoMoreInteractions(methodDescription); - } - - @Test - public void testObjectProperties() throws Exception { - ObjectPropertyAssertion.of(ModifierResolver.Desynchronizing.class).apply(); - } -} diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/ModifierResolverRetainingTest.java b/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/ModifierResolverRetainingTest.java deleted file mode 100644 index 98fffafbb8c..00000000000 --- a/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/ModifierResolverRetainingTest.java +++ /dev/null @@ -1,50 +0,0 @@ -package net.bytebuddy.dynamic; - -import net.bytebuddy.description.method.MethodDescription; -import net.bytebuddy.test.utility.MockitoRule; -import net.bytebuddy.test.utility.ObjectPropertyAssertion; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TestRule; -import org.mockito.Mock; - -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.core.Is.is; -import static org.mockito.Matchers.anyBoolean; -import static org.mockito.Mockito.*; - -public class ModifierResolverRetainingTest { - - private static final int MODIFIERS = 42; - - @Rule - public TestRule mockitoRule = new MockitoRule(this); - - @Mock - public MethodDescription methodDescription; - - @Before - public void setUp() throws Exception { - when(methodDescription.getAdjustedModifiers(anyBoolean())).thenReturn(MODIFIERS); - } - - @Test - public void testModifierResolutionImplemented() throws Exception { - assertThat(ModifierResolver.Retaining.INSTANCE.transform(methodDescription, true), is(MODIFIERS)); - verify(methodDescription).getAdjustedModifiers(true); - verifyNoMoreInteractions(methodDescription); - } - - @Test - public void testModifierResolutionNonImplemented() throws Exception { - assertThat(ModifierResolver.Retaining.INSTANCE.transform(methodDescription, false), is(MODIFIERS)); - verify(methodDescription).getAdjustedModifiers(false); - verifyNoMoreInteractions(methodDescription); - } - - @Test - public void testObjectProperties() throws Exception { - ObjectPropertyAssertion.of(ModifierResolver.Retaining.class).apply(); - } -} diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/scaffold/MethodRegistryDefaultTest.java b/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/scaffold/MethodRegistryDefaultTest.java index 3e66519ff38..74f41fe9dbd 100644 --- a/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/scaffold/MethodRegistryDefaultTest.java +++ b/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/scaffold/MethodRegistryDefaultTest.java @@ -4,6 +4,7 @@ import net.bytebuddy.description.method.MethodList; import net.bytebuddy.description.type.TypeDescription; import net.bytebuddy.description.type.generic.GenericTypeDescription; +import net.bytebuddy.dynamic.MethodTransformer; import net.bytebuddy.implementation.Implementation; import net.bytebuddy.implementation.LoadedTypeInitializer; import net.bytebuddy.implementation.attribute.MethodAttributeAppender; @@ -74,6 +75,9 @@ public class MethodRegistryDefaultTest { @Mock private Implementation.Target implementationTarget; + @Mock + private MethodTransformer methodTransformer; + @Before @SuppressWarnings("unchecked") public void setUp() throws Exception { @@ -94,18 +98,19 @@ public void setUp() throws Exception { when(firstFactory.make(typeDescription)).thenReturn(firstAppender); when(secondFactory.make(typeDescription)).thenReturn(secondAppender); when(implementationTargetFactory.make(typeDescription, methodGraph)).thenReturn(implementationTarget); - when(firstCompiledHandler.assemble(firstAppender, instrumentedMethod)).thenReturn(firstRecord); - when(secondCompiledHandler.assemble(secondAppender, instrumentedMethod)).thenReturn(secondRecord); + when(firstCompiledHandler.assemble(instrumentedMethod, firstAppender)).thenReturn(firstRecord); + when(secondCompiledHandler.assemble(instrumentedMethod, secondAppender)).thenReturn(secondRecord); when(typeDescription.asRawType()).thenReturn(typeDescription); when(implementationTarget.getTypeDescription()).thenReturn(typeDescription); + when(methodTransformer.transform(instrumentedMethod)).thenReturn(instrumentedMethod); } @Test public void testNonMatchedIsNotIncluded() throws Exception { when(resolvedMethodFilter.matches(instrumentedMethod)).thenReturn(true); MethodRegistry.Prepared methodRegistry = new MethodRegistry.Default() - .append(firstMatcher, firstHandler, firstFactory) - .append(secondMatcher, secondHandler, secondFactory) + .append(firstMatcher, firstHandler, firstFactory, methodTransformer) + .append(secondMatcher, secondHandler, secondFactory, methodTransformer) .prepare(firstType, methodGraphCompiler, methodFilter); assertThat(methodRegistry.getInstrumentedType(), is((TypeDescription) typeDescription)); assertThat(methodRegistry.getInstrumentedMethods().size(), is(0)); @@ -120,8 +125,8 @@ public void testIgnoredIsNotIncluded() throws Exception { when(firstFilter.matches(instrumentedMethod)).thenReturn(true); when(secondFilter.matches(instrumentedMethod)).thenReturn(true); MethodRegistry.Prepared methodRegistry = new MethodRegistry.Default() - .append(firstMatcher, firstHandler, firstFactory) - .append(secondMatcher, secondHandler, secondFactory) + .append(firstMatcher, firstHandler, firstFactory, methodTransformer) + .append(secondMatcher, secondHandler, secondFactory, methodTransformer) .prepare(firstType, methodGraphCompiler, methodFilter); assertThat(methodRegistry.getInstrumentedType(), is((TypeDescription) typeDescription)); assertThat(methodRegistry.getInstrumentedMethods().size(), is(0)); @@ -137,8 +142,8 @@ public void testMatchedFirst() throws Exception { when(resolvedMethodFilter.matches(instrumentedMethod)).thenReturn(true); when(firstFilter.matches(instrumentedMethod)).thenReturn(true); MethodRegistry.Prepared methodRegistry = new MethodRegistry.Default() - .append(firstMatcher, firstHandler, firstFactory) - .append(secondMatcher, secondHandler, secondFactory) + .append(firstMatcher, firstHandler, firstFactory, methodTransformer) + .append(secondMatcher, secondHandler, secondFactory, methodTransformer) .prepare(firstType, methodGraphCompiler, methodFilter); assertThat(methodRegistry.getInstrumentedType(), is((TypeDescription) typeDescription)); assertThat(methodRegistry.getInstrumentedMethods(), is((MethodList) new MethodList.Explicit(Collections.singletonList(instrumentedMethod)))); @@ -154,8 +159,8 @@ public void testMatchedSecond() throws Exception { when(resolvedMethodFilter.matches(instrumentedMethod)).thenReturn(true); when(secondFilter.matches(instrumentedMethod)).thenReturn(true); MethodRegistry.Prepared methodRegistry = new MethodRegistry.Default() - .append(firstMatcher, firstHandler, firstFactory) - .append(secondMatcher, secondHandler, secondFactory) + .append(firstMatcher, firstHandler, firstFactory, methodTransformer) + .append(secondMatcher, secondHandler, secondFactory, methodTransformer) .prepare(firstType, methodGraphCompiler, methodFilter); assertThat(methodRegistry.getInstrumentedType(), is((TypeDescription) typeDescription)); assertThat(methodRegistry.getInstrumentedMethods(), is((MethodList) new MethodList.Explicit(Collections.singletonList(instrumentedMethod)))); @@ -172,14 +177,14 @@ public void testMultipleRegistryDoesNotPrepareMultipleTimes() throws Exception { when(firstFilter.matches(instrumentedMethod)).thenReturn(true); when(secondFilter.matches(instrumentedMethod)).thenReturn(true); MethodRegistry.Prepared methodRegistry = new MethodRegistry.Default() - .append(firstMatcher, firstHandler, firstFactory) - .append(firstMatcher, firstHandler, firstFactory) - .append(secondMatcher, firstHandler, firstFactory) - .append(secondMatcher, firstHandler, secondFactory) - .append(secondMatcher, secondHandler, secondFactory) - .append(firstMatcher, secondHandler, secondFactory) - .append(firstMatcher, firstHandler, secondFactory) - .append(firstMatcher, secondHandler, firstFactory) + .append(firstMatcher, firstHandler, firstFactory, methodTransformer) + .append(firstMatcher, firstHandler, firstFactory, methodTransformer) + .append(secondMatcher, firstHandler, firstFactory, methodTransformer) + .append(secondMatcher, firstHandler, secondFactory, methodTransformer) + .append(secondMatcher, secondHandler, secondFactory, methodTransformer) + .append(firstMatcher, secondHandler, secondFactory, methodTransformer) + .append(firstMatcher, firstHandler, secondFactory, methodTransformer) + .append(firstMatcher, secondHandler, firstFactory, methodTransformer) .prepare(firstType, methodGraphCompiler, methodFilter); assertThat(methodRegistry.getInstrumentedType(), is((TypeDescription) typeDescription)); assertThat(methodRegistry.getInstrumentedMethods(), is((MethodList) new MethodList.Explicit(Collections.singletonList(instrumentedMethod)))); @@ -197,8 +202,8 @@ public void testCompiledAppendingMatchesFirstAppended() throws Exception { when(secondFilter.matches(instrumentedMethod)).thenReturn(true); when(resolvedMethodFilter.matches(instrumentedMethod)).thenReturn(true); MethodRegistry.Compiled methodRegistry = new MethodRegistry.Default() - .append(firstMatcher, firstHandler, firstFactory) - .append(secondMatcher, secondHandler, secondFactory) + .append(firstMatcher, firstHandler, firstFactory, methodTransformer) + .append(secondMatcher, secondHandler, secondFactory, methodTransformer) .prepare(firstType, methodGraphCompiler, methodFilter) .compile(implementationTargetFactory); assertThat(methodRegistry.getInstrumentedType(), is((TypeDescription) typeDescription)); @@ -220,8 +225,8 @@ public void testCompiledPrependingMatchesLastPrepended() throws Exception { when(secondFilter.matches(instrumentedMethod)).thenReturn(true); when(resolvedMethodFilter.matches(instrumentedMethod)).thenReturn(true); MethodRegistry.Compiled methodRegistry = new MethodRegistry.Default() - .append(secondMatcher, secondHandler, secondFactory) - .prepend(firstMatcher, firstHandler, firstFactory) + .append(secondMatcher, secondHandler, secondFactory, methodTransformer) + .prepend(firstMatcher, firstHandler, firstFactory, methodTransformer) .prepare(firstType, methodGraphCompiler, methodFilter) .compile(implementationTargetFactory); assertThat(methodRegistry.getInstrumentedType(), is((TypeDescription) typeDescription)); @@ -243,8 +248,8 @@ public void testCompiledAppendingMatchesSecondAppendedIfFirstDoesNotMatch() thro when(secondFilter.matches(instrumentedMethod)).thenReturn(true); when(resolvedMethodFilter.matches(instrumentedMethod)).thenReturn(true); MethodRegistry.Compiled methodRegistry = new MethodRegistry.Default() - .append(firstMatcher, firstHandler, firstFactory) - .append(secondMatcher, secondHandler, secondFactory) + .append(firstMatcher, firstHandler, firstFactory, methodTransformer) + .append(secondMatcher, secondHandler, secondFactory, methodTransformer) .prepare(firstType, methodGraphCompiler, methodFilter) .compile(implementationTargetFactory); assertThat(methodRegistry.getInstrumentedType(), is((TypeDescription) typeDescription)); @@ -268,8 +273,8 @@ public void testSkipEntryIfNotMatchedAndVisible() throws Exception { when(declaringType.asRawType()).thenReturn(declaringType); when(instrumentedMethod.getDeclaringType()).thenReturn(declaringType); MethodRegistry.Compiled methodRegistry = new MethodRegistry.Default() - .append(firstMatcher, firstHandler, firstFactory) - .append(secondMatcher, secondHandler, secondFactory) + .append(firstMatcher, firstHandler, firstFactory, methodTransformer) + .append(secondMatcher, secondHandler, secondFactory, methodTransformer) .prepare(firstType, methodGraphCompiler, methodFilter) .compile(implementationTargetFactory); assertThat(methodRegistry.getInstrumentedType(), is((TypeDescription) typeDescription)); @@ -304,8 +309,8 @@ public void testVisibilityBridgeIfNotMatchedAndVisible() throws Exception { when(methodToken.accept(any(GenericTypeDescription.Visitor.class))).thenReturn(methodToken); when(typeDescription.accept(any(GenericTypeDescription.Visitor.class))).thenReturn(typeDescription); MethodRegistry.Compiled methodRegistry = new MethodRegistry.Default() - .append(firstMatcher, firstHandler, firstFactory) - .append(secondMatcher, secondHandler, secondFactory) + .append(firstMatcher, firstHandler, firstFactory, methodTransformer) + .append(secondMatcher, secondHandler, secondFactory, methodTransformer) .prepare(firstType, methodGraphCompiler, methodFilter) .compile(implementationTargetFactory); assertThat(methodRegistry.getInstrumentedType(), is((TypeDescription) typeDescription)); diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/scaffold/MethodRegistryHandlerTest.java b/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/scaffold/MethodRegistryHandlerTest.java index 08cdcde97ee..eafc15d4f40 100644 --- a/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/scaffold/MethodRegistryHandlerTest.java +++ b/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/scaffold/MethodRegistryHandlerTest.java @@ -1,8 +1,6 @@ package net.bytebuddy.dynamic.scaffold; import net.bytebuddy.description.method.MethodDescription; -import net.bytebuddy.description.type.TypeDescription; -import net.bytebuddy.dynamic.ModifierResolver; import net.bytebuddy.implementation.Implementation; import net.bytebuddy.implementation.attribute.MethodAttributeAppender; import net.bytebuddy.test.utility.MockitoRule; @@ -48,9 +46,6 @@ public class MethodRegistryHandlerTest { @Mock private MethodDescription methodDescription; - @Mock - private ModifierResolver modifierResolver; - @Before public void setUp() throws Exception { when(implementation.prepare(instrumentedType)).thenReturn(preparedInstrumentedType); @@ -58,29 +53,26 @@ public void setUp() throws Exception { @Test public void testHandlerForAbstractMethod() throws Exception { - MethodRegistry.Handler handler = new MethodRegistry.Handler.ForAbstractMethod(modifierResolver); + MethodRegistry.Handler handler = MethodRegistry.Handler.ForAbstractMethod.INSTANCE; assertThat(handler.prepare(instrumentedType), is(instrumentedType)); - TypeWriter.MethodPool.Record record = handler.compile(implementationTarget).assemble(attributeAppender, methodDescription); + TypeWriter.MethodPool.Record record = handler.compile(implementationTarget).assemble(methodDescription, attributeAppender); assertThat(record.getSort(), is(TypeWriter.MethodPool.Record.Sort.DEFINED)); - assertThat(record.getModifierResolver(), is(modifierResolver)); } @Test public void testHandlerForImplementation() throws Exception { - MethodRegistry.Handler handler = new MethodRegistry.Handler.ForImplementation(implementation, modifierResolver); + MethodRegistry.Handler handler = new MethodRegistry.Handler.ForImplementation(implementation); assertThat(handler.prepare(instrumentedType), is(preparedInstrumentedType)); - TypeWriter.MethodPool.Record record = handler.compile(implementationTarget).assemble(attributeAppender, methodDescription); + TypeWriter.MethodPool.Record record = handler.compile(implementationTarget).assemble(methodDescription, attributeAppender); assertThat(record.getSort(), is(TypeWriter.MethodPool.Record.Sort.IMPLEMENTED)); - assertThat(record.getModifierResolver(), is(modifierResolver)); } @Test public void testHandlerForAnnotationValue() throws Exception { - MethodRegistry.Handler handler = new MethodRegistry.Handler.ForAnnotationValue(annotationValue, modifierResolver); + MethodRegistry.Handler handler = new MethodRegistry.Handler.ForAnnotationValue(annotationValue); assertThat(handler.prepare(instrumentedType), is(instrumentedType)); - TypeWriter.MethodPool.Record record = handler.compile(implementationTarget).assemble(attributeAppender, methodDescription); + TypeWriter.MethodPool.Record record = handler.compile(implementationTarget).assemble(methodDescription, attributeAppender); assertThat(record.getSort(), is(TypeWriter.MethodPool.Record.Sort.DEFINED)); - assertThat(record.getModifierResolver(), is(modifierResolver)); } @Test(expected = IllegalStateException.class) diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/scaffold/TypeWriterMethodPoolRecordTest.java b/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/scaffold/TypeWriterMethodPoolRecordTest.java index 5b0c58666c8..6f8ef3ca060 100644 --- a/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/scaffold/TypeWriterMethodPoolRecordTest.java +++ b/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/scaffold/TypeWriterMethodPoolRecordTest.java @@ -6,7 +6,6 @@ import net.bytebuddy.description.type.TypeDescription; import net.bytebuddy.description.type.TypeList; import net.bytebuddy.description.type.generic.GenericTypeList; -import net.bytebuddy.dynamic.ModifierResolver; import net.bytebuddy.implementation.Implementation; import net.bytebuddy.implementation.attribute.MethodAttributeAppender; import net.bytebuddy.implementation.bytecode.ByteCodeAppender; @@ -71,9 +70,6 @@ public class TypeWriterMethodPoolRecordTest { @Mock private ParameterDescription parameterDescription; - @Mock - private ModifierResolver modifierResolver; - @Mock private TypeWriter.MethodPool.Record delegate; @@ -90,7 +86,6 @@ public void setUp() throws Exception { when(methodDescription.getDescriptor()).thenReturn(BAR); when(methodDescription.getGenericSignature()).thenReturn(QUX); when(methodDescription.getExceptionTypes()).thenReturn(exceptionTypes); - when(modifierResolver.transform(eq(methodDescription), anyBoolean())).thenReturn(MODIFIERS); when(methodDescription.getAdjustedModifiers(anyBoolean())).thenReturn(MODIFIERS); when(exceptionTypes.asRawTypes()).thenReturn(rawExceptionTypes); when(rawExceptionTypes.toInternalNames()).thenReturn(new String[]{BAZ}); @@ -132,9 +127,7 @@ public void testSkippedMethodCannotBeAppliedHead() throws Exception { @Test public void testDefinedMethod() throws Exception { - TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.ForDefinedMethod.WithoutBody(methodDescription, - methodAttributeAppender, - modifierResolver); + TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.ForDefinedMethod.WithoutBody(methodDescription, methodAttributeAppender); assertThat(record.getSort(), is(TypeWriter.MethodPool.Record.Sort.DEFINED)); record.apply(classVisitor, implementationContext); verify(classVisitor).visitMethod(MODIFIERS, FOO, BAR, QUX, new String[]{BAZ}); @@ -150,9 +143,7 @@ public void testDefinedMethod() throws Exception { public void testDefinedMethodHeadOnly() throws Exception { when(parameterDescription.hasModifiers()).thenReturn(true); when(parameterDescription.isNamed()).thenReturn(true); - TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.ForDefinedMethod.WithoutBody(methodDescription, - methodAttributeAppender, - modifierResolver); + TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.ForDefinedMethod.WithoutBody(methodDescription, methodAttributeAppender); record.applyHead(methodVisitor); verifyZeroInteractions(methodVisitor); verifyZeroInteractions(implementationContext); @@ -163,9 +154,7 @@ public void testDefinedMethodHeadOnly() throws Exception { public void testDefinedMethodBodyOnly() throws Exception { when(parameterDescription.hasModifiers()).thenReturn(true); when(parameterDescription.isNamed()).thenReturn(true); - TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.ForDefinedMethod.WithoutBody(methodDescription, - methodAttributeAppender, - modifierResolver); + TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.ForDefinedMethod.WithoutBody(methodDescription, methodAttributeAppender); record.applyBody(methodVisitor, implementationContext); verifyZeroInteractions(methodVisitor); verifyZeroInteractions(implementationContext); @@ -176,9 +165,7 @@ public void testDefinedMethodBodyOnly() throws Exception { public void testDefinedMethodWithParameters() throws Exception { when(parameterDescription.hasModifiers()).thenReturn(true); when(parameterDescription.isNamed()).thenReturn(true); - TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.ForDefinedMethod.WithoutBody(methodDescription, - methodAttributeAppender, - modifierResolver); + TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.ForDefinedMethod.WithoutBody(methodDescription, methodAttributeAppender); assertThat(record.getSort(), is(TypeWriter.MethodPool.Record.Sort.DEFINED)); record.apply(classVisitor, implementationContext); verify(classVisitor).visitMethod(MODIFIERS, FOO, BAR, QUX, new String[]{BAZ}); @@ -193,7 +180,7 @@ public void testDefinedMethodWithParameters() throws Exception { @Test(expected = IllegalStateException.class) public void testDefinedMethodPrepended() throws Exception { - new TypeWriter.MethodPool.Record.ForDefinedMethod.WithoutBody(methodDescription, methodAttributeAppender, modifierResolver).prepend(otherAppender); + new TypeWriter.MethodPool.Record.ForDefinedMethod.WithoutBody(methodDescription, methodAttributeAppender).prepend(otherAppender); } @Test @@ -202,8 +189,7 @@ public void testDefaultValueMethod() throws Exception { when(methodDescription.isDefaultValue(FOO)).thenReturn(true); TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.ForDefinedMethod.WithAnnotationDefaultValue(methodDescription, FOO, - methodAttributeAppender, - modifierResolver); + methodAttributeAppender); assertThat(record.getSort(), is(TypeWriter.MethodPool.Record.Sort.DEFINED)); record.apply(classVisitor, implementationContext); verify(classVisitor).visitMethod(MODIFIERS, FOO, BAR, QUX, new String[]{BAZ}); @@ -227,8 +213,7 @@ public void testDefaultValueMethodHeadOnly() throws Exception { when(methodDescription.isDefaultValue(FOO)).thenReturn(true); TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.ForDefinedMethod.WithAnnotationDefaultValue(methodDescription, FOO, - methodAttributeAppender, - modifierResolver); + methodAttributeAppender); record.applyHead(methodVisitor); verify(methodVisitor).visitAnnotationDefault(); verifyNoMoreInteractions(methodVisitor); @@ -245,8 +230,7 @@ public void testDefaultValueMethodBodyOnly() throws Exception { when(parameterDescription.isNamed()).thenReturn(true); TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.ForDefinedMethod.WithAnnotationDefaultValue(methodDescription, FOO, - methodAttributeAppender, - modifierResolver); + methodAttributeAppender); record.applyBody(methodVisitor, implementationContext); verifyZeroInteractions(methodVisitor); verifyZeroInteractions(implementationContext); @@ -262,8 +246,7 @@ public void testDefaultValueMethodWithParameters() throws Exception { when(methodDescription.isDefaultValue(FOO)).thenReturn(true); TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.ForDefinedMethod.WithAnnotationDefaultValue(methodDescription, FOO, - methodAttributeAppender, - modifierResolver); + methodAttributeAppender); assertThat(record.getSort(), is(TypeWriter.MethodPool.Record.Sort.DEFINED)); record.apply(classVisitor, implementationContext); verify(classVisitor).visitMethod(MODIFIERS, FOO, BAR, QUX, new String[]{BAZ}); @@ -282,27 +265,22 @@ public void testDefaultValueMethodWithParameters() throws Exception { @Test(expected = IllegalStateException.class) public void testDefaultValueMethodPrepended() throws Exception { - new TypeWriter.MethodPool.Record.ForDefinedMethod.WithAnnotationDefaultValue(methodDescription, - FOO, - methodAttributeAppender, - modifierResolver).prepend(otherAppender); + new TypeWriter.MethodPool.Record.ForDefinedMethod.WithAnnotationDefaultValue(methodDescription, FOO, methodAttributeAppender) + .prepend(otherAppender); } @Test(expected = IllegalStateException.class) public void testNoDefaultValue() throws Exception { when(methodDescription.isDefaultValue(FOO)).thenReturn(false); - new TypeWriter.MethodPool.Record.ForDefinedMethod.WithAnnotationDefaultValue(methodDescription, - FOO, - methodAttributeAppender, - modifierResolver).apply(classVisitor, implementationContext); + new TypeWriter.MethodPool.Record.ForDefinedMethod.WithAnnotationDefaultValue(methodDescription, FOO, methodAttributeAppender) + .apply(classVisitor, implementationContext); } @Test public void testImplementedMethod() throws Exception { TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.ForDefinedMethod.WithBody(methodDescription, byteCodeAppender, - methodAttributeAppender, - modifierResolver); + methodAttributeAppender); assertThat(record.getSort(), is(TypeWriter.MethodPool.Record.Sort.IMPLEMENTED)); record.apply(classVisitor, implementationContext); verify(classVisitor).visitMethod(MODIFIERS, FOO, BAR, QUX, new String[]{BAZ}); @@ -324,8 +302,7 @@ public void testImplementedMethodHeadOnly() throws Exception { when(parameterDescription.isNamed()).thenReturn(true); TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.ForDefinedMethod.WithBody(methodDescription, byteCodeAppender, - methodAttributeAppender, - modifierResolver); + methodAttributeAppender); record.applyHead(methodVisitor); verifyNoMoreInteractions(methodVisitor); verifyZeroInteractions(implementationContext); @@ -339,8 +316,7 @@ public void testImplementedMethodBodyOnly() throws Exception { when(parameterDescription.isNamed()).thenReturn(true); TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.ForDefinedMethod.WithBody(methodDescription, byteCodeAppender, - methodAttributeAppender, - modifierResolver); + methodAttributeAppender); record.applyBody(methodVisitor, implementationContext); verify(methodVisitor).visitCode(); verify(methodVisitor).visitMaxs(ONE, TWO); @@ -357,8 +333,7 @@ public void testImplementedMethodWithParameters() throws Exception { when(parameterDescription.isNamed()).thenReturn(true); TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.ForDefinedMethod.WithBody(methodDescription, byteCodeAppender, - methodAttributeAppender, - modifierResolver); + methodAttributeAppender); assertThat(record.getSort(), is(TypeWriter.MethodPool.Record.Sort.IMPLEMENTED)); record.apply(classVisitor, implementationContext); verify(classVisitor).visitMethod(MODIFIERS, FOO, BAR, QUX, new String[]{BAZ}); @@ -379,8 +354,7 @@ public void testImplementedMethodWithParameters() throws Exception { public void testImplementedMethodPrepended() throws Exception { TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.ForDefinedMethod.WithBody(methodDescription, byteCodeAppender, - methodAttributeAppender, - modifierResolver) + methodAttributeAppender) .prepend(otherAppender); assertThat(record.getSort(), is(TypeWriter.MethodPool.Record.Sort.IMPLEMENTED)); record.apply(classVisitor, implementationContext); @@ -405,7 +379,6 @@ public void testVisibilityBridgeProperties() throws Exception { bridgeTarget, superType, methodAttributeAppender); - assertThat(record.getModifierResolver(), instanceOf(ModifierResolver.Retaining.class)); assertThat(record.getSort(), is(TypeWriter.MethodPool.Record.Sort.IMPLEMENTED)); } @@ -420,14 +393,12 @@ public void testVisibilityBridgePrepending() throws Exception { @Test public void testAccessorBridgeProperties() throws Exception { when(delegate.getSort()).thenReturn(TypeWriter.MethodPool.Record.Sort.IMPLEMENTED); - when(delegate.getModifierResolver()).thenReturn(modifierResolver); TypeWriter.MethodPool.Record record = new TypeWriter.MethodPool.Record.AccessBridgeWrapper(delegate, instrumentedType, bridgeTarget, Collections.singleton(typeToken), methodAttributeAppender); assertThat(record.getSort(), Is.is(TypeWriter.MethodPool.Record.Sort.IMPLEMENTED)); - assertThat(record.getModifierResolver(), Is.is(modifierResolver)); } @Test diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/scaffold/subclass/ConstructorStrategyDefaultTest.java b/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/scaffold/subclass/ConstructorStrategyDefaultTest.java index b3beab1f10d..fcea6acfd41 100644 --- a/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/scaffold/subclass/ConstructorStrategyDefaultTest.java +++ b/byte-buddy-dep/src/test/java/net/bytebuddy/dynamic/scaffold/subclass/ConstructorStrategyDefaultTest.java @@ -3,6 +3,7 @@ import net.bytebuddy.description.ByteCodeElement; import net.bytebuddy.description.method.MethodDescription; import net.bytebuddy.description.method.MethodList; +import net.bytebuddy.dynamic.MethodTransformer; import net.bytebuddy.dynamic.scaffold.InstrumentedType; import net.bytebuddy.dynamic.scaffold.MethodRegistry; import net.bytebuddy.implementation.attribute.MethodAttributeAppender; @@ -48,7 +49,8 @@ public class ConstructorStrategyDefaultTest { public void setUp() throws Exception { when(methodRegistry.append(any(LatentMethodMatcher.class), any(MethodRegistry.Handler.class), - any(MethodAttributeAppender.Factory.class))).thenReturn(methodRegistry); + any(MethodAttributeAppender.Factory.class), + any(MethodTransformer.class))).thenReturn(methodRegistry); when(instrumentedType.getSuperType()).thenReturn(superType); when(superType.getDeclaredMethods()).thenReturn((MethodList) methodList); when(superType.asRawType()).thenReturn(superType); @@ -70,7 +72,10 @@ public void testImitateSuperTypeStrategy() throws Exception { assertThat(ConstructorStrategy.Default.IMITATE_SUPER_TYPE.extractConstructors(instrumentedType), is((List) filteredMethodTokenList)); assertThat(ConstructorStrategy.Default.IMITATE_SUPER_TYPE.inject(methodRegistry, methodAttributeAppenderFactory), is(methodRegistry)); - verify(methodRegistry).append(any(LatentMethodMatcher.class), any(MethodRegistry.Handler.class), eq(methodAttributeAppenderFactory)); + verify(methodRegistry).append(any(LatentMethodMatcher.class), + any(MethodRegistry.Handler.class), + eq(methodAttributeAppenderFactory), + eq(MethodTransformer.Retaining.INSTANCE)); verifyNoMoreInteractions(methodRegistry); verify(instrumentedType, atLeastOnce()).getSuperType(); verifyNoMoreInteractions(instrumentedType); @@ -83,7 +88,10 @@ public void testImitateSuperTypePublicStrategy() throws Exception { assertThat(ConstructorStrategy.Default.IMITATE_SUPER_TYPE_PUBLIC.extractConstructors(instrumentedType), is((List) filteredMethodTokenList)); assertThat(ConstructorStrategy.Default.IMITATE_SUPER_TYPE_PUBLIC.inject(methodRegistry, methodAttributeAppenderFactory), is(methodRegistry)); - verify(methodRegistry).append(any(LatentMethodMatcher.class), any(MethodRegistry.Handler.class), eq(methodAttributeAppenderFactory)); + verify(methodRegistry).append(any(LatentMethodMatcher.class), + any(MethodRegistry.Handler.class), + eq(methodAttributeAppenderFactory), + eq(MethodTransformer.Retaining.INSTANCE)); verifyNoMoreInteractions(methodRegistry); verify(instrumentedType, atLeastOnce()).getSuperType(); verifyNoMoreInteractions(instrumentedType); @@ -97,7 +105,10 @@ public void testDefaultConstructorStrategy() throws Exception { assertThat(ConstructorStrategy.Default.DEFAULT_CONSTRUCTOR.extractConstructors(instrumentedType), is((List) filteredMethodTokenList)); assertThat(ConstructorStrategy.Default.DEFAULT_CONSTRUCTOR.inject(methodRegistry, methodAttributeAppenderFactory), is(methodRegistry)); - verify(methodRegistry).append(any(LatentMethodMatcher.class), any(MethodRegistry.Handler.class), eq(methodAttributeAppenderFactory)); + verify(methodRegistry).append(any(LatentMethodMatcher.class), + any(MethodRegistry.Handler.class), + eq(methodAttributeAppenderFactory), + eq(MethodTransformer.Retaining.INSTANCE)); verifyNoMoreInteractions(methodRegistry); verify(instrumentedType, atLeastOnce()).getSuperType(); verifyNoMoreInteractions(instrumentedType);