GNSR continued

Author: ondrejmirtes

build/PHPStan/Build/IgnoreGeneratorNodeScopeResolverUsageProvider.php

@@ -147,7 +147,3 @@ services:
 		class: PHPStan\Build\ContainerDynamicReturnTypeExtension
 		tags:
 			- phpstan.broker.dynamicMethodReturnTypeExtension
-	-
-		class: PHPStan\Build\IgnoreGeneratorNodeScopeResolverUsageProvider
-		tags:
-			- shipmonk.deadCode.memberUsageProvider

build/phpstan.neon

@@ -3,6 +3,7 @@
 namespace PHPStan\Analyser;
 
 use Closure;
+use PHPStan\Analyser\Generator\GeneratorNodeScopeResolver;
 use PHPStan\Collectors\CollectedData;
 use PHPStan\Collectors\Registry as CollectorRegistry;
 use PHPStan\DependencyInjection\AutowiredParameter;
@@ -25,7 +26,8 @@ public function __construct(
 		private FileAnalyser $fileAnalyser,
 		private RuleRegistry $ruleRegistry,
 		private CollectorRegistry $collectorRegistry,
-		private NodeScopeResolver $nodeScopeResolver,
+		#[AutowiredParameter(ref: '@' . NodeScopeResolver::class)]
+		private GeneratorNodeScopeResolver|NodeScopeResolver $nodeScopeResolver,
 		#[AutowiredParameter]
 		private int $internalErrorsCountLimit,
 	)

src/Analyser/Analyser.php

@@ -4,6 +4,7 @@
 
 use PhpParser\Node;
 use PHPStan\AnalysedCodeException;
+use PHPStan\Analyser\Generator\GeneratorNodeScopeResolver;
 use PHPStan\BetterReflection\NodeCompiler\Exception\UnableToCompileNode;
 use PHPStan\BetterReflection\Reflection\Exception\CircularReference;
 use PHPStan\BetterReflection\Reflector\Exception\IdentifierNotFound;
