24275250560

Committed 11 Apr 2026 05:02AM UTC coverage: 82.928% (+0.07%) from 82.857%

Build # 24275250560

Build Type

Pull #79

github

Committed by

web-flow

Commit Message

Merge 287c4b76a into 3fcaa1a81

Pull Request Pull Request #79: Fix PHP 8 type resolution order and safe autoloading for newer syntax

Coverage Stats

63 of 124 new or added lines in 11 files covered. (50.81%)

7 existing lines in 1 file now uncovered.

1569 of 1892 relevant lines covered (82.93%)

33.27 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.11

/src/voku/SimplePhpParser/Parsers/PhpCodeParser.php

<?php

declare(strict_types=1);

namespace voku\SimplePhpParser\Parsers;

use FilesystemIterator;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitor\NameResolver;
use PhpParser\ParserFactory;
use React\Filesystem\Node\FileInterface;
use React\Filesystem\Node\NodeInterface;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use SplFileInfo;
use voku\cache\Cache;
use voku\SimplePhpParser\Model\PHPInterface;
use voku\SimplePhpParser\Parsers\Helper\ParserContainer;
use voku\SimplePhpParser\Parsers\Helper\ParserErrorHandler;
use voku\SimplePhpParser\Parsers\Helper\Utils;
use voku\SimplePhpParser\Parsers\Visitors\ASTVisitor;
use voku\SimplePhpParser\Parsers\Visitors\ParentConnector;
use function React\Async\await;
use function React\Promise\all;

final class PhpCodeParser
{
    /**
     * @internal
     */
    private const CACHE_KEY_HELPER = 'simple-php-code-parser-v6-';

    /**
     * @param string   $code
     * @param string[] $autoloaderProjectPaths
     *
     * @return \voku\SimplePhpParser\Parsers\Helper\ParserContainer
     */
    public static function getFromString(
        string $code,
        array $autoloaderProjectPaths = []
    ): ParserContainer {
        return self::getPhpFiles(
            $code,
            $autoloaderProjectPaths
        );
    }

    /**
     * @param string   $className
     * @param string[] $autoloaderProjectPaths
     *
     * @phpstan-param class-string $className
     *
     * @return \voku\SimplePhpParser\Parsers\Helper\ParserContainer
     */
    public static function getFromClassName(
        string $className,
        array $autoloaderProjectPaths = []
    ): ParserContainer {
        $reflectionClass = Utils::createClassReflectionInstance($className);

        return self::getPhpFiles(
            (string) $reflectionClass->getFileName(),
            $autoloaderProjectPaths
        );
    }

    /**
     * @param string   $pathOrCode
     * @param string[] $autoloaderProjectPaths
     * @param string[] $pathExcludeRegex
     * @param string[] $fileExtensions
     *
     * @return \voku\SimplePhpParser\Parsers\Helper\ParserContainer
     */
    public static function getPhpFiles(
        string $pathOrCode,
        array $autoloaderProjectPaths = [],
        array $pathExcludeRegex = [],
        array $fileExtensions = []
    ): ParserContainer {
        // Push a disposable handler so restore_error_handler() below will only
        // pop this one entry, leaving any pre-existing handlers (e.g. PHPUnit's)
        // intact on the stack.
        \set_error_handler(null);
        try {
            foreach ($autoloaderProjectPaths as $projectPath) {
                if (\file_exists($projectPath) && \is_file($projectPath)) {
                    require_once $projectPath;
                } elseif (\file_exists($projectPath . '/vendor/autoload.php')) {
                    require_once $projectPath . '/vendor/autoload.php';
                } elseif (\file_exists($projectPath . '/../vendor/autoload.php')) {
                    require_once $projectPath . '/../vendor/autoload.php';
                }
            }
        } finally {
            \restore_error_handler();
        }

        $phpCodes = self::getCode(
            $pathOrCode,
            $pathExcludeRegex,
            $fileExtensions
        );

        $parserContainer = new ParserContainer();
        $visitor = new ASTVisitor($parserContainer);

        $processResults = [];
        $phpCodesChunks = \array_chunk($phpCodes, Utils::getCpuCores(), true);

        foreach ($phpCodesChunks as $phpCodesChunk) {
            foreach ($phpCodesChunk as $codeAndFileName) {
                $processResults[] = self::process(
                    $codeAndFileName['content'],
                    $codeAndFileName['fileName'],
                    $parserContainer,
                    $visitor
                );
            }
        }

        foreach ($processResults as $response) {
            if ($response instanceof ParserContainer) {
                $parserContainer->setTraits($response->getTraits());
                $parserContainer->setClasses($response->getClasses());
                $parserContainer->setInterfaces($response->getInterfaces());
                $parserContainer->setEnums($response->getEnums());
                $parserContainer->setConstants($response->getConstants());
                $parserContainer->setFunctions($response->getFunctions());
            } elseif ($response instanceof ParserErrorHandler) {
                $parserContainer->setParseError($response);
            }
        }

        $interfaces = $parserContainer->getInterfaces();
        foreach ($interfaces as &$interface) {
            $interface->parentInterfaces = $visitor->combineParentInterfaces($interface);
        }
        unset($interface);

        $pathTmp = null;
        if (\is_file($pathOrCode)) {
            $pathTmp = \realpath(\pathinfo($pathOrCode, \PATHINFO_DIRNAME));
        } elseif (\is_dir($pathOrCode)) {
            $pathTmp = \realpath($pathOrCode);
        }

        $classesTmp = &$parserContainer->getClassesByReference();
        foreach ($classesTmp as &$classTmp) {
            $classTmp->interfaces = Utils::flattenArray(
                $visitor->combineImplementedInterfaces($classTmp),
                false
            );

            self::mergeInheritdocData(
                $classTmp,
                $classesTmp,
                $interfaces,
                $parserContainer
            );
        }
        unset($classTmp);

        // remove properties / methods / classes from outside of the current file-path-scope
        if ($pathTmp) {
            $classesTmp2 = &$parserContainer->getClassesByReference();
            foreach ($classesTmp2 as $classKey => $classTmp2) {
                foreach ($classTmp2->constants as $constantKey => $constant) {
                    if ($constant->file && \strpos($constant->file, $pathTmp) === false) {
                        unset($classTmp2->constants[$constantKey]);
                    }
                }

                foreach ($classTmp2->properties as $propertyKey => $property) {
                    if ($property->file && \strpos($property->file, $pathTmp) === false) {
                        unset($classTmp2->properties[$propertyKey]);
                    }
                }

                foreach ($classTmp2->methods as $methodKey => $method) {
                    if ($method->file && \strpos($method->file, $pathTmp) === false) {
                        unset($classTmp2->methods[$methodKey]);
                    }
                }

                if ($classTmp2->file && \strpos($classTmp2->file, $pathTmp) === false) {
                    unset($classesTmp2[$classKey]);
                }
            }
        }

        return $parserContainer;
    }

