Resolve method reflection for dynamic static calls ($var::method()) to enable purity and side-effect checking

- In `StaticCallHandler::processExpr()`, when the class part of a static call
  is an expression (e.g. `$enum::from()`), resolve the method reflection via
  `getObjectTypeOrClassStringObjectType()` — the same approach already used in
  `resolveType()` for return type computation.
- Previously, `$methodReflection` was always null for `$expr->class instanceof Expr`,
  causing a false "call to unknown method" impure point for every dynamic static call.
- Guard `$this`-invalidation and promoted-property initialization logic with
  `$expr->class instanceof Name` to prevent incorrect scope effects when the call
  target is an expression (e.g. `$other::__construct()`).
- Update `CallToStaticMethodStatementWithoutSideEffectsRuleTest::testDynamicStaticCall`
  expectations: pure dynamic static calls are now correctly detected as having no effect.

Author: phpstan-bot

src/Analyser/ExprHandler/StaticCallHandler.php

@@ -144,6 +144,18 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 				} else {
 					$throwPoints[] = InternalThrowPoint::createImplicit($scope, $expr);
 				}
+			} elseif ($expr->class instanceof Expr) {
+				$classType = TypeCombinator::removeNull($scope->getType($expr->class))->getObjectTypeOrClassStringObjectType();
+				$methodName = $expr->name->name;
+				$methodReflection = $scope->getMethodReflection($classType, $methodName);
+				if ($methodReflection !== null) {
+					$parametersAcceptor = ParametersAcceptorSelector::selectFromArgs(
+						$scope,
+						$expr->getArgs(),
+						$methodReflection->getVariants(),
+						$methodReflection->getNamedArgumentsVariants(),
+					);
+				}
 			}
 		} else {
 			$nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->name, $scope, $storage, $nodeCallback, $context->enterDeep());
@@ -202,7 +214,8 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 		}
 
 		if (
-			$methodReflection !== null
+			$expr->class instanceof Name
+			&& $methodReflection !== null
 			&& (
 				(
 					!$methodReflection->isStatic()
@@ -215,7 +228,8 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 		) {
 			$scope = $scope->invalidateExpression(new Variable('this'), true, $methodReflection->getDeclaringClass());
 		} elseif (
-			$methodReflection !== null
+			$expr->class instanceof Name
+			&& $methodReflection !== null
 			&& $this->rememberPossiblyImpureFunctionValues
 			&& $scope->isInClass()
 			&& $scope->getClassReflection()->is($methodReflection->getDeclaringClass()->getName())
@@ -230,7 +244,8 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 		}
 
 		if (
-			$methodReflection !== null
+			$expr->class instanceof Name
+			&& $methodReflection !== null
 			&& !$methodReflection->isStatic()
 			&& $methodReflection->getName() === '__construct'
 			&& $scopeFunction instanceof MethodReflection

tests/PHPStan/Rules/Methods/CallToStaticMethodStatementWithoutSideEffectsRuleTest.php

@@ -132,7 +132,20 @@ public function testBug10819(): void
 
 	public function testDynamicStaticCall(): void
 	{
-		$this->analyse([__DIR__ . '/data/dynamic-static-call.php'], []);
+		$this->analyse([__DIR__ . '/data/dynamic-static-call.php'], [
+			[
+				'Call to static method DynamicStaticCall\Foo::doFoo() on a separate line has no effect.',
+				32,
+			],
+			[
+				'Call to static method DynamicStaticCall\FinalFoo::doFoo() on a separate line has no effect.',
+				33,
+			],
+			[
+				'Call to static method DynamicStaticCall\Bar::finalFoo() on a separate line has no effect.',
+				34,
+			],
+		]);
 	}
 
 	#[RequiresPhp('>= 8.5.0')]

tests/PHPStan/Rules/Pure/PureFunctionRuleTest.php

@@ -219,4 +219,10 @@ public function testBug14511(): void
 		$this->analyse([__DIR__ . '/data/bug-14511.php'], []);
 	}
 
+	#[RequiresPhp('>= 8.1.0')]
+	public function testBug14557(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-14557-function.php'], []);
+	}
+
 }

tests/PHPStan/Rules/Pure/PureMethodRuleTest.php

@@ -389,4 +389,16 @@ public function testBug14511(): void
 		$this->analyse([__DIR__ . '/data/bug-14511-method.php'], []);
 	}
 
