24287978923

Committed 11 Apr 2026 05:41PM UTC coverage: 81.31% (-1.6%) from 82.886%

Build # 24287978923

Build Type

Pull #83

github

Committed by

web-flow

Commit Message

Merge 29aa9bda8 into 90e1e60d3

Pull Request Pull Request #83: Fix CI pipeline: phpunit.xml validation warning, php-parser v4 test skip, and comprehensive type-analysis regression coverage

Coverage Stats

247 of 288 new or added lines in 7 files covered. (85.76%)

30 existing lines in 3 files now uncovered.

1688 of 2076 relevant lines covered (81.31%)

27.68 hits per line

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

6.45

/src/voku/SimplePhpParser/Model/BasePHPClass.php

<?php

declare(strict_types=1);

namespace voku\SimplePhpParser\Model;

abstract class BasePHPClass extends BasePHPElement
{
    use PHPDocElement;

    private const PHP_VERSION_8_2_0 = 80200;

    private const PHP_VERSION_8_3_0 = 80300;

    private const PHP_VERSION_8_4_0 = 80400;

    /**
     * @var array<string, PHPMethod>
     */
    public array $methods = [];

    /**
     * @var array<string, PHPProperty>
     */
    public array $properties = [];

    /**
     * @var array<string, PHPConst>
     */
    public array $constants = [];

    /**
     * PHP 8.0+ attributes on this class/interface/trait/enum.
     *
     * @var PHPAttribute[]
     */
    public array $attributes = [];

    public ?bool $is_final = null;

    public ?bool $is_abstract = null;

    public ?bool $is_readonly = null;

    public ?bool $is_anonymous = null;

    public ?bool $is_cloneable = null;

    public ?bool $is_instantiable = null;

    public ?bool $is_iterable = null;

    /**
     * Check if the parsed class-like node can be safely autoloaded on the
     * current runtime without triggering fatal syntax errors from newer PHP features.
     */
    protected static function canAutoloadFromPhpNode(\PhpParser\Node $node): bool
    {
        if (\PHP_VERSION_ID < self::PHP_VERSION_8_2_0 && self::containsPHP82PlusSyntax($node)) {
            return false;
        }

        if (\PHP_VERSION_ID < self::PHP_VERSION_8_3_0 && self::containsPHP83PlusSyntax($node)) {
            return false;
        }

        if (\PHP_VERSION_ID < self::PHP_VERSION_8_4_0 && self::containsPHP84PlusSyntax($node)) {
            return false;
        }

        return true;
    }

    /**
     * Detect PHP 8.2-only syntax within a class-like AST such as readonly classes,
     * DNF types, and standalone null/true/false types.
     */
    private static function containsPHP82PlusSyntax(\PhpParser\Node $node): bool
    {
        if (
            $node instanceof \PhpParser\Node\Stmt\Class_
            &&
            $node->isReadonly()
        ) {
            return true;
        }

        if ($node instanceof \PhpParser\Node\UnionType) {
            foreach ($node->types as $innerType) {
                if ($innerType instanceof \PhpParser\Node\IntersectionType) {
                    return true;
                }
            }
        }

        if ($node instanceof \PhpParser\Node\Identifier) {
            $typeName = \strtolower($node->name);

            // Standalone null/true/false are represented as Identifier nodes too,
            // so they are only PHP 8.2+ when they are not part of a union type.
            if (
                ($typeName === 'null' || $typeName === 'true' || $typeName === 'false')
                &&
                !($node->getAttribute('parent') instanceof \PhpParser\Node\UnionType)
            ) {
                return true;
            }
        }

        foreach ($node->getSubNodeNames() as $subNodeName) {
            $subNode = $node->{$subNodeName};

            if ($subNode instanceof \PhpParser\Node && self::containsPHP82PlusSyntax($subNode)) {
                return true;
            }

            if (!\is_array($subNode)) {
                continue;
            }

            foreach ($subNode as $subNodeInner) {
                if ($subNodeInner instanceof \PhpParser\Node && self::containsPHP82PlusSyntax($subNodeInner)) {
                    return true;
                }
            }
        }

        return false;
    }

