Report non-stringable names in variable variables, dynamic method calls and dynamic static property/method access

src/DependencyInjection/ContainerFactory.php

@@ -379,11 +379,15 @@ private function processSchema(array $statements, bool $required = true): Schema
 		$parameterSchema = null;
 		foreach ($statements as $statement) {
 			$processedArguments = array_map(fn ($argument) => $this->processArgument($argument), $statement->arguments);
+			$entity = $statement->getEntity();
+			if (!is_string($entity)) {
+				throw new ShouldNotHappenException();
+			}
 			if ($parameterSchema === null) {
 				/** @var Type|AnyOf|Structure $parameterSchema */
-				$parameterSchema = Expect::{$statement->getEntity()}(...$processedArguments);
+				$parameterSchema = Expect::{$entity}(...$processedArguments);
 			} else {
-				$parameterSchema->{$statement->getEntity()}(...$processedArguments);
+				$parameterSchema->{$entity}(...$processedArguments);
 			}
 		}
 

src/Rules/Classes/ClassConstantRule.php

@@ -5,11 +5,9 @@
 use PhpParser\Node;
 use PhpParser\Node\Expr\BinaryOp\Identical;
 use PhpParser\Node\Expr\ClassConstFetch;
-use PhpParser\Node\Name;
 use PhpParser\Node\Scalar\String_;
 use PHPStan\Analyser\NullsafeOperatorHelper;
 use PHPStan\Analyser\Scope;
-use PHPStan\DependencyInjection\AutowiredParameter;
 use PHPStan\DependencyInjection\RegisteredRule;
 use PHPStan\Internal\SprintfHelper;
 use PHPStan\Php\PhpVersion;
@@ -18,6 +16,7 @@
 use PHPStan\Rules\ClassNameNodePair;
 use PHPStan\Rules\ClassNameUsageLocation;
 use PHPStan\Rules\IdentifierRuleError;
+use PHPStan\Rules\NonStringableDynamicAccessCheck;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
@@ -44,8 +43,7 @@ public function __construct(
 		private RuleLevelHelper $ruleLevelHelper,
 		private ClassNameCheck $classCheck,
 		private PhpVersion $phpVersion,
-		#[AutowiredParameter(ref: '%featureToggles.checkNonStringableDynamicAccess%')]
-		private bool $checkNonStringableDynamicAccess,
+		private NonStringableDynamicAccessCheck $nonStringableDynamicAccessCheck,
 	)
 	{
 	}
@@ -68,25 +66,13 @@ public function processNode(Node $node, Scope $scope): array
 				$constantNameScopes[$name] = $scope->filterByTruthyValue(new Identical($node->name, new String_($name)));
 			}
 
