add a fix for #11758; the bug is fixed by checking the reference metadata first and only loading definitions if a @Replaces stereotype is present on the reference.

Author: Jarvx

inject/src/main/java/io/micronaut/context/DefaultBeanContext.java

@@ -2521,14 +2521,58 @@ protected void processParallelBeans(List<BeanDefinitionProducer> parallelBeans)
 
     private <T> void filterReplacedBeans(BeanResolutionContext resolutionContext, Collection<BeanDefinition<T>> candidates) {
         if (candidates.size() > 1) {
+            // Collect replacement definitions not only from the current candidates, but also
+            // from the global registry so replacements declared elsewhere are considered.
             List<BeanDefinition<T>> replacementTypes = new ArrayList<>(2);
+
+            // 1) Check already-loaded candidates for @Replaces
             for (BeanDefinition<T> candidate : candidates) {
                 if (candidate.getAnnotationMetadata().hasStereotype(REPLACES_ANN)) {
                     replacementTypes.add(candidate);
                 }
             }
+
+            // 2) Scan global bean producers for references that declare @Replaces.
+            // Try to use the reference metadata first to avoid loading the full definition.
+            for (BeanDefinitionProducer producer : this.beanDefinitionsClasses) {
+                BeanDefinitionReference<?> ref = producer.getReferenceIfEnabled(this);
+                if (ref == null) {
+                    continue;
+                }
+                if (ref.getAnnotationMetadata().hasStereotype(REPLACES_ANN)) {
+                    // We need a BeanDefinition to perform detailed replace matching.
+                    // Use getDefinitionIfEnabled which may load/cached the definition.
+                    @SuppressWarnings("unchecked") BeanDefinition<T> def = (BeanDefinition<T>) producer.getDefinitionIfEnabled(this);
+                    if (def != null) {
+                        replacementTypes.add(def);
+                    }
+                }
+            }
+
             if (!replacementTypes.isEmpty()) {
-                candidates.removeIf(definition -> checkIfReplacementExists(resolutionContext, replacementTypes, definition));
+                candidates.removeIf(definition -> {
+                    boolean replaced = checkIfReplacementExists(resolutionContext, replacementTypes, definition);
+                    if (replaced) {
+                        // Targeted cache invalidation: purge candidate & resolution caches for the replaced bean type
+                        try {
+                            purgeCacheForBeanType(definition.getBeanType());
+                        } catch (Exception e) {
+                            if (LOG.isDebugEnabled()) {
+                                LOG.debug("Error purging caches for replaced bean type [{}]: {}", definition.getBeanType(), e.getMessage(), e);
+                            }
+                        }
+                        // Remove any singleton registration associated with the replaced definition so subsequent lookups
+                        // don't return the stale instance.
+                        try {
+                            singletonScope.removeRegistrationForDefinition(definition);
+                        } catch (Exception e) {
+                            if (LOG.isDebugEnabled()) {
+                                LOG.debug("Error removing singleton registration for replaced bean definition [{}]: {}", definition, e.getMessage(), e);
+                            }
+                        }
+                    }
+                    return replaced;
+                });
             }
         }
     }

inject/src/main/java/io/micronaut/context/SingletonScope.java

@@ -304,6 +304,21 @@ synchronized <T> void purgeCacheForBeanInstance(BeanDefinition<T> beanDefinition
         singletonByArgumentAndQualifier.entrySet().removeIf(entry -> entry.getKey().beanType.isInstance(bean));
     }
 
+    /**
+     * Remove any singleton registration associated with the given bean definition.
+     * This is a targeted cache invalidation used when a bean definition is replaced.
+     *
+     * @param beanDefinition The bean definition whose registration should be removed
+     */
+    synchronized void removeRegistrationForDefinition(BeanDefinition<?> beanDefinition) {
+        BeanDefinitionIdentity id = BeanDefinitionIdentity.of(beanDefinition);
+        BeanRegistration removed = singletonByBeanDefinition.remove(id);
+        if (removed != null) {
+            // Remove any indexed entries that point to the removed registration.
+            singletonByArgumentAndQualifier.entrySet().removeIf(entry -> entry.getValue() == removed);
+        }
+    }
+
     /**
      * Cleanup the scope.
      */