Install the right container before every test and data provider on PHPUnit 9 too

PHPStanPHPUnitExtension implements the PHPUnit >= 10 extension interface and is
registered through <extensions><bootstrap>, which PHPUnit 9 rejects outright
("Element 'bootstrap': This element is not expected. Expected is ( extension )").
The "Tests with old PHPUnit" jobs therefore ran without its two subscribers, so
nothing made a data provider or a test see its own test class's container - and
because ParaTest reuses one worker process for many test files, whatever
container the previous file installed stayed installed.

That is what flaked IntersectionTypeTest::testIsAcceptedBy on the 8.1 jobs: a
bleeding edge test file left BleedingEdgeToggle on, dataIsAcceptedBy() built its
ConstantArrayTypes sealed (the constructor reads the toggle), dataGetEnumCases()
then called createReflectionProvider() and switched the toggle back off, and
every data set expecting Maybe came out No. Reproduced deterministically with

	paratest --runner WrapperRunner -p 1 -c <config without the extension>

over a bleeding edge test file followed by IntersectionTypeTest. The same gap
made VerbosityLevelTest and 29 other files fail with
MissingStaticAccessorInstanceException whenever they were the first file a
worker picked up.

setUp() now always installs the test class's own container, tearDownAfterClass()
restores the base one for the next file's data providers, and the bootstrap
installs it for the first file's - which makes
$reinitializeContainerBeforeEachTest redundant - and InitContainerBeforeTestSubscriber
too, so setUp() is now the one mechanism for tests on every PHPUnit version.

InitContainerBeforeDataProviderSubscriber stays: data providers run while the suite
is being built, and a single-process PHPUnit >= 10 run calls every class's providers
before the first test, so a provider that installs its own container would otherwise
leak it into the next class's providers. PHPUnit 9 has no such hook, so a data
provider of a test class whose container is not the base one still has to ask for
it itself there, the way TypeGetFiniteTypesTest now does.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019isZYNh3Zms6xGKGGXqxgp

Author: ondrejmirtes

src/Testing/PHPStanTestCase.php

@@ -22,6 +22,7 @@
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Reflection\ReflectionProvider\DirectReflectionProviderProvider;
 use PHPStan\Rules\Properties\PropertyReflectionFinder;
+use PHPStan\Testing\PHPUnit\ContainerInitializer;
 use PHPStan\Type\Constant\OversizedArrayBuilder;
 use PHPStan\Type\ExpressionTypeResolverExtension;
 use PHPStan\Type\OperatorTypeSpecifyingExtensionRegistry;
@@ -43,21 +44,28 @@ abstract class PHPStanTestCase extends TestCase
 	use PHPStanTestCaseTrait;
 
 	/**
-	 * Re-register the runtime container as the global static reflection provider before
-	 * every test. Enable this in tests that construct Type objects directly and assert
-	 * PHP-version-dependent reflection results, so a foreign PhpVersion leaked by another
-	 * test can't flake them. See https://github.com/phpstan/phpstan/issues/14860
+	 * Re-register this test class's container as the owner of the global static state
+	 * (the reflection provider, the PhpVersion, the bleeding edge toggle) before every
+	 * test, so a container another test class installed can't flake tests that build
+	 * Type objects directly. See https://github.com/phpstan/phpstan/issues/14860
+	 *
+	 * This is the only hook that does it, on every PHPUnit version. Data providers
+	 * are covered separately - see PHPStanTestCaseTrait::restoreBaseContainer().
 	 */
-	protected bool $reinitializeContainerBeforeEachTest = false;
-
 	#[Override]
 	protected function setUp(): void
 	{
-		if (!$this->reinitializeContainerBeforeEachTest) {
-			return;
-		}
+		ContainerInitializer::initialize(static::class);
+	}
+
+	#[Override]
+	public static function tearDownAfterClass(): void
+	{
+		parent::tearDownAfterClass();
 
-		self::getContainer();
+		// The next test class's data providers run before any hook this test case has
+		// on PHPUnit 9, in the same ParaTest worker process - see restoreBaseContainer().
+		self::restoreBaseContainer();
 	}
 
 	public static function getParser(): Parser

src/Testing/PHPStanTestCaseTrait.php

