Treat first-class callable NullsafeMethodCall as a MethodCall instead of throwing

src/Analyser/ExprHandler/Virtual/NullsafeFirstClassCallableNodeHandler.php

@@ -0,0 +1,73 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser\ExprHandler\Virtual;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Stmt;
+use PHPStan\Analyser\ExpressionContext;
+use PHPStan\Analyser\ExpressionResult;
+use PHPStan\Analyser\ExpressionResultStorage;
+use PHPStan\Analyser\ExprHandler;
+use PHPStan\Analyser\MutatingScope;
+use PHPStan\Analyser\NodeScopeResolver;
+use PHPStan\Analyser\Scope;
+use PHPStan\Analyser\SpecifiedTypes;
+use PHPStan\Analyser\TypeSpecifier;
+use PHPStan\Analyser\TypeSpecifierContext;
+use PHPStan\DependencyInjection\AutowiredService;
+use PHPStan\Node\NullsafeFirstClassCallableNode;
+use PHPStan\Type\MixedType;
+use PHPStan\Type\Type;
+use function array_merge;
+
+/**
+ * @implements ExprHandler<NullsafeFirstClassCallableNode>
+ */
+#[AutowiredService]
+final class NullsafeFirstClassCallableNodeHandler implements ExprHandler
+{
+
+	public function supports(Expr $expr): bool
+	{
+		return $expr instanceof NullsafeFirstClassCallableNode;
+	}
+
+	public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult
+	{
+		$varResult = $nodeScopeResolver->processExprNode($stmt, $expr->getVar(), $scope, $storage, $nodeCallback, ExpressionContext::createDeep());
+		$scope = $varResult->getScope();
+		$hasYield = $varResult->hasYield();
+		$throwPoints = $varResult->getThrowPoints();
+		$impurePoints = $varResult->getImpurePoints();
+		$isAlwaysTerminating = false;
+		if ($expr->getName() instanceof Expr) {
+			$nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->getName(), $scope, $storage, $nodeCallback, ExpressionContext::createDeep());
+			$scope = $nameResult->getScope();
+			$hasYield = $hasYield || $nameResult->hasYield();
+			$throwPoints = array_merge($throwPoints, $nameResult->getThrowPoints());
+			$impurePoints = array_merge($impurePoints, $nameResult->getImpurePoints());
+			$isAlwaysTerminating = $nameResult->isAlwaysTerminating();
+		}
+
+		return new ExpressionResult(
+			$scope,
+			hasYield: $hasYield,
+			isAlwaysTerminating: $isAlwaysTerminating,
+			throwPoints: $throwPoints,
+			impurePoints: $impurePoints,
+		);
+	}
+
+	public function resolveType(MutatingScope $scope, Expr $expr): Type
+	{
+		// in practice the type of the first-class callable is resolved
+		// by NullsafeMethodCallHandler / FirstClassCallableMethodCallHandler
+		return new MixedType();
+	}
+
+	public function specifyTypes(TypeSpecifier $typeSpecifier, Scope $scope, Expr $expr, TypeSpecifierContext $context): SpecifiedTypes
+	{
+		return $typeSpecifier->specifyDefaultTypes($scope, $expr, $context);
+	}
+
+}

src/Analyser/NodeScopeResolver.php

@@ -101,6 +101,7 @@
 use PHPStan\Node\MethodCallableNode;
 use PHPStan\Node\MethodReturnStatementsNode;
 use PHPStan\Node\NoopExpressionNode;
+use PHPStan\Node\NullsafeFirstClassCallableNode;
 use PHPStan\Node\PropertyAssignNode;
 use PHPStan\Node\PropertyHookReturnStatementsNode;
 use PHPStan\Node\PropertyHookStatementNode;