+	#[RequiresPhp('>= 8.1.0')]
+	public function testBug14557(): void
+	{
+		$this->treatPhpDocTypesAsCertain = true;
+		$this->analyse([__DIR__ . '/data/bug-14557.php'], [
+			[
+				'Impure call to method Bug14557\SomeClass::impureStaticMethod() in pure method Bug14557\Foo::impureViaClassString().',
+				85,
+			],
+		]);
+	}
+
 }

tests/PHPStan/Rules/Pure/data/bug-14557-function.php

@@ -0,0 +1,47 @@
+<?php // lint >= 8.1
+
+declare(strict_types = 1);
+
+namespace Bug14557Function;
+
+enum MyEnum: string
+{
+	case Foo = 'foo';
+	case Bar = 'bar';
+}
+
+/**
+ * @param enum-string<MyEnum> $enum
+ * @phpstan-pure
+ */
+function fromEnumString(string $enum): MyEnum
+{
+	return $enum::from('foo');
+}
+
+/**
+ * @param enum-string<MyEnum> $enum
+ * @phpstan-pure
+ */
+function tryFromEnumString(string $enum): ?MyEnum
+{
+	return $enum::tryFrom('foo');
+}
+
+/**
+ * @param class-string<MyEnum> $enum
+ * @phpstan-pure
+ */
+function fromClassString(string $enum): MyEnum
+{
+	return $enum::from('foo');
+}
+
+/**
+ * @param class-string<MyEnum> $enum
+ * @phpstan-pure
+ */
+function tryFromClassString(string $enum): ?MyEnum
+{
+	return $enum::tryFrom('foo');
+}

tests/PHPStan/Rules/Pure/data/bug-14557.php

@@ -0,0 +1,88 @@
+<?php // lint >= 8.1
+
+declare(strict_types = 1);
+
+namespace Bug14557;
+
+enum MyEnum: string
+{
+	case Foo = 'foo';
+	case Bar = 'bar';
+}
+
+class SomeClass
+{
+
+	/** @phpstan-pure */
+	public static function pureStaticMethod(): int
+	{
+		return 1;
+	}
+
+	/** @phpstan-impure */
+	public static function impureStaticMethod(): int
+	{
+		echo 'hello';
+		return 1;
+	}
+
+}
+
+class Foo
+{
+
+	/**
+	 * @param enum-string<MyEnum> $enum
+	 * @phpstan-pure
+	 */
+	public function doFoo(string $enum): MyEnum
+	{
+		return $enum::from('foo');
+	}
+
+	/**
+	 * @param enum-string<MyEnum> $enum
+	 * @phpstan-pure
+	 */
+	public function doBar(string $enum): ?MyEnum
+	{
+		return $enum::tryFrom('foo');
+	}
+
+	/**
+	 * @param class-string<MyEnum> $enum
+	 * @phpstan-pure
+	 */
+	public function doBaz(string $enum): MyEnum
+	{
+		return $enum::from('foo');
+	}
+
+	/**
+	 * @param class-string<MyEnum> $enum
+	 * @phpstan-pure
+	 */
+	public function doLorem(string $enum): ?MyEnum
+	{
+		return $enum::tryFrom('foo');
+	}
+
+	/**
+	 * @param class-string<SomeClass> $class
+	 * @phpstan-pure
+	 */
+	public function pureViaClassString(string $class): int
+	{
+		return $class::pureStaticMethod();
+	}
+
+	/**
+	 * @param class-string<SomeClass> $class
+	 * @phpstan-pure
+	 */
+	public function impureViaClassString(string $class): int
+	{
+		return $class::impureStaticMethod(); // error
+	}
+
+}