Support dynamic name expressions in rules

Author: zonuexe

Diff for: src/Rules/Classes/ClassConstantRule.php

@@ -11,6 +11,7 @@
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Rules\ClassNameCheck;
 use PHPStan\Rules\ClassNameNodePair;
+use PHPStan\Rules\IdentifierRuleError;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Rules\RuleLevelHelper;
@@ -20,6 +21,7 @@
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\VerbosityLevel;
+use function array_map;
 use function array_merge;
 use function in_array;
 use function sprintf;
@@ -47,11 +49,26 @@ public function getNodeType(): string
 
 	public function processNode(Node $node, Scope $scope): array
 	{
-		if (!$node->name instanceof Node\Identifier) {
-			return [];
+		$errors = [];
+		if ($node->name instanceof Node\Identifier) {
+			$constantNames = [$node->name->name];
+		} else {
+			$fetchType = $scope->getType($node->name);
+			$constantNames = array_map(static fn ($type): string => $type->getValue(), $fetchType->getConstantStrings());
+		}
+
+		foreach ($constantNames as $constantName) {
+			$errors = array_merge($errors, $this->processSingleClassConstFetch($scope, $node, $constantName));
 		}
-		$constantName = $node->name->name;
 
+		return $errors;
+	}
+
+	/**
+	 * @return list<IdentifierRuleError>
+	 */
+	private function processSingleClassConstFetch(Scope $scope, ClassConstFetch $node, string $constantName): array
+	{
 		$class = $node->class;
 		$messages = [];
 		if ($class instanceof Node\Name) {

Diff for: src/Rules/Methods/CallMethodsRule.php

@@ -8,7 +8,10 @@
 use PHPStan\Internal\SprintfHelper;
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Rules\FunctionCallParametersCheck;
+use PHPStan\Rules\IdentifierRuleError;
 use PHPStan\Rules\Rule;
+use PHPStan\Type\Constant\ConstantStringType;
+use function array_map;
 use function array_merge;
 
 /**
@@ -31,12 +34,26 @@ public function getNodeType(): string
 
 	public function processNode(Node $node, Scope $scope): array
 	{
-		if (!$node->name instanceof Node\Identifier) {
-			return [];
+		$errors = [];
+		if ($node->name instanceof Node\Identifier) {
+			$methodNames = [$node->name->name];
+		} else {
+			$callType = $scope->getType($node->name);
+			$methodNames = array_map(static fn (ConstantStringType $type): string => $type->getValue(), $callType->getConstantStrings());
 		}
 
-		$methodName = $node->name->name;
+		foreach ($methodNames as $methodName) {
+			$errors = array_merge($errors, $this->processSingleMethodCall($scope, $node, $methodName));
+		}
+
+		return $errors;
+	}
 
+	/**
+	 * @return list<IdentifierRuleError>
+	 */
+	private function processSingleMethodCall(Scope $scope, MethodCall $node, string $methodName): array
+	{
 		[$errors, $methodReflection] = $this->methodCallCheck->check($scope, $methodName, $node->var);
 		if ($methodReflection === null) {
 			return $errors;

Diff for: src/Rules/Methods/CallStaticMethodsRule.php

@@ -8,7 +8,10 @@
 use PHPStan\Internal\SprintfHelper;
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Rules\FunctionCallParametersCheck;
+use PHPStan\Rules\IdentifierRuleError;
 use PHPStan\Rules\Rule;
+use PHPStan\Type\Constant\ConstantStringType;
+use function array_map;
 use function array_merge;
 use function sprintf;
 
@@ -32,11 +35,26 @@ public function getNodeType(): string
 
 	public function processNode(Node $node, Scope $scope): array
 	{
-		if (!$node->name instanceof Node\Identifier) {
-			return [];
+		$errors = [];
+		if ($node->name instanceof Node\Identifier) {
+			$methodNames = [$node->name->name];
+		} else {
+			$callType = $scope->getType($node->name);
+			$methodNames = array_map(static fn (ConstantStringType $type): string => $type->getValue(), $callType->getConstantStrings());
 		}
-		$methodName = $node->name->name;
 
+		foreach ($methodNames as $methodName) {
+			$errors = array_merge($errors, $this->processSingleMethodCall($scope, $node, $methodName));
+		}
+
+		return $errors;
+	}
+
+	/**
+	 * @return list<IdentifierRuleError>
+	 */
+	private function processSingleMethodCall(Scope $scope, StaticCall $node, string $methodName): array
+	{
 		[$errors, $method] = $this->methodCallCheck->check($scope, $methodName, $node->class);
 		if ($method === null) {
 			return $errors;

Diff for: src/Rules/Variables/DefinedVariableRule.php

@@ -5,8 +5,12 @@
 use PhpParser\Node;
 use PhpParser\Node\Expr\Variable;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\IdentifierRuleError;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\Type\Constant\ConstantStringType;
+use function array_map;
+use function array_merge;
 use function in_array;
 use function is_string;
 use function sprintf;
@@ -31,11 +35,27 @@ public function getNodeType(): string
 
 	public function processNode(Node $node, Scope $scope): array
 	{
-		if (!is_string($node->name)) {
-			return [];
+		$errors = [];
+		if (is_string($node->name)) {
+			$variableNames = [$node->name];
+		} else {
+			$fetchType = $scope->getType($node->name);
+			$variableNames = array_map(static fn (ConstantStringType $type): string => $type->getValue(), $fetchType->getConstantStrings());
+		}
+
+		foreach ($variableNames as $name) {
+			$errors = array_merge($errors, $this->processSingleVariable($scope, $node, $name));
 		}
 
-		if ($this->cliArgumentsVariablesRegistered && in_array($node->name, [
+		return $errors;
+	}
+
+	/**
+	 * @return list<IdentifierRuleError>
+	 */
+	private function processSingleVariable(Scope $scope, Variable $node, string $variableName): array
+	{
+		if ($this->cliArgumentsVariablesRegistered && in_array($variableName, [
 			'argc',
 			'argv',
 		], true)) {
@@ -49,18 +69,18 @@ public function processNode(Node $node, Scope $scope): array
 			return [];
 		}
 
-		if ($scope->hasVariableType($node->name)->no()) {
+		if ($scope->hasVariableType($variableName)->no()) {
 			return [
-				RuleErrorBuilder::message(sprintf('Undefined variable: $%s', $node->name))
+				RuleErrorBuilder::message(sprintf('Undefined variable: $%s', $variableName))
 					->identifier('variable.undefined')
 					->build(),
 			];
 		} elseif (
 			$this->checkMaybeUndefinedVariables
-			&& !$scope->hasVariableType($node->name)->yes()
+			&& !$scope->hasVariableType($variableName)->yes()
 		) {
 			return [
-				RuleErrorBuilder::message(sprintf('Variable $%s might not be defined.', $node->name))
+				RuleErrorBuilder::message(sprintf('Variable $%s might not be defined.', $variableName))
 					->identifier('variable.undefined')
 					->build(),
 			];