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

phpunit.xml

@@ -9,9 +9,4 @@
     <testsuite name="Simple-PHP-Code-Parser Test Suite">
         <directory>tests</directory>
     </testsuite>
-    <source>
-        <include>
-            <directory suffix=".php">./src/</directory>
-        </include>
-    </source>
 </phpunit>

src/voku/SimplePhpParser/Model/BasePHPClass.php

@@ -12,6 +12,8 @@
 
     private const PHP_VERSION_8_3_0 = 80300;
 
+    private const PHP_VERSION_8_4_0 = 80400;
+
     /**
      * @var array<string, PHPMethod>
      */
@@ -52,7 +54,7 @@
      * 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;
@@ -62,6 +64,10 @@
             return false;
         }
 
+        if (\PHP_VERSION_ID < self::PHP_VERSION_8_4_0 && self::containsPHP84PlusSyntax($node)) {
+            return false;
+        }
+
         return true;
     }
 
@@ -155,4 +161,57 @@
 
         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;
+    }
 }

src/voku/SimplePhpParser/Model/BasePHPElement.php

@@ -103,4 +103,59 @@
             ? $node->getStartLine()
             : $node->getLine();
     }
+
+    /**
+     * @phpstan-return ''|'private'|'protected'|'public'
+     */
+    protected static function getAsymmetricSetVisibility(object $node): string
+    {
+        if (\method_exists($node, 'isPublicSet') && $node->isPublicSet()) {
+            return 'public';
+        }
+
+        if (\method_exists($node, 'isProtectedSet') && $node->isProtectedSet()) {
+            return 'protected';
+        }
+
+        if (\method_exists($node, 'isPrivateSet') && $node->isPrivateSet()) {
+            return 'private';
+        }
+
+        return '';
+    }
+
+    protected static function isPromotedParameter(\PhpParser\Node\Param $parameter): bool
+    {
+        return ($parameter->flags & \PhpParser\Node\Stmt\Class_::VISIBILITY_MODIFIER_MASK) !== 0;
+    }
+
+    /**
+     * @phpstan-return ''|'private'|'protected'|'public'
+     */
+    protected static function getVisibilityFromModifierFlags(int $flags): string
+    {
+        if (($flags & \PhpParser\Node\Stmt\Class_::MODIFIER_PRIVATE) !== 0) {
+            return 'private';
+        }
+
+        if (($flags & \PhpParser\Node\Stmt\Class_::MODIFIER_PROTECTED) !== 0) {
+            return 'protected';
+        }
+
+        if (($flags & \PhpParser\Node\Stmt\Class_::MODIFIER_PUBLIC) !== 0) {
+            return 'public';
+        }
+
+        return '';
+    }
+
+    protected static function hasReadonlyModifier(int $flags): bool
+    {
+        return ($flags & \PhpParser\Node\Stmt\Class_::MODIFIER_READONLY) !== 0;
+    }
+
+    protected static function hasFinalModifier(int $flags): bool
+    {
+        return ($flags & \PhpParser\Node\Stmt\Class_::MODIFIER_FINAL) !== 0;
+    }
 }

src/voku/SimplePhpParser/Model/PHPClass.php

@@ -58,12 +58,9 @@
             $this->attributes = Utils::extractAttributesFromAstNode($node->attrGroups);
         }
 
-        // PHP < 8.2 raises an uncatchable E_COMPILE_ERROR for certain PHP 8.2+ syntax
-        // (standalone true/false/null types, DNF types, readonly class). Similarly,
-        // PHP < 8.3 raises an error for PHP 8.3+ syntax (typed class constants).
-        // Skip autoloading in those cases; AST data is still read from the node below.
-        $canAutoload = (\PHP_VERSION_ID >= 80200 || !self::nodeUsesPHP82PlusSyntax($node))
-            && (\PHP_VERSION_ID >= 80300 || !self::nodeUsesPHP83PlusSyntax($node));
+        // Skip autoloading when the current runtime cannot safely compile newer syntax;
+        // AST data is still read from the node below.
+        $canAutoload = self::canAutoloadFromPhpNode($node);
         $classExists = false;
         if ($canAutoload) {
             try {
@@ -122,6 +119,8 @@
             }
         }
 
+        $this->addPromotedPropertiesFromConstructor($node);
+
         if (!empty($node->implements)) {
             foreach ($node->implements as $interfaceObject) {
                 $interfaceFQN = $interfaceObject->toString();
@@ -462,101 +461,80 @@
         }
     }
 
