Fix PHP8.4 tests for ReflectionProperty features

Author: lisachenko

.github/workflows/phpunit.yml

@@ -2,7 +2,6 @@ name: "PHPUnit tests"
 
 on:
   pull_request:
-  push:
 
 jobs:
   phpunit:

composer.json

@@ -23,7 +23,7 @@
   },
   "require": {
     "php": ">=8.2",
-    "nikic/php-parser": "^5.0"
+    "nikic/php-parser": "^5.4"
   },
   "require-dev": {
     "phpunit/phpunit": "^11.0.7",

src/ReflectionProperty.php

@@ -199,9 +199,21 @@ public function getModifiers(): int
         if ($this->isReadOnly()) {
             $modifiers += self::IS_READONLY;
         }
+        if (PHP_VERSION_ID >= 80400 && $this->isAbstract()) {
+            $modifiers += self::IS_ABSTRACT;
+        }
+        if (PHP_VERSION_ID >= 80400 && $this->isFinal()) {
+            $modifiers += self::IS_FINAL;
+        }
+        if (PHP_VERSION_ID >= 80400 && $this->isProtectedSet()) {
+            $modifiers += self::IS_PROTECTED_SET;
+        }
+        if (PHP_VERSION_ID >= 80400 && $this->isPrivateSet()) {
+            $modifiers += self::IS_PRIVATE_SET;
+        }
 
         // Handle PHP 8.4+ asymmetric visibility modifiers
-        // Note: IS_PRIVATE_SET and IS_PROTECTED_SET are only added for properties with explicit 
+        // Note: IS_PRIVATE_SET and IS_PROTECTED_SET are only added for properties with explicit
         // asymmetric visibility syntax like "public private(set) $prop", not for regular readonly properties
         // TODO: Implement when nikic/php-parser supports asymmetric visibility syntax
 
@@ -277,6 +289,18 @@ public function getDefaultValue(): mixed
         return $this->defaultValue;
     }
 
+    /**
+     * @inheritDoc
+     */
+    public function isAbstract(): bool
+    {
+        if ($this->propertyOrPromotedParam instanceof Property) {
+            return $this->propertyOrPromotedParam->isAbstract();
+        }
+
+        return false;
+    }
+
     /**
      * @inheritDoc
      */
@@ -287,6 +311,22 @@ public function isDefault(): bool
         return true;
     }
 
+    /**
+     * {@inheritDoc}
+     *
+     * @see Property::isFinal()
+     */
+    public function isFinal(): bool
+    {
+        $explicitFinal = false;
+        if ($this->propertyOrPromotedParam instanceof Property) {
+            $explicitFinal = $this->propertyOrPromotedParam->isFinal();
+        }
+
+        // Property with private(set) modifier is implicitly final
+        return $explicitFinal || $this->isPrivateSet();
+    }
+
     /**
      * {@inheritDoc}
      *
@@ -298,6 +338,17 @@ public function isPrivate(): bool
         return $this->propertyOrPromotedParam->isPrivate();
     }
 
+    /**
+     * @inheritDoc
+     *
+     * @see Property::isPrivateSet()
+     * @see Param::isPrivateSet()
+     */
+    public function isPrivateSet(): bool
+    {
+        return ($this->propertyOrPromotedParam->isPrivateSet() && !$this->propertyOrPromotedParam->isPrivate());
+    }
+
     /**
      * {@inheritDoc}
      *
@@ -309,6 +360,22 @@ public function isProtected(): bool
         return $this->propertyOrPromotedParam->isProtected();
     }
 
+    /**
+     * @inheritDoc
+     *
+     * @see Property::isProtectedSet()
+     * @see Param::isProtectedSet()
+     */
+    public function isProtectedSet(): bool
+    {
+        /*
+         * Behavior of readonly is to imply protected(set), not private(set).
+         * A readonly property may still be explicitly declared private(set), in which case it will also be implicitly final
+         */
+        return ($this->propertyOrPromotedParam->isProtectedSet() && !$this->propertyOrPromotedParam->isProtected())
+            || ($this->isPublic() && $this->isReadonly() && !$this->isPrivateSet() && !$this->propertyOrPromotedParam->isPublicSet());
+    }
+
     /**
      * {@inheritDoc}
      *
@@ -352,7 +419,6 @@ public function isReadOnly(): bool
         return $this->propertyOrPromotedParam->isReadonly() || $this->getDeclaringClass()->isReadOnly();
     }
 
-
     /**
      * {@inheritDoc}
      */
@@ -369,6 +435,14 @@ public function isInitialized(?object $object = null): bool
         return $this->hasDefaultValue();
     }
 
+    /**
+     * @inheritDoc
+     */
+    public function isVirtual(): bool
+    {
+        return $this->propertyOrPromotedParam->isVirtual();
+    }
+
     /**
      * {@inheritDoc}
      */

tests/AbstractTestCase.php