@@ -22,11 +22,43 @@ trait PHPStanTestCaseTrait
 
 	public static function getContainer(): Container
 	{
-		$additionalConfigFiles = [__DIR__ . '/TestCase.neon'];
+		$additionalConfigFiles = [self::getBaseConfigFile()];
 		foreach (static::getAdditionalConfigFiles() as $configFile) {
 			$additionalConfigFiles[] = $configFile;
 		}
-		$composerAutoloaderProjectPaths = static::getComposerAutoloaderProjectPaths();
+
+		return self::getContainerForConfigFiles($additionalConfigFiles, static::getComposerAutoloaderProjectPaths());
+	}
+
+	/**
+	 * Installs the global state of the container built from just the base config -
+	 * the bleeding edge toggle, the static reflection provider, the PhpVersion and
+	 * the type caches all live in static properties that the last initialized
+	 * container owns.
+	 *
+	 * PHPStanTestCase::setUp() installs the right container before every test. Data
+	 * providers are called while the test suite is being built, so on PHPUnit >= 10
+	 * InitContainerBeforeDataProviderSubscriber installs it before each of them.
+	 * PHPUnit 9 - which the "Tests with old PHPUnit" jobs run - rejects that extension
+	 * and has no hook that fires before a data provider, while ParaTest reuses one
+	 * worker process for many test files. A
+	 * class whose container turns on e.g. bleeding edge would therefore leak that
+	 * state into the data providers of the next test file, which build Type objects
+	 * that read the toggle in their constructor. Restoring the base state when a test
+	 * class is done keeps those data providers deterministic on every supported
+	 * PHPUnit version.
+	 */
+	public static function restoreBaseContainer(): void
+	{
+		self::getContainerForConfigFiles([self::getBaseConfigFile()], []);
+	}
+
+	/**
+	 * @param string[] $additionalConfigFiles
+	 * @param string[] $composerAutoloaderProjectPaths
+	 */
+	private static function getContainerForConfigFiles(array $additionalConfigFiles, array $composerAutoloaderProjectPaths): Container
+	{
 		$cacheKey = hash('sha256', implode("\n", $additionalConfigFiles) . "\0" . implode("\n", $composerAutoloaderProjectPaths));
 
 		if (!isset(self::$containers[$cacheKey])) {
@@ -66,6 +98,11 @@ public static function getContainer(): Container
 		return self::$containers[$cacheKey];
 	}
 
+	private static function getBaseConfigFile(): string
+	{
+		return __DIR__ . '/TestCase.neon';
+	}
+
 	/**
 	 * @return string[]
 	 */

src/Testing/PHPUnit/InitContainerBeforeTestSubscriber.php

@@ -21,9 +21,6 @@ public function bootstrap(
 		$facade->registerSubscriber(
 			new InitContainerBeforeDataProviderSubscriber(),
 		);
-		$facade->registerSubscriber(
-			new InitContainerBeforeTestSubscriber(),
-		);
 	}
 
 }

src/Testing/PHPUnit/PHPStanPHPUnitExtension.php

@@ -0,0 +1,31 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Testing;
+
+use Override;
+use PHPStan\DependencyInjection\BleedingEdgeToggle;
+
+/**
+ * The global state a container installs - here the bleeding edge toggle, which
+ * ConstantArrayType reads in its constructor - has to belong to the test class
+ * that is running, not to whichever class ran before it in the same ParaTest
+ * worker process. PHPStanTestCase::setUp() guarantees that on every PHPUnit
+ * version.
+ */
+class BleedingEdgeContainerStateTest extends PHPStanTestCase
+{
+
+	#[Override]
+	public static function getAdditionalConfigFiles(): array
+	{
+		return [
+			__DIR__ . '/../../../conf/bleedingEdge.neon',
+		];
+	}
+
+	public function testThisClassesContainerOwnsTheGlobalState(): void
+	{
+		$this->assertTrue(BleedingEdgeToggle::isBleedingEdge());
+	}
+
+}

tests/PHPStan/Testing/BleedingEdgeContainerStateTest.php

@@ -0,0 +1,18 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Testing;
+
+use PHPStan\DependencyInjection\BleedingEdgeToggle;
+
+/**
+ * @see BleedingEdgeContainerStateTest for the same guarantee with a non-base container
+ */
+class ContainerStateTest extends PHPStanTestCase
+{
+
+	public function testThisClassesContainerOwnsTheGlobalState(): void
+	{
+		$this->assertFalse(BleedingEdgeToggle::isBleedingEdge());
+	}
+
+}

tests/PHPStan/Testing/ContainerStateTest.php

@@ -23,11 +23,6 @@
 class HasPropertyTypeTest extends PHPStanTestCase
 {
 
-	// Pin the runtime container so a foreign PhpVersion leaked by another test
-	// can't flake the version-dependent Closure data set below.
-	// See https://github.com/phpstan/phpstan/issues/14860
-	protected bool $reinitializeContainerBeforeEachTest = true;
-
 	public static function dataIsSuperTypeOf(): array
 	{
 		return [

tests/PHPStan/Type/Accessory/HasPropertyTypeTest.php

@@ -32,11 +32,6 @@
 class GenericObjectTypeTest extends PHPStanTestCase
 {
 
-	// Pin the runtime container so a foreign PhpVersion leaked by another test
-	// can't flake the version-dependent data sets (reflected variance of built-in
-	// generics). See https://github.com/phpstan/phpstan/issues/14860
-	protected bool $reinitializeContainerBeforeEachTest = true;
-
 	public static function dataIsSuperTypeOf(): array
 	{
 		return [

tests/PHPStan/Type/Generic/GenericObjectTypeTest.php

@@ -53,11 +53,6 @@
 class ObjectTypeTest extends PHPStanTestCase
 {
 
-	// Pin the runtime container so a foreign PhpVersion leaked by another test
-	// can't flake the version-dependent Closure data sets (dynamic-property
-	// handling). See https://github.com/phpstan/phpstan/issues/14860
-	protected bool $reinitializeContainerBeforeEachTest = true;
-
 	public static function dataIsIterable(): array
 	{
 		return [

tests/PHPStan/Type/ObjectTypeTest.php

@@ -74,11 +74,6 @@
 class TypeCombinatorTest extends PHPStanTestCase
 {
 
-	// Pin the runtime container so a foreign PhpVersion leaked by another test
-	// can't flake the version-dependent data sets (dynamic-property handling of
-	// final classes). See https://github.com/phpstan/phpstan/issues/14860
-	protected bool $reinitializeContainerBeforeEachTest = true;
-
 	public static function dataAddNull(): array
 	{
 		return [