    /**
     * @param string                                               $phpCode
     * @param string|null                                          $fileName
     * @param \voku\SimplePhpParser\Parsers\Helper\ParserContainer $parserContainer
     * @param \voku\SimplePhpParser\Parsers\Visitors\ASTVisitor    $visitor
     *
     * @return \voku\SimplePhpParser\Parsers\Helper\ParserContainer|\voku\SimplePhpParser\Parsers\Helper\ParserErrorHandler
     */
    public static function process(
        string $phpCode,
        ?string $fileName,
        ParserContainer $parserContainer,
        ASTVisitor $visitor
    ) {
        $parser = (new ParserFactory())->createForNewestSupportedVersion();

        $errorHandler = new ParserErrorHandler();

        $nameResolver = new NameResolver(
            $errorHandler,
            [
                'preserveOriginalNames' => true,
            ]
        );

        /** @var \PhpParser\Node[]|null $parsedCode */
        $parsedCode = $parser->parse($phpCode, $errorHandler);

        if ($parsedCode === null) {
            return $errorHandler;
        }

        // Pass 1: set parent attributes and fully resolve all names in the AST.
        // NameResolver modifies Name nodes in-place (converting them to FullyQualified),
        // so by the time ASTVisitor runs in pass 2, every type-hint Name node already
        // carries its fully-qualified form. This is necessary because ASTVisitor processes
        // class members (properties, methods) eagerly inside enterNode(Class_), before
        // the single-pass traverser would have had a chance to visit those child nodes.
        $traverser1 = new NodeTraverser();
        $traverser1->addVisitor(new ParentConnector());
        $traverser1->addVisitor($nameResolver);
        $traverser1->traverse($parsedCode);

        $visitor->fileName = $fileName;

        // Pass 2: extract model objects from the already-resolved AST.
        $traverser2 = new NodeTraverser();
        $traverser2->addVisitor($visitor);
        $traverser2->traverse($parsedCode);

        return $parserContainer;
    }