@@ -85,6 +85,9 @@ public static function getFilesToAnalyze(): \Generator
         if (PHP_VERSION_ID >= 80300) {
             yield 'PHP8.3' => [__DIR__ . '/Stub/FileWithClasses83.php'];
         }
+        if (PHP_VERSION_ID >= 80400) {
+            yield 'PHP8.4' => [__DIR__ . '/Stub/FileWithClasses84.php'];
+        }
     }
 
     /**

tests/ReflectionClassTest.php

@@ -5,6 +5,7 @@
 
 use Go\ParserReflection\Stub\ClassWithPhp50ConstantsAndInheritance;
 use Go\ParserReflection\Stub\ClassWithPhp50MagicConstants;
+use Go\ParserReflection\Stub\ClassWithPhp84PropertyHooks;
 use Go\ParserReflection\Stub\SimplePhp50ClassWithMethodsAndProperties;
 use Go\ParserReflection\Stub\ClassWithPhp50ScalarConstants;
 use Go\ParserReflection\Stub\ClassWithPhp50FinalKeyword;
@@ -69,6 +70,12 @@ public function testReflectionGetterParity(
                 "See https://github.com/goaop/parser-reflection/issues/132"
             );
         }
+        if ($parsedClass->getName() === ClassWithPhp84PropertyHooks::class && in_array($getterName, ['isIterable', 'isIterateable'], true)) {
+            $this->markTestSkipped(
+                "isIterable for class with hooks returns true.\n" .
+                "See https://github.com/php/php-src/issues/20217"
+            );
+        }
         $this->assertSame(
             $expectedValue,
             $actualValue,

tests/ReflectionPropertyTest.php

@@ -175,10 +175,16 @@ public static function propertiesDataProvider(): \Generator
      */
     protected static function getGettersToCheck(): array
     {
-        return [
+        $getters = [
             'isDefault', 'getName', 'getModifiers', 'getDocComment',
             'isPrivate', 'isProtected', 'isPublic', 'isStatic', 'isReadOnly', 'isInitialized',
             'hasType', 'hasDefaultValue', 'getDefaultValue', '__toString'
         ];
+
+        if (PHP_VERSION_ID >= 80400) {
+            array_push($getters, 'isAbstract', 'isProtectedSet', 'isPrivateSet', 'isFinal');
+        }
+
+        return $getters;
     }
 }

tests/Stub/FileWithClasses84.php

@@ -0,0 +1,69 @@
+<?php
+/**
+ * Parser Reflection API
+ *
+ * @copyright Copyright 2025, Lisachenko Alexander <[email protected]>
+ *
+ * This source file is subject to the license that is bundled
+ * with this source code in the file LICENSE.
+ */
+declare(strict_types=1);
+
+namespace Go\ParserReflection\Stub;
+
+/**
+ * @see https://wiki.php.net/rfc/property-hooks
+ */
+
+class ClassWithPhp84PropertyHooks
+{
+    private string $backing = 'default';
+
+    public string $name {
+        get => $this->backing;
+        set => $this->backing = strtoupper($value);
+    }
+}
+
+/* Not supported yet
+interface InterfaceWithPhp84AbstractProperty
+{
+    public string $name { get; }
+}
+*/
+
+/**
+ * https://wiki.php.net/rfc/asymmetric-visibility-v2
+ */
+class ClassWithPhp84AsymmetricVisibility
+{
+    // These create a public-read, protected-write, write-once property.
+    public protected(set) readonly string $explicitPublicWriteOnceProtectedProperty;
+    public readonly string $implicitPublicReadonlyWriteOnceProperty;
+    readonly string $implicitReadonlyWriteOnceProperty;
+
+    // These creates a public-read, private-set, write-once, final property.
+    public private(set) readonly string $explicitPublicWriteOncePrivateProperty;
+    private(set) readonly string $implicitPublicReadonlyWriteOncePrivateProperty;
+
+    // These create a public-read, public-write, write-once property.
+    // While use cases for this configuration are likely few,
+    // there's no intrinsic reason it should be forbidden.
+    public public(set) readonly string $explicitPublicWriteOncePublicProperty;
+    public(set) readonly string $implicitPublicReadonlyWriteOncePublicProperty;
+
+    // These create a private-read, private-write, write-once, final property.
+    private private(set) readonly string $explicitPrivateWriteOncePrivateProperty;
+    private readonly string $implicitPrivateReadonlyWriteOncePrivateProperty;
+
+    // These create a protected-read, protected-write, write-once property.
+    protected protected(set) readonly string $explicitProtectedWriteOnceProtectedProperty;
+    protected readonly string $implicitProtectedReadonlyWriteOnceProtectedProperty;
+
+    public function __construct(
+        private(set) string $promotedPrivateSetStringProperty,
+        protected(set) string $promotedProtectedSetStringProperty,
+        protected private(set) int $promotedProtectedPrivateSetIntProperty,
+    ) {}
+
+}