@@ -55,7 +56,8 @@ final class FileAnalyser
 
 	public function __construct(
 		private ScopeFactory $scopeFactory,
-		private NodeScopeResolver $nodeScopeResolver,
+		#[AutowiredParameter(ref: '@' . NodeScopeResolver::class)]
+		private GeneratorNodeScopeResolver|NodeScopeResolver $nodeScopeResolver,
 		#[AutowiredParameter(ref: '@defaultAnalysisParser')]
 		private Parser $parser,
 		private DependencyResolver $dependencyResolver,

src/Analyser/FileAnalyser.php

@@ -87,7 +87,25 @@ public function processNodes(
 	): void
 	{
 		$storage = new NodeScopeResolverRunStorage();
+		$this->processStmtNodes(
+			$storage,
+			$stmts,
+			$scope,
+			$nodeCallback,
+		);
+	}
 
+	/**
+	 * @param array<Node\Stmt> $stmts
+	 * @param callable(Node, Scope): void $nodeCallback
+	 */
+	private function processStmtNodes(
+		NodeScopeResolverRunStorage $storage,
+		array $stmts,
+		GeneratorScope $scope,
+		callable $nodeCallback,
+	): StmtAnalysisResult
+	{
 		$stack = [];
 
 		$gen = $this->analyzeStmts($stmts, $scope);
@@ -126,10 +144,29 @@ public function processNodes(
 			}
 
 			$result = $gen->getReturn();
-
 			if (count($stack) === 0) {
+				foreach ($storage->pendingFibers as $pending) {
+					$request = $pending['request'];
+					$exprAnalysisResult = $this->lookupExprAnalysisResult($storage, $request->expr);
+
+					if ($exprAnalysisResult !== null) {
+						throw new ShouldNotHappenException('Pending fibers with an empty stack should be about synthetic nodes');
+					}
+
+					$this->processStmtNodes(
+						$storage,
+						[new Stmt\Expression($request->expr)],
+						$request->scope,
+						static function () {
+						},
+					);
+				}
+
 				if (count($storage->pendingFibers) === 0) {
-					return;
+					if (!$result instanceof StmtAnalysisResult) {
+						throw new ShouldNotHappenException('Top node should be Stmt');
+					}
+					return $result;
 				}
 
 				throw new ShouldNotHappenException(sprintf('Cannot finish analysis, pending fibers about: %s', implode(', ', array_map(static fn (array $fiber) => get_class($fiber['request']->expr), $storage->pendingFibers))));

src/Analyser/Generator/GeneratorNodeScopeResolver.php

@@ -11,6 +11,7 @@
 use PHPStan\Analyser\NodeCallbackInvoker;
 use PHPStan\Analyser\Scope;
 use PHPStan\Php\PhpVersions;
+use PHPStan\Reflection\Assertions;
 use PHPStan\Reflection\ClassConstantReflection;
 use PHPStan\Reflection\ClassReflection;
 use PHPStan\Reflection\ExtendedMethodReflection;
@@ -21,6 +22,7 @@
 use PHPStan\ShouldNotHappenException;
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\ClosureType;
+use PHPStan\Type\Generic\TemplateTypeMap;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeWithClassName;
 
@@ -47,6 +49,55 @@ public function assignVariable(string $variableName, Type $type): self
 		return new self($expressionTypes);
 	}
 
+	public function enterNamespace(string $namespaceName): self
+	{
+		// TODO: Implement enterNamespace() method.
+		throw new ShouldNotHappenException('Not implemented yet');
+	}
+
+	public function enterClass(ClassReflection $classReflection): self
+	{
+		// TODO: Implement enterClass() method.
+		throw new ShouldNotHappenException('Not implemented yet');
+	}
+
+	/**
+	 * @param Type[] $phpDocParameterTypes
+	 * @param Type[] $parameterOutTypes
+	 * @param array<string, bool> $immediatelyInvokedCallableParameters
+	 * @param array<string, Type> $phpDocClosureThisTypeParameters
+	 */
+	public function enterClassMethod(
+		Node\Stmt\ClassMethod $classMethod,
+		TemplateTypeMap $templateTypeMap,
+		array $phpDocParameterTypes,
+		?Type $phpDocReturnType,
+		?Type $throwType,
+		?string $deprecatedDescription,
+		bool $isDeprecated,
+		bool $isInternal,
+		bool $isFinal,
+		?bool $isPure = null,
+		bool $acceptsNamedArguments = true,
+		?Assertions $asserts = null,
+		?Type $selfOutType = null,
+		?string $phpDocComment = null,
+		array $parameterOutTypes = [],
+		array $immediatelyInvokedCallableParameters = [],
+		array $phpDocClosureThisTypeParameters = [],
+		bool $isConstructor = false,
+	): self
+	{
+		// TODO: Implement enterClassMethod() method.
+		throw new ShouldNotHappenException('Not implemented yet');
+	}
+
+	public function generalizeWith(self $otherScope): self
+	{
+		// TODO: Implement generalizeWith() method.
+		throw new ShouldNotHappenException('Not implemented yet');
+	}
+
 	public function isInClass(): bool
 	{
 		// TODO: Implement isInClass() method.
@@ -98,13 +149,13 @@ public function getNamespace(): ?string
 	public function getFile(): string
 	{
 		// TODO: Implement getFile() method.
-		throw new ShouldNotHappenException('Not implemented yet');
+		return 'foo.php';
 	}
 
 	public function getFileDescription(): string
 	{
 		// TODO: Implement getFileDescription() method.
-		throw new ShouldNotHappenException('Not implemented yet');
+		return 'foo.php';
 	}
 
 	public function isDeclareStrictTypes(): bool
@@ -116,7 +167,7 @@ public function isDeclareStrictTypes(): bool
 	public function isInTrait(): bool
 	{
 		// TODO: Implement isInTrait() method.
-		throw new ShouldNotHappenException('Not implemented yet');
+		return false;
 	}
 
 	public function getTraitReflection(): ?ClassReflection
@@ -200,7 +251,7 @@ public function getStaticPropertyReflection(Type $typeWithProperty, string $prop
 	public function getMethodReflection(Type $typeWithMethod, string $methodName): ?ExtendedMethodReflection
 	{
 		// TODO: Implement getMethodReflection() method.
-		throw new ShouldNotHappenException('Not implemented yet');
+		return null;
 	}
 
 	public function getConstantReflection(Type $typeWithConstant, string $constantName): ?ClassConstantReflection

src/Analyser/Generator/GeneratorScope.php

@@ -7019,6 +7019,9 @@ private function processNodesForCalledMethod($node, string $fileName, MethodRefl
 					}
 
 					$scope = $this->scopeFactory->create(ScopeContext::create($fileName))->enterClass($declaringClass);
+					if (!$scope instanceof MutatingScope) {
+						throw new ShouldNotHappenException();
+					}
 					$this->processStmtNode($stmt, $scope, $nodeCallback, StatementContext::createTopLevel());
 				}
 				return;

src/Analyser/NodeScopeResolver.php

@@ -3,6 +3,7 @@
 namespace PHPStan\Analyser;
 
 use PhpParser\Node;
+use PHPStan\Analyser\Generator\GeneratorScope;
 use PHPStan\DependencyInjection\AutowiredService;
 
 /**
@@ -12,15 +13,30 @@
 final class ScopeFactory
 {
 
-	public function __construct(private InternalScopeFactoryFactory $internalScopeFactoryFactory)
+	public function __construct(
+		private InternalScopeFactoryFactory $internalScopeFactoryFactory,
+		private bool $createGeneratorScope = false,
+	)
 	{
 	}
 
+	/**
+	 * @internal
+	 */
+	public function getInternalScopeFactoryFactory(): InternalScopeFactoryFactory
+	{
+		return $this->internalScopeFactoryFactory;
+	}
+
 	/**
 	 * @param callable(Node $node, Scope $scope): void $nodeCallback
 	 */
-	public function create(ScopeContext $context, ?callable $nodeCallback = null): MutatingScope
+	public function create(ScopeContext $context, ?callable $nodeCallback = null): MutatingScope|GeneratorScope
 	{
+		if ($this->createGeneratorScope) {
+			return new GeneratorScope([]);
+		}
+
 		return $this->internalScopeFactoryFactory->create($nodeCallback)->create($context);
 	}
 

src/Analyser/ScopeFactory.php

@@ -8,7 +8,6 @@
 use PHPStan\Analyser\NodeScopeResolver;
 use PHPStan\Analyser\RicherScopeGetTypeHelper;
 use PHPStan\Analyser\ScopeFactory;
-use PHPStan\Analyser\TypeSpecifier;
 use PHPStan\BetterReflection\Reflector\Reflector;
 use PHPStan\DependencyInjection\Container;
 use PHPStan\DependencyInjection\ContainerFactory;
@@ -130,14 +129,16 @@ public static function getClassReflectionExtensionRegistryProvider(): ClassRefle
 	/**
 	 * @param string[] $dynamicConstantNames
 	 */
-	public static function createScopeFactory(ReflectionProvider $reflectionProvider, TypeSpecifier $typeSpecifier, array $dynamicConstantNames = []): ScopeFactory
+	public static function createScopeFactory(array $dynamicConstantNames = []): ScopeFactory
 	{
 		$container = self::getContainer();
 
 		if (count($dynamicConstantNames) === 0) {
 			$dynamicConstantNames = $container->getParameter('dynamicConstantNames');
 		}
 
+		$reflectionProvider = self::createReflectionProvider();
+		$typeSpecifier = self::getContainer()->getService('typeSpecifier');
 		$reflectionProviderProvider = new DirectReflectionProviderProvider($reflectionProvider);
 		$composerPhpVersionFactory = $container->getByType(ComposerPhpVersionFactory::class);
 		$constantResolver = new ConstantResolver($reflectionProviderProvider, $dynamicConstantNames, null, $composerPhpVersionFactory, $container);