    /**
     * @param string   $pathOrCode
     * @param string[] $pathExcludeRegex
     * @param string[] $fileExtensions
     *
     * @return array
     *
     * @psalm-return array<string, array{content: string, fileName: null|string}>
     */
    private static function getCode(
        string $pathOrCode,
        array $pathExcludeRegex = [],
        array $fileExtensions = []
    ): array {
        // init
        $phpCodes = [];
        /** @var SplFileInfo[] $phpFileIterators */
        $phpFileIterators = [];
        /** @var list<\React\Promise\PromiseInterface<array{content: \React\Promise\PromiseInterface<string>, fileName: string, cacheKey: string}>> $phpFilePromises */
        $phpFilePromises = [];

        // fallback
        if (\count($fileExtensions) === 0) {
            $fileExtensions = ['.php'];
        }

        if (\is_file($pathOrCode)) {
            $phpFileIterators = [new SplFileInfo($pathOrCode)];
        } elseif (\is_dir($pathOrCode)) {
            $phpFileIterators = new RecursiveIteratorIterator(
                new RecursiveDirectoryIterator($pathOrCode, FilesystemIterator::SKIP_DOTS)
            );
        } else {
            $cacheKey = self::CACHE_KEY_HELPER . \md5($pathOrCode);

            $phpCodes[$cacheKey]['content'] = $pathOrCode;
            $phpCodes[$cacheKey]['fileName'] = null;
        }

        $cache = new Cache(null, null, false);

        $phpFileArray = [];
        foreach ($phpFileIterators as $fileOrCode) {
            $path = $fileOrCode->getRealPath();
            if (!$path) {
                continue;
            }

            $fileExtensionFound = false;
            foreach ($fileExtensions as $fileExtension) {
                if (\substr($path, -\strlen($fileExtension)) === $fileExtension) {
                    $fileExtensionFound = true;

                    break;
                }
            }
            if ($fileExtensionFound === false) {
                continue;
            }

            foreach ($pathExcludeRegex as $regex) {
                if (\preg_match($regex, $path)) {
                    continue 2;
                }
            }

            $cacheKey = self::CACHE_KEY_HELPER . \md5($path) . '--' . \filemtime($path);
            if ($cache->getCacheIsReady() === true && $cache->existsItem($cacheKey)) {
                $response = $cache->getItem($cacheKey);
                /** @noinspection PhpSillyAssignmentInspection - helper for phpstan */
                /** @phpstan-var array{content: string, fileName: string, cacheKey: string} $response */
                $response = $response;

                $phpCodes[$response['cacheKey']]['content'] = $response['content'];
                $phpCodes[$response['cacheKey']]['fileName'] = $response['fileName'];

                continue;
            }

            $phpFileArray[$cacheKey] = $path;
        }

        $phpFileArrayChunks = \array_chunk($phpFileArray, Utils::getCpuCores(), true);
        foreach ($phpFileArrayChunks as $phpFileArrayChunk) {
            $filesystem = \React\Filesystem\Factory::create();

            foreach ($phpFileArrayChunk as $cacheKey => $path) {
                $phpFilePromises[] = $filesystem->detect($path)->then(
                    static function (NodeInterface $node) use ($path, $cacheKey): array {
                        if (!$node instanceof FileInterface) {
                            throw new \RuntimeException('Expected a file node for: ' . $path);
                        }

                        return [
                            'content'  => $node->getContents()->then(static function (string $contents): string {
                                return $contents;
                            }),
                            'fileName' => $path,
                            'cacheKey' => $cacheKey,
                        ];
                    },
                    function ($e) {
                        throw $e;
                    }
                );
            }

            /** @var list<array{content: \React\Promise\PromiseInterface<string>, fileName: string, cacheKey: string}> $phpFilePromiseResponses */
            $phpFilePromiseResponses = await(all($phpFilePromises));
            foreach ($phpFilePromiseResponses as $response) {
                $response['content'] = await($response['content']);

                assert(is_string($response['content']));
                assert(is_string($response['cacheKey']));
                assert($response['fileName'] === null || is_string($response['fileName']));

                @$cache->setItem($response['cacheKey'], $response);

                $phpCodes[$response['cacheKey']]['content'] = $response['content'];
                $phpCodes[$response['cacheKey']]['fileName'] = $response['fileName'];
            }
        }

        return $phpCodes;
    }

