Fix 5 type narrowing cases thanks to PHPactor's tests

Author: AJenbo

docs/CHANGELOG.md

@@ -9,6 +9,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **Invoked closure and arrow function return types.** `(fn(): Foo => new Foo())()` and `(function(): Bar { return new Bar(); })()` now resolve to the return type of the closure or arrow function. Previously these patterns produced no completions.
+- **`new $classStringVar` and `$classStringVar::method()`.** When a variable holds a class-string value (e.g. `$f = Foo::class`), `new $f` resolves to `Foo` and `$f::staticMethod()` resolves through `Foo`'s static members.
+- **`iterator_to_array()` element type.** `iterator_to_array($iter)` now resolves the element type from the iterator's generic annotation, so `$items[0]->` offers the correct completions.
+- **Compound negated guard clause narrowing.** After `if (!$x instanceof A && !$x instanceof B) { return; }`, the surviving code narrows `$x` to `A|B`. Previously only single negated instanceof guard clauses were recognized.
 - **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.
 - **`@implements` generic resolution.** When a class declares `@implements SomeInterface<ConcreteType>`, template parameters on the interface's methods and properties are now substituted with the concrete types. Works with `@template-implements` and `@phpstan-implements` aliases, multiple `@implements` annotations on the same class, parameter type substitution (not just return types), and chained resolution through parent classes (e.g. `Test2 extends Test1<int>` where `Test1` has `@implements Iterator<TKey, string>`). Foreach iteration over classes implementing generic iterable interfaces (including through intermediate interface chains like `TypedCollection extends IteratorAggregate`) now resolves value and key types correctly.
 - **`@phpstan-assert` on static methods.** Type guard annotations (`@phpstan-assert`, `@phpstan-assert-if-true`, `@phpstan-assert-if-false`) now work on static method calls like `Assert::instanceOf($value, Foo::class)`. Previously only standalone function calls triggered assertion-based narrowing.
@@ -23,6 +27,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **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.
+- **Arrow function parameter completion with incomplete expressions.** Typing `$foo->` inside an arrow function body (e.g. `fn(Foo $foo) => $foo->`) now resolves the parameter type even when the expression is incomplete. The parser recovery inserts a dummy token so the surrounding arrow function structure is recognized.
 
 
 - **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.

docs/todo/completion.md

@@ -42,7 +42,6 @@ These functions have return type semantics that don't fit into either
 | `array_count_values` | Returns `array<TValue, int>` | `ArrayCountValuesDynamicReturnTypeExtension` |
 | `array_key_first` / `array_key_last` | Returns key type (usually scalar, low completion value) | `ArrayFirstLastDynamicReturnTypeExtension` |
 | `array_find_key` | Returns key type (PHP 8.4) | `ArrayFindKeyFunctionReturnTypeExtension` |
-| `iterator_to_array` | Preserves iterable key/value types into array | `IteratorToArrayFunctionReturnTypeExtension` |
 | `compact` | Builds typed array from variable names | `CompactFunctionReturnTypeExtension` |
 | `count` / `sizeof` | Returns precise int range based on array size | `CountFunctionReturnTypeExtension` |
 | `min` / `max` | Returns union of argument types | `MinMaxFunctionReturnTypeExtension` |

docs/todo/testing.md

@@ -1,11 +1,11 @@
 # PHPantom — Ignored Fixture Tasks
 
-There are **228 fixture tests** in `tests/fixtures/`. Of these, **207
-pass** and **21 are ignored** because they exercise features or bug
+There are **228 fixture tests** in `tests/fixtures/`. Of these, **214
+pass** and **14 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 21 ignored fixtures by the underlying work
+This document groups the 14 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
@@ -78,52 +78,6 @@ work without further changes.
 
 ---
 
