Merge branch '7.4' into 8.0

* 7.4:
  [DependencyInjection] Fix lazy proxy type resolution for decorated services
  [HttpClient] Fix dealing with truncated streams after headers arrived with CurlHttpClient
  [PropertyInfo] Fix DocBlock resolution for inherited promoted properties
  [HttpFoundation] Fix PdoSessionHandler charset-collation mismatch with the Doctrine DBAL on MySQL
  [HttpClient] Fix dealing with multiple levels of AsyncResponse decoration
  [Messenger] Only send UNLISTEN query if we are actively listening
  [RateLimiter] Persist state when consuming negative tokens

Author: nicolas-grekas

Compiler/AutowirePass.php

@@ -335,11 +335,6 @@ private function autowireMethod(\ReflectionFunctionAbstract $reflectionMethod, a
                         $value = $this->doProcessValue($value);
                     } elseif ($lazy = $attribute->lazy) {
                         $value ??= $getValue();
-                        $type = $this->resolveProxyType($type, $value->getType());
-                        $definition = (new Definition($type))
-                            ->setFactory('current')
-                            ->setArguments([[$value]])
-                            ->setLazy(true);
 
                         if (!\is_array($lazy)) {
                             if (str_contains($type, '|')) {
@@ -348,8 +343,14 @@ private function autowireMethod(\ReflectionFunctionAbstract $reflectionMethod, a
                             $lazy = str_contains($type, '&') ? explode('&', $type) : [];
                         }
 
+                        $proxyType = $lazy ? $type : $this->resolveProxyType($type, $value);
+                        $definition = (new Definition($proxyType))
+                            ->setFactory('current')
+                            ->setArguments([[$value]])
+                            ->setLazy(true);
+
                         if ($lazy) {
-                            if (!class_exists($type) && !interface_exists($type, false)) {
+                            if (!$this->container->getReflectionClass($proxyType, false)) {
                                 $definition->setClass('object');
                             }
                             foreach ($lazy as $v) {
@@ -757,7 +758,7 @@ private function resolveProxyType(string $originalType, string $serviceId): stri
         $resolvedType = $this->container->findDefinition($serviceId)->getClass();
         $resolvedType = $this->container->getParameterBag()->resolveValue($resolvedType);
 
-        if (!$resolvedType || !class_exists($resolvedType, false) && !interface_exists($resolvedType, false)) {
+        if (!$resolvedType || !$this->container->getReflectionClass($resolvedType, false)) {
             return $originalType;
         }
 

Tests/Compiler/AutowirePassTest.php

@@ -1487,4 +1487,30 @@ public function testLazyProxyWithClassInheritance()
         $dep = $service->getDependency()->getSelf();
         $this->assertInstanceOf(ExtendedLazyProxyClass::class, $dep);
     }
+
+    public function testLazyProxyForDecoratedService()
+    {
+        $container = new ContainerBuilder();
+
+        $container->register('some_service', SomeServiceClass::class)
+            ->setPublic(true);
+
+        $container->register('some_service.decorated', DecoratedSomeServiceClass::class)
+            ->setDecoratedService('some_service')
+            ->addArgument(new Reference('.inner'));
+
+        $container->register(LazyDecoratedServiceConsumer::class)
+            ->setAutowired(true)
+            ->setPublic(true);
+
+        $container->setAlias(SomeServiceInterface::class, 'some_service');
+
+        $container->compile();
+
+        $service = $container->get(LazyDecoratedServiceConsumer::class);
+        $this->assertInstanceOf(LazyDecoratedServiceConsumer::class, $service);
+
+        $result = $service->getValue();
+        $this->assertSame('decorated:original', $result);
+    }
 }

Tests/Fixtures/includes/autowiring_classes.php

@@ -605,3 +605,42 @@ public function __construct(public ContainerInterface $container)
     {
     }
 }
+
+interface SomeServiceInterface
+{
+    public function getValue(): string;
+}
+
+class SomeServiceClass implements SomeServiceInterface
+{
+    public function getValue(): string
+    {
+        return 'original';
+    }
+}
+
+class DecoratedSomeServiceClass implements SomeServiceInterface
+{
+    public function __construct(private SomeServiceInterface $inner)
+    {
+    }
+
+    public function getValue(): string
+    {
+        return 'decorated:'.$this->inner->getValue();
+    }
+}
+
+class LazyDecoratedServiceConsumer
+{
+    public function __construct(
+        #[Autowire(service: 'some_service', lazy: true)]
+        private SomeServiceInterface $service,
+    ) {
+    }
+
+    public function getValue(): string
+    {
+        return $this->service->getValue();
+    }
+}