New option: polluteScopeWithBlock

conf/config.neon

@@ -154,6 +154,7 @@ parameters:
 	phpVersion: null
 	polluteScopeWithLoopInitialAssignments: true
 	polluteScopeWithAlwaysIterableForeach: true
+	polluteScopeWithBlock: true
 	propertyAlwaysWrittenTags: []
 	propertyAlwaysReadTags: []
 	fixerTmpDir: %pro.tmpDir% #unused
@@ -544,6 +545,7 @@ services:
 			reflector: @nodeScopeResolverReflector
 			polluteScopeWithLoopInitialAssignments: %polluteScopeWithLoopInitialAssignments%
 			polluteScopeWithAlwaysIterableForeach: %polluteScopeWithAlwaysIterableForeach%
+			polluteScopeWithBlock: %polluteScopeWithBlock%
 			earlyTerminatingMethodCalls: %earlyTerminatingMethodCalls%
 			earlyTerminatingFunctionCalls: %earlyTerminatingFunctionCalls%
 			implicitThrows: %exceptions.implicitThrows%

conf/parametersSchema.neon

@@ -148,6 +148,7 @@ parametersSchema:
 	phpVersion: schema(anyOf(schema(int(), min(70100), max(80499))), nullable())
 	polluteScopeWithLoopInitialAssignments: bool()
 	polluteScopeWithAlwaysIterableForeach: bool()
+	polluteScopeWithBlock: bool()
 	propertyAlwaysWrittenTags: listOf(string())
 	propertyAlwaysReadTags: listOf(string())
 	additionalConstructors: listOf(string())

src/Analyser/NodeScopeResolver.php

@@ -253,6 +253,7 @@ public function __construct(
 		private readonly ScopeFactory $scopeFactory,
 		private readonly bool $polluteScopeWithLoopInitialAssignments,
 		private readonly bool $polluteScopeWithAlwaysIterableForeach,
+		private readonly bool $polluteScopeWithBlock,
 		private readonly array $earlyTerminatingMethodCalls,
 		private readonly array $earlyTerminatingFunctionCalls,
 		private readonly array $universalObjectCratesClasses,
@@ -1895,7 +1896,20 @@ static function (Node $node, Scope $scope) use ($nodeCallback): void {
 				new ImpurePoint($scope, $stmt, 'betweenPhpTags', 'output between PHP opening and closing tags', true),
 			];
 		} elseif ($stmt instanceof Node\Stmt\Block) {
-			return $this->processStmtNodes($stmt, $stmt->stmts, $scope, $nodeCallback, $context);
+			$result = $this->processStmtNodes($stmt, $stmt->stmts, $scope, $nodeCallback, $context);
+			if ($this->polluteScopeWithBlock) {
+				return $result;
+			}
+
+			return new StatementResult(
+				$scope->mergeWith($result->getScope()),
+				$result->hasYield(),
+				$result->isAlwaysTerminating(),
+				$result->getExitPoints(),
+				$result->getThrowPoints(),
+				$result->getImpurePoints(),
+				$result->getEndStatements(),
+			);
 		} elseif ($stmt instanceof Node\Stmt\Nop) {
 			$hasYield = false;
 			$throwPoints = $overridingThrowPoints ?? [];

src/Testing/RuleTestCase.php

@@ -99,6 +99,7 @@ private function getAnalyser(DirectRuleRegistry $ruleRegistry): Analyser
 				self::createScopeFactory($reflectionProvider, $typeSpecifier),
 				$this->shouldPolluteScopeWithLoopInitialAssignments(),
 				$this->shouldPolluteScopeWithAlwaysIterableForeach(),
+				self::getContainer()->getParameter('polluteScopeWithBlock'),
 				[],
 				[],
 				self::getContainer()->getParameter('universalObjectCratesClasses'),

src/Testing/TypeInferenceTestCase.php

@@ -79,6 +79,7 @@ public static function processFile(
 			self::createScopeFactory($reflectionProvider, $typeSpecifier),
 			self::getContainer()->getParameter('polluteScopeWithLoopInitialAssignments'),
 			self::getContainer()->getParameter('polluteScopeWithAlwaysIterableForeach'),
+			self::getContainer()->getParameter('polluteScopeWithBlock'),
 			static::getEarlyTerminatingMethodCalls(),
 			static::getEarlyTerminatingFunctionCalls(),
 			self::getContainer()->getParameter('universalObjectCratesClasses'),

tests/PHPStan/Analyser/AnalyserTest.php

@@ -735,6 +735,7 @@ private function createAnalyser(bool $enableIgnoreErrorsWithinPhpDocs): Analyser
 			self::createScopeFactory($reflectionProvider, $typeSpecifier),
 			false,
 			true,
+			true,
 			[],
 			[],
 			[stdClass::class],

tests/PHPStan/Analyser/DoNotPolluteScopeWithBlockTest.php

@@ -0,0 +1,36 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser;
+
+use PHPStan\Testing\TypeInferenceTestCase;
+
+class DoNotPolluteScopeWithBlockTest extends TypeInferenceTestCase
+{
+
+	public function dataFileAsserts(): iterable
+	{
+		yield from $this->gatherAssertTypes(__DIR__ . '/data/do-not-pollute-scope-with-block.php');
+	}
+
+	/**
+	 * @dataProvider dataFileAsserts
+	 * @param mixed ...$args
+	 */
+	public function testFileAsserts(
+		string $assertType,
+		string $file,
+		...$args,
+	): void
+	{
+		$this->assertFileAsserts($assertType, $file, ...$args);
+	}
+
+	public static function getAdditionalConfigFiles(): array
+	{
+		return [
+			__DIR__ . '/../../../conf/bleedingEdge.neon',
+			__DIR__ . '/do-not-pollute-scope-with-block.neon',
+		];
+	}
+
+}

tests/PHPStan/Analyser/data/do-not-pollute-scope-with-block.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace DoNotPolluteScopeWithBlock;
+
+use PHPStan\TrinaryLogic;
+use function PHPStan\Testing\assertType;
+use function PHPStan\Testing\assertVariableCertainty;
+
+class Foo
+{
+
+	public function doFoo(): void
+	{
+		$a = 1;
+		{
+			$b = 2;
+		}
+
+		assertVariableCertainty(TrinaryLogic::createYes(), $a);
+		assertType('1', $a);
+
+		assertVariableCertainty(TrinaryLogic::createMaybe(), $b);
+		assertType('2', $b);
+	}
+
+}

tests/PHPStan/Analyser/do-not-pollute-scope-with-block.neon

@@ -0,0 +1,2 @@
+parameters:
+	polluteScopeWithBlock: false