-			if ($this->checkNonStringableDynamicAccess) {
-				$nameTypeResult = $this->ruleLevelHelper->findTypeToCheck(
-					$scope,
-					$node->name,
-					'',
-					static fn (Type $type) => $type->isString()->yes(),
-				);
-
-				$nameType = $nameTypeResult->getType();
-				if (!$nameType instanceof ErrorType && !$nameType->isString()->yes()) {
-					$className = $node->class instanceof Name
-						? $scope->resolveName($node->class)
-						: $scope->getType($node->class)->describe(VerbosityLevel::typeOnly());
-
-					$errors[] = RuleErrorBuilder::message(sprintf('Class constant name for %s must be a string, but %s was given.', $className, $nameType->describe(VerbosityLevel::precise())))
-						->identifier('classConstant.nameNotString')
-						->build();
-				}
-			}
+			$errors = array_merge($errors, $this->nonStringableDynamicAccessCheck->checkStringName(
+				$scope,
+				$node->name,
+				'Class constant name for %s must be a string, but %s was given.',
+				$node->class,
+				'classConstant.nameNotString',
+			));
 		}
 
 		foreach ($constantNameScopes as $constantName => $constantScope) {

src/Rules/Methods/CallMethodsRule.php

@@ -14,6 +14,7 @@
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Rules\FunctionCallParametersCheck;
 use PHPStan\Rules\IdentifierRuleError;
+use PHPStan\Rules\NonStringableDynamicAccessCheck;
 use PHPStan\Rules\Rule;
 use function array_merge;
 
@@ -27,6 +28,7 @@ final class CallMethodsRule implements Rule
 	public function __construct(
 		private MethodCallCheck $methodCallCheck,
 		private FunctionCallParametersCheck $parametersCheck,
+		private NonStringableDynamicAccessCheck $nonStringableDynamicAccessCheck,
 	)
 	{
 	}
@@ -48,6 +50,14 @@ public function processNode(Node $node, Scope&NodeCallbackInvoker&CollectedDataE
 				$name = $constantString->getValue();
 				$methodNameScopes[$name] = $scope->filterByTruthyValue(new Identical($node->name, new String_($name)));
 			}
+
+			$errors = array_merge($errors, $this->nonStringableDynamicAccessCheck->checkStringName(
+				$scope,
+				$node->name,
+				'Method name for %s must be a string, but %s was given.',
+				$node->var,
+				'method.nameNotString',
+			));
 		}
 
 		foreach ($methodNameScopes as $methodName => $methodScope) {

src/Rules/Methods/CallStaticMethodsRule.php

@@ -14,6 +14,7 @@
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Rules\FunctionCallParametersCheck;
 use PHPStan\Rules\IdentifierRuleError;
+use PHPStan\Rules\NonStringableDynamicAccessCheck;
 use PHPStan\Rules\Rule;
 use function array_merge;
 use function sprintf;
@@ -28,6 +29,7 @@ final class CallStaticMethodsRule implements Rule
 	public function __construct(
 		private StaticMethodCallCheck $methodCallCheck,
 		private FunctionCallParametersCheck $parametersCheck,
+		private NonStringableDynamicAccessCheck $nonStringableDynamicAccessCheck,
 	)
 	{
 	}
@@ -49,6 +51,14 @@ public function processNode(Node $node, Scope&NodeCallbackInvoker&CollectedDataE
 				$name = $constantString->getValue();
 				$methodNameScopes[$name] = $scope->filterByTruthyValue(new Identical($node->name, new String_($name)));
 			}
+
+			$errors = array_merge($errors, $this->nonStringableDynamicAccessCheck->checkStringName(
+				$scope,
+				$node->name,
+				'Method name for %s must be a string, but %s was given.',
+				$node->class,
+				'staticMethod.nameNotString',
+			));
 		}
 
 		foreach ($methodNameScopes as $methodName => $methodScope) {

src/Rules/NonStringableDynamicAccessCheck.php

@@ -0,0 +1,111 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Name;
+use PHPStan\Analyser\Scope;
+use PHPStan\DependencyInjection\AutowiredParameter;
+use PHPStan\DependencyInjection\AutowiredService;
+use PHPStan\Type\ErrorType;
+use PHPStan\Type\Type;
+use PHPStan\Type\VerbosityLevel;
+use function sprintf;
+
+/**
+ * Checks whether the name of a dynamically accessed variable or member
+ * (`$$name`, `$obj->{$name}`, `$obj->{$name}()`, `Foo::{$name}()`,
+ * `Foo::${$name}`, `Foo::{$name}`) can actually be used as a name at runtime.
+ *
+ * Gated behind the `checkNonStringableDynamicAccess` feature toggle.
+ */
+#[AutowiredService]
+final class NonStringableDynamicAccessCheck
+{
+
+	public function __construct(
+		private RuleLevelHelper $ruleLevelHelper,
+		#[AutowiredParameter(ref: '%featureToggles.checkNonStringableDynamicAccess%')]
+		private bool $checkNonStringableDynamicAccess,
+	)
+	{
+	}
+
+	/**
+	 * For names that PHP casts to string at runtime (variable variables,
+	 * property and static property names) objects implementing __toString are
+	 * accepted.
+	 *
+	 * @param Name|Expr|null $classNode the node whose name/type fills the leading `%s` placeholder, or null when the message has none
+	 * @return list<IdentifierRuleError>
+	 */
+	public function checkStringCastableName(Scope $scope, Expr $name, string $messageFormat, $classNode, string $identifier): array
+	{
+		if (!$this->checkNonStringableDynamicAccess) {
+			return [];
+		}
+
+		$nameType = $this->ruleLevelHelper->findTypeToCheck(
+			$scope,
+			$name,
+			'',
+			static fn (Type $type) => !$type->toString() instanceof ErrorType && $type->toString()->isString()->yes(),
+		)->getType();
+
+		if (
+			!$nameType instanceof ErrorType
+			&& ($nameType->toString() instanceof ErrorType || !$nameType->toString()->isString()->yes())
+		) {
+			return [$this->buildError($scope, $name, $scope->getType($name), $messageFormat, $classNode, $identifier)];
+		}
+
+		return [];
+	}
+
+	/**
+	 * For names that must be actual strings (method, static method and class
+	 * constant names) objects implementing __toString are not accepted.
+	 *
+	 * @param Name|Expr|null $classNode the node whose name/type fills the leading `%s` placeholder, or null when the message has none
+	 * @return list<IdentifierRuleError>
+	 */
+	public function checkStringName(Scope $scope, Expr $name, string $messageFormat, $classNode, string $identifier): array
+	{
+		if (!$this->checkNonStringableDynamicAccess) {
+			return [];
+		}
+
+		$nameType = $this->ruleLevelHelper->findTypeToCheck(
+			$scope,
+			$name,
+			'',
+			static fn (Type $type) => $type->isString()->yes(),
+		)->getType();
+
+		if (!$nameType instanceof ErrorType && !$nameType->isString()->yes()) {
+			return [$this->buildError($scope, $name, $nameType, $messageFormat, $classNode, $identifier)];
+		}
+
+		return [];
+	}
+
+	/**
+	 * @param Name|Expr|null $classNode
+	 */
+	private function buildError(Scope $scope, Expr $name, Type $nameType, string $messageFormat, $classNode, string $identifier): IdentifierRuleError
+	{
+		$messageArgs = [];
+		if ($classNode !== null) {
+			$messageArgs[] = $classNode instanceof Name
+				? $scope->resolveName($classNode)
+				: $scope->getType($classNode)->describe(VerbosityLevel::typeOnly());
+		}
+		$messageArgs[] = $nameType->describe(VerbosityLevel::precise());
+
+		return RuleErrorBuilder::message(sprintf($messageFormat, ...$messageArgs))
+			->line($name->getStartLine())
+			->identifier($identifier)
+			->build();
+	}
+
+}

src/Rules/Properties/AccessPropertiesCheck.php

@@ -18,6 +18,7 @@
 use PHPStan\Reflection\MissingPropertyFromReflectionException;
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Rules\IdentifierRuleError;
+use PHPStan\Rules\NonStringableDynamicAccessCheck;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\Constant\ConstantStringType;
@@ -39,12 +40,11 @@ public function __construct(
 		private ReflectionProvider $reflectionProvider,
 		private RuleLevelHelper $ruleLevelHelper,
 		private PhpVersion $phpVersion,
+		private NonStringableDynamicAccessCheck $nonStringableDynamicAccessCheck,
 		#[AutowiredParameter]
 		private bool $reportMagicProperties,
 		#[AutowiredParameter]
 		private bool $checkDynamicProperties,
-		#[AutowiredParameter(ref: '%featureToggles.checkNonStringableDynamicAccess%')]
-		private bool $checkNonStringableDynamicAccess,
 	)
 	{
 	}
@@ -60,28 +60,14 @@ public function check(PropertyFetch $node, Scope $scope, bool $write): array
 		} else {
 			$names = array_map(static fn (ConstantStringType $type): string => $type->getValue(), $scope->getType($node->name)->getConstantStrings());
 
-			if (!$write && $this->checkNonStringableDynamicAccess) {
-				$nameTypeResult = $this->ruleLevelHelper->findTypeToCheck(
+			if (!$write) {
+				$errors = array_merge($errors, $this->nonStringableDynamicAccessCheck->checkStringCastableName(
 					$scope,
 					$node->name,
-					'',
-					static fn (Type $type) => !$type->toString() instanceof ErrorType && $type->toString()->isString()->yes(),
-				);
-				$nameType = $nameTypeResult->getType();
-				if (
-					!$nameType instanceof ErrorType
-					&& (
-						$nameType->toString() instanceof ErrorType
-						|| !$nameType->toString()->isString()->yes()
-					)
-				) {
-					$originalNameType = $scope->getType($node->name);
-					$className = $scope->getType($node->var)->describe(VerbosityLevel::typeOnly());
-					$errors[] = RuleErrorBuilder::message(sprintf('Property name for %s must be a string, but %s was given.', $className, $originalNameType->describe(VerbosityLevel::precise())))
-						->line($node->name->getStartLine())
-						->identifier('property.nameNotString')
-						->build();
-				}
+					'Property name for %s must be a string, but %s was given.',
+					$node->var,
+					'property.nameNotString',
+				));
 			}
 		}
 

src/Rules/Properties/AccessStaticPropertiesCheck.php

@@ -22,6 +22,7 @@
 use PHPStan\Rules\ClassNameNodePair;
 use PHPStan\Rules\ClassNameUsageLocation;
 use PHPStan\Rules\IdentifierRuleError;
+use PHPStan\Rules\NonStringableDynamicAccessCheck;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\Constant\ConstantStringType;
@@ -48,6 +49,7 @@ public function __construct(
 		private RuleLevelHelper $ruleLevelHelper,
 		private ClassNameCheck $classCheck,
 		private PhpVersion $phpVersion,
+		private NonStringableDynamicAccessCheck $nonStringableDynamicAccessCheck,
 		#[AutowiredParameter(ref: '%tips.discoveringSymbols%')]
 		private bool $discoveringSymbolsTip,
 	)
@@ -59,13 +61,23 @@ public function __construct(
 	 */
 	public function check(StaticPropertyFetch $node, Scope $scope, bool $write): array
 	{
+		$errors = [];
 		if ($node->name instanceof Node\VarLikeIdentifier) {
 			$names = [$node->name->name];
 		} else {
 			$names = array_map(static fn (ConstantStringType $type): string => $type->getValue(), $scope->getType($node->name)->getConstantStrings());
+
+			if (!$write) {
+				$errors = array_merge($errors, $this->nonStringableDynamicAccessCheck->checkStringCastableName(
+					$scope,
+					$node->name,
+					'Static property name for %s must be a string, but %s was given.',
+					$node->class,
+					'staticProperty.nameNotString',
+				));
+			}
 		}
 
-		$errors = [];
 		foreach ($names as $name) {
 			$errors = array_merge($errors, $this->processSingleProperty($scope, $node, $name, $write));
 		}

src/Rules/Variables/DefinedVariableRule.php

@@ -10,6 +10,7 @@
 use PHPStan\DependencyInjection\AutowiredParameter;
 use PHPStan\DependencyInjection\RegisteredRule;
 use PHPStan\Rules\IdentifierRuleError;
+use PHPStan\Rules\NonStringableDynamicAccessCheck;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
 use function array_merge;
@@ -25,6 +26,7 @@ final class DefinedVariableRule implements Rule
 {
 
 	public function __construct(
+		private NonStringableDynamicAccessCheck $nonStringableDynamicAccessCheck,
 		#[AutowiredParameter]
 		private bool $cliArgumentsVariablesRegistered,
 		#[AutowiredParameter]
@@ -50,6 +52,14 @@ public function processNode(Node $node, Scope $scope): array
 				$name = $constantString->getValue();
 				$variableNameScopes[$name] = $scope->filterByTruthyValue(new Identical($node->name, new String_($name)));
 			}
+
+			$errors = array_merge($errors, $this->nonStringableDynamicAccessCheck->checkStringCastableName(
+				$scope,
+				$node->name,
+				'Variable variable name must be a string, but %s was given.',
+				null,
+				'variable.nameNotString',
+			));
 		}
 
 		foreach ($variableNameScopes as $name => $variableScope) {

tests/PHPStan/Analyser/Bug9307CallMethodsRuleTest.php

@@ -5,6 +5,7 @@
 use PHPStan\Rules\FunctionCallParametersCheck;
 use PHPStan\Rules\Methods\CallMethodsRule;
 use PHPStan\Rules\Methods\MethodCallCheck;
+use PHPStan\Rules\NonStringableDynamicAccessCheck;
 use PHPStan\Rules\NullsafeCheck;
 use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper;
 use PHPStan\Rules\Properties\PropertyReflectionFinder;
@@ -49,6 +50,7 @@ protected function getRule(): Rule
 				checkExtraArguments: true,
 				checkMissingTypehints: true,
 			),
+			new NonStringableDynamicAccessCheck($ruleLevelHelper, true),
 		);
 	}