    /**
     * Detect PHP 8.3-only syntax within a class-like AST such as typed class constants.
     */
    private static function containsPHP83PlusSyntax(\PhpParser\Node $node): bool
    {
        if (
            $node instanceof \PhpParser\Node\Stmt\ClassConst
            &&
            $node->type !== null
        ) {
            return true;
        }

        foreach ($node->getSubNodeNames() as $subNodeName) {
            $subNode = $node->{$subNodeName};

            if ($subNode instanceof \PhpParser\Node && self::containsPHP83PlusSyntax($subNode)) {
                return true;
            }

            if (!\is_array($subNode)) {
                continue;
            }

            foreach ($subNode as $subNodeInner) {
                if ($subNodeInner instanceof \PhpParser\Node && self::containsPHP83PlusSyntax($subNodeInner)) {
                    return true;
                }
            }
        }

        return false;
    }

    /**
     * Detect PHP 8.4-only syntax within a class-like AST such as property hooks
     * and asymmetric visibility modifiers.
     */
    protected static function containsPHP84PlusSyntax(\PhpParser\Node $node): bool
    {
        // Property hooks (PHP 8.4+)
        if ($node instanceof \PhpParser\Node\Stmt\Property && !empty($node->hooks)) {
            return true;
        }

        // Asymmetric visibility on properties (PHP 8.4+)
        if (
            $node instanceof \PhpParser\Node\Stmt\Property
            && self::getAsymmetricSetVisibility($node) !== ''
        ) {
            return true;
        }

        // Property hooks on promoted constructor parameters (PHP 8.4+)
        if ($node instanceof \PhpParser\Node\Param && !empty($node->hooks)) {
            return true;
        }

        // Asymmetric visibility on promoted constructor parameters (PHP 8.4+)
        if (
            $node instanceof \PhpParser\Node\Param
            && self::getAsymmetricSetVisibility($node) !== ''
        ) {
            return true;
        }

        foreach ($node->getSubNodeNames() as $subNodeName) {
            $subNode = $node->{$subNodeName};

            if ($subNode instanceof \PhpParser\Node && self::containsPHP84PlusSyntax($subNode)) {
                return true;
            }

            if (!\is_array($subNode)) {
                continue;
            }

            foreach ($subNode as $subNodeInner) {
                if ($subNodeInner instanceof \PhpParser\Node && self::containsPHP84PlusSyntax($subNodeInner)) {
                    return true;
                }
            }
        }

        return false;
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace voku\SimplePhpParser\Model;
6
7	abstract class BasePHPClass extends BasePHPElement
8	{
9	use PHPDocElement;
10
11	private const PHP_VERSION_8_2_0 = 80200;
12
13	private const PHP_VERSION_8_3_0 = 80300;
14
15	private const PHP_VERSION_8_4_0 = 80400;
16
17	/**
18	* @var array<string, PHPMethod>
19	*/
20	public array $methods = [];
21
22	/**
23	* @var array<string, PHPProperty>
24	*/
25	public array $properties = [];
26
27	/**
28	* @var array<string, PHPConst>
29	*/
30	public array $constants = [];
31
32	/**
33	* PHP 8.0+ attributes on this class/interface/trait/enum.
34	*
35	* @var PHPAttribute[]
36	*/
37	public array $attributes = [];
38
39	public ?bool $is_final = null;
40
41	public ?bool $is_abstract = null;
42
43	public ?bool $is_readonly = null;
44
45	public ?bool $is_anonymous = null;
46
47	public ?bool $is_cloneable = null;
48
49	public ?bool $is_instantiable = null;
50
51	public ?bool $is_iterable = null;
52
53	/**
54	* Check if the parsed class-like node can be safely autoloaded on the
55	* current runtime without triggering fatal syntax errors from newer PHP features.
56	*/
57	protected static function canAutoloadFromPhpNode(\PhpParser\Node $node): bool
58	{
59	if (\PHP_VERSION_ID < self::PHP_VERSION_8_2_0 && self::containsPHP82PlusSyntax($node)) {	87✔
60	return false;	×
61	}
62
63	if (\PHP_VERSION_ID < self::PHP_VERSION_8_3_0 && self::containsPHP83PlusSyntax($node)) {	87✔
64	return false;	×
65	}
66
67	if (\PHP_VERSION_ID < self::PHP_VERSION_8_4_0 && self::containsPHP84PlusSyntax($node)) {	87✔
NEW 68	return false;	×
69	}
70
71	return true;	87✔
72	}
73
74	/**
75	* Detect PHP 8.2-only syntax within a class-like AST such as readonly classes,
76	* DNF types, and standalone null/true/false types.
77	*/
78	private static function containsPHP82PlusSyntax(\PhpParser\Node $node): bool
79	{
80	if (
81	$node instanceof \PhpParser\Node\Stmt\Class_	×
82	&&
83	$node->isReadonly()	×
84	) {
85	return true;	×
86	}
87
88	if ($node instanceof \PhpParser\Node\UnionType) {	×
89	foreach ($node->types as $innerType) {	×
90	if ($innerType instanceof \PhpParser\Node\IntersectionType) {	×
91	return true;	×
92	}
93	}
94	}
95
96	if ($node instanceof \PhpParser\Node\Identifier) {	×
97	$typeName = \strtolower($node->name);	×
98
99	// Standalone null/true/false are represented as Identifier nodes too,
100	// so they are only PHP 8.2+ when they are not part of a union type.
101	if (
102	($typeName === 'null' \|\| $typeName === 'true' \|\| $typeName === 'false')	×
103	&&
104	!($node->getAttribute('parent') instanceof \PhpParser\Node\UnionType)	×
105	) {
106	return true;	×
107	}
108	}
109
110	foreach ($node->getSubNodeNames() as $subNodeName) {	×
111	$subNode = $node->{$subNodeName};	×
112
113	if ($subNode instanceof \PhpParser\Node && self::containsPHP82PlusSyntax($subNode)) {	×
114	return true;	×
115	}
116
117	if (!\is_array($subNode)) {	×
118	continue;	×
119	}
120
121	foreach ($subNode as $subNodeInner) {	×
122	if ($subNodeInner instanceof \PhpParser\Node && self::containsPHP82PlusSyntax($subNodeInner)) {	×
123	return true;	×
124	}
125	}
126	}
127
128	return false;	×
129	}
130
131	/**
132	* Detect PHP 8.3-only syntax within a class-like AST such as typed class constants.
133	*/
134	private static function containsPHP83PlusSyntax(\PhpParser\Node $node): bool
135	{
136	if (
137	$node instanceof \PhpParser\Node\Stmt\ClassConst	×
138	&&
139	$node->type !== null	×
140	) {
141	return true;	×
142	}
143
144	foreach ($node->getSubNodeNames() as $subNodeName) {	×
145	$subNode = $node->{$subNodeName};	×
146
147	if ($subNode instanceof \PhpParser\Node && self::containsPHP83PlusSyntax($subNode)) {	×
148	return true;	×
149	}
150
151	if (!\is_array($subNode)) {	×
152	continue;	×
153	}
154
155	foreach ($subNode as $subNodeInner) {	×
156	if ($subNodeInner instanceof \PhpParser\Node && self::containsPHP83PlusSyntax($subNodeInner)) {	×
157	return true;	×
158	}
159	}
160	}
161
162	return false;	×
163	}
164
165	/**
166	* Detect PHP 8.4-only syntax within a class-like AST such as property hooks
167	* and asymmetric visibility modifiers.
168	*/
169	protected static function containsPHP84PlusSyntax(\PhpParser\Node $node): bool
170	{
171	// Property hooks (PHP 8.4+)
NEW 172	if ($node instanceof \PhpParser\Node\Stmt\Property && !empty($node->hooks)) {	×
NEW 173	return true;	×
174	}
175
176	// Asymmetric visibility on properties (PHP 8.4+)
177	if (
NEW 178	$node instanceof \PhpParser\Node\Stmt\Property	×
NEW 179	&& self::getAsymmetricSetVisibility($node) !== ''	×
180	) {
NEW 181	return true;	×
182	}
183
184	// Property hooks on promoted constructor parameters (PHP 8.4+)
NEW 185	if ($node instanceof \PhpParser\Node\Param && !empty($node->hooks)) {	×
NEW 186	return true;	×
187	}
188
189	// Asymmetric visibility on promoted constructor parameters (PHP 8.4+)
190	if (
NEW 191	$node instanceof \PhpParser\Node\Param	×
NEW 192	&& self::getAsymmetricSetVisibility($node) !== ''	×
193	) {
NEW 194	return true;	×
195	}
196
NEW 197	foreach ($node->getSubNodeNames() as $subNodeName) {	×
NEW 198	$subNode = $node->{$subNodeName};	×
199
NEW 200	if ($subNode instanceof \PhpParser\Node && self::containsPHP84PlusSyntax($subNode)) {	×
NEW 201	return true;	×
202	}
203
NEW 204	if (!\is_array($subNode)) {	×
NEW 205	continue;	×
206	}
207
NEW 208	foreach ($subNode as $subNodeInner) {	×
NEW 209	if ($subNodeInner instanceof \PhpParser\Node && self::containsPHP84PlusSyntax($subNodeInner)) {	×
NEW 210	return true;	×
211	}
212	}
213	}
214
NEW 215	return false;	×
216	}
217	}

voku / Simple-PHP-Code-Parser / 24287978923

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