Bleeding edge - use lighter NodeConnectingVisitor

conf/bleedingEdge.neon

@@ -5,5 +5,6 @@ parameters:
 		explicitMixedInUnknownGenericNew: true
 		arrayFilter: true
 		arrayUnpacking: true
+		nodeConnectingVisitorCompatibility: false
 	stubFiles:
 		- ../stubs/bleedingEdge/Countable.stub

conf/config.neon

@@ -30,6 +30,7 @@ parameters:
 		explicitMixedInUnknownGenericNew: false
 		arrayFilter: false
 		arrayUnpacking: false
+		nodeConnectingVisitorCompatibility: true
 	fileExtensions:
 		- php
 	checkAdvancedIsset: false
@@ -215,6 +216,7 @@ parametersSchema:
 		explicitMixedInUnknownGenericNew: bool(),
 		arrayFilter: bool(),
 		arrayUnpacking: bool(),
+		nodeConnectingVisitorCompatibility: bool(),
 	])
 	fileExtensions: listOf(string())
 	checkAdvancedIsset: bool()
@@ -344,6 +346,8 @@ conditionalTags:
 		phpstan.rules.rule: %exceptions.check.tooWideThrowType%
 	PHPStan\Rules\Exceptions\TooWideMethodThrowTypeRule:
 		phpstan.rules.rule: %exceptions.check.tooWideThrowType%
+	PhpParser\NodeVisitor\NodeConnectingVisitor:
+		phpstan.parser.richParserNodeVisitor: %featureToggles.nodeConnectingVisitorCompatibility%
 
 services:
 	-
@@ -358,6 +362,31 @@ services:
 			options:
 				preserveOriginalNames: true
 
+	-
+		class: PHPStan\Parser\ArrayFilterArgVisitor
+		tags:
+			- phpstan.parser.richParserNodeVisitor
+
+	-
+		class: PHPStan\Parser\ArrayMapArgVisitor
+		tags:
+			- phpstan.parser.richParserNodeVisitor
+
+	-
+		class: PHPStan\Parser\NewAssignedToPropertyVisitor
+		tags:
+			- phpstan.parser.richParserNodeVisitor
+
+	-
+		class: PHPStan\Parser\ParentStmtTypesVisitor
+		tags:
+			- phpstan.parser.richParserNodeVisitor
+
+	-
+		class: PHPStan\Parser\TryCatchTypeVisitor
+		tags:
+			- phpstan.parser.richParserNodeVisitor
+
 	-
 		class: PhpParser\NodeVisitor\NodeConnectingVisitor
 

src/Analyser/MutatingScope.php

@@ -1642,32 +1642,11 @@ private function resolveType(Expr $node): Type
 			}
 
 			$callableParameters = null;