    /**
     * @param \voku\SimplePhpParser\Model\PHPClass   $class
     * @param \voku\SimplePhpParser\Model\PHPClass[] $classes
     * @param PHPInterface[]                         $interfaces
     * @param ParserContainer                        $parserContainer
     */
    private static function mergeInheritdocData(
        \voku\SimplePhpParser\Model\PHPClass $class,
        array $classes,
        array $interfaces,
        ParserContainer $parserContainer
    ): void {
        foreach ($class->properties as &$property) {
            if (!$class->parentClass) {
                break;
            }

            if (!$property->is_inheritdoc) {
                continue;
            }

            if (
                !isset($classes[$class->parentClass])
                &&
                \class_exists($class->parentClass, true)
            ) {
                $reflectionClassTmp = Utils::createClassReflectionInstance($class->parentClass);
                $classTmp = (new \voku\SimplePhpParser\Model\PHPClass($parserContainer))->readObjectFromReflection($reflectionClassTmp);
                if ($classTmp->name) {
                    $classes[$classTmp->name] = $classTmp;
                }
            }

            if (!isset($classes[$class->parentClass])) {
                continue;
            }

            if (!isset($classes[$class->parentClass]->properties[$property->name])) {
                continue;
            }

            $parentMethod = $classes[$class->parentClass]->properties[$property->name];

            foreach ($property as $key => &$value) {
                if (
                    $value === null
                    &&
                    $parentMethod->{$key} !== null
                    &&
                    \stripos($key, 'type') !== false
                ) {
                    $value = $parentMethod->{$key};
                }
            }
        }
        unset($property, $value); /* @phpstan-ignore-line ? */

        foreach ($class->methods as &$method) {
            if (!$method->is_inheritdoc) {
                continue;
            }

            foreach ($class->interfaces as $interfaceStr) {
                if (
                    !isset($interfaces[$interfaceStr])
                    &&
                    \interface_exists($interfaceStr, true)
                ) {
                    $reflectionInterfaceTmp = Utils::createClassReflectionInstance($interfaceStr);
                    $interfaceTmp = (new PHPInterface($parserContainer))->readObjectFromReflection($reflectionInterfaceTmp);
                    if ($interfaceTmp->name) {
                        $interfaces[$interfaceTmp->name] = $interfaceTmp;
                    }
                }

                if (!isset($interfaces[$interfaceStr])) {
                    continue;
                }

                if (!isset($interfaces[$interfaceStr]->methods[$method->name])) {
                    continue;
                }

                $interfaceMethod = $interfaces[$interfaceStr]->methods[$method->name];

                foreach ($method as $key => &$value) {
                    if (
                        $value === null
                        &&
                        $interfaceMethod->{$key} !== null
                        &&
                        \stripos($key, 'type') !== false
                    ) {
                        $value = $interfaceMethod->{$key};
                    }

                    if ($key === 'parameters') {
                        $parameterCounter = 0;
                        foreach ($value as &$parameter) {
                            ++$parameterCounter;

                            \assert($parameter instanceof \voku\SimplePhpParser\Model\PHPParameter);

                            $interfaceMethodParameter = null;
                            $parameterCounterInterface = 0;
                            foreach ($interfaceMethod->parameters as $parameterInterface) {
                                ++$parameterCounterInterface;

                                if ($parameterCounterInterface === $parameterCounter) {
                                    $interfaceMethodParameter = $parameterInterface;
                                }
                            }

                            if (!$interfaceMethodParameter) {
                                continue;
                            }

                            foreach ($parameter as $keyInner => &$valueInner) {
                                if (
                                    $valueInner === null
                                    &&
                                    $interfaceMethodParameter->{$keyInner} !== null
                                    &&
                                    \stripos($keyInner, 'type') !== false
                                ) {
                                    $valueInner = $interfaceMethodParameter->{$keyInner};
                                }
                            }
                            unset($valueInner); /* @phpstan-ignore-line ? */
                        }
                        unset($parameter);
                    }
                }
                unset($value); /* @phpstan-ignore-line ? */
            }

            if (!isset($classes[$class->parentClass])) {
                continue;
            }

            if (!isset($classes[$class->parentClass]->methods[$method->name])) {
                continue;
            }

            $parentMethod = $classes[$class->parentClass]->methods[$method->name];

            foreach ($method as $key => &$value) {
                if (
                    $value === null
                    &&
                    $parentMethod->{$key} !== null
                    &&
                    \stripos($key, 'type') !== false
                ) {
                    $value = $parentMethod->{$key};
                }

                if ($key === 'parameters') {
                    $parameterCounter = 0;
                    foreach ($value as &$parameter) {
                        ++$parameterCounter;

                        \assert($parameter instanceof \voku\SimplePhpParser\Model\PHPParameter);

                        $parentMethodParameter = null;
                        $parameterCounterParent = 0;
                        foreach ($parentMethod->parameters as $parameterParent) {
                            ++$parameterCounterParent;

                            if ($parameterCounterParent === $parameterCounter) {
                                $parentMethodParameter = $parameterParent;
                            }
                        }

                        if (!$parentMethodParameter) {
                            continue;
                        }

                        foreach ($parameter as $keyInner => &$valueInner) {
                            if (
                                $valueInner === null
                                &&
                                $parentMethodParameter->{$keyInner} !== null
                                &&
                                \stripos($keyInner, 'type') !== false
                            ) {
                                $valueInner = $parentMethodParameter->{$keyInner};
                            }
                        }
                    }
                }
            }
        }
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace voku\SimplePhpParser\Parsers;
6
7	use FilesystemIterator;
8	use PhpParser\NodeTraverser;
9	use PhpParser\NodeVisitor\NameResolver;
10	use PhpParser\ParserFactory;
11	use React\Filesystem\Node\FileInterface;
12	use React\Filesystem\Node\NodeInterface;
13	use RecursiveDirectoryIterator;
14	use RecursiveIteratorIterator;
15	use SplFileInfo;
16	use voku\cache\Cache;
17	use voku\SimplePhpParser\Model\PHPInterface;
18	use voku\SimplePhpParser\Parsers\Helper\ParserContainer;
19	use voku\SimplePhpParser\Parsers\Helper\ParserErrorHandler;
20	use voku\SimplePhpParser\Parsers\Helper\Utils;
21	use voku\SimplePhpParser\Parsers\Visitors\ASTVisitor;
22	use voku\SimplePhpParser\Parsers\Visitors\ParentConnector;
23	use function React\Async\await;
24	use function React\Promise\all;
25
26	final class PhpCodeParser
27	{
28	/**
29	* @internal
30	*/
31	private const CACHE_KEY_HELPER = 'simple-php-code-parser-v6-';
32
33	/**
34	* @param string $code
35	* @param string[] $autoloaderProjectPaths
36	*
37	* @return \voku\SimplePhpParser\Parsers\Helper\ParserContainer
38	*/
39	public static function getFromString(
40	string $code,
41	array $autoloaderProjectPaths = []
42	): ParserContainer {
43	return self::getPhpFiles(	28✔
44	$code,	28✔
45	$autoloaderProjectPaths	28✔
46	);	28✔
47	}
48
49	/**
50	* @param string $className
51	* @param string[] $autoloaderProjectPaths
52	*
53	* @phpstan-param class-string $className
54	*
55	* @return \voku\SimplePhpParser\Parsers\Helper\ParserContainer
56	*/
57	public static function getFromClassName(
58	string $className,
59	array $autoloaderProjectPaths = []
60	): ParserContainer {
61	$reflectionClass = Utils::createClassReflectionInstance($className);	3✔
62
63	return self::getPhpFiles(	3✔
64	(string) $reflectionClass->getFileName(),	3✔
65	$autoloaderProjectPaths	3✔
66	);	3✔
67	}
68
69	/**
70	* @param string $pathOrCode
71	* @param string[] $autoloaderProjectPaths
72	* @param string[] $pathExcludeRegex
73	* @param string[] $fileExtensions
74	*
75	* @return \voku\SimplePhpParser\Parsers\Helper\ParserContainer
76	*/
77	public static function getPhpFiles(
78	string $pathOrCode,
79	array $autoloaderProjectPaths = [],
80	array $pathExcludeRegex = [],
81	array $fileExtensions = []
82	): ParserContainer {
83	// Push a disposable handler so restore_error_handler() below will only
84	// pop this one entry, leaving any pre-existing handlers (e.g. PHPUnit's)
85	// intact on the stack.
86	\set_error_handler(null);	115✔
87	try {
88	foreach ($autoloaderProjectPaths as $projectPath) {	115✔
89	if (\file_exists($projectPath) && \is_file($projectPath)) {	×
90	require_once $projectPath;	×
91	} elseif (\file_exists($projectPath . '/vendor/autoload.php')) {	×
92	require_once $projectPath . '/vendor/autoload.php';	×
93	} elseif (\file_exists($projectPath . '/../vendor/autoload.php')) {	×
94	require_once $projectPath . '/../vendor/autoload.php';	×
95	}
96	}
97	} finally {
98	\restore_error_handler();	115✔
99	}
100
101	$phpCodes = self::getCode(	115✔
102	$pathOrCode,	115✔
103	$pathExcludeRegex,	115✔
104	$fileExtensions	115✔
105	);	115✔
106
107	$parserContainer = new ParserContainer();	115✔
108	$visitor = new ASTVisitor($parserContainer);	115✔
109
110	$processResults = [];	115✔
111	$phpCodesChunks = \array_chunk($phpCodes, Utils::getCpuCores(), true);	115✔
112
113	foreach ($phpCodesChunks as $phpCodesChunk) {	115✔
114	foreach ($phpCodesChunk as $codeAndFileName) {	115✔
115	$processResults[] = self::process(	115✔
116	$codeAndFileName['content'],	115✔
117	$codeAndFileName['fileName'],	115✔
118	$parserContainer,	115✔
119	$visitor	115✔
120	);	115✔
121	}
122	}
123
124	foreach ($processResults as $response) {	115✔
125	if ($response instanceof ParserContainer) {	115✔
126	$parserContainer->setTraits($response->getTraits());	115✔
127	$parserContainer->setClasses($response->getClasses());	115✔
128	$parserContainer->setInterfaces($response->getInterfaces());	115✔
129	$parserContainer->setEnums($response->getEnums());	115✔
130	$parserContainer->setConstants($response->getConstants());	115✔
131	$parserContainer->setFunctions($response->getFunctions());	115✔
132	} elseif ($response instanceof ParserErrorHandler) {	×
133	$parserContainer->setParseError($response);	×
134	}
135	}
136
137	$interfaces = $parserContainer->getInterfaces();	115✔
138	foreach ($interfaces as &$interface) {	115✔
139	$interface->parentInterfaces = $visitor->combineParentInterfaces($interface);	6✔
140	}
141	unset($interface);	115✔
142
143	$pathTmp = null;	115✔
144	if (\is_file($pathOrCode)) {	115✔
145	$pathTmp = \realpath(\pathinfo($pathOrCode, \PATHINFO_DIRNAME));	81✔
146	} elseif (\is_dir($pathOrCode)) {	34✔
147	$pathTmp = \realpath($pathOrCode);	6✔
148	}
149
150	$classesTmp = &$parserContainer->getClassesByReference();	115✔
151	foreach ($classesTmp as &$classTmp) {	115✔
152	$classTmp->interfaces = Utils::flattenArray(	89✔
153	$visitor->combineImplementedInterfaces($classTmp),	89✔
154	false	89✔
155	);	89✔
156
157	self::mergeInheritdocData(	89✔
158	$classTmp,	89✔
159	$classesTmp,	89✔
160	$interfaces,	89✔
161	$parserContainer	89✔
162	);	89✔
163	}
164	unset($classTmp);	115✔
165
166	// remove properties / methods / classes from outside of the current file-path-scope
167	if ($pathTmp) {	115✔
168	$classesTmp2 = &$parserContainer->getClassesByReference();	87✔
169	foreach ($classesTmp2 as $classKey => $classTmp2) {	87✔
170	foreach ($classTmp2->constants as $constantKey => $constant) {	73✔
171	if ($constant->file && \strpos($constant->file, $pathTmp) === false) {	40✔
172	unset($classTmp2->constants[$constantKey]);	4✔
173	}
174	}
175
176	foreach ($classTmp2->properties as $propertyKey => $property) {	73✔
177	if ($property->file && \strpos($property->file, $pathTmp) === false) {	63✔
178	unset($classTmp2->properties[$propertyKey]);	6✔
179	}
180	}
181
182	foreach ($classTmp2->methods as $methodKey => $method) {	73✔
183	if ($method->file && \strpos($method->file, $pathTmp) === false) {	72✔
184	unset($classTmp2->methods[$methodKey]);	6✔
185	}
186	}
187
188	if ($classTmp2->file && \strpos($classTmp2->file, $pathTmp) === false) {	73✔
189	unset($classesTmp2[$classKey]);	6✔
190	}
191	}
192	}
193
194	return $parserContainer;	115✔
195	}
196
197	/**
198	* @param string $phpCode
199	* @param string\|null $fileName
200	* @param \voku\SimplePhpParser\Parsers\Helper\ParserContainer $parserContainer
201	* @param \voku\SimplePhpParser\Parsers\Visitors\ASTVisitor $visitor
202	*
203	* @return \voku\SimplePhpParser\Parsers\Helper\ParserContainer\|\voku\SimplePhpParser\Parsers\Helper\ParserErrorHandler
204	*/
205	public static function process(
206	string $phpCode,
207	?string $fileName,
208	ParserContainer $parserContainer,
209	ASTVisitor $visitor
210	) {
211	$parser = (new ParserFactory())->createForNewestSupportedVersion();	115✔
212
213	$errorHandler = new ParserErrorHandler();	115✔
214
215	$nameResolver = new NameResolver(	115✔
216	$errorHandler,	115✔
217	[	115✔
218	'preserveOriginalNames' => true,	115✔
219	]	115✔
220	);	115✔
221
222	/** @var \PhpParser\Node[]\|null $parsedCode */
223	$parsedCode = $parser->parse($phpCode, $errorHandler);	115✔
224
225	if ($parsedCode === null) {	115✔
226	return $errorHandler;	×
227	}
228
229	// Pass 1: set parent attributes and fully resolve all names in the AST.
230	// NameResolver modifies Name nodes in-place (converting them to FullyQualified),
231	// so by the time ASTVisitor runs in pass 2, every type-hint Name node already
232	// carries its fully-qualified form. This is necessary because ASTVisitor processes
233	// class members (properties, methods) eagerly inside enterNode(Class_), before
234	// the single-pass traverser would have had a chance to visit those child nodes.
235	$traverser1 = new NodeTraverser();	115✔
236	$traverser1->addVisitor(new ParentConnector());	115✔
237	$traverser1->addVisitor($nameResolver);	115✔
238	$traverser1->traverse($parsedCode);	115✔
239
240	$visitor->fileName = $fileName;	115✔
241
242	// Pass 2: extract model objects from the already-resolved AST.
243	$traverser2 = new NodeTraverser();	115✔
244	$traverser2->addVisitor($visitor);	115✔
245	$traverser2->traverse($parsedCode);	115✔
246
247	return $parserContainer;	115✔
248	}
249
250	/**
251	* @param string $pathOrCode
252	* @param string[] $pathExcludeRegex
253	* @param string[] $fileExtensions
254	*
255	* @return array
256	*
257	* @psalm-return array<string, array{content: string, fileName: null\|string}>
258	*/
259	private static function getCode(
260	string $pathOrCode,
261	array $pathExcludeRegex = [],
262	array $fileExtensions = []
263	): array {
264	// init
265	$phpCodes = [];	115✔
266	/** @var SplFileInfo[] $phpFileIterators */
267	$phpFileIterators = [];	115✔
268	/** @var list<\React\Promise\PromiseInterface<array{content: \React\Promise\PromiseInterface<string>, fileName: string, cacheKey: string}>> $phpFilePromises */
269	$phpFilePromises = [];	115✔
270
271	// fallback
272	if (\count($fileExtensions) === 0) {	115✔
273	$fileExtensions = ['.php'];	115✔
274	}
275
276	if (\is_file($pathOrCode)) {	115✔
277	$phpFileIterators = [new SplFileInfo($pathOrCode)];	81✔
278	} elseif (\is_dir($pathOrCode)) {	34✔
279	$phpFileIterators = new RecursiveIteratorIterator(	6✔
280	new RecursiveDirectoryIterator($pathOrCode, FilesystemIterator::SKIP_DOTS)	6✔
281	);	6✔
282	} else {
283	$cacheKey = self::CACHE_KEY_HELPER . \md5($pathOrCode);	28✔
284
285	$phpCodes[$cacheKey]['content'] = $pathOrCode;	28✔
286	$phpCodes[$cacheKey]['fileName'] = null;	28✔
287	}
288
289	$cache = new Cache(null, null, false);	115✔
290
291	$phpFileArray = [];	115✔
292	foreach ($phpFileIterators as $fileOrCode) {	115✔
293	$path = $fileOrCode->getRealPath();	87✔
294	if (!$path) {	87✔
295	continue;	×
296	}
297
298	$fileExtensionFound = false;	87✔
299	foreach ($fileExtensions as $fileExtension) {	87✔
300	if (\substr($path, -\strlen($fileExtension)) === $fileExtension) {	87✔
301	$fileExtensionFound = true;	87✔
302
303	break;	87✔
304	}
305	}
306	if ($fileExtensionFound === false) {	87✔
307	continue;	×
308	}
309
310	foreach ($pathExcludeRegex as $regex) {	87✔
311	if (\preg_match($regex, $path)) {	3✔
312	continue 2;	3✔
313	}
314	}
315
316	$cacheKey = self::CACHE_KEY_HELPER . \md5($path) . '--' . \filemtime($path);	87✔
317	if ($cache->getCacheIsReady() === true && $cache->existsItem($cacheKey)) {	87✔
318	$response = $cache->getItem($cacheKey);	58✔
319	/** @noinspection PhpSillyAssignmentInspection - helper for phpstan */
320	/** @phpstan-var array{content: string, fileName: string, cacheKey: string} $response */
321	$response = $response;	58✔
322
323	$phpCodes[$response['cacheKey']]['content'] = $response['content'];	58✔
324	$phpCodes[$response['cacheKey']]['fileName'] = $response['fileName'];	58✔
325
326	continue;	58✔
327	}
328
329	$phpFileArray[$cacheKey] = $path;	35✔
330	}
331
332	$phpFileArrayChunks = \array_chunk($phpFileArray, Utils::getCpuCores(), true);	115✔
333	foreach ($phpFileArrayChunks as $phpFileArrayChunk) {	115✔
334	$filesystem = \React\Filesystem\Factory::create();	35✔
335
336	foreach ($phpFileArrayChunk as $cacheKey => $path) {	35✔
337	$phpFilePromises[] = $filesystem->detect($path)->then(	35✔
338	static function (NodeInterface $node) use ($path, $cacheKey): array {	35✔
339	if (!$node instanceof FileInterface) {	35✔
NEW 340	throw new \RuntimeException('Expected a file node for: ' . $path);	×
341	}
342
343	return [	35✔
344	'content' => $node->getContents()->then(static function (string $contents): string {	35✔
345	return $contents;	35✔
346	}),	35✔
347	'fileName' => $path,	35✔
348	'cacheKey' => $cacheKey,	35✔
349	];	35✔
350	},	35✔
351	function ($e) {	35✔
352	throw $e;	×
353	}	35✔
354	);	35✔
355	}
356
357	/** @var list<array{content: \React\Promise\PromiseInterface<string>, fileName: string, cacheKey: string}> $phpFilePromiseResponses */
358	$phpFilePromiseResponses = await(all($phpFilePromises));	35✔
359	foreach ($phpFilePromiseResponses as $response) {	35✔
360	$response['content'] = await($response['content']);	35✔
361
362	assert(is_string($response['content']));
363	assert(is_string($response['cacheKey']));
364	assert($response['fileName'] === null \|\| is_string($response['fileName']));
365
366	@$cache->setItem($response['cacheKey'], $response);	35✔
367
368	$phpCodes[$response['cacheKey']]['content'] = $response['content'];	35✔
369	$phpCodes[$response['cacheKey']]['fileName'] = $response['fileName'];	35✔
370	}
371	}
372
373	return $phpCodes;	115✔
374	}
375
376	/**
377	* @param \voku\SimplePhpParser\Model\PHPClass $class
378	* @param \voku\SimplePhpParser\Model\PHPClass[] $classes
379	* @param PHPInterface[] $interfaces
380	* @param ParserContainer $parserContainer
381	*/
382	private static function mergeInheritdocData(
383	\voku\SimplePhpParser\Model\PHPClass $class,
384	array $classes,
385	array $interfaces,
386	ParserContainer $parserContainer
387	): void {
388	foreach ($class->properties as &$property) {	89✔
389	if (!$class->parentClass) {	69✔
390	break;	54✔
391	}
392
393	if (!$property->is_inheritdoc) {	30✔
394	continue;	30✔
395	}
396
397	if (
398	!isset($classes[$class->parentClass])	×
399	&&
400	\class_exists($class->parentClass, true)	×
401	) {
402	$reflectionClassTmp = Utils::createClassReflectionInstance($class->parentClass);	×
403	$classTmp = (new \voku\SimplePhpParser\Model\PHPClass($parserContainer))->readObjectFromReflection($reflectionClassTmp);	×
404	if ($classTmp->name) {	×
405	$classes[$classTmp->name] = $classTmp;	×
406	}
407	}
408
409	if (!isset($classes[$class->parentClass])) {	×
410	continue;	×
411	}
412
413	if (!isset($classes[$class->parentClass]->properties[$property->name])) {	×
414	continue;	×
415	}
416
417	$parentMethod = $classes[$class->parentClass]->properties[$property->name];	×
418
419	foreach ($property as $key => &$value) {	×
420	if (
UNCOV 421	$value === null	×
422	&&
UNCOV 423	$parentMethod->{$key} !== null	×
424	&&
UNCOV 425	\stripos($key, 'type') !== false	×
426	) {
UNCOV 427	$value = $parentMethod->{$key};	×
428	}
429	}
430	}
431	unset($property, $value); /* @phpstan-ignore-line ? */	89✔
432
433	foreach ($class->methods as &$method) {	89✔
434	if (!$method->is_inheritdoc) {	84✔
435	continue;	81✔
436	}
437
438	foreach ($class->interfaces as $interfaceStr) {	23✔
439	if (
440	!isset($interfaces[$interfaceStr])	23✔
441	&&
442	\interface_exists($interfaceStr, true)	23✔
443	) {
444	$reflectionInterfaceTmp = Utils::createClassReflectionInstance($interfaceStr);	17✔
445	$interfaceTmp = (new PHPInterface($parserContainer))->readObjectFromReflection($reflectionInterfaceTmp);	17✔
446	if ($interfaceTmp->name) {	17✔
447	$interfaces[$interfaceTmp->name] = $interfaceTmp;	17✔
448	}
449	}
450
451	if (!isset($interfaces[$interfaceStr])) {	23✔
UNCOV 452	continue;	×
453	}
454
455	if (!isset($interfaces[$interfaceStr]->methods[$method->name])) {	23✔
456	continue;	18✔
457	}
458
459	$interfaceMethod = $interfaces[$interfaceStr]->methods[$method->name];	14✔
460
461	foreach ($method as $key => &$value) {	14✔
462	if (
463	$value === null	14✔
464	&&
465	$interfaceMethod->{$key} !== null	14✔
466	&&
467	\stripos($key, 'type') !== false	14✔
468	) {
469	$value = $interfaceMethod->{$key};	14✔
470	}
471
472	if ($key === 'parameters') {	14✔
473	$parameterCounter = 0;	14✔
474	foreach ($value as &$parameter) {	14✔
475	++$parameterCounter;	14✔
476
477	\assert($parameter instanceof \voku\SimplePhpParser\Model\PHPParameter);
478
479	$interfaceMethodParameter = null;	14✔
480	$parameterCounterInterface = 0;	14✔
481	foreach ($interfaceMethod->parameters as $parameterInterface) {	14✔
482	++$parameterCounterInterface;	14✔
483
484	if ($parameterCounterInterface === $parameterCounter) {	14✔
485	$interfaceMethodParameter = $parameterInterface;	14✔
486	}
487	}
488
489	if (!$interfaceMethodParameter) {	14✔
NEW 490	continue;	×
491	}
492
493	foreach ($parameter as $keyInner => &$valueInner) {	14✔
494	if (
495	$valueInner === null	14✔
496	&&
497	$interfaceMethodParameter->{$keyInner} !== null	14✔
498	&&
499	\stripos($keyInner, 'type') !== false	14✔
500	) {
501	$valueInner = $interfaceMethodParameter->{$keyInner};	14✔
502	}
503	}
504	unset($valueInner); /* @phpstan-ignore-line ? */	14✔
505	}
506	unset($parameter);	14✔
507	}
508	}
509	unset($value); /* @phpstan-ignore-line ? */	14✔
510	}
511
512	if (!isset($classes[$class->parentClass])) {	23✔
513	continue;	14✔
514	}
515
516	if (!isset($classes[$class->parentClass]->methods[$method->name])) {	15✔
UNCOV 517	continue;	×
518	}
519
520	$parentMethod = $classes[$class->parentClass]->methods[$method->name];	15✔
521
522	foreach ($method as $key => &$value) {	15✔
523	if (
524	$value === null	15✔
525	&&
526	$parentMethod->{$key} !== null	15✔
527	&&
528	\stripos($key, 'type') !== false	15✔
529	) {
530	$value = $parentMethod->{$key};	15✔
531	}
532
533	if ($key === 'parameters') {	15✔
534	$parameterCounter = 0;	15✔
535	foreach ($value as &$parameter) {	15✔
536	++$parameterCounter;	15✔
537
538	\assert($parameter instanceof \voku\SimplePhpParser\Model\PHPParameter);
539
540	$parentMethodParameter = null;	15✔
541	$parameterCounterParent = 0;	15✔
542	foreach ($parentMethod->parameters as $parameterParent) {	15✔
543	++$parameterCounterParent;	15✔
544
545	if ($parameterCounterParent === $parameterCounter) {	15✔
546	$parentMethodParameter = $parameterParent;	15✔
547	}
548	}
549
550	if (!$parentMethodParameter) {	15✔
UNCOV 551	continue;	×
552	}
553
554	foreach ($parameter as $keyInner => &$valueInner) {	15✔
555	if (
556	$valueInner === null	15✔
557	&&
558	$parentMethodParameter->{$keyInner} !== null	15✔
559	&&
560	\stripos($keyInner, 'type') !== false	15✔
561	) {
562	$valueInner = $parentMethodParameter->{$keyInner};	15✔
563	}
564	}
565	}
566	}
567	}
568	}
569	}
570	}

voku / Simple-PHP-Code-Parser / 24275250560

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous