Merge branch '7.4' into 8.0

nicolas-grekas · nicolas-grekas · commit 00bbe9c489ef · 2025-11-12T19:42:57.000+01:00
* 7.4:
  [Translation][Lokalise] fix "Project too big for sync export"
  [DependencyInjection] Fix lazy proxy creation for interfaces aliased to final classes
  [HttpKernel] Fix StreamedResponse with chunks support in HttpKernelBrowser
  [HttpFoundation] Fix AcceptHeader overwrites items with different parameters
  [JsonStreamer] Rebuild cache on class update
  [Routing] Fix default value not taken if usigng name:entity.attribute
  [Mime] Remove unused  variable in Email::prepareParts
  [DependencyInjection] Fix merging explicit tags and #[AsTaggeditem]
diff --git a/Attribute/AsTaggedItem.php b/Attribute/AsTaggedItem.php
@@ -20,8 +20,8 @@
 class AsTaggedItem
 {
     /**
-     * @param string|null $index    The property or method to use to index the item in the iterator/locator
-     * @param int|null    $priority The priority of the item; the higher the number, the earlier the tagged service will be located in the iterator/locator
+     * @param string|null $index    The index at which the service will be found when consuming tagged iterators/locators
+     * @param int|null    $priority The priority of the service in iterators/locators; the higher the number, the earlier it will
      */
     public function __construct(
         public ?string $index = null,
diff --git a/Compiler/AutowirePass.php b/Compiler/AutowirePass.php
@@ -335,9 +335,7 @@ private function autowireMethod(\ReflectionFunctionAbstract $reflectionMethod, a
                         $value = $this->doProcessValue($value);
                     } elseif ($lazy = $attribute->lazy) {
                         $value ??= $getValue();
-                        if ($this->container->has($value->getType())) {
-                            $type = $this->container->findDefinition($value->getType())->getClass();
-                        }
+                        $type = $this->resolveProxyType($type, $value->getType());
                         $definition = (new Definition($type))
                             ->setFactory('current')
                             ->setArguments([[$value]])
@@ -743,4 +741,26 @@ private function getCombinedAlias(string $type, ?string $name = null, ?string $t
 
         return $alias;
     }
+
+    /**
+     * Resolves the class name that should be proxied for a lazy service.
+     *
+     * @param string $originalType The original parameter type-hint (e.g., the interface)
+     * @param string $serviceId    The service ID the type-hint resolved to (e.g., the alias)
+     */
+    private function resolveProxyType(string $originalType, string $serviceId): string
+    {
+        if (!$this->container->has($serviceId)) {
+            return $originalType;
+        }
+
+        $resolvedType = $this->container->findDefinition($serviceId)->getClass();
+        $resolvedType = $this->container->getParameterBag()->resolveValue($resolvedType);
+
+        if (!$resolvedType || !class_exists($resolvedType, false) && !interface_exists($resolvedType, false)) {
+            return $originalType;
+        }
+
+        return $resolvedType;
+    }
 }
diff --git a/Compiler/PriorityTaggedServiceTrait.php b/Compiler/PriorityTaggedServiceTrait.php
@@ -65,61 +65,69 @@ private function findAndSortTaggedServices(string|TaggedIteratorArgument $tagNam
             $class = $definition->getClass();
             $class = $container->getParameterBag()->resolveValue($class) ?: null;
             $reflector = null !== $class ? $container->getReflectionClass($class) : null;
-            $checkTaggedItem = !$definition->hasTag($definition->isAutoconfigured() ? 'container.ignore_attributes' : $tagName);
+            $loadFromDefaultMethods = $reflector && null !== $defaultPriorityMethod;
+            $phpAttributes = $definition->isAutoconfigured() && !$definition->hasTag('container.ignore_attributes') ? $reflector?->getAttributes(AsTaggedItem::class) : [];
+
+            foreach ($phpAttributes ??= [] as $i => $attribute) {
+                $attribute = $attribute->newInstance();
+                $phpAttributes[$i] = [
+                    'priority' => $attribute->priority,
+                    $indexAttribute ?? '' => $attribute->index,
+                ];
+                if (null === $defaultPriority) {
+                    $defaultPriority = $attribute->priority ?? 0;
+                    $defaultIndex = $attribute->index;
+                }
+            }
+            if (1 >= \count($phpAttributes)) {
+                $phpAttributes = [];
+            }
+
+            for ($i = 0; $i < \count($attributes); ++$i) {
+                if (!($attribute = $attributes[$i]) && $phpAttributes) {
+                    array_splice($attributes, $i--, 1, $phpAttributes);
+                    continue;
+                }
 
-            foreach ($attributes as $attribute) {
                 $index = $priority = null;
 
                 if (isset($attribute['priority'])) {
                     $priority = $attribute['priority'];
-                } elseif (null === $defaultPriority && $defaultPriorityMethod && $reflector) {
-                    $defaultPriority = PriorityTaggedServiceUtil::getDefault($serviceId, $reflector, $defaultPriorityMethod, $tagName, 'priority', $checkTaggedItem);
+                } elseif ($loadFromDefaultMethods) {
+                    $defaultPriority = PriorityTaggedServiceUtil::getDefault($serviceId, $reflector, $defaultPriorityMethod, $tagName, 'priority') ?? $defaultPriority;
+                    $defaultIndex = PriorityTaggedServiceUtil::getDefault($serviceId, $reflector, $defaultIndexMethod ?? 'getDefaultName', $tagName, $indexAttribute) ?? $defaultIndex;
+                    $loadFromDefaultMethods = false;
                 }
                 $priority ??= $defaultPriority ??= 0;
 
                 if (null === $indexAttribute && !$defaultIndexMethod && !$needsIndexes) {
-                    $services[] = [$priority, ++$i, null, $serviceId, null];
+                    $services[] = [$priority, $i, null, $serviceId, null];
                     continue 2;
                 }
 
                 if (null !== $indexAttribute && isset($attribute[$indexAttribute])) {
                     $index = $parameterBag->resolveValue($attribute[$indexAttribute]);
                 }
-                if (null === $index && null === $defaultIndex && $defaultPriorityMethod && $reflector) {
-                    $defaultIndex = PriorityTaggedServiceUtil::getDefault($serviceId, $reflector, $defaultIndexMethod ?? 'getDefaultName', $tagName, $indexAttribute, $checkTaggedItem);
+                if (null === $index && $loadFromDefaultMethods) {
+                    $defaultPriority = PriorityTaggedServiceUtil::getDefault($serviceId, $reflector, $defaultPriorityMethod, $tagName, 'priority') ?? $defaultPriority;
+                    $defaultIndex = PriorityTaggedServiceUtil::getDefault($serviceId, $reflector, $defaultIndexMethod ?? 'getDefaultName', $tagName, $indexAttribute) ?? $defaultIndex;
+                    $loadFromDefaultMethods = false;
                 }
                 $index ??= $defaultIndex ??= $definition->getTag('container.decorator')[0]['id'] ?? $serviceId;
 
-                $services[] = [$priority, ++$i, $index, $serviceId, $class];
-            }
-
-            if ($reflector) {
-                $attributes = $reflector->getAttributes(AsTaggedItem::class);
-                $attributeCount = \count($attributes);
-
-                foreach ($attributes as $attribute) {
-                    $instance = $attribute->newInstance();
-
-                    if (!$instance->index && 1 < $attributeCount) {
-                        throw new InvalidArgumentException(\sprintf('Attribute "%s" on class "%s" cannot have an empty index when repeated.', AsTaggedItem::class, $class));
-                    }
-
-                    $services[] = [$instance->priority ?? 0, ++$i, $instance->index ?? $serviceId, $serviceId, $class];
-                }
+                $services[] = [$priority, $i, $index, $serviceId, $class];
             }
         }
 
         uasort($services, static fn ($a, $b) => $b[0] <=> $a[0] ?: $a[1] <=> $b[1]);
 
         $refs = [];
         foreach ($services as [, , $index, $serviceId, $class]) {
-            if (!$class) {
-                $reference = new Reference($serviceId);
-            } elseif ($index === $serviceId) {
-                $reference = new TypedReference($serviceId, $class);
-            } else {
-                $reference = new TypedReference($serviceId, $class, ContainerBuilder::EXCEPTION_ON_INVALID_REFERENCE, $index);
-            }
+            $reference = match (true) {
+                !$class => new Reference($serviceId),
+                $index === $serviceId => new TypedReference($serviceId, $class),
+                default => new TypedReference($serviceId, $class, ContainerBuilder::EXCEPTION_ON_INVALID_REFERENCE, $index),
+            };
 
             if (null === $index) {
                 $refs[] = $reference;
@@ -137,25 +145,16 @@ private function findAndSortTaggedServices(string|TaggedIteratorArgument $tagNam
  */
 class PriorityTaggedServiceUtil
 {
-    public static function getDefault(string $serviceId, \ReflectionClass $r, string $defaultMethod, string $tagName, ?string $indexAttribute, bool $checkTaggedItem): string|int|null
+    public static function getDefault(string $serviceId, \ReflectionClass $r, string $defaultMethod, string $tagName, ?string $indexAttribute): string|int|null
     {
-        $class = $r->getName();
-
-        if (!$checkTaggedItem && !$r->hasMethod($defaultMethod)) {
-            return null;
-        }
-
-        if ($checkTaggedItem && !$r->hasMethod($defaultMethod)) {
-            foreach ($r->getAttributes(AsTaggedItem::class) as $attribute) {
-                return 'priority' === $indexAttribute ? $attribute->newInstance()->priority : $attribute->newInstance()->index;
-            }
-
+        if (!$r->hasMethod($defaultMethod)) {
             return null;
         }
 
         if ($r->isInterface()) {
             return null;
         }
+        $class = $r->name;
 
         if (null !== $indexAttribute) {
             $service = $class !== $serviceId ? \sprintf('service "%s"', $serviceId) : 'on the corresponding service';
diff --git a/Tests/Compiler/AutowirePassTest.php b/Tests/Compiler/AutowirePassTest.php
@@ -1446,4 +1446,45 @@ public function testAutowireAttributeWithEnvVar()
         $this->assertSame('%env(bool:ENABLED)%', $container->resolveEnvPlaceholders($definition->getArguments()[0]));
         $this->assertSame('%env(default::OPTIONAL)%', $container->resolveEnvPlaceholders($definition->getArguments()[1]));
     }
+
+    public function testLazyProxyForInterfaceWithFinalImplementation()
+    {
+        $container = new ContainerBuilder();
+        $container->register('final_impl', FinalLazyProxyImplementation::class);
+        $container->setAlias(LazyProxyTestInterface::class, 'final_impl');
+
+        $container->register(LazyProxyInterfaceConsumer::class)
+            ->setAutoconfigured(true)
+            ->setAutowired(true)
+            ->setPublic(true);
+
+        $container->compile();
+
+        $service = $container->get(LazyProxyInterfaceConsumer::class);
+        $this->assertInstanceOf(LazyProxyInterfaceConsumer::class, $service);
+
+        // Trigger lazy load
+        $dep = $service->getDep()->getSelf();
+        $this->assertInstanceOf(FinalLazyProxyImplementation::class, $dep);
+    }
+
+    public function testLazyProxyWithClassInheritance()
+    {
+        $container = new ContainerBuilder();
+        $container->register(BaseLazyProxyClass::class, ExtendedLazyProxyClass::class);
+
+        $container->register(LazyProxyInheritanceConsumer::class)
+            ->setAutoconfigured(true)
+            ->setAutowired(true)
+            ->setPublic(true);
+
+        $container->compile();
+
+        $service = $container->get(LazyProxyInheritanceConsumer::class);
+        $this->assertInstanceOf(LazyProxyInheritanceConsumer::class, $service);
+
+        // Trigger lazy load
+        $dep = $service->getDependency()->getSelf();
+        $this->assertInstanceOf(ExtendedLazyProxyClass::class, $dep);
+    }
 }
diff --git a/Tests/Compiler/PriorityTaggedServiceTraitTest.php b/Tests/Compiler/PriorityTaggedServiceTraitTest.php
@@ -232,29 +232,14 @@ public function testTaggedItemAttributes()
             'hello' => new TypedReference('service2', HelloNamedService::class),
             'multi_hello_1' => new TypedReference('service6', MultiTagHelloNamedService::class),
             'service1' => new TypedReference('service1', FooTagClass::class),
+            'multi_hello_0' => new TypedReference('service6', MultiTagHelloNamedService::class),
         ];
 
         $services = $priorityTaggedServiceTraitImplementation->test($tag, $container);
         $this->assertSame(array_keys($expected), array_keys($services));
         $this->assertEquals($expected, $priorityTaggedServiceTraitImplementation->test($tag, $container));
     }
 
-    public function testTaggedItemAttributesRepeatedWithoutNameThrows()
-    {
-        $container = new ContainerBuilder();
-        $container->register('service1', MultiNoNameTagHelloNamedService::class)
-            ->setAutoconfigured(true)
-            ->addTag('my_custom_tag');
-
-        (new ResolveInstanceofConditionalsPass())->process($container);
-        $tag = new TaggedIteratorArgument('my_custom_tag', 'foo', 'getFooBar', exclude: ['service4', 'service5']);
-
-        $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage('Attribute "Symfony\Component\DependencyInjection\Attribute\AsTaggedItem" on class "Symfony\Component\DependencyInjection\Tests\Compiler\MultiNoNameTagHelloNamedService" cannot have an empty index when repeated.');
-
-        (new PriorityTaggedServiceTraitImplementation())->test($tag, $container);
-    }
-
     public function testResolveIndexedTags()
     {
         $container = new ContainerBuilder();
@@ -282,6 +267,48 @@ public function testResolveIndexedTags()
         $this->assertSame(array_keys($expected), array_keys($services));
         $this->assertEquals($expected, $priorityTaggedServiceTraitImplementation->test($tag, $container));
     }
+
+    public function testAttributesAreMergedWithTags()
+    {
+        $container = new ContainerBuilder();
+        $definition = $container->register('service_attr_first', MultiTagHelloNamedService::class);
+        $definition->setAutoconfigured(true);
+        $definition->addTag('my_custom_tag', ['foo' => 'z']);
+        $definition->addTag('my_custom_tag', []);
+
+        (new ResolveInstanceofConditionalsPass())->process($container);
+
+        $priorityTaggedServiceTraitImplementation = new PriorityTaggedServiceTraitImplementation();
+
+        $tag = new TaggedIteratorArgument('my_custom_tag', 'foo', 'getFooBar');
+        $services = $priorityTaggedServiceTraitImplementation->test($tag, $container);
+
+        $expected = [
+            'multi_hello_2' => new TypedReference('service_attr_first', MultiTagHelloNamedService::class),
+            'multi_hello_1' => new TypedReference('service_attr_first', MultiTagHelloNamedService::class),
+            'z' => new TypedReference('service_attr_first', MultiTagHelloNamedService::class),
+            'multi_hello_0' => new TypedReference('service_attr_first', MultiTagHelloNamedService::class),
+        ];
+        $this->assertSame(array_keys($expected), array_keys($services));
+        $this->assertEquals($expected, $services);
+    }
+
+    public function testAttributesAreFallbacks()
+    {
+        $container = new ContainerBuilder();
+        $definition = $container->register('service_attr_first', MultiTagHelloNamedService::class);
+        $definition->setAutoconfigured(true);
+        $definition->addTag('my_custom_tag', ['foo' => 'z']);
+
+        (new ResolveInstanceofConditionalsPass())->process($container);
+
+        $priorityTaggedServiceTraitImplementation = new PriorityTaggedServiceTraitImplementation();
+
+        $tag = new TaggedIteratorArgument('my_custom_tag', 'foo', 'getFooBar');
+        $services = $priorityTaggedServiceTraitImplementation->test($tag, $container);
+
+        $this->assertEquals(['z' => new TypedReference('service_attr_first', MultiTagHelloNamedService::class)], $services);
+    }
 }
 
 class PriorityTaggedServiceTraitImplementation
@@ -304,18 +331,13 @@ class HelloNamedService2
 {
 }
 
+#[AsTaggedItem(index: 'multi_hello_0', priority: 0)]
 #[AsTaggedItem(index: 'multi_hello_1', priority: 1)]
 #[AsTaggedItem(index: 'multi_hello_2', priority: 2)]
 class MultiTagHelloNamedService
 {
 }
 
-#[AsTaggedItem(priority: 1)]
-#[AsTaggedItem(priority: 2)]
-class MultiNoNameTagHelloNamedService
-{
-}
-
 interface HelloInterface
 {
     public static function getFooBar(): string;
diff --git a/Tests/Fixtures/includes/autowiring_classes.php b/Tests/Fixtures/includes/autowiring_classes.php
@@ -524,3 +524,56 @@ public static function staticCreateFooWithParam(mixed $someParam): MyInlineServi
         return new MyInlineService($someParam);
     }
 }
+
+interface LazyProxyTestInterface
+{
+    public function getSelf(): self;
+}
+
+final class FinalLazyProxyImplementation implements LazyProxyTestInterface
+{
+    public function getSelf(): self
+    {
+        return $this;
+    }
+}
+
+class BaseLazyProxyClass
+{
+    public function getSelf(): self
+    {
+        return $this;
+    }
+}
+
+class ExtendedLazyProxyClass extends BaseLazyProxyClass
+{
+    public function getSelf(): self
+    {
+        return $this;
+    }
+}
+
+class LazyProxyInterfaceConsumer
+{
+    public function __construct(#[Autowire(lazy: true)] private readonly LazyProxyTestInterface $dep)
+    {
+    }
+
+    public function getDep(): LazyProxyTestInterface
+    {
+        return $this->dep;
+    }
+}
+
+class LazyProxyInheritanceConsumer
+{
+    public function __construct(#[Autowire(lazy: true)] private readonly BaseLazyProxyClass $dep)
+    {
+    }
+
+    public function getDependency(): BaseLazyProxyClass
+    {
+        return $this->dep;
+    }
+}