-			$arg = $node->getAttribute('parent');
-			if ($arg instanceof Arg) {
-				$funcCall = $arg->getAttribute('parent');
-				$argOrder = $arg->getAttribute('expressionOrder');
-				if ($funcCall instanceof FuncCall && $funcCall->name instanceof Name) {
-					$functionName = $this->reflectionProvider->resolveFunctionName($funcCall->name, $this);
-					if (
-						$functionName === 'array_map'
-						&& $argOrder === 0
-						&& isset($funcCall->getArgs()[1])
-					) {
-						if (!isset($funcCall->getArgs()[2])) {
-							$callableParameters = [
-								new DummyParameter('item', $this->getType($funcCall->getArgs()[1]->value)->getIterableValueType(), false, PassedByReference::createNo(), false, null),
-							];
-						} else {
-							$callableParameters = [];
-							foreach ($funcCall->getArgs() as $i => $funcCallArg) {
-								if ($i === 0) {
-									continue;
-								}
-
-								$callableParameters[] = new DummyParameter('item', $this->getType($funcCallArg->value)->getIterableValueType(), false, PassedByReference::createNo(), false, null);
-							}
-						}
-					}
+			$arrayMapArgs = $node->getAttribute('arrayMapArgs');
+			if ($arrayMapArgs !== null) {
+				$callableParameters = [];
+				foreach ($arrayMapArgs as $funcCallArg) {
+					$callableParameters[] = new DummyParameter('item', $this->getType($funcCallArg->value)->getIterableValueType(), false, PassedByReference::createNo(), false, null);
 				}
 			}
 
@@ -5745,14 +5724,8 @@ private function exactInstantiation(New_ $node, string $className): ?Type
 			return $objectType;
 		}
 
-		$parentNode = $node->getAttribute('parent');
-		if (
-			(
-				$parentNode instanceof Expr\Assign
-				|| $parentNode instanceof Expr\AssignRef
-			)
-			&& $parentNode->var instanceof PropertyFetch
-		) {
+		$assignedToProperty = $node->getAttribute('assignedToProperty');
+		if ($assignedToProperty !== null) {
 			$constructorVariant = ParametersAcceptorSelector::selectSingle($constructorMethod->getVariants());
 			$classTemplateTypes = $classReflection->getTemplateTypeMap()->getTypes();
 			$originalClassTemplateTypes = $classTemplateTypes;
@@ -5771,7 +5744,7 @@ private function exactInstantiation(New_ $node, string $className): ?Type
 			}
 
 			if (count($classTemplateTypes) === count($originalClassTemplateTypes)) {
-				$propertyType = $this->getType($parentNode->var);
+				$propertyType = $this->getType($assignedToProperty);
 				if ($objectType->isSuperTypeOf($propertyType)->yes()) {
 					return $propertyType;
 				}

src/DependencyInjection/ConditionalTagsExtension.php

@@ -7,6 +7,7 @@
 use Nette\Schema\Expect;
 use PHPStan\Analyser\TypeSpecifierFactory;
 use PHPStan\Broker\BrokerFactory;
+use PHPStan\Parser\RichParser;
 use PHPStan\PhpDoc\TypeNodeResolverExtension;
 use PHPStan\Rules\RegistryFactory;
 use PHPStan\ShouldNotHappenException;
@@ -31,6 +32,7 @@ public function getConfigSchema(): Nette\Schema\Schema
 			TypeSpecifierFactory::FUNCTION_TYPE_SPECIFYING_EXTENSION_TAG => $bool,
 			TypeSpecifierFactory::METHOD_TYPE_SPECIFYING_EXTENSION_TAG => $bool,
 			TypeSpecifierFactory::STATIC_METHOD_TYPE_SPECIFYING_EXTENSION_TAG => $bool,
+			RichParser::VISITOR_SERVICE_TAG => $bool,
 		])->min(1));
 	}
 

src/Parser/ArrayFilterArgVisitor.php

@@ -0,0 +1,25 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Parser;
+
+use PhpParser\Node;
+use PhpParser\NodeVisitorAbstract;
+
+class ArrayFilterArgVisitor extends NodeVisitorAbstract
+{
+
+	public function enterNode(Node $node): ?Node
+	{
+		if ($node instanceof Node\Expr\FuncCall && $node->name instanceof Node\Name) {
+			$functionName = $node->name->toLowerString();
+			if ($functionName === 'array_filter') {
+				$args = $node->getArgs();
+				if (isset($args[0])) {
+					$args[0]->setAttribute('isArrayFilterArg', $args);
+				}
+			}
+		}
+		return null;
+	}
+
+}

src/Parser/ArrayMapArgVisitor.php

@@ -0,0 +1,30 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Parser;
+
+use PhpParser\Node;
+use PhpParser\NodeVisitorAbstract;
+use function array_slice;
+use function count;
+
+class ArrayMapArgVisitor extends NodeVisitorAbstract
+{
+
+	public function enterNode(Node $node): ?Node
+	{
+		if ($node instanceof Node\Expr\FuncCall && $node->name instanceof Node\Name) {
+			$functionName = $node->name->toLowerString();
+			if ($functionName === 'array_map') {
+				$args = $node->getArgs();
+				if (isset($args[0])) {
+					$slicedArgs = array_slice($args, 1);
+					if (count($slicedArgs) > 0) {
+						$args[0]->value->setAttribute('arrayMapArgs', $slicedArgs);
+					}
+				}
+			}
+		}
+		return null;
+	}
+
+}

src/Parser/NewAssignedToPropertyVisitor.php

@@ -0,0 +1,21 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Parser;
+
+use PhpParser\Node;
+use PhpParser\NodeVisitorAbstract;
+
+class NewAssignedToPropertyVisitor extends NodeVisitorAbstract
+{
+
+	public function enterNode(Node $node): ?Node
+	{
+		if ($node instanceof Node\Expr\Assign || $node instanceof Node\Expr\AssignRef) {
+			if ($node->var instanceof Node\Expr\PropertyFetch && $node->expr instanceof Node\Expr\New_) {
+				$node->expr->setAttribute('assignedToProperty', $node->var);
+			}
+		}
+		return null;
+	}
+
+}

src/Parser/ParentStmtTypesVisitor.php

