Fix 3 bugs caught by PHPactor's tests

Author: AJenbo

docs/CHANGELOG.md

@@ -9,6 +9,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **Enum case properties.** Completing on an enum case variable (`$case->`) now shows `name` (on all enums) and `value` (on backed enums) inherited from the `UnitEnum` and `BackedEnum` interfaces.
+
+### Fixed
+
+- **Inherited `@method` and `@property` tags.** Virtual members declared via `@method` or `@property` on a parent class now appear on child classes. Previously only the declaring class itself surfaced these members.
+- **Class constant and enum case assignment resolution.** Assigning from a class constant (`$x = Foo::SOME_CONST`) or enum case (`$x = Status::Active`) now resolves the variable's type correctly for subsequent completion.
+- **Sequential assert narrowing.** Multiple `assert($x instanceof A); assert($x instanceof B);` statements now accumulate, showing members from both types. Previously only the last assertion's narrowing applied.
+
+
 - **Project configuration.** PHPantom now reads a `.phpantom.toml` file from the project root (next to `composer.json`) for per-project settings. Currently supports `[php] version` to override the detected PHP version, and `[diagnostics] unresolved-member-access` to enable the new unresolved member access diagnostic. Run `phpantom --init` to generate a default config file with all options commented out. When the file is missing, all settings use their defaults. Parse errors are reported as a warning in the editor.
 - **Unresolved member access diagnostic (opt-in).** A new hint-level diagnostic flags `->`, `?->`, and `::` accesses where PHPantom cannot resolve the subject type at all. Off by default because most codebases lack full type coverage. Enable it by adding `unresolved-member-access = true` under `[diagnostics]` in `.phpantom.toml`. Useful for discovering gaps in type annotations or places where PHPantom's inference falls short.
 - **Rename.** `textDocument/rename` with `prepareRename` support. Rename variables, classes, methods, properties, functions, and constants across the entire workspace. Variable renames are scoped to the enclosing function or closure. Property renames handle the `$` prefix correctly at declaration vs. access sites. Symbols defined in vendor files are rejected. Non-renameable tokens (`$this`, `self`, `static`, `parent`) are rejected at the prepare step so the editor never opens the rename prompt.

docs/todo/bugs.md

@@ -138,20 +138,6 @@ error message.
 
 ---
 
-## 9. Enum case instance properties not shown in `->` completion
-**Impact: Medium · Effort: Low**
-
-After resolving an enum case, `->` completion does not show the `name`
-property (available on all enums) or the `value` property (available on
-backed enums). These are implicit instance properties defined by the
-`UnitEnum` and `BackedEnum` interfaces. The enum's own methods and
-trait methods appear, but these built-in properties are missing.
-
-**Discovered via:** fixture conversion (enum/backed_enum_case_members,
-enum/enum_case_members).
-
----
-
 ## 10. Mixed arrow then static accessor chaining not resolved
 **Impact: Low · Effort: Low**
 

docs/todo/testing.md

@@ -1,11 +1,11 @@
 # PHPantom — Ignored Fixture Tasks
 
-There are **228 fixture tests** in `tests/fixtures/`. Of these, **178
-pass** and **50 are ignored** because they exercise features or bug
+There are **228 fixture tests** in `tests/fixtures/`. Of these, **183
+pass** and **45 are ignored** because they exercise features or bug
 fixes that are not yet implemented. Each ignored fixture has a
 `// ignore:` comment explaining what is missing.
 
-This document groups the 50 ignored fixtures by the underlying work
+This document groups the 45 ignored fixtures by the underlying work
 needed to un-ignore them. Tasks are ordered by the number of fixtures
 they unblock (descending), then by estimated effort. Once a task is
 complete, remove the `// ignore:` line from each fixture, verify the
@@ -172,31 +172,6 @@ work without further changes.
 
 ---
 
