Merge branch '7.4' into 8.0

* 7.4: (21 commits)
  [SecurityBundle] Fix tests with Symfony 7.4
  [DependencyInjection] Ensure deprecation detection does not trigger a PHP error
  [DependencyInjection][FrameworkBundle] fix BC break when dumping container for build/lint commands
  [Form] Clean up wrong method docblocks in data transformers
  Fix merge
  [DependencyInjection] Throw when using `$this` or its internal scope from PHP config files; use the `$loader` variable instead
  [HttpClient] Fix sharing CurlClientState between clones of CurlHttpClient instances
  [FrameworkBundle] Don't exclude classes with constraint/serialization attributes from being registered as services
  Revert "[HttpClient] Lazily initialize CurlClientState"
  [Yaml] Fix regression handling blank lines in unquoted scalars
  [Cache] Fix NullAdapter must set taggable
  [FrameworkBundle] Order alphabetically known tags of `UnusedTagsPass`
  allow the installation of MercureBundle 0.4
  [Console] don't discard existing aliases when constructing Command
  Import all node definition classes to DefinitionConfigurator
  Fix the creation of a redis connection with only ext-relay
  [FrameworkBundle] Dump bundles config reference first
  [DependencyInjection] Don't add the .container.known_envs parameter when empty
  [DependencyInjection] Reset resolved state when setting a parameter
  [HttpKernel] Don't reset services between fragments redering when using in HttpCache
  ...

Author: nicolas-grekas

Kernel.php

@@ -65,6 +65,7 @@ abstract class Kernel implements KernelInterface, RebootableInterface, Terminabl
     private ?string $warmupDir = null;
     private int $requestStackSize = 0;
     private bool $resetServices = false;
+    private bool $handlingHttpCache = false;
 
     /**
      * @var array<string, bool>
@@ -96,6 +97,7 @@ public function __clone()
         $this->container = null;
         $this->requestStackSize = 0;
         $this->resetServices = false;
+        $this->handlingHttpCache = false;
     }
 
     public function boot(): void
@@ -168,13 +170,22 @@ public function handle(Request $request, int $type = HttpKernelInterface::MAIN_R
             $container = $this->container ?? $this->preBoot();
 
             if ($container->has('http_cache')) {
-                return $container->get('http_cache')->handle($request, $type, $catch);
+                $this->handlingHttpCache = true;
+
+                try {
+                    return $container->get('http_cache')->handle($request, $type, $catch);
+                } finally {
+                    $this->handlingHttpCache = false;
+                    $this->resetServices = true;
+                }
             }
         }
 
         $this->boot();
         ++$this->requestStackSize;
-        $this->resetServices = true;
+        if (!$this->handlingHttpCache) {
+            $this->resetServices = true;
+        }
 
         try {
             return $this->getHttpKernel()->handle($request, $type, $catch);

Tests/KernelTest.php

@@ -17,6 +17,7 @@
 use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\Reference;
 use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;
 use Symfony\Component\Filesystem\Exception\IOException;
 use Symfony\Component\Filesystem\Filesystem;
@@ -30,6 +31,7 @@
 use Symfony\Component\HttpKernel\HttpKernel;
 use Symfony\Component\HttpKernel\HttpKernelInterface;
 use Symfony\Component\HttpKernel\Kernel;
+use Symfony\Component\HttpKernel\KernelInterface;
 use Symfony\Component\HttpKernel\Tests\Fixtures\KernelWithoutBundles;
 use Symfony\Component\HttpKernel\Tests\Fixtures\ResettableService;
 
@@ -492,6 +494,39 @@ public function testServicesResetter()
         $this->assertEquals(1, ResettableService::$counter);
     }
 
+    public function testServicesAreNotResetBetweenHttpCacheFragments()
+    {
+        ResettableService::$counter = 0;
+        $fragmentKernel = new FragmentHandlingKernel();
+
+        $kernel = new CustomProjectDirKernel(function (ContainerBuilder $container) {
+            $container->addCompilerPass(new ResettableServicePass());
+            $container->register('kernel', CustomProjectDirKernel::class)
+                ->setSynthetic(true)
+                ->setPublic(true);
+            $container->register('one', ResettableService::class)
+                ->setPublic(true)
+                ->addTag('kernel.reset', ['method' => 'reset']);
+            $container->register('services_resetter', ServicesResetter::class)->setPublic(true);
+            $container->register('http_cache', FragmentRenderingHttpCache::class)
+                ->setPublic(true)
+                ->addArgument(new Reference('kernel'));
+        }, $fragmentKernel, 'http_cache_fragments');
+
+        $kernel->handle(new Request());
+
+        $this->assertSame([
+            ['/first-fragment', HttpKernelInterface::MAIN_REQUEST],
+            ['/second-fragment', HttpKernelInterface::MAIN_REQUEST],
+        ], $fragmentKernel->handledPaths);
+        $this->assertSame([0, 0], $fragmentKernel->resetCounters);
+        $this->assertSame(0, ResettableService::$counter);
+
+        $kernel->boot();
+
+        $this->assertSame(1, ResettableService::$counter);
+    }
+
     #[Group('time-sensitive')]
     public function testKernelStartTimeIsResetWhileBootingAlreadyBootedKernel()
     {
@@ -731,3 +766,39 @@ public function doLoadClassCache(): void
     {
     }
 }
+
+class FragmentHandlingKernel implements HttpKernelInterface
+{
+    public array $handledPaths = [];
+    public array $resetCounters = [];
+
+    public function handle(Request $request, int $type = self::MAIN_REQUEST, bool $catch = true): Response
+    {
+        $this->handledPaths[] = [$request->getPathInfo(), $type];
+        $this->resetCounters[] = ResettableService::$counter;
+
+        return new Response($request->getPathInfo());
+    }
+}
+
+class FragmentRenderingHttpCache implements HttpKernelInterface
+{
+    public function __construct(
+        private KernelInterface $kernel,
+        private string $trackedServiceId = 'one',
+    ) {
+    }
+
+    public function handle(Request $request, int $type = self::MAIN_REQUEST, bool $catch = true): Response
+    {
+        $this->kernel->boot();
+        $this->kernel->getContainer()->get($this->trackedServiceId);
+
+        $responses = [];
+        foreach (['/first-fragment', '/second-fragment'] as $path) {
+            $responses[] = $this->kernel->handle(Request::create($path), self::MAIN_REQUEST, $catch);
+        }
+
+        return new Response(implode('', array_map(static fn (Response $response) => $response->getContent(), $responses)));
+    }
+}