Add contextual naming strategy and make it default for Graal builds.

raphw · raphw · commit 54b22a380cfe · 2021-11-07T21:01:18.000+01:00
diff --git a/byte-buddy-dep/src/main/java/net/bytebuddy/ByteBuddy.java b/byte-buddy-dep/src/main/java/net/bytebuddy/ByteBuddy.java
@@ -105,9 +105,10 @@ public class ByteBuddy {
 
     /**
      * A property that controls the default naming strategy. If not set, Byte Buddy is generating
-     * random names for types that are not named explicitly. If set to {@code fixed}, Byte Buddy is setting
-     * names deterministically without any random element. If set to a numeric value, Byte Buddy
-     * is generating random names using the number as a seed.
+     * random names for types that are not named explicitly. If set to {@code fixed}, Byte Buddy is
+     * setting names deterministically without any random element, or to {@code caller}, if a name
+     * should be fixed but contain the name of the caller class and method. If set to a numeric
+     * value, Byte Buddy is generating random names, using the number as a seed.
      */
     public static final String DEFAULT_NAMING_PROPERTY = "net.bytebuddy.naming";
 
@@ -141,7 +142,7 @@ public class ByteBuddy {
         if (value == null) {
             if (GraalImageCode.getCurrent().isDefined()) {
                 namingStrategy = new NamingStrategy.Suffixing(BYTE_BUDDY_DEFAULT_PREFIX,
-                        NamingStrategy.Suffixing.BaseNameResolver.ForUnnamedType.INSTANCE,
+                        new NamingStrategy.Suffixing.BaseNameResolver.WithCallerSuffix(NamingStrategy.Suffixing.BaseNameResolver.ForUnnamedType.INSTANCE),
                         NamingStrategy.BYTE_BUDDY_RENAME_PACKAGE);
                 auxiliaryNamingStrategy = new AuxiliaryType.NamingStrategy.Enumerating(BYTE_BUDDY_DEFAULT_SUFFIX);
             } else {
@@ -153,6 +154,11 @@ public class ByteBuddy {
                     NamingStrategy.Suffixing.BaseNameResolver.ForUnnamedType.INSTANCE,
                     NamingStrategy.BYTE_BUDDY_RENAME_PACKAGE);
             auxiliaryNamingStrategy = new AuxiliaryType.NamingStrategy.Enumerating(BYTE_BUDDY_DEFAULT_SUFFIX);
+        } else if (value.equalsIgnoreCase("caller")) {
+            namingStrategy = new NamingStrategy.Suffixing(BYTE_BUDDY_DEFAULT_PREFIX,
+                    new NamingStrategy.Suffixing.BaseNameResolver.WithCallerSuffix(NamingStrategy.Suffixing.BaseNameResolver.ForUnnamedType.INSTANCE),
+                    NamingStrategy.BYTE_BUDDY_RENAME_PACKAGE);
+            auxiliaryNamingStrategy = new AuxiliaryType.NamingStrategy.Enumerating(BYTE_BUDDY_DEFAULT_SUFFIX);
         } else {
             long seed;
             try {
diff --git a/byte-buddy-dep/src/main/java/net/bytebuddy/NamingStrategy.java b/byte-buddy-dep/src/main/java/net/bytebuddy/NamingStrategy.java
@@ -272,6 +272,48 @@ public String resolve(TypeDescription typeDescription) {
                     return name;
                 }
             }
+
+            /**
+             * A base name resolver that adds the name of the class that is invoking {@link ByteBuddy}. This
+             * base name resolver can therefore not be invoked directly.
+             */
+            @HashCodeAndEqualsPlugin.Enhance
+            class WithCallerSuffix implements BaseNameResolver {
+
+                /**
+                 * The base name resolver that is resolving the base name.
+                 */
+                private final BaseNameResolver delegate;
+
+                /**
+                 * Creates a new base name resolver that appends a caller suffix.
+                 *
+                 * @param delegate The base name resolver that is resolving the base name.
+                 */
+                public WithCallerSuffix(BaseNameResolver delegate) {
+                    this.delegate = delegate;
+                }
+
+                /**
+                 * {@inheritDoc}
+                 */
+                public String resolve(TypeDescription typeDescription) {
+                    boolean matched = false;
+                    String caller = null;
+                    for (StackTraceElement stackTraceElement : new Throwable().getStackTrace()) {
+                        if (stackTraceElement.getClassName().equals(ByteBuddy.class.getName())) {
+                            matched = true;
+                        } else if (matched) {
+                            caller = stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName();
+                            break;
+                        }
+                    }
+                    if (caller == null) {
+                        throw new IllegalStateException("Base name resolver not invoked via " + ByteBuddy.class);
+                    }
+                    return delegate.resolve(typeDescription) + "$" + caller.replace('.', '$');
+                }
+            }
         }
     }
 
diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/ByteBuddyTest.java b/byte-buddy-dep/src/test/java/net/bytebuddy/ByteBuddyTest.java
@@ -188,6 +188,20 @@ public void testClassCompiledToJsr14() throws Exception {
                 .newInstance(), notNullValue());
     }
 
+    @Test
+    public void testCallerSuffixNamingStrategy() throws Exception {
+        Class<?> type = new ByteBuddy()
+                .with(new NamingStrategy.Suffixing("SuffixedName", new NamingStrategy.Suffixing.BaseNameResolver.WithCallerSuffix(
+                        new NamingStrategy.Suffixing.BaseNameResolver.ForFixedValue("foo.Bar"))))
+                .subclass(Object.class)
+                .make()
+                .load(ClassLoadingStrategy.BOOTSTRAP_LOADER, ClassLoadingStrategy.Default.WRAPPER)
+                .getLoaded();
+        assertThat(type.getName(), is("foo.Bar$"
+                + ByteBuddyTest.class.getName().replace('.', '$')
+                + "$testCallerSuffixNamingStrategy$SuffixedName"));
+    }
+
     public static class Recorder {
 
         public int counter;
diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/NamingStrategyTest.java b/byte-buddy-dep/src/test/java/net/bytebuddy/NamingStrategyTest.java
@@ -141,11 +141,6 @@ public void testSuffixingRandomRedefine() throws Exception {
         verifyNoMoreInteractions(rawTypeDescription);
     }
 
-
-
-
-
-
     @Test
     public void testBaseNameResolvers() throws Exception {
         assertThat(new NamingStrategy.SuffixingRandom.BaseNameResolver.ForFixedValue(FOO).resolve(rawTypeDescription), is(FOO));
@@ -182,4 +177,10 @@ public void testPrefixingRandomRedefine() throws Exception {
         verify(rawTypeDescription).getName();
         verifyNoMoreInteractions(rawTypeDescription);
     }
+
+    @Test(expected = IllegalStateException.class)
+    public void testCallerSen() {
+        new NamingStrategy.Suffixing.BaseNameResolver.WithCallerSuffix(mock(NamingStrategy.Suffixing.BaseNameResolver.class))
+                .resolve(mock(TypeDescription.class));
+    }
 }
