fix: prevent Lazy TypePool from drifting after type resolution (#1857)

A Lazy TypePool was mutating during type resolution, causing its
configuration to deviate from the initial state. This commit ensures
the TypePool retains its original configuration by freezing the base
state before resolution and isolating resolved types in a temporary
context.

Author: FuncGuy

byte-buddy-dep/src/main/java/net/bytebuddy/pool/TypePool.java

@@ -406,6 +406,66 @@ public void clear() {
             }
         }
 
+        /**
+         * A cache provider wrapper that avoids caching illegal resolutions so that future lookups can be reattempted.
+         */
+        @HashCodeAndEqualsPlugin.Enhance
+        class WithIllegalResolutionReattempt implements CacheProvider {
+
+            /**
+             * The delegated cache provider.
+             */
+            private final CacheProvider delegate;
+
+            /**
+             * Creates a new cache provider that suppresses caching of illegal resolutions.
+             *
+             * @param delegate The cache provider to delegate to.
+             */
+            public WithIllegalResolutionReattempt(CacheProvider delegate) {
+                this.delegate = delegate;
+            }
+
+            /**
+             * Returns a cache provider that suppresses caching of illegal resolutions without wrapping twice.
+             *
+             * @param cacheProvider The cache provider to potentially wrap.
+             * @return A cache provider that does not store illegal resolutions.
+             */
+            public static CacheProvider of(CacheProvider cacheProvider) {
+                return cacheProvider instanceof WithIllegalResolutionReattempt
+                        ? cacheProvider
+                        : new WithIllegalResolutionReattempt(cacheProvider);
+            }
+
+            /**
+             * {@inheritDoc}
+             */
+            @MaybeNull
+            public Resolution find(String name) {
+                Resolution resolution = delegate.find(name);
+                return resolution != null && !resolution.isResolved()
+                        ? UNRESOLVED
+                        : resolution;
+            }
+
+            /**
+             * {@inheritDoc}
+             */
+            public Resolution register(String name, Resolution resolution) {
+                return resolution.isResolved()
+                        ? delegate.register(name, resolution)
+                        : resolution;
+            }
+
+            /**
+             * {@inheritDoc}
+             */
+            public void clear() {
+                delegate.clear();
+            }
+        }
+
         /**
          * A discriminating cache provider that delegates a type name to one of two caches.
          */