@@ -0,0 +1,48 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Parser;
+
+use PhpParser\Node;
+use PhpParser\NodeVisitorAbstract;
+use function array_pop;
+use function count;
+use function get_class;
+
+final class ParentStmtTypesVisitor extends NodeVisitorAbstract
+{
+
+	/** @var array<int, class-string<Node\Stmt|Node\Expr\Closure>> */
+	private array $typeStack = [];
+
+	public function beforeTraverse(array $nodes): ?array
+	{
+		$this->typeStack = [];
+		return null;
+	}
+
+	public function enterNode(Node $node): ?Node
+	{
+		if (!$node instanceof Node\Stmt && !$node instanceof Node\Expr\Closure) {
+			return null;
+		}
+
+		if (count($this->typeStack) > 0) {
+			$node->setAttribute('parentStmtTypes', $this->typeStack);
+		}
+		$this->typeStack[] = get_class($node);
+
+		return null;
+	}
+
+	public function leaveNode(Node $node): ?Node
+	{
+		if (!$node instanceof Node\Stmt && !$node instanceof Node\Expr\Closure) {
+			return null;
+		}
+
+		array_pop($this->typeStack);
+
+		return null;
+	}
+
+}

src/Parser/RichParser.php

@@ -7,9 +7,8 @@
 use PhpParser\Node;
 use PhpParser\NodeTraverser;
 use PhpParser\NodeVisitor\NameResolver;
-use PhpParser\NodeVisitor\NodeConnectingVisitor;
+use PHPStan\DependencyInjection\Container;
 use PHPStan\File\FileReader;
-use PHPStan\NodeVisitor\StatementOrderVisitor;
 use PHPStan\ShouldNotHappenException;
 use function is_string;
 use function strpos;
@@ -20,12 +19,13 @@
 class RichParser implements Parser
 {
 
+	public const VISITOR_SERVICE_TAG = 'phpstan.parser.richParserNodeVisitor';
+
 	public function __construct(
 		private \PhpParser\Parser $parser,
 		private Lexer $lexer,
 		private NameResolver $nameResolver,
-		private NodeConnectingVisitor $nodeConnectingVisitor,
-		private StatementOrderVisitor $statementOrderVisitor,
+		private Container $container,
 	)
 	{
 	}
@@ -60,8 +60,10 @@ public function parseString(string $sourceCode): array
 
 		$nodeTraverser = new NodeTraverser();
 		$nodeTraverser->addVisitor($this->nameResolver);
-		$nodeTraverser->addVisitor($this->nodeConnectingVisitor);
-		$nodeTraverser->addVisitor($this->statementOrderVisitor);
+
+		foreach ($this->container->getServicesByTag(self::VISITOR_SERVICE_TAG) as $visitor) {
+			$nodeTraverser->addVisitor($visitor);
+		}
 
 		/** @var array<Node\Stmt> */
 		$nodes = $nodeTraverser->traverse($nodes);

src/Parser/TryCatchTypeVisitor.php

@@ -0,0 +1,73 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Parser;
+
+use PhpParser\Node;
+use PhpParser\NodeVisitorAbstract;
+use function array_pop;
+use function array_reverse;
+use function count;
+
+final class TryCatchTypeVisitor extends NodeVisitorAbstract
+{
+
+	/** @var array<int, array<int, string>|null> */
+	private array $typeStack = [];
+
+	public function beforeTraverse(array $nodes): ?array
+	{
+		$this->typeStack = [];
+		return null;
+	}
+
+	public function enterNode(Node $node): ?Node
+	{
+		if ($node instanceof Node\Stmt || $node instanceof Node\Expr\Match_) {
+			if (count($this->typeStack) > 0) {
+				$node->setAttribute('tryCatchTypes', $this->typeStack[count($this->typeStack) - 1]);
+			}
+		}
+
+		if ($node instanceof Node\FunctionLike) {
+			$this->typeStack[] = null;
+		}
+
+		if ($node instanceof Node\Stmt\TryCatch) {
+			$types = [];
+			foreach (array_reverse($this->typeStack) as $stackTypes) {
+				if ($stackTypes === null) {
+					break;
+				}
+
+				foreach ($stackTypes as $type) {
+					$types[] = $type;
+				}
+			}
+			foreach ($node->catches as $catch) {
+				foreach ($catch->types as $type) {
+					$types[] = $type->toString();
+				}
+			}
+
+			$this->typeStack[] = $types;
+		}
+
+		return null;
+	}
+
+	public function leaveNode(Node $node): ?Node
+	{
+		if (
+			!$node instanceof Node\Stmt\TryCatch
+			&& !$node instanceof Node\FunctionLike
+			&& !$node instanceof Node\Expr\Match_
+		) {
+			return null;
+		}
+
+		array_pop($this->typeStack);
+
+		return null;
+	}
+
+}