resolveType for first class callable handlers

Author: ondrejmirtes

src/Analyser/ExprHandler/FirstClassCallableFuncCallHandler.php

@@ -0,0 +1,75 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser\ExprHandler;
+
+use Closure;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\FuncCall;
+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\DependencyInjection\AutowiredService;
+use PHPStan\Reflection\InitializerExprContext;
+use PHPStan\Reflection\InitializerExprTypeResolver;
+use PHPStan\ShouldNotHappenException;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+
+/**
+ * @implements ExprHandler<FuncCall>
+ */
+#[AutowiredService]
+final class FirstClassCallableFuncCallHandler implements ExprHandler
+{
+
+	public function __construct(
+		private InitializerExprTypeResolver $initializerExprTypeResolver,
+	)
+	{
+	}
+
+	public function supports(Expr $expr): bool
+	{
+		return $expr instanceof FuncCall && $expr->isFirstClassCallable();
+	}
+
+	public function processExpr(
+		NodeScopeResolver $nodeScopeResolver,
+		Stmt $stmt,
+		Expr $expr,
+		MutatingScope $scope,
+		ExpressionResultStorage $storage,
+		callable $nodeCallback,
+		ExpressionContext $context,
+	): ExpressionResult
+	{
+		// handled in NodeScopeResolver before ExprHandlers are called
+		throw new ShouldNotHappenException();
+	}
+
+	/**
+	 * @param FuncCall $expr
+	 */
+	public function resolveType(MutatingScope $scope, Expr $expr): Type
+	{
+		if ($expr->name instanceof Expr) {
+			$callableType = $scope->getType($expr->name);
+			if (!$callableType->isCallable()->yes()) {
+				return new ObjectType(Closure::class);
+			}
+
+			return $this->initializerExprTypeResolver->createFirstClassCallable(
+				null,
+				$callableType->getCallableParametersAcceptors($scope),
+				$scope->nativeTypesPromoted,
+			);
+		}
+
+		return $this->initializerExprTypeResolver->getFirstClassCallableType($expr, InitializerExprContext::fromScope($scope), $scope->nativeTypesPromoted);
+	}
+
+}

src/Analyser/ExprHandler/FirstClassCallableMethodCallHandler.php

@@ -0,0 +1,76 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser\ExprHandler;
+
+use Closure;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Identifier;
+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\DependencyInjection\AutowiredService;
+use PHPStan\Reflection\InitializerExprTypeResolver;
+use PHPStan\ShouldNotHappenException;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+
+/**
+ * @implements ExprHandler<MethodCall>
+ */
+#[AutowiredService]
+final class FirstClassCallableMethodCallHandler implements ExprHandler
+{
+
+	public function __construct(
+		private InitializerExprTypeResolver $initializerExprTypeResolver,
+	)
+	{
+	}
+
+	public function supports(Expr $expr): bool
+	{
+		return $expr instanceof MethodCall && $expr->isFirstClassCallable();
+	}
+
+	public function processExpr(
+		NodeScopeResolver $nodeScopeResolver,
+		Stmt $stmt,
+		Expr $expr,
+		MutatingScope $scope,
+		ExpressionResultStorage $storage,
+		callable $nodeCallback,
+		ExpressionContext $context,
+	): ExpressionResult
+	{
+		// handled in NodeScopeResolver before ExprHandlers are called
+		throw new ShouldNotHappenException();
+	}
+
+	/**
+	 * @param MethodCall $expr
+	 */
+	public function resolveType(MutatingScope $scope, Expr $expr): Type
+	{
+		if (!$expr->name instanceof Identifier) {
+			return new ObjectType(Closure::class);
+		}
+
+		$varType = $scope->getType($expr->var);
+		$method = $scope->getMethodReflection($varType, $expr->name->toString());
+		if ($method === null) {
+			return new ObjectType(Closure::class);
+		}
+
+		return $this->initializerExprTypeResolver->createFirstClassCallable(
+			$method,
+			$method->getVariants(),
+			$scope->nativeTypesPromoted,
+		);
+	}
+
+}

src/Analyser/ExprHandler/FirstClassCallableNewHandler.php