@@ -1014,7 +1074,7 @@ public WithLazyResolution(CacheProvider cacheProvider, ClassFileLocator classFil
              * @param lazinessMode     The mode of lazy resolution.
              */
             public WithLazyResolution(CacheProvider cacheProvider, ClassFileLocator classFileLocator, ReaderMode readerMode, LazinessMode lazinessMode) {
-                super(cacheProvider, classFileLocator, readerMode);
+                super(CacheProvider.WithIllegalResolutionReattempt.of(cacheProvider), classFileLocator, readerMode);
                 this.lazinessMode = lazinessMode;
             }
 
@@ -1028,7 +1088,7 @@ public WithLazyResolution(CacheProvider cacheProvider, ClassFileLocator classFil
              * @param lazinessMode     The mode of lazy resolution.
              */
             public WithLazyResolution(CacheProvider cacheProvider, ClassFileLocator classFileLocator, ReaderMode readerMode, TypePool parentPool, LazinessMode lazinessMode) {
-                super(cacheProvider, classFileLocator, readerMode, parentPool);
+                super(CacheProvider.WithIllegalResolutionReattempt.of(cacheProvider), classFileLocator, readerMode, parentPool);
                 this.lazinessMode = lazinessMode;
             }
 
@@ -1042,7 +1102,7 @@ public WithLazyResolution(CacheProvider cacheProvider, ClassFileLocator classFil
              * @param lazinessMode       The mode of lazy resolution.
              */
             public WithLazyResolution(CacheProvider cacheProvider, ClassFileLocator classFileLocator, ReaderMode readerMode, AsmClassReader.Factory classReaderFactory, LazinessMode lazinessMode) {
-                super(cacheProvider, classFileLocator, readerMode, classReaderFactory);
+                super(CacheProvider.WithIllegalResolutionReattempt.of(cacheProvider), classFileLocator, readerMode, classReaderFactory);
                 this.lazinessMode = lazinessMode;
             }
 
@@ -1057,7 +1117,7 @@ public WithLazyResolution(CacheProvider cacheProvider, ClassFileLocator classFil
              * @param lazinessMode       The mode of lazy resolution.
              */
             public WithLazyResolution(CacheProvider cacheProvider, ClassFileLocator classFileLocator, ReaderMode readerMode, AsmClassReader.Factory classReaderFactory, TypePool parentPool, LazinessMode lazinessMode) {
-                super(cacheProvider, classFileLocator, readerMode, classReaderFactory, parentPool);
+                super(CacheProvider.WithIllegalResolutionReattempt.of(cacheProvider), classFileLocator, readerMode, classReaderFactory, parentPool);
                 this.lazinessMode = lazinessMode;
             }
 

byte-buddy-dep/src/test/java/net/bytebuddy/pool/TypePoolCacheProviderTest.java

@@ -1,5 +1,6 @@
 package net.bytebuddy.pool;
 
+import net.bytebuddy.description.type.TypeDescription;
 import net.bytebuddy.matcher.ElementMatchers;
 import org.junit.Rule;
 import org.junit.Test;
@@ -82,6 +83,18 @@ public void testDiscriminatingMatched() throws Exception {
         verify(unmatched).clear();
     }
 
+    @Test
+    public void testWithIllegalResolutionReattempt() throws Exception {
+        TypePool.CacheProvider cacheProvider = TypePool.CacheProvider.WithIllegalResolutionReattempt.of(new TypePool.CacheProvider.Simple());
+        TypePool.Resolution illegal = new TypePool.Resolution.Illegal(FOO);
+        assertThat(cacheProvider.register(FOO, illegal), sameInstance(illegal));
+        assertThat(cacheProvider.find(FOO), nullValue(TypePool.Resolution.class));
+        TypePool.Resolution legal = new TypePool.Resolution.Simple(TypeDescription.ForLoadedType.of(Object.class));
+        assertThat(cacheProvider.register(FOO, legal), sameInstance(legal));
+        assertThat(cacheProvider.find(FOO), sameInstance(legal));
+        assertThat(TypePool.CacheProvider.WithIllegalResolutionReattempt.of(cacheProvider), sameInstance(cacheProvider));
+    }
+
     @Test
     public void testDiscriminatingUnmatched() throws Exception {
         TypePool.CacheProvider matched = mock(TypePool.CacheProvider.class), unmatched = mock(TypePool.CacheProvider.class);

byte-buddy-dep/src/test/java/net/bytebuddy/pool/TypePoolDefaultWithLazyResolutionTypeDescriptionTest.java

@@ -77,6 +77,19 @@ protected TypeDescription.Generic describeInterfaceType(Class<?> type, int index
         return describe(type).getInterfaces().get(index);
     }
 
+    @Test
+    public void testIllegalResolutionDoesNotPersist() throws Exception {
+        TypePool typePool = new TypePool.Default.WithLazyResolution(new TypePool.CacheProvider.Simple(),
+                ClassFileLocator.NoOp.INSTANCE,
+                TypePool.Default.ReaderMode.FAST,
+                lazinessMode);
+        String name = "foo.Bar";
+        TypePool.Resolution resolution = typePool.describe(name);
+        assertThat(resolution.resolve().getName(), CoreMatchers.is(name));
+        assertThat(resolution.isResolved(), CoreMatchers.is(false));
+        assertThat(typePool.describe(name).resolve().getName(), CoreMatchers.is(name));
+    }
+
     @Test
     public void testTypeIsLazy() throws Exception {
         ClassFileLocator classFileLocator = spy(ClassFileLocator.ForClassLoader.ofSystemLoader());