@@ -2755,6 +2756,11 @@ public function processExprNode(
 				$newExpr = new FunctionCallableNode($expr->name, $expr);
 			} elseif ($expr instanceof MethodCall) {
 				$newExpr = new MethodCallableNode($expr->var, $expr->name, $expr);
+			} elseif ($expr instanceof Expr\NullsafeMethodCall) {
+				// $foo?->bar(...) is a fatal error in PHP ("Cannot combine nullsafe
+				// operator with Closure creation"), but it must not crash the analyser.
+				// The error is reported by NullsafeFirstClassCallableRule.
+				$newExpr = new NullsafeFirstClassCallableNode($expr->var, $expr->name, $expr);
 			} elseif ($expr instanceof StaticCall) {
 				$newExpr = new StaticMethodCallableNode($expr->class, $expr->name, $expr);
 			} elseif ($expr instanceof New_ && !$expr->class instanceof Class_) {

src/Dependency/DependencyResolver.php

@@ -21,6 +21,7 @@
 use PHPStan\Node\InPropertyHookNode;
 use PHPStan\Node\InstantiationCallableNode;
 use PHPStan\Node\MethodCallableNode;
+use PHPStan\Node\NullsafeFirstClassCallableNode;
 use PHPStan\Node\StaticMethodCallableNode;
 use PHPStan\Reflection\ClassReflection;
 use PHPStan\Reflection\ExtendedParameterReflection;
@@ -486,6 +487,10 @@ public function resolveDependencies(Node $node, Scope $scope): NodeDependencies
 			foreach ($this->resolveDependencies(new Node\Expr\MethodCall($node->getVar(), $node->getName()), $scope)->getReflections() as $dependency) {
 				$dependenciesReflections[] = $dependency;
 			}
+		} elseif ($node instanceof NullsafeFirstClassCallableNode) {
+			foreach ($this->resolveDependencies(new Node\Expr\NullsafeMethodCall($node->getVar(), $node->getName()), $scope)->getReflections() as $dependency) {
+				$dependenciesReflections[] = $dependency;
+			}
 		} elseif ($node instanceof FunctionCallableNode) {
 			foreach ($this->resolveDependencies(new Node\Expr\FuncCall($node->getName()), $scope)->getReflections() as $dependency) {
 				$dependenciesReflections[] = $dependency;

src/Node/NullsafeFirstClassCallableNode.php

@@ -0,0 +1,61 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Node;
+
+use Override;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Identifier;
+
+/**
+ * Represents `$foo?->bar(...)` - combining the nullsafe operator with the
+ * first-class callable syntax. This is a fatal error in PHP ("Cannot combine
+ * nullsafe operator with Closure creation"), reported by NullsafeFirstClassCallableRule.
+ *
+ * @api
+ */
+final class NullsafeFirstClassCallableNode extends Expr implements VirtualNode
+{
+
+	public function __construct(
+		private Expr $var,
+		private Identifier|Expr $name,
+		private Expr\NullsafeMethodCall $originalNode,
+	)
+	{
+		parent::__construct($originalNode->getAttributes());
+	}
+
+	public function getVar(): Expr
+	{
+		return $this->var;
+	}
+
+	/**
+	 * @return Expr|Identifier
+	 */
+	public function getName()
+	{
+		return $this->name;
+	}
+
+	public function getOriginalNode(): Expr\NullsafeMethodCall
+	{
+		return $this->originalNode;
+	}
+
+	#[Override]
+	public function getType(): string
+	{
+		return 'PHPStan_Node_NullsafeFirstClassCallableNode';
+	}
+
+	/**
+	 * @return string[]
+	 */
+	#[Override]
+	public function getSubNodeNames(): array
+	{
+		return [];
+	}
+
+}

src/Node/Printer/Printer.php

@@ -29,6 +29,7 @@
 use PHPStan\Node\InstantiationCallableNode;
 use PHPStan\Node\IssetExpr;
 use PHPStan\Node\MethodCallableNode;
+use PHPStan\Node\NullsafeFirstClassCallableNode;
 use PHPStan\Node\StaticMethodCallableNode;
 use PHPStan\Type\VerbosityLevel;
 use function sprintf;
@@ -160,6 +161,11 @@ protected function pPHPStan_Node_MethodCallableNode(MethodCallableNode $expr): s
 		return sprintf('__phpstanMethodCallable(%s)', $this->p($expr->getOriginalNode()));
 	}
 
+	protected function pPHPStan_Node_NullsafeFirstClassCallableNode(NullsafeFirstClassCallableNode $expr): string // phpcs:ignore
+	{
+		return sprintf('__phpstanNullsafeFirstClassCallable(%s)', $this->p($expr->getOriginalNode()));
+	}
+
 	protected function pPHPStan_Node_StaticMethodCallableNode(StaticMethodCallableNode $expr): string // phpcs:ignore
 	{
 		return sprintf('__phpstanStaticMethodCallable(%s)', $this->p($expr->getOriginalNode()));

src/Rules/Methods/NullsafeFirstClassCallableRule.php

@@ -0,0 +1,34 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Methods;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\DependencyInjection\RegisteredRule;
+use PHPStan\Node\NullsafeFirstClassCallableNode;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+
+/**
+ * @implements Rule<NullsafeFirstClassCallableNode>
+ */
+#[RegisteredRule(level: 0)]
+final class NullsafeFirstClassCallableRule implements Rule
+{
+
+	public function getNodeType(): string
+	{
+		return NullsafeFirstClassCallableNode::class;
+	}
+
+	public function processNode(Node $node, Scope $scope): array
+	{
+		return [
+			RuleErrorBuilder::message('Cannot combine nullsafe operator with Closure creation.')
+				->nonIgnorable()
+				->identifier('nullsafe.firstClassCallable')
+				->build(),
+		];
+	}
+
+}

tests/PHPStan/Analyser/AnalyserIntegrationTest.php

@@ -1599,6 +1599,17 @@ public function testBug14707(): void
 		$this->assertNoErrors($errors);
 	}
 
+	public function testBug9746(): void
+	{
+		// first-class callable NullsafeMethodCall used to crash with an internal error
+		$errors = $this->runAnalyse(__DIR__ . '/data/bug-9746.php');
+		$this->assertCount(2, $errors);
+		$this->assertSame('Call to method Bug9746\HelloWorld::sayHello() on a separate line has no effect.', $errors[0]->getMessage());
+		$this->assertSame(11, $errors[0]->getLine());
+		$this->assertSame('Cannot combine nullsafe operator with Closure creation.', $errors[1]->getMessage());
+		$this->assertSame(11, $errors[1]->getLine());
+	}
+
 	/**
 	 * @param string[]|null $allAnalysedFiles
 	 * @return list<Error>

tests/PHPStan/Analyser/data/bug-9746.php

@@ -0,0 +1,13 @@
+<?php // lint >= 8.1
+
+declare(strict_types = 1);
+
+namespace Bug9746;
+
+class HelloWorld
+{
+	public function sayHello(?self $self): void
+	{
+		$self?->sayHello(...);
+	}
+}

tests/PHPStan/Rules/Methods/NullsafeFirstClassCallableRuleTest.php

@@ -0,0 +1,31 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Methods;
+
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+use PHPUnit\Framework\Attributes\RequiresPhp;
+
+/**
+ * @extends RuleTestCase<NullsafeFirstClassCallableRule>
+ */
+class NullsafeFirstClassCallableRuleTest extends RuleTestCase
+{
+
+	protected function getRule(): Rule
+	{
+		return new NullsafeFirstClassCallableRule();
+	}
+
+	#[RequiresPhp('>= 8.1.0')]
+	public function testRule(): void
+	{
+		$this->analyse([__DIR__ . '/data/nullsafe-first-class-callable.php'], [
+			[
+				'Cannot combine nullsafe operator with Closure creation.',
+				20,
+			],
+		]);
+	}
+
+}

tests/PHPStan/Rules/Methods/data/nullsafe-first-class-callable.php

@@ -0,0 +1,21 @@
+<?php // lint >= 8.1
+
+declare(strict_types = 1);
+
+namespace MethodCallableNullsafe;
+
+class Foo
+{
+
+	public function doFoo(): int
+	{
+		return 1;
+	}
+
+}
+
+function test(?Foo $foo): void
+{
+	// fatal error in PHP: "Cannot combine nullsafe operator with Closure creation"
+	$foo?->doFoo(...);
+}