-## 7. Invoked closure/arrow function return type (2 fixtures)
-
-**Ref:** [type-inference.md §30](type-inference.md#30-invoked-closurearrow-function-return-type)
-**Impact: Low · Effort: Low-Medium**
-
-Immediately invoked closures and arrow functions do not resolve their
-return type. `(fn(): Foo => new Foo())()` and similar patterns produce
-`mixed`.
-
-**Fixtures:**
-
-- [ ] `call_expression/arrow_fn_invocation.fixture` — `(fn() => new Foo())()->` resolves
-- [ ] `arrow_function/parameter_type.fixture` — arrow function parameter type for completion inside body
-
-**Implementation notes:**
-
-In the call expression resolution path, detect when the callee is a
-parenthesized closure or arrow function expression. Extract the return
-type from its signature or body. For `arrow_function/parameter_type`,
-the arrow function parameter's type hint should be resolved the same
-way closure parameters are (likely in `variable/closure_resolution.rs`).
-
----
-
-## 8. `new $classStringVar` / `$classStringVar::staticMethod()` (2 fixtures)
-
-**Ref:** [type-inference.md §27](type-inference.md#27-new-classstringvar-and-classstringvarstaticmethod)
-**Impact: Low-Medium · Effort: Medium**
-
-When a variable holds a `class-string<Foo>`, `new $var` should resolve
-to `Foo` and `$var::staticMethod()` should resolve through `Foo`'s
-static methods.
-
-**Fixtures:**
-
-- [ ] `type/class_string_new.fixture` — `new $classStringVar` resolves to the class type
-- [ ] `type/class_string_static_call.fixture` — `$classStringVar::staticMethod()` resolves return type
-
-**Implementation notes:**
-
-In the object creation and static call resolution paths, when the class
-name is a variable, resolve the variable's type. If it is
-`class-string<T>`, extract `T` and use it as the class name.
-
----
-
 ## 11. `class-string<T>` on interface method not inherited (1 fixture)
 
 **Ref:** [type-inference.md §25](type-inference.md#25-class-stringt-on-interface-method-not-inherited)
@@ -139,38 +93,6 @@ merging.
 
 ---
 
-
-
-## 13. Compound negated guard clause narrowing (1 fixture)
-
-**Ref:** [type-inference.md §23](type-inference.md#23-double-negated-instanceof-narrowing) (related)
-**Impact: Low · Effort: Low-Medium**
-
-After `if (!$x instanceof A && !$x instanceof B) { return; }`, the
-surviving code should know that `$x` is `A|B`. This requires the
-narrowing engine to invert compound negated conditions across guard
-clauses.
-
-**Fixture:**
-
-- [ ] `completion/parenthesized_narrowing.fixture` — compound negated instanceof with guard clause narrows to union
-
----
-
-## 15. Negated `@phpstan-assert !Type` (1 fixture)
-
-**Ref:** [type-inference.md §19](type-inference.md#19-negated-phpstan-assert-type)
-**Impact: Medium · Effort: Low-Medium**
-
-`@phpstan-assert !Foo $param` should remove `Foo` from the variable's
-union type. The `!` prefix is not parsed today.
-
-**Fixture:**
-
-- [ ] `narrowing/phpstan_assert_negated.fixture` — negated assert removes type from union
-
----
-
 ## 16. Generic `@phpstan-assert` with `class-string<T>` (1 fixture)
 
 **Ref:** [type-inference.md §20](type-inference.md#20-generic-phpstan-assert-with-class-stringt-parameter-inference)
@@ -203,21 +125,6 @@ narrowing propagation issue rather than `is_*()` parsing.
 
 ---
 
-## 21. `iterator_to_array()` return type (1 fixture)
-
-**Ref:** [completion.md §1](completion.md#1-array-functions-needing-new-code-paths)
-**Impact: Medium · Effort: Medium**
-
-`iterator_to_array()` should return the iterator's value type as an
-array element type. This needs a special code path similar to the
-existing `array_pop`/`array_shift` handling.
-
-**Fixture:**
-
-- [ ] `function/iterator_to_array.fixture` — `iterator_to_array($gen)` resolves element type
-
----
-
 ## 24. Variable scope isolation in closures (1 fixture)
 
 **Impact: Low · Effort: Low-Medium**
@@ -281,6 +188,14 @@ Moderate wins (Low-Medium effort, few fixtures):
 | §25 Pass-by-reference parameter type inference | 1 |
 | §26 Pipe operator (PHP 8.5) | 1 |
 
+Medium effort, single fixture:
+
+| Task | Fixtures |
+|---|---|
+| §11 `class-string<T>` on interface method | 1 |
+| §16 Generic `@phpstan-assert` with `class-string<T>` | 1 |
+| §20 Elseif chain narrowing with `is_*()` | 1 |
+
 Biggest unlocks (Medium effort, many fixtures):
 
 | Task | Fixtures |

docs/todo/type-inference.md

@@ -483,19 +483,6 @@ type:
 
 ---
 
-
-## 19. Negated `@phpstan-assert !Type`
-**Impact: Medium · Effort: Low-Medium**
-
-When a function declares `@phpstan-assert !Foo $param`, calling it
-should remove `Foo` from the variable's union type. Today the negation
-prefix is not parsed, so the assertion is either ignored or
-misinterpreted as a positive assertion.
-
-**Discovered via:** fixture conversion (phpstan_assert_negated).
-
----
-
 ## 20. Generic `@phpstan-assert` with `class-string<T>` parameter inference
 **Impact: Medium · Effort: Medium-High**
 
@@ -545,19 +532,6 @@ inheritance merging.
 
 ---
 
-
-## 27. `new $classStringVar` and `$classStringVar::staticMethod()`
-**Impact: Low-Medium · Effort: Medium**
-
-When a variable holds a `class-string<T>`, `new $var` should resolve
-to `T` and `$var::staticMethod()` should resolve through `T`'s static
-methods. Neither path is supported today.
-
-**Discovered via:** fixture conversion (type/class_string_new,
-type/class_string_static_call).
-
----
-
 ## 28. `__invoke()` return type resolution
 **Impact: Low-Medium · Effort: Low**
 
@@ -570,24 +544,6 @@ an object type.
 
 ---
 
-## 30. Invoked closure/arrow function return type
-**Impact: Low · Effort: Low-Medium**
-
-Immediately invoked closures and arrow functions do not resolve their
-return type:
-
-```php
-$result = (fn(): Foo => new Foo())();
-$result->method(); // unresolved
-```
-
-The call expression resolution does not detect that the callee is a
-parenthesized closure/arrow function expression.
-
-**Discovered via:** fixture conversion (call_expression/arrow_fn_invocation).
-
----
-
 ## 31. Resolved-class cache: key by FQN + generic args (done)
 **Impact: High · Effort: Medium**
 

example.php

@@ -728,6 +728,65 @@ public function demo(): void
         // Variable assigned from callable invocation
         $fromClosure = $makePen();
         $fromClosure->write();                    // $result = $fn() resolves return type
+
+        // Immediately invoked arrow function with return type
+        $result = (fn(): Pen => new Pen())();
+        $result->write();                         // resolves Pen from arrow fn return type
+
+        // Immediately invoked closure with return type
+        $obj = (function(): Pencil { return new Pencil(); })();
+        $obj->sketch();                           // resolves Pencil from closure return type
+    }
+}
+
+
+// ── class-string Variable Resolution ────────────────────────────────────────
+
+class ClassStringVarDemo
+{
+    public function demo(): void
+    {
+        // new $var where $var holds a class-string
+        $cls = Pen::class;
+        $pen = new $cls;
+        $pen->write();                            // resolves Pen from class-string
+
+        // $var::staticMethod() where $var holds a class-string
+        $userClass = User::class;
+        $found = $userClass::findByEmail('test@example.com');
+        $found->getEmail();                       // resolves User from class-string static call
+    }
+}
+
+
+// ── iterator_to_array Resolution ────────────────────────────────────────────
+
+class IteratorToArrayDemo
+{
+    public function demo(): void
+    {
+        /** @var \Iterator<int, Pen> $iter */
+        $iter = getUnknownValue();
+
+        $items = iterator_to_array($iter);
+        $items[0]->write();                       // resolves Pen from iterator value type
+    }
+}
+
+
+// ── Compound Negated Guard Clause Narrowing ─────────────────────────────────
+
+class CompoundNegatedNarrowingDemo
+{
+    /** @param Rock|Banana|Lamp $thing */
+    public function demo($thing): void
+    {
+        // After both negated instanceof checks exit, $thing is Rock|Banana
+        if (!$thing instanceof Rock && !$thing instanceof Banana) {
+            return;
+        }
+
+        $thing->weigh();                          // both Rock and Banana have weigh()
     }
 }
 

src/completion/handler.rs

@@ -731,11 +731,45 @@ impl Backend {
                         resolved_class_cache: Some(&self.resolved_class_cache),
                         function_loader: Some(&function_loader),
                     };
-                    super::resolver::resolve_target_classes(
+                    let mut resolved = super::resolver::resolve_target_classes(
                         &target.subject,
                         target.access_kind,
                         &rctx,
-                    )
+                    );
+
+                    // ── Incomplete-expression retry ─────────────────
+                    // When the cursor sits right after `->` (or `?->`)
+                    // at the end of an expression with no trailing
+                    // semicolon (e.g. inside an arrow function body the
+                    // user is still typing), the PHP parser may fail to
+                    // produce the enclosing statement.  Patch the
+                    // content by appending a dummy identifier +
+                    // semicolon so the parser can recover.
+                    if resolved.is_empty() && target.subject.starts_with('$') {
+                        let patched = Self::patch_incomplete_member_access(content, position);
+                        if patched != content {
+                            let patched_classes = self.parse_php(&patched);
+                            let patched_offset = position_to_offset(&patched, position);
+                            let patched_current =
+                                find_class_at_offset(&patched_classes, patched_offset);
+                            let patched_rctx = ResolutionCtx {
+                                current_class: patched_current,
+                                all_classes: &patched_classes,
+                                content: &patched,
+                                cursor_offset: patched_offset,
+                                class_loader: &class_loader,
+                                resolved_class_cache: Some(&self.resolved_class_cache),
+                                function_loader: Some(&function_loader),
+                            };
+                            resolved = super::resolver::resolve_target_classes(
+                                &target.subject,
+                                target.access_kind,
+                                &patched_rctx,
+                            );
+                        }
+                    }
+
+                    resolved
                 };
                 if candidates.is_empty() {
                     return vec![];
@@ -1056,6 +1090,49 @@ impl Backend {
     /// (e.g. `$this->greet(|` where the closing `)` hasn't been typed
     /// yet).  Closing the call expression lets the parser recover the
     /// surrounding class/function structure.
+    /// Patch incomplete member-access expressions for parser recovery.
+    ///
+    /// When the cursor is right after `->` or `?->` and the line has no
+    /// semicolon, the PHP parser may fail to recognise the enclosing
+    /// statement (e.g. an arrow function body).  This inserts a dummy
+    /// identifier and semicolon (`_x;`) at the cursor so the parser can
+    /// recover the surrounding structure.
+    fn patch_incomplete_member_access(content: &str, position: Position) -> String {
+        let line_idx = position.line as usize;
+        let col = position.character as usize;
+        let mut result = String::with_capacity(content.len() + 4);
+
+        for (i, line) in content.lines().enumerate() {
+            if i == line_idx {
+                let byte_col = line
+                    .char_indices()
+                    .nth(col)
+                    .map(|(idx, _)| idx)
+                    .unwrap_or(line.len());
+                // Only patch when the cursor is right after `->` or
+                // `?->` with nothing meaningful following it.
+                let before = &line[..byte_col];
+                let after = line[byte_col..].trim();
+                if (before.ends_with("->") || before.ends_with("?->")) && after.is_empty() {
+                    result.push_str(before);
+                    result.push_str("_x;");
+                    result.push_str(&line[byte_col..]);
+                } else {
+                    result.push_str(line);
+                }
+            } else {
+                result.push_str(line);
+            }
+            result.push('\n');
+        }
+
+        if !content.ends_with('\n') && result.ends_with('\n') {
+            result.pop();
+        }
+
+        result
+    }
+
     fn patch_content_at_cursor(content: &str, position: Position) -> String {
         let line_idx = position.line as usize;
         let col = position.character as usize;