@@ -0,0 +1,61 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser\ExprHandler;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\New_;
+use PhpParser\Node\Stmt;
+use PhpParser\Node\Stmt\Class_;
+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\DependencyInjection\AutowiredService;
+use PHPStan\Reflection\InitializerExprContext;
+use PHPStan\Reflection\InitializerExprTypeResolver;
+use PHPStan\ShouldNotHappenException;
+use PHPStan\Type\Type;
+
+/**
+ * @implements ExprHandler<New_>
+ */
+#[AutowiredService]
+final class FirstClassCallableNewHandler implements ExprHandler
+{
+
+	public function __construct(
+		private InitializerExprTypeResolver $initializerExprTypeResolver,
+	)
+	{
+	}
+
+	public function supports(Expr $expr): bool
+	{
+		return $expr instanceof New_ && !$expr->class instanceof Class_ && $expr->isFirstClassCallable();
+	}
+
+	public function processExpr(
+		NodeScopeResolver $nodeScopeResolver,
+		Stmt $stmt,
+		Expr $expr,
+		MutatingScope $scope,
+		ExpressionResultStorage $storage,
+		callable $nodeCallback,
+		ExpressionContext $context,
+	): ExpressionResult
+	{
+		// handled in NodeScopeResolver before ExprHandlers are called
+		throw new ShouldNotHappenException();
+	}
+
+	/**
+	 * @param New_ $expr
+	 */
+	public function resolveType(MutatingScope $scope, Expr $expr): Type
+	{
+		return $this->initializerExprTypeResolver->getFirstClassCallableType($expr, InitializerExprContext::fromScope($scope), $scope->nativeTypesPromoted);
+	}
+
+}

src/Analyser/ExprHandler/FirstClassCallableStaticCallHandler.php

@@ -0,0 +1,60 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser\ExprHandler;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\StaticCall;
+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\DependencyInjection\AutowiredService;
+use PHPStan\Reflection\InitializerExprContext;
+use PHPStan\Reflection\InitializerExprTypeResolver;
+use PHPStan\ShouldNotHappenException;
+use PHPStan\Type\Type;
+
+/**
+ * @implements ExprHandler<StaticCall>
+ */
+#[AutowiredService]
+final class FirstClassCallableStaticCallHandler implements ExprHandler
+{
+
+	public function __construct(
+		private InitializerExprTypeResolver $initializerExprTypeResolver,
+	)
+	{
+	}
+
+	public function supports(Expr $expr): bool
+	{
+		return $expr instanceof StaticCall && $expr->isFirstClassCallable();
+	}
+
+	public function processExpr(
+		NodeScopeResolver $nodeScopeResolver,
+		Stmt $stmt,
+		Expr $expr,
+		MutatingScope $scope,
+		ExpressionResultStorage $storage,
+		callable $nodeCallback,
+		ExpressionContext $context,
+	): ExpressionResult
+	{
+		// handled in NodeScopeResolver before ExprHandlers are called
+		throw new ShouldNotHappenException();
+	}
+
+	/**
+	 * @param StaticCall $expr
+	 */
+	public function resolveType(MutatingScope $scope, Expr $expr): Type
+	{
+		return $this->initializerExprTypeResolver->getFirstClassCallableType($expr, InitializerExprContext::fromScope($scope), $scope->nativeTypesPromoted);
+	}
+
+}

src/Analyser/MutatingScope.php

@@ -2,7 +2,6 @@
 
 namespace PHPStan\Analyser;
 
-use Closure;
 use PhpParser\Node;
 use PhpParser\Node\Arg;
 use PhpParser\Node\ComplexType;
@@ -1072,9 +1071,7 @@ private function resolveType(string $exprString, Expr $node): Type
 			return $this->nativeTypesPromoted ? $node->getNativeExprType() : $node->getExprType();
 		}
 
-		if ($node instanceof Expr\CallLike && $node->isFirstClassCallable()) {
-			return $this->getFirstClassCallableType($node);
-		} elseif ($node instanceof Unset_) {
+		if ($node instanceof Unset_) {
 			return new NullType();
 		}
 
@@ -4853,39 +4850,4 @@ private function getMethodCallType(MethodCall $node): ?Type
 		return null;
 	}
 
-	private function getFirstClassCallableType(Expr\CallLike $node): Type
-	{
-		if ($node instanceof FuncCall && $node->name instanceof Expr) {
-			$callableType = $this->getType($node->name);
-			if (!$callableType->isCallable()->yes()) {
-				return new ObjectType(Closure::class);
-			}
-
-			return $this->initializerExprTypeResolver->createFirstClassCallable(
-				null,
-				$callableType->getCallableParametersAcceptors($this),
-				$this->nativeTypesPromoted,
-			);
-		}
-		if ($node instanceof MethodCall) {
-			if (!$node->name instanceof Node\Identifier) {
-				return new ObjectType(Closure::class);
-			}
-
-			$varType = $this->getType($node->var);
-			$method = $this->getMethodReflection($varType, $node->name->toString());
-			if ($method === null) {
-				return new ObjectType(Closure::class);
-			}
-
-			return $this->initializerExprTypeResolver->createFirstClassCallable(
-				$method,
-				$method->getVariants(),
-				$this->nativeTypesPromoted,
-			);
-		}
-
-		return $this->initializerExprTypeResolver->getFirstClassCallableType($node, InitializerExprContext::fromScope($this), $this->nativeTypesPromoted);
-	}
-
 }