-    /**
-     * Returns true if the class node uses syntax that requires PHP 8.2+ and would
-     * cause an uncatchable E_COMPILE_ERROR when autoloaded on PHP < 8.2.
-     *
-     * @param Class_ $node
-     *
-     * @return bool
-     */
-    private static function nodeUsesPHP82PlusSyntax(Class_ $node): bool
+    private function addPromotedPropertiesFromConstructor(Class_ $node): void
     {
-        // readonly class is PHP 8.2+
-        if ($node->isReadonly()) {
-            return true;
-        }
+        foreach ($node->getMethods() as $method) {
+            if ($method->name->name !== '__construct') {
+                continue;
+            }
 
-        foreach ($node->stmts as $stmt) {
-            if ($stmt instanceof \PhpParser\Node\Stmt\ClassMethod) {
-                if (self::containsPHP82PlusType($stmt->returnType)) {
-                    return true;
+            foreach ($method->params as $parameter) {
+                if (!self::isPromotedParameter($parameter)) {
+                    continue;
                 }
-                foreach ($stmt->params as $param) {
-                    if (self::containsPHP82PlusType($param->type)) {
-                        return true;
-                    }
+
+                $parameterVar = $parameter->var;
+                if (
+                    !($parameterVar instanceof \PhpParser\Node\Expr\Variable)
+                    || !\is_string($parameterVar->name)
+                ) {
+                    continue;
                 }
-            } elseif ($stmt instanceof \PhpParser\Node\Stmt\Property) {
-                if (self::containsPHP82PlusType($stmt->type)) {
-                    return true;
+
+                $promotedProperty = (new PHPProperty($this->parserContainer))
+                    ->readObjectFromPromotedParam($parameter, $this->name);
+
+                $propertyName = $parameterVar->name;
+                $existingProperty = $this->properties[$propertyName] ?? null;
+                if ($existingProperty !== null) {
+                    $this->mergePromotedPropertyData($existingProperty, $promotedProperty, $parameter);
+
+                    continue;
                 }
+
+                $this->properties[$propertyName] = $promotedProperty;
             }
-        }
 
-        return false;
+            break;
+        }
     }
 
-    /**
-     * Returns true if the class node uses syntax that requires PHP 8.3+ and would
-     * cause an uncatchable E_COMPILE_ERROR when autoloaded on PHP < 8.3.
-     *
-     * Covers: typed class constants (Stmt\ClassConst with a non-null type).
-     *
-     * @param Class_ $node
-     *
-     * @return bool
-     */
-    private static function nodeUsesPHP83PlusSyntax(Class_ $node): bool
-    {
-        foreach ($node->stmts as $stmt) {
-            // Typed class constants are PHP 8.3+
-            if ($stmt instanceof \PhpParser\Node\Stmt\ClassConst && $stmt->type !== null) {
-                return true;
-            }
+    private function mergePromotedPropertyData(
+        PHPProperty $existingProperty,
+        PHPProperty $promotedProperty,
+        \PhpParser\Node\Param $parameter
+    ): void {
+        if ($existingProperty->access === '' && $promotedProperty->access !== '') {
+            $existingProperty->access = $promotedProperty->access;
         }
 
-        return false;
-    }
+        if ($existingProperty->type === null && $promotedProperty->type !== null) {
+            $existingProperty->type = $promotedProperty->type;
+        }
 
-    /**
-     * Returns true if the given type node is a PHP 8.2+ type that causes an
-     * uncatchable E_COMPILE_ERROR when loaded on PHP < 8.2.
-     *
-     * Covers: standalone true/false/null types and DNF types (union of intersections).
-     *
-     * @param \PhpParser\Node|null $typeNode
-     *
-     * @return bool
-     */
-    private static function containsPHP82PlusType($typeNode): bool
-    {
-        if ($typeNode === null) {
-            return false;
+        if ($existingProperty->is_readonly === null && $promotedProperty->is_readonly !== null) {
+            $existingProperty->is_readonly = $promotedProperty->is_readonly;
         }
 
-        // Standalone true, false, null as the *sole* type (not in a nullable like ?string)
-        // are PHP 8.2+ only. PHP-Parser represents these as Identifier nodes (not Name).
-        // Nullable null (?null) is syntactically invalid; NullableType wraps the inner type.
-        if ($typeNode instanceof \PhpParser\Node\Identifier) {
-            $name = \strtolower($typeNode->name);
-            return $name === 'true' || $name === 'false' || $name === 'null';
+        if ($existingProperty->is_final === null && $promotedProperty->is_final !== null) {
+            $existingProperty->is_final = $promotedProperty->is_final;
         }
 
-        // DNF types: union type containing an intersection type (PHP 8.2+)
-        if ($typeNode instanceof \PhpParser\Node\UnionType) {
-            foreach ($typeNode->types as $t) {
-                if ($t instanceof \PhpParser\Node\IntersectionType || self::containsPHP82PlusType($t)) {
-                    return true;
-                }
-            }
+        if ($existingProperty->access_set === '' && $promotedProperty->access_set !== '') {
+            $existingProperty->access_set = $promotedProperty->access_set;
         }
 
-        // Recurse into nullable type
-        if ($typeNode instanceof \PhpParser\Node\NullableType) {
-            return self::containsPHP82PlusType($typeNode->type);
+        if ($existingProperty->hooks === [] && $promotedProperty->hooks !== []) {
+            $existingProperty->hooks = $promotedProperty->hooks;
         }
 
-        return false;
+        if ($existingProperty->attributes === [] && $promotedProperty->attributes !== []) {
+            $existingProperty->attributes = $promotedProperty->attributes;
+        }
+
+        if ($parameter->default !== null && $promotedProperty->typeFromDefaultValue !== null) {
+            $existingProperty->defaultValue = $promotedProperty->defaultValue;
+            $existingProperty->typeFromDefaultValue = $promotedProperty->typeFromDefaultValue;
+        }
     }
 }

src/voku/SimplePhpParser/Model/PHPFunction.php

@@ -297,7 +297,7 @@
     /**
      * @throws \PHPStan\PhpDocParser\Parser\ParserException
      */
     private function readPhpDocByTokens(string $docComment): void
     {
         $tokens = Utils::modernPhpdocTokens($docComment);
 
@@ -327,7 +327,20 @@
             if (!$this->returnPhpDocRaw) {
                 $this->returnPhpDocRaw = $returnContent;
             }
-            $this->returnTypeFromPhpDocExtended = Utils::modernPhpdoc($returnContent);
+            try {
+                $this->returnTypeFromPhpDocExtended = Utils::modernPhpdoc($returnContent);
+            } catch (\PHPStan\PhpDocParser\Parser\ParserException $e) {
+                $recoveredType = Utils::recoverBrokenPhpdocType($returnContent);
+                if ($recoveredType !== null) {
+                    $normalizedRecoveredType = Utils::normalizePhpType($recoveredType);
+                    $this->returnTypeFromPhpDoc = $this->returnTypeFromPhpDoc ?? $normalizedRecoveredType;
+                    $this->returnTypeFromPhpDocSimple = $this->returnTypeFromPhpDocSimple ?? $normalizedRecoveredType;
+                    $this->returnTypeFromPhpDocExtended = $recoveredType;
+                }
+
+                $tmpErrorMessage = $this->name . ':' . ($this->line ?? '?') . ' | ' . $e->getMessage();
+                $this->parseError[\md5($tmpErrorMessage)] = $tmpErrorMessage;
+            }
         }
     }
 }

src/voku/SimplePhpParser/Model/PHPParameter.php

@@ -325,7 +325,7 @@
     /**
      * @throws \PHPStan\PhpDocParser\Parser\ParserException
      */
     private function readPhpDocByTokens(string $docComment, string $parameterName): void
     {
         $tokens = Utils::modernPhpdocTokens($docComment);
 
@@ -355,7 +355,19 @@
             if (!$this->phpDocRaw) {
                 $this->phpDocRaw = $paramContent . ' ' . '$' . $parameterName;
             }
-            $this->typeFromPhpDocExtended = Utils::modernPhpdoc($paramContent);
+            try {
+                $this->typeFromPhpDocExtended = Utils::modernPhpdoc($paramContent);
+            } catch (\PHPStan\PhpDocParser\Parser\ParserException $e) {
+                $recoveredType = Utils::recoverBrokenPhpdocType($paramContent);
+                if ($recoveredType !== null) {
+                    $normalizedRecoveredType = Utils::normalizePhpType($recoveredType);
+                    $this->typeFromPhpDoc = $this->typeFromPhpDoc ?? $normalizedRecoveredType;
+                    $this->typeFromPhpDocSimple = $this->typeFromPhpDocSimple ?? $normalizedRecoveredType;
+                    $this->typeFromPhpDocExtended = $recoveredType;
+                }
+
+                $this->addParseError($e);
+            }
         }
     }