more unresolvable coverage (#169)

Co-authored-by: Markus Staab <[email protected]>

Author: staabm

.phpstan-dba.cache

@@ -5,45 +5,22 @@
 namespace staabm\PHPStanDba\PdoReflection;
 
 use PDOStatement;
-use PhpParser\Node;
 use PhpParser\Node\Expr;
-use PhpParser\Node\Expr\Assign;
 use PhpParser\Node\Expr\MethodCall;
-use PhpParser\Node\FunctionLike;
-use PhpParser\NodeFinder;
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\ShouldNotHappenException;
+use staabm\PHPStanDba\QueryReflection\ExpressionFinder;
 
 final class PdoStatementReflection
 {
-    /**
-     * Do not change, part of internal PHPStan naming.
-     *
-     * @var string
-     */
-    private const PREVIOUS = 'previous';
-
-    /**
-     * Convention key name in php-parser and PHPStan for parent node.
-     *
-     * @var string
-     */
-    private const PARENT = 'parent';
-
-    private NodeFinder $nodeFinder;
-
-    public function __construct()
-    {
-        $this->nodeFinder = new NodeFinder();
-    }
-
     public function findPrepareQueryStringExpression(MethodReflection $methodReflection, MethodCall $methodCall): ?Expr
     {
         if ('execute' !== $methodReflection->getName() || PdoStatement::class !== $methodReflection->getDeclaringClass()->getName()) {
             throw new ShouldNotHappenException();
         }
 
-        $queryExpr = $this->findQueryStringExpression($methodCall);
+        $exprFinder = new ExpressionFinder();
+        $queryExpr = $exprFinder->findQueryStringExpression($methodCall);
 
         // resolve query parameter from "prepare"
         if ($queryExpr instanceof MethodCall) {
@@ -54,74 +31,4 @@ public function findPrepareQueryStringExpression(MethodReflection $methodReflect
 
         return null;
     }
-
-    private function findQueryStringExpression(MethodCall $methodCall): ?Expr
-    {
-        // todo: use astral simpleNameResolver
-        $nameResolver = function ($node) {
-            if (\is_string($node->name)) {
-                return $node->name;
-            }
-            if ($node->name instanceof Node\Identifier) {
-                return $node->name->toString();
-            }
-        };
-
-        $current = $methodCall;
-        while (null !== $current) {
-            /** @var Assign|null $assign */
-            $assign = $this->findFirstPreviousOfNode($current, function ($node) {
-                return $node instanceof Assign;
-            });
-
-            if (null !== $assign && $nameResolver($assign->var) === $nameResolver($methodCall->var)) {
-                return $assign->expr;
-            }
-
-            $current = $assign;
-        }
-
-        return null;
-    }
-
-    /**
-     * @param callable(Node $node):bool $filter
-     */
-    private function findFirstPreviousOfNode(Node $node, callable $filter): ?Node
-    {
-        // move to previous expression
-        $previousStatement = $node->getAttribute(self::PREVIOUS);
-        if (null !== $previousStatement) {
-            if (!$previousStatement instanceof Node) {
-                throw new ShouldNotHappenException();
-            }
-            $foundNode = $this->findFirst([$previousStatement], $filter);
-            // we found what we need
-            if (null !== $foundNode) {
-                return $foundNode;
-            }
-
-            return $this->findFirstPreviousOfNode($previousStatement, $filter);
-        }
-
-        $parent = $node->getAttribute(self::PARENT);
-        if ($parent instanceof FunctionLike) {
-            return null;
-        }
-
-        if ($parent instanceof Node) {
-            return $this->findFirstPreviousOfNode($parent, $filter);
-        }
-
-        return null;
-    }
-
-    /**
-     * @param Node|Node[] $nodes
-     * @param callable(Node $node):bool $filter
-     */
-    private function findFirst(Node|array $nodes, callable $filter): ?Node
-    {
-        return $this->nodeFinder->findFirst($nodes, $filter);
-    }
 }