Resolve self/parent/static class constants inside Closure::bind() scope

Annotate special class-name nodes (self/parent/static) that appear inside a
Closure::bind() call with the bind scope argument via ClosureBindArgVisitor, and
resolve the class constant type against that bound class in ClassConstFetchHandler.

Reconstruction of PR phpstan#4081 (closure-bind-scope) rebased onto 2.2.x: the original
MutatingScope::getType() ClassConstFetch branch no longer exists after expression
handling was split into ExprHandler services.

Author: zonuexe

src/Analyser/ExprHandler/ClassConstFetchHandler.php

@@ -5,6 +5,7 @@
 use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\ClassConstFetch;
 use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
 use PhpParser\Node\Stmt;
 use PHPStan\Analyser\ExpressionContext;
 use PHPStan\Analyser\ExpressionResult;
@@ -18,10 +19,14 @@
 use PHPStan\Analyser\TypeSpecifier;
 use PHPStan\Analyser\TypeSpecifierContext;
 use PHPStan\DependencyInjection\AutowiredService;
+use PHPStan\Parser\ClosureBindArgVisitor;
+use PHPStan\Reflection\ClassReflection;
 use PHPStan\Reflection\InitializerExprTypeResolver;
+use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\Type;
 use function array_merge;
+use function count;
 
 /**
  * @implements ExprHandler<ClassConstFetch>
@@ -33,6 +38,7 @@ final class ClassConstFetchHandler implements ExprHandler
 	public function __construct(
 		private InitializerExprTypeResolver $initializerExprTypeResolver,
 		private ExpressionResultFactory $expressionResultFactory,
+		private ReflectionProvider $reflectionProvider,
 	)
 	{
 	}
@@ -48,14 +54,51 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type
 			return new MixedType();
 		}
 
+		$classReflection = $scope->isInClass() ? $scope->getClassReflection() : null;
+		$bindScopeReflection = $this->resolveClosureBindScopeReflection($scope, $expr->class);
+		if ($bindScopeReflection !== null) {
+			$classReflection = $bindScopeReflection;
+		}
+
 		return $this->initializerExprTypeResolver->getClassConstFetchTypeByReflection(
 			$expr->class,
 			$expr->name->name,
-			$scope->isInClass() ? $scope->getClassReflection() : null,
+			$classReflection,
 			static fn (Expr $e): Type => $scope->getType($e),
 		);
 	}
 
+	/**
+	 * Resolves the `Closure::bind()` scope class annotated on a `self`/`parent`/`static`
+	 * class name node by {@see ClosureBindArgVisitor}. Returns null when the node is not
+	 * inside a bound closure or the scope argument does not resolve to a single known class.
+	 */
+	private function resolveClosureBindScopeReflection(MutatingScope $scope, Expr|Name $class): ?ClassReflection
+	{
+		if (!$class instanceof Name || !$class->hasAttribute(ClosureBindArgVisitor::SCOPE_ATTRIBUTE_NAME)) {
+			return null;
+		}
+
+		$scopeArg = $class->getAttribute(ClosureBindArgVisitor::SCOPE_ATTRIBUTE_NAME);
+		if (!$scopeArg instanceof Expr) {
+			// null attribute means the default "static" scope: keep the enclosing class.
+			return null;
+		}
+
+		$scopeArgType = $scope->getType($scopeArg);
+		$objectClassNames = $scopeArgType->getClassStringObjectType()->getObjectClassNames();
+		if (count($objectClassNames) !== 1) {
+			return null;
+		}
+
+		$className = $objectClassNames[0];
+		if (!$this->reflectionProvider->hasClass($className)) {
+			return null;
+		}
+
+		return $this->reflectionProvider->getClass($className);
+	}
+
 	public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult
 	{
 		$beforeScope = $scope;

src/Parser/ClosureBindArgVisitor.php

@@ -4,9 +4,14 @@
 
 use Override;
 use PhpParser\Node;
+use PhpParser\Node\Expr;
 use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
 use PhpParser\NodeVisitorAbstract;
 use PHPStan\DependencyInjection\AutowiredService;
+use function array_key_exists;
+use function array_shift;
+use function array_unshift;
 use function count;
 
 #[AutowiredService]
@@ -15,6 +20,11 @@ final class ClosureBindArgVisitor extends NodeVisitorAbstract
 
 	public const ATTRIBUTE_NAME = 'closureBindArg';
 
+	public const SCOPE_ATTRIBUTE_NAME = 'closureBindScope';
+
+	/** @var list<?Expr> */
+	private array $scopeStack = [];
+
 	#[Override]
 	public function enterNode(Node $node): ?Node
 	{
@@ -30,7 +40,35 @@ public function enterNode(Node $node): ?Node
 			if (count($args) > 1) {
 				$args[0]->setAttribute(self::ATTRIBUTE_NAME, true);
 			}
+
+			// null means default scope "static"
+			array_unshift($this->scopeStack, $args[2]->value ?? null);
+		}
+
+		if ($node instanceof Name
+			&& array_key_exists(0, $this->scopeStack)
+			&& $node->isSpecialClassName()
+		) {
+			$node->setAttribute(self::SCOPE_ATTRIBUTE_NAME, $this->scopeStack[0]);
+		}
+
+		return null;
+	}
+
+	#[Override]
+	public function leaveNode(Node $node): ?Node
+	{
+		if (
+			$node instanceof Node\Expr\StaticCall
+			&& $node->class instanceof Node\Name
+			&& $node->class->toLowerString() === 'closure'
+			&& $node->name instanceof Identifier
+			&& $node->name->toLowerString() === 'bind'
+			&& !$node->isFirstClassCallable()
+		) {
+			array_shift($this->scopeStack);
 		}
+
 		return null;
 	}
 

tests/PHPStan/Analyser/nsrt/closure-bind-scope.php

@@ -0,0 +1,43 @@
+<?php declare(strict_types = 1);
+
+namespace ClosureBindScope;
+
+use Closure;
+use function PHPStan\Testing\assertType;
+
+class Foo
+{
+
+	protected const A = 'Foo';
+
+}
+
+final class Bar extends Foo
+{
+
+	protected const A = 'Bar';
+
+}
+
+// Explicit class names resolve regardless of the bound scope.
+assertType("'Foo'", Closure::bind(static fn () => Foo::A, null, Foo::class)());
+assertType("'Foo'", Closure::bind(static fn () => Foo::A, null, Bar::class)());
+assertType("'Bar'", Closure::bind(static fn () => Bar::A, null, Bar::class)());
+
+// `self` / `parent` resolve against the Closure::bind() scope (3rd argument).
+assertType("'Foo'", Closure::bind(static fn () => self::A, null, Foo::class)());
+assertType("'Bar'", Closure::bind(static fn () => self::A, null, Bar::class)());
+assertType("'Foo'", Closure::bind(static fn () => parent::A, null, Bar::class)());
+
+class Container
+{
+
+	public function doBindFromInsideClass(): void
+	{
+		// Even when Closure::bind() is called from inside another class, the bound
+		// scope wins over the enclosing class.
+		assertType("'Foo'", Closure::bind(static fn () => self::A, null, Foo::class)());
+		assertType("'Bar'", Closure::bind(static fn () => self::A, null, Bar::class)());
+	}
+
+}