ClassMethodHandler.php

<?php declare(strict_types = 1);

namespace PHPStan\Analyser\StmtHandler;

use PhpParser\Node;
use PhpParser\Node\Expr;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Stmt;
use PhpParser\Node\Stmt\ClassMethod;
use PhpParser\Node\Stmt\Return_;
use PHPStan\Analyser\AttributesHandler;
use PHPStan\Analyser\DeprecatedAttributeResolver;
use PHPStan\Analyser\ExpressionResultStorage;
use PHPStan\Analyser\ImpurePoint;
use PHPStan\Analyser\InternalStatementResult;
use PHPStan\Analyser\MutatingScope;
use PHPStan\Analyser\NodeScopeResolver;
use PHPStan\Analyser\ParametersProcessor;
use PHPStan\Analyser\PhpDocsResolver;
use PHPStan\Analyser\PropertyHooksProcessor;
use PHPStan\Analyser\Scope;
use PHPStan\Analyser\StatementContext;
use PHPStan\Analyser\StmtHandler;
use PHPStan\Analyser\VariableLivenessResolver;
use PHPStan\Dependency\Dependencies;
use PHPStan\Dependency\DependencyTypes;
use PHPStan\DependencyInjection\AutowiredService;
use PHPStan\Node\ClassPropertyNode;
use PHPStan\Node\ExecutionEndNode;
use PHPStan\Node\Expr\PropertyInitializationExpr;
use PHPStan\Node\InClassMethodNode;
use PHPStan\Node\MethodReturnStatementsNode;
use PHPStan\Node\PropertyAssignNode;
use PHPStan\Node\ReturnAfterFinallyNode;
use PHPStan\Node\ReturnStatement;
use PHPStan\Reflection\Php\PhpMethodFromParserNodeReflection;
use PHPStan\ShouldNotHappenException;
use PHPStan\Turbo\ShadowedByTurboExtension;
use PHPStan\Type\MixedType;
use PHPStan\Type\ParserNodeTypeToPHPStanType;
use PHPStan\Type\TypeUtils;
use function array_merge;
use function is_string;

/**
 * @implements StmtHandler<ClassMethod>
 */
#[AutowiredService]
#[ShadowedByTurboExtension(implementation: __DIR__ . '/../../../turbo-ext/src/ClassMethodHandler.cpp')]
final class ClassMethodHandler implements StmtHandler
{

	public function __construct(
		private DeprecatedAttributeResolver $deprecatedAttributeResolver,
		private PhpDocsResolver $phpDocsResolver,
		private PropertyHooksProcessor $propertyHooksProcessor,
		private AttributesHandler $attributesHandler,
		private ParametersProcessor $parametersProcessor,
	)
	{
	}

	public function supports(Stmt $stmt): bool
	{
		return $stmt instanceof ClassMethod;
	}

