Rework allowInMethodsWithAttributes in signatures to use a node visitor (#395)

PHPStan's `$scope->getFunction()` returns `null` in param return types because scope has not entered the function or method body yet. The previous workaround #315 (fixing #314) used a stateful object and four helper rules that set/unset the current method or function name, relying on a rule execution order being strictly top-down - an undocumented implementation detail, not a contract.

`TypeHintContextVisitor` (ex-`TypeHintPositionVisitor`) already annotated type nodes at parse time with position information. Extending it to also carry the enclosing function's attribute names solves the same problem at the right level, with no ordering assumptions and no shared state.

Author: spaze

extension.neon

@@ -499,13 +499,12 @@ parametersSchema:
 
 services:
 	-
-		class: Spaze\PHPStan\Rules\Disallowed\Type\TypeHintPositionVisitor
+		class: Spaze\PHPStan\Rules\Disallowed\Type\TypeHintContextVisitor
 		tags:
 			- phpstan.parser.richParserNodeVisitor
 	- Spaze\PHPStan\Rules\Disallowed\Allowed\Allowed
 	- Spaze\PHPStan\Rules\Disallowed\Allowed\AllowedConfigFactory
 	- Spaze\PHPStan\Rules\Disallowed\Allowed\AllowedPath
-	- Spaze\PHPStan\Rules\Disallowed\Allowed\GetAttributesWhenInSignature
 	- Spaze\PHPStan\Rules\Disallowed\DisallowedAttributeFactory
 	- Spaze\PHPStan\Rules\Disallowed\DisallowedCallFactory
 	- Spaze\PHPStan\Rules\Disallowed\DisallowedConstantFactory
@@ -690,19 +689,4 @@ services:
 		factory: Spaze\PHPStan\Rules\Disallowed\Usages\StaticPropertyUsages(disallowedProperties: %disallowedProperties%)
 		tags:
 			- phpstan.rules.rule
-	-
-		factory: Spaze\PHPStan\Rules\Disallowed\HelperRules\SetCurrentClassMethodNameHelperRule
-		tags:
-			- phpstan.rules.rule
-	-
-		factory: Spaze\PHPStan\Rules\Disallowed\HelperRules\UnsetCurrentClassMethodNameHelperRule
-		tags:
-			- phpstan.rules.rule
-	-
-		factory: Spaze\PHPStan\Rules\Disallowed\HelperRules\SetCurrentFunctionNameHelperRule
-		tags:
-			- phpstan.rules.rule
-	-
-		factory: Spaze\PHPStan\Rules\Disallowed\HelperRules\UnsetCurrentFunctionNameHelperRule
-		tags:
-			- phpstan.rules.rule
+

src/Allowed/Allowed.php

@@ -8,9 +8,6 @@
 use PhpParser\Node\Stmt\ClassMethod;
 use PhpParser\Node\Stmt\Function_;
 use PHPStan\Analyser\Scope;
-use PHPStan\BetterReflection\Reflection\Adapter\FakeReflectionAttribute;
-use PHPStan\BetterReflection\Reflection\Adapter\ReflectionAttribute;
-use PHPStan\BetterReflection\Reflection\ReflectionAttribute as BetterReflectionAttribute;
 use PHPStan\BetterReflection\Reflector\Reflector;
 use PHPStan\Reflection\FunctionReflection;
 use PHPStan\Reflection\MethodReflection;
@@ -23,6 +20,7 @@
 use Spaze\PHPStan\Rules\Disallowed\Formatter\Formatter;
 use Spaze\PHPStan\Rules\Disallowed\Identifier\Identifier;
 use Spaze\PHPStan\Rules\Disallowed\Params\Param;
+use Spaze\PHPStan\Rules\Disallowed\Type\TypeHintContextVisitor;
 
 class Allowed
 {
@@ -33,22 +31,18 @@ class Allowed
 
 	private Identifier $identifier;
 
-	private GetAttributesWhenInSignature $attributesWhenInSignature;
-
 	private AllowedPath $allowedPath;
 
 
 	public function __construct(
 		Formatter $formatter,
 		Reflector $reflector,
 		Identifier $identifier,
-		GetAttributesWhenInSignature $attributesWhenInSignature,
 		AllowedPath $allowedPath
 	) {
 		$this->formatter = $formatter;
 		$this->reflector = $reflector;
 		$this->identifier = $identifier;
-		$this->attributesWhenInSignature = $attributesWhenInSignature;
 		$this->allowedPath = $allowedPath;
 	}
 
@@ -220,18 +214,14 @@ private function hasAllowedParamsInAllowed(Scope $scope, ?array $args, Disallowe
 
 
 	/**
-	 * @param list<FakeReflectionAttribute|ReflectionAttribute|BetterReflectionAttribute> $attributes
+	 * @param list<string> $attributeNames
 	 * @param list<string> $allowConfig
 	 * @return bool
 	 */
-	private function hasAllowedAttribute(array $attributes, array $allowConfig): bool
+	private function hasAllowedAttribute(array $attributeNames, array $allowConfig): bool
 	{
-		$names = [];
-		foreach ($attributes as $attribute) {
-			$names[] = $attribute->getName();
-		}
 		foreach ($allowConfig as $allowAttribute) {
-			foreach ($names as $name) {
+			foreach ($attributeNames as $name) {
 				if ($this->identifier->matches($allowAttribute, $name)) {
 					return true;
 				}
@@ -264,35 +254,50 @@ private function getArgType(array $args, Scope $scope, Param $param): ?Type
 
 	/**
 	 * @param Scope $scope
-	 * @return list<FakeReflectionAttribute>|list<ReflectionAttribute>
+	 * @return list<string>
 	 */
 	private function getAttributes(Scope $scope): array
 	{
-		return $scope->isInClass() ? $scope->getClassReflection()->getNativeReflection()->getAttributes() : [];
+		if (!$scope->isInClass()) {
+			return [];
+		}
+		return array_map(static fn($a) => $a->getName(), $scope->getClassReflection()->getNativeReflection()->getAttributes());
 	}
 
 
 	/**
 	 * @param Node|null $node
 	 * @param Scope $scope
-	 * @return list<FakeReflectionAttribute|ReflectionAttribute|BetterReflectionAttribute>
+	 * @return list<string>
 	 */
 	private function getCallAttributes(?Node $node, Scope $scope): array
 	{
 		$function = $scope->getFunction();
 		if ($function instanceof MethodReflection) {
-			return $scope->isInClass() ? $scope->getClassReflection()->getNativeReflection()->getMethod($function->getName())->getAttributes() : [];
+			if (!$scope->isInClass()) {
+				return [];
+			}
+			return array_map(static fn($a) => $a->getName(), $scope->getClassReflection()->getNativeReflection()->getMethod($function->getName())->getAttributes());
 		} elseif ($function instanceof FunctionReflection) {
-			return $this->reflector->reflectFunction($function->getName())->getAttributes();
+			return array_map(static fn($a) => $a->getName(), $this->reflector->reflectFunction($function->getName())->getAttributes());
 		} elseif ($function === null) {
 			if ($node instanceof ClassMethod && $scope->isInClass()) {
-				return $scope->getClassReflection()->getNativeReflection()->getMethod($node->name->name)->getAttributes();
+				return array_map(static fn($a) => $a->getName(), $scope->getClassReflection()->getNativeReflection()->getMethod($node->name->name)->getAttributes());
 			} elseif ($node instanceof Function_) {
-				return $this->reflector->reflectFunction($node->name->name)->getAttributes();
+				return array_map(static fn($a) => $a->getName(), $this->reflector->reflectFunction(($node->namespacedName ?? $node->name)->toString())->getAttributes());
 			}
-			$attributes = $this->attributesWhenInSignature->get($scope);
-			if ($attributes !== null) {
-				return $attributes;
+			// $scope->getFunction() is null in param/return type hints, use the enclosing function attributes stored by TypeHintContextVisitor
+			if ($node !== null) {
+				$names = $node->getAttribute(TypeHintContextVisitor::ATTRIBUTE_ENCLOSING_FUNCTION_ATTR_NAMES);
+				if (is_array($names)) {
+					$result = [];
+					foreach ($names as $name) {
+						if (is_string($name)) {
+							$result[] = $name;
+						}
+					}
+					return $result;
+				}
 			}
 		}
 		return [];
@@ -301,21 +306,20 @@ private function getCallAttributes(?Node $node, Scope $scope): array
 
 	/**
 	 * @param Scope $scope
-	 * @return list<FakeReflectionAttribute>|list<ReflectionAttribute>
+	 * @return list<string>
 	 */
 	private function getAllMethodAttributes(Scope $scope): array
 	{
 		if (!$scope->isInClass()) {
 			return [];
 		}
-		$attributes = [];
+		$names = [];
 		foreach ($scope->getClassReflection()->getNativeReflection()->getMethods() as $method) {
-			$methodAttributes = $method->getAttributes();
-			if ($methodAttributes !== []) {
-				$attributes = array_merge($attributes, $methodAttributes);
+			foreach ($method->getAttributes() as $attribute) {
+				$names[] = $attribute->getName();
 			}
 		}
-		return $attributes;
+		return $names;
 	}
 
 }