-## 6. `@method` with `static`/`$this` return type on parent (2 fixtures)
-
-**Ref:** [type-inference.md §26](type-inference.md#26-method-with-static-or-this-return-type-on-parent-class)
-**Impact: Medium · Effort: Low-Medium**
-
-When a parent class declares `@method static foo()` or
-`@method $this bar()`, calling the method on a child class should
-return the child class type. Virtual method return types are not
-rewritten through the inheritance chain today.
-
-**Fixtures:**
-
-- [ ] `virtual_member/method_returns_static.fixture` — `@method static foo()` on parent, called on child
-- [ ] `virtual_member/method_returns_this.fixture` — `@method $this bar()` on parent, called on child
-
-**Implementation notes:**
-
-During inheritance merging, when copying virtual methods from a parent
-class, apply the same `static`/`$this`/`self` return type rewriting
-that already works for regular methods. Check `rewrite_self_static` in
-`inheritance.rs` and ensure it also processes `MethodInfo` entries that
-originated from `@method` tags.
-
----
-
 ## 7. Invoked closure/arrow function return type (2 fixtures)
 
 **Ref:** [type-inference.md §30](type-inference.md#30-invoked-closurearrow-function-return-type)
@@ -243,32 +218,6 @@ name is a variable, resolve the variable's type. If it is
 
 ---
 
-## 9. Enum case instance properties (2 fixtures)
-
-**Ref:** [bugs.md §9](bugs.md#9-enum-case-instance-properties-not-shown-in---completion)
-**Impact: Medium · Effort: Low**
-
-`->` completion on an enum case does not show the `name` property
-(available on all enums via `UnitEnum`) or the `value` property
-(available on backed enums via `BackedEnum`). The enum's own methods
-and trait methods appear, but these built-in properties are missing.
-
-**Fixtures:**
-
-- [ ] `enum/enum_case_members.fixture` — `$case->name` available on unit enum
-- [ ] `enum/backed_enum_case_members.fixture` — `$case->value` and `$case->name` on backed enum
-
-**Implementation notes:**
-
-During enum class resolution (or in the completion builder), inject
-synthetic `PropertyInfo` entries for `name` (type `string`, on all
-enums) and `value` (type matching the backing type, on backed enums).
-These are defined by the `UnitEnum` and `BackedEnum` interfaces in the
-stubs, so alternatively ensure that enum resolution inherits from those
-interfaces and their properties are included.
-
----
-
 ## 10. Mixed `->` then `::` accessor chaining (2 fixtures)
 
 **Ref:** [bugs.md §10](bugs.md#10-mixed-arrow-then-static-accessor-chaining-not-resolved)
@@ -307,20 +256,7 @@ merging.
 
 ---
 
-## 12. Sequential `assert()` calls do not accumulate (1 fixture)
-
-**Ref:** [type-inference.md §22](type-inference.md#22-sequential-assert-calls-do-not-accumulate)
-**Impact: Low-Medium · Effort: Low**
 
-Multiple `assert($x instanceof Foo); assert($x instanceof Bar);`
-statements should accumulate. Only the last assertion's narrowing
-applies today.
-
-**Fixture:**
-
-- [ ] `combination/intersect_interface_assert.fixture` — sequential assert narrows to both types
-
----
 
 ## 13. Compound negated guard clause narrowing (1 fixture)
 
@@ -504,14 +440,11 @@ Quick wins (Low effort, 1 fixture each):
 | Task | Fixture |
 |---|---|
 | §23 `@phpstan-type` in foreach | `type/phpstan_type_alias` |
-| §12 Sequential assert accumulation | `combination/intersect_interface_assert` |
 
 Moderate wins (Low-Medium effort, multiple fixtures):
 
 | Task | Fixtures |
 |---|---|
-| §6 `@method` static/`$this` rewriting | 2 |
-| §9 Enum case `name`/`value` properties | 2 |
 | §10 Mixed `->` then `::` chaining | 2 |
 
 Biggest unlocks (Medium effort, many fixtures):

docs/todo/type-inference.md

@@ -681,16 +681,7 @@ property_narrowing_negated, combination/property_instanceof).
 
 ---
 
-## 22. Sequential `assert()` calls do not accumulate
-**Impact: Low-Medium · Effort: Low**
-
-Multiple `assert($x instanceof Foo); assert($x instanceof Bar);`
-statements on the same variable should accumulate. Today only the
-last assertion's narrowing applies.
 
-**Discovered via:** fixture conversion (sequential_narrowing).
-
----
 
 ## 24. Literal string conditional return type
 **Impact: Low · Effort: Low-Medium**
@@ -716,18 +707,6 @@ inheritance merging.
 
 ---
 
-## 26. `@method` with `static` or `$this` return type on parent class
-**Impact: Medium · Effort: Low-Medium**
-
-When a parent class declares `@method static foo()` or
-`@method $this bar()`, calling the method on a child class should
-return the child class type. Today the virtual method's return type
-is not rewritten through the inheritance chain.
-
-**Discovered via:** fixture conversion (virtual_member/method_returns_static,
-virtual_member/method_returns_this).
-
----
 
 ## 27. `new $classStringVar` and `$classStringVar::staticMethod()`
 **Impact: Low-Medium · Effort: Medium**

example.php

@@ -1329,8 +1329,18 @@ public function demo(): void
 
         Status::Active;              // backed enum case
         Status::Active->label();     // enum method
+        Status::Active->name;        // "Active" (from UnitEnum)
+        Status::Active->value;       // "active" (from BackedEnum)
         Priority::High;              // int-backed enum
+        Priority::High->name;        // "High" (from UnitEnum)
+        Priority::High->value;       // 3 (from BackedEnum, int)
         Mode::Manual;                // unit enum
+        Mode::Manual->name;          // "Manual" (from UnitEnum)
+
+        // Enum case assigned to variable
+        $status = Status::Active;
+        $status->name;               // resolves through variable
+        $status->value;
     }
 }
 

src/completion/variable/resolution.rs

@@ -460,6 +460,18 @@ pub(in crate::completion) fn walk_statements_for_assignments<'b>(
     results: &mut Vec<ClassInfo>,
     conditional: bool,
 ) {
+    /// Return the sorted set of class names in `results`.
+    fn result_names(results: &[ClassInfo]) -> Vec<String> {
+        let mut names: Vec<String> = results.iter().map(|c| c.name.clone()).collect();
+        names.sort();
+        names
+    }
+
+    // Accumulator for sequential `assert($x instanceof ...)` calls.
+    // Each assert narrows to a single type; this vec collects them
+    // so that two asserts in a row produce a union (intersection type).
+    let mut assert_narrowed_types: Vec<ClassInfo> = Vec::new();
+
     for stmt in statements {
         // ── Closure / arrow-function scope ──
         // If the cursor falls *inside* this statement, check whether
@@ -485,6 +497,7 @@ pub(in crate::completion) fn walk_statements_for_assignments<'b>(
                 // If the docblock resolves successfully (and passes
                 // the same override check we apply to @return), use
                 // it and skip normal resolution for this statement.
+                let pre_assign_names = result_names(results);
                 if !try_inline_var_override(
                     expr_stmt.expression,
                     stmt.span().start.offset as usize,
@@ -499,16 +512,47 @@ pub(in crate::completion) fn walk_statements_for_assignments<'b>(
                         conditional,
                     );
                 }
+                // If an assignment (or @var override) changed the
+                // results, the variable was reassigned — any prior
+                // assert-narrowed types are no longer valid.
+                if result_names(results) != pre_assign_names {
+                    assert_narrowed_types.clear();
+                }
 
                 // ── assert($var instanceof ClassName) narrowing ──
                 // When `assert($var instanceof Foo)` appears before
                 // the cursor, narrow the variable to `Foo` for the
                 // remainder of the current scope.
+                //
+                // Sequential asserts accumulate an intersection type:
+                //   assert($x instanceof A);
+                //   assert($x instanceof B);
+                // → results contains members from both A and B.
+                //
+                // Save the pre-assert state so we can detect when
+                // the assert actually narrowed, and merge with any
+                // prior assert-narrowed types.
+                let pre_assert_names = result_names(results);
                 narrowing::try_apply_assert_instanceof_narrowing(
                     expr_stmt.expression,
                     ctx,
                     results,
                 );
+                let changed = result_names(results) != pre_assert_names;
+                // If the assert changed results AND we had prior
+                // assert-narrowed types, merge the old narrowed
+                // types back in (accumulate the intersection).
+                if changed && !assert_narrowed_types.is_empty() {
+                    for cls in &assert_narrowed_types {
+                        if !results.iter().any(|c| c.name == cls.name) {
+                            results.push(cls.clone());
+                        }
+                    }
+                }
+                // Track types that came from assert narrowing.
+                if changed {
+                    assert_narrowed_types.clone_from(results);
+                }
 
                 // ── @phpstan-assert / @psalm-assert narrowing ──
                 // When a function with `@phpstan-assert Type $param`

src/completion/variable/rhs_resolution.rs

@@ -536,6 +536,58 @@ fn resolve_rhs_property_access(access: &Access<'_>, ctx: &VarResolutionCtx<'_>)
     let all_classes = ctx.all_classes;
     let class_loader = ctx.class_loader;
 
+    // ── Class constant / enum case access: `Foo::BAR` ──
+    // When the RHS is a class constant access, resolve the class and
+    // check whether the constant is an enum case (→ type is the enum
+    // itself) or a typed constant (→ use its type_hint).
+    if let Access::ClassConstant(cca) = access {
+        let class_name = match cca.class {
+            Expression::Identifier(ident) => Some(ident.value().to_string()),
+            Expression::Self_(_) => Some(current_class_name.to_string()),
+            Expression::Static(_) => Some(current_class_name.to_string()),
+            _ => None,
+        };
+        if let Some(class_name) = class_name {
+            let resolved_name = crate::docblock::types::clean_type(&class_name);
+            let target_classes = crate::completion::type_resolution::type_hint_to_classes(
+                &resolved_name,
+                current_class_name,
+                all_classes,
+                class_loader,
+            );
+
+            let const_name = match &cca.constant {
+                ClassLikeConstantSelector::Identifier(ident) => Some(ident.value.to_string()),
+                _ => None,
+            };
+
+            if let Some(const_name) = const_name {
+                for cls in &target_classes {
+                    // Check if the constant is an enum case — the
+                    // result type is the enum class itself.
+                    if let Some(c) = cls.constants.iter().find(|c| c.name == const_name) {
+                        if c.is_enum_case {
+                            return target_classes;
+                        }
+                        // Typed class constant — resolve via type_hint.
+                        if let Some(ref th) = c.type_hint {
+                            let resolved = crate::completion::type_resolution::type_hint_to_classes(
+                                th,
+                                current_class_name,
+                                all_classes,
+                                class_loader,
+                            );
+                            if !resolved.is_empty() {
+                                return resolved;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return vec![];
+    }
+
     let (object_expr, prop_selector) = match access {
         Access::Property(pa) => (Some(pa.object), Some(&pa.property)),
         Access::NullSafeProperty(pa) => (Some(pa.object), Some(&pa.property)),