Use the new getAttributes() API to get attributes

The API is available starting with PHPStan 2.1.3 https://github.com/phpstan/phpstan/releases/tag/2.1.3 so I'll need to decide when to merge this and when or how to remove support for earlier versions.

Also require nikic/php-parser 5.0+ because first PHPStan 2.x requires and uses it and second, Function_::namespacedName is not available in earlier versions.

Author: spaze

composer.json

@@ -22,11 +22,11 @@
 	},
 	"require": {
 		"php": "^7.4 || ^8.0",
-		"phpstan/phpstan": "^1.12.6 || ^2.0"
+		"phpstan/phpstan": "^2.1.3"
 	},
 	"require-dev": {
 		"nette/neon": "^3.3.1",
-		"nikic/php-parser": "^4.13 || ^5.0",
+		"nikic/php-parser": "^5.0",
 		"phpunit/phpunit": "^8.5.14 || ^10.1 || ^11.0 || ^12.0",
 		"php-parallel-lint/php-parallel-lint": "^1.2",
 		"php-parallel-lint/php-console-highlighter": "^1.0",

src/Allowed/Allowed.php

@@ -8,12 +8,10 @@
 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\AttributeReflection;
 use PHPStan\Reflection\FunctionReflection;
 use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Type\Type;
 use PHPStan\Type\UnionType;
 use Spaze\PHPStan\Rules\Disallowed\Disallowed;
@@ -28,7 +26,7 @@ class Allowed
 
 	private Formatter $formatter;
 
-	private Reflector $reflector;
+	private ReflectionProvider $reflectionProvider;
 
 	private Identifier $identifier;
 
@@ -37,12 +35,12 @@ class Allowed
 
 	public function __construct(
 		Formatter $formatter,
-		Reflector $reflector,
+		ReflectionProvider $reflectionProvider,
 		Identifier $identifier,
 		AllowedPath $allowedPath
 	) {
 		$this->formatter = $formatter;
-		$this->reflector = $reflector;
+		$this->reflectionProvider = $reflectionProvider;
 		$this->identifier = $identifier;
 		$this->allowedPath = $allowedPath;
 	}
@@ -199,7 +197,7 @@ private function hasAllowedParamsInAllowed(Scope $scope, ?array $args, Disallowe
 
 
 	/**
-	 * @param list<FakeReflectionAttribute|ReflectionAttribute|BetterReflectionAttribute> $attributes
+	 * @param list<AttributeReflection> $attributes
 	 * @param list<string> $allowConfig
 	 * @return bool
 	 */
@@ -243,49 +241,46 @@ private function getArgType(array $args, Scope $scope, Param $param): ?Type
 
 	/**
 	 * @param Scope $scope
-	 * @return list<FakeReflectionAttribute>|list<ReflectionAttribute>
+	 * @return list<AttributeReflection>
 	 */
 	private function getAttributes(Scope $scope): array
 	{
-		return $scope->isInClass() ? $scope->getClassReflection()->getNativeReflection()->getAttributes() : [];
+		return $scope->isInClass() ? $scope->getClassReflection()->getAttributes() : [];
 	}
 
 
 	/**
 	 * @param Node|null $node
 	 * @param Scope $scope
-	 * @return list<FakeReflectionAttribute|ReflectionAttribute|BetterReflectionAttribute>
+	 * @return list<AttributeReflection>
 	 */
 	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() : [];
-		} elseif ($function instanceof FunctionReflection) {
-			return $this->reflector->reflectFunction($function->getName())->getAttributes();
-		} elseif ($function === null) {
-			if ($node instanceof ClassMethod && $scope->isInClass()) {
-				return $scope->getClassReflection()->getNativeReflection()->getMethod($node->name->name)->getAttributes();
-			} elseif ($node instanceof Function_) {
-				return $this->reflector->reflectFunction($node->name->name)->getAttributes();
-			}
+		if ($function !== null) {
+			return $function->getAttributes();
+		} elseif ($node instanceof ClassMethod && $scope->isInClass()) {
+			return $scope->getClassReflection()->getNativeMethod($node->name->name)->getAttributes();
+		} elseif ($node instanceof Function_ && $node->namespacedName !== null) {
+			return $this->reflectionProvider->getFunction($node->namespacedName, $scope)->getAttributes();
 		}
 		return [];
 	}
 
 
 	/**
 	 * @param Scope $scope
-	 * @return list<FakeReflectionAttribute>|list<ReflectionAttribute>
+	 * @return list<AttributeReflection>
 	 */
 	private function getAllMethodAttributes(Scope $scope): array
 	{
 		if (!$scope->isInClass()) {
 			return [];
 		}
 		$attributes = [];
-		foreach ($scope->getClassReflection()->getNativeReflection()->getMethods() as $method) {
-			$methodAttributes = $method->getAttributes();
+		$classReflection = $scope->getClassReflection();
+		foreach ($classReflection->getNativeReflection()->getMethods() as $method) {
+			$methodAttributes = $classReflection->getNativeMethod($method->getName())->getAttributes();
 			if ($methodAttributes !== []) {
 				$attributes = array_merge($attributes, $methodAttributes);
 			}