	public function processStmt(
		NodeScopeResolver $nodeScopeResolver,
		Stmt $stmt,
		MutatingScope $scope,
		ExpressionResultStorage $storage,
		callable $nodeCallback,
		StatementContext $context,
	): InternalStatementResult
	{
		$dependencies = [];
		$dependencies[] = $this->attributesHandler->processAttributeGroups($nodeScopeResolver, $stmt, $stmt->attrGroups, $scope, $storage, $nodeCallback);
		[$templateTypeMap, $phpDocParameterTypes, $phpDocImmediatelyInvokedCallableParameters, $phpDocClosureThisTypeParameters, $phpDocReturnType, $phpDocThrowType, $deprecatedDescription, $isDeprecated, $isInternal, $isFinal, $isPure, $acceptsNamedArguments, $isReadOnly, $phpDocComment, $asserts, $selfOutType, $phpDocParameterOutTypes, , , , $pureUnlessCallableIsImpureParameters, $pureUnlessParameterPassedParameters] = $this->phpDocsResolver->getPhpDocs($scope, $stmt);

		$dependencies[] = $this->parametersProcessor->processParams($nodeScopeResolver, $stmt, $stmt->params, $scope, $storage, $nodeCallback);

		if ($stmt->returnType !== null) {
			$nodeScopeResolver->callNodeCallback($nodeCallback, $stmt->returnType, $scope, $storage);
		}

		if (!$isDeprecated) {
			[$isDeprecated, $deprecatedDescription] = $this->deprecatedAttributeResolver->getDeprecatedAttribute($scope, $stmt);
		}

		$isFromTrait = $stmt->getAttribute('originalTraitMethodName') === '__construct';
		$isConstructor = $isFromTrait || $stmt->name->toLowerString() === '__construct';

		$methodScope = $scope->enterClassMethod(
			$stmt,
			$templateTypeMap,
			$phpDocParameterTypes,
			$phpDocReturnType,
			$phpDocThrowType,
			$deprecatedDescription,
			$isDeprecated,
			$isInternal,
			$isFinal,
			$isPure,
			$acceptsNamedArguments,
			$asserts,
			$selfOutType,
			$phpDocComment,
			$phpDocParameterOutTypes,
			$phpDocImmediatelyInvokedCallableParameters,
			$phpDocClosureThisTypeParameters,
			$isConstructor,
			null,
			$pureUnlessCallableIsImpureParameters,
			$pureUnlessParameterPassedParameters,
		);

		if (!$scope->isInClass()) {
			throw new ShouldNotHappenException();
		}

		$classReflection = $scope->getClassReflection();

		if ($isConstructor) {
			foreach ($stmt->params as $param) {
				if ($param->flags === 0 && $param->hooks === []) {
					continue;
				}

				if (!$param->var instanceof Variable || !is_string($param->var->name) || $param->var->name === '') {
					throw new ShouldNotHappenException();
				}
				$phpDoc = null;
				if ($param->getDocComment() !== null) {
					$phpDoc = $param->getDocComment()->getText();
				}
				$promotedNativeType = $param->type !== null ? ParserNodeTypeToPHPStanType::resolve($param->type, $classReflection) : null;
				$dependencies[] = Dependencies::create($methodScope->getFile(), [$promotedNativeType, $phpDocParameterTypes[$param->var->name] ?? null]);
				$nodeScopeResolver->callNodeCallback($nodeCallback, new ClassPropertyNode(
					$param->var->name,
					$param->flags,
					$promotedNativeType,
					null,
					$phpDoc,
					$phpDocParameterTypes[$param->var->name] ?? null,
					true,
					$isFromTrait,
					$param,
					$isReadOnly,
					$scope->isInTrait(),
					$classReflection->isReadOnly(),
					false,
					$classReflection,
				), $methodScope, $storage);
				$dependencies[] = $this->propertyHooksProcessor->processPropertyHooks(
					$nodeScopeResolver,
					$stmt,
					$param->type,
					$phpDocParameterTypes[$param->var->name] ?? null,
					$param->var->name,
					$param->hooks,
					$scope,
					$storage,
					$nodeCallback,
				);
				$methodScope = $methodScope->assignExpression(new PropertyInitializationExpr($param->var->name), new MixedType(), new MixedType());
			}
		}

		if ($stmt->getAttribute('virtual', false) === false) {
			$methodReflection = $methodScope->getFunction();
			if (!$methodReflection instanceof PhpMethodFromParserNodeReflection) {
				throw new ShouldNotHappenException();
			}
			$dependencies[] = Dependencies::create($methodScope->getFile(), [...DependencyTypes::ofDeclaration($methodReflection, true), $methodReflection->getSelfOutType()]);
			$nodeScopeResolver->callNodeCallback($nodeCallback, new InClassMethodNode($classReflection, $methodReflection, $stmt), $methodScope, $storage);
		}

		if ($stmt->stmts !== null) {
			$gatheredReturnStatements = [];
			$gatheredReturnStatementsAfterFinally = [];
			$gatheredYieldStatements = [];
			$executionEnds = [];
			$methodImpurePoints = [];
			// the body's results live in a per-body storage released right
			// after the MethodReturnStatementsNode rules ran: later asks about
			// body expressions (e.g. class-level rules pricing gathered nodes)
			// go through the on-demand bridge, so keeping the results for the
			// rest of the file would only pin the body's whole result graph
			// (callbacks, scopes, types) at no benefit
			$bodyStorage = $storage->duplicate();
			$scope->pushExpressionResultStorage($bodyStorage);
			try {
				$nodeScopeResolver->pushNodeGatherer(static function (Node $node, Scope $scope) use ($nodeScopeResolver, $methodScope, &$gatheredReturnStatements, &$gatheredReturnStatementsAfterFinally, &$gatheredYieldStatements, &$executionEnds, &$methodImpurePoints): void {
					if ($scope->getFunction() !== $methodScope->getFunction()) {
						return;
					}
					if ($scope->isInAnonymousFunction()) {
						return;
					}
					if ($node instanceof PropertyAssignNode) {
						if (
							$node->getPropertyFetch() instanceof Expr\PropertyFetch
							&& $scope->getFunction() instanceof PhpMethodFromParserNodeReflection
							&& $scope->getFunction()->getDeclaringClass()->hasConstructor()
							&& $scope->getFunction()->getDeclaringClass()->getConstructor()->getName() === $scope->getFunction()->getName()
							&& TypeUtils::findThisType($nodeScopeResolver->readScopeStateOrSyntheticType($node->getPropertyFetch()->var, $scope->toWalkScope())) !== null
						) {
							return;
						}
						$methodImpurePoints[] = new ImpurePoint(
							$scope,
							$node,
							'propertyAssign',
							'property assignment',
							true,
						);
						return;
					}
					if ($node instanceof ExecutionEndNode) {
						$executionEnds[] = $node;
						return;
					}
					if ($node instanceof ReturnAfterFinallyNode) {
						$gatheredReturnStatementsAfterFinally[] = new ReturnStatement($scope, $node->getReturnNode());
						return;
					}
					if ($node instanceof Expr\Yield_ || $node instanceof Expr\YieldFrom) {
						$gatheredYieldStatements[] = $node;
					}
					if (!$node instanceof Return_) {
						return;
					}

					$gatheredReturnStatements[] = new ReturnStatement($scope, $node);
				});
				try {
					$internalStatementResult = $nodeScopeResolver->processStmtNodesInternal($stmt, $stmt->stmts, $methodScope, $bodyStorage, $nodeCallback, StatementContext::createTopLevel($context->shouldResolveTemplateArguments()));
					$dependencies[] = $internalStatementResult->getDependencies();
					$statementResult = $internalStatementResult->toPublic();
				} finally {
					$nodeScopeResolver->popNodeGatherer();
				}

				$methodReflection = $methodScope->getFunction();
				if (!$methodReflection instanceof PhpMethodFromParserNodeReflection) {
					throw new ShouldNotHappenException();
				}

				$nodeScopeResolver->callNodeCallback($nodeCallback, new MethodReturnStatementsNode(
					$stmt,
					$gatheredReturnStatements,
					$gatheredReturnStatementsAfterFinally,
					$gatheredYieldStatements,
					$statementResult,
					$executionEnds,
					array_merge($statementResult->getImpurePoints(), $methodImpurePoints),
					$classReflection,
					$methodReflection,
				), $methodScope, $bodyStorage);
				$nodeScopeResolver->callNodeCallback($nodeCallback, VariableLivenessResolver::resolve($stmt, $internalStatementResult->getVariableFlow()), $methodScope, $bodyStorage);
			} finally {
				$scope->popExpressionResultStorage();
			}

			if ($isConstructor) {
				$finalScope = null;

				foreach ($executionEnds as $executionEnd) {
					if ($executionEnd->getStatementResult()->isAlwaysTerminating()) {
						continue;
					}

					$endScope = $executionEnd->getStatementResult()->getScope();
					if ($finalScope === null) {
						$finalScope = $endScope;
						continue;
					}

					$finalScope = $finalScope->mergeWith($endScope);
				}

				foreach ($gatheredReturnStatements as $statement) {
					if ($finalScope === null) {
						$finalScope = $statement->getScope()->toWalkScope();
						continue;
					}

					$finalScope = $finalScope->mergeWith($statement->getScope()->toWalkScope());
				}

				if ($finalScope !== null) {
					$scope = $finalScope->rememberConstructorScope();
				}

			}
		}

		return new InternalStatementResult($scope, hasYield: false, isAlwaysTerminating: false, exitPoints: [], throwPoints: [], impurePoints: [], dependencies: Dependencies::merge(...$dependencies));
	}

}