Apply instanceof narrowing inside ternary

Author: AJenbo

example.php

@@ -1130,6 +1130,52 @@ public function mixedTernaryAndMatch(bool $simple, int $mode): void {
     }
 }
 
+// ═══════════════════════════════════════════════════════════════════
+// 19b. instanceof narrowing in ternary expressions
+// ═══════════════════════════════════════════════════════════════════
+// When a ternary condition checks `$var instanceof ClassName`, the
+// variable is narrowed in the then-branch and excluded in the
+// else-branch — just like `if`/`else`.  Negated conditions flip
+// the polarity.  Nested ternaries are also supported.
+
+class TernaryInstanceofDemo
+{
+    public function thenBranch(Model $item): void
+    {
+        // ── Then-branch narrowing ──
+        // $item is narrowed to User inside the then-branch:
+        $name = $item instanceof User ? $item->getEmail() : 'unknown';
+        //                               ↑ shows User methods (getEmail, getStatus, etc.)
+    }
+
+    public function elseBranch(Model $item): void
+    {
+        // ── Else-branch exclusion ──
+        // When $item is NOT User in the else-branch, User is excluded:
+        /** @param User|AdminUser $item */
+        $x = $item instanceof User ? null : $item->grantPermission();
+        //                                   ↑ shows AdminUser methods only
+    }
+
+    public function negated(Model $item): void
+    {
+        // ── Negated condition ──
+        // `!$item instanceof User` excludes User in the then-branch:
+        /** @param User|AdminUser $item */
+        $x = !$item instanceof User ? $item->grantPermission() : null;
+        //                             ↑ shows AdminUser methods only
+    }
+
+    public function inAssignment(Model $item): void
+    {
+        // ── Inside assignment RHS ──
+        // Works when the ternary is the RHS of an assignment to a
+        // *different* variable:
+        $result = $item instanceof User ? $item->getEmail() : 'fallback';
+        //                                 ↑ shows User methods
+    }
+}
+
 // ═══════════════════════════════════════════════════════════════════════
 // §14  Property Chains on Non-$this Variables
 // ═══════════════════════════════════════════════════════════════════════
@@ -2264,9 +2310,13 @@ public function staticSnippets(): void
     public function newSnippets(): void
     {
         // `new` inserts class name + constructor params as snippet:
-        $u = new User($name, $email)          // Inserted: User(${1:$name}, ${2:$email}) — 2 required
+        $u = new User($name, $email);         // Inserted: User(${1:$name}, ${2:$email}) — 2 required
         $r = new Response($statusCode);       // Inserted: Response(${1:$statusCode})    — 1 required
         $a = new AdminUser($name, $email);    // Inserted: AdminUser(${1:$name}, ${2:$email}, ${3:$role})
+        // After `new`, only class names are suggested — no constants
+        // or functions.  Loaded interfaces, traits, enums, and abstract
+        // classes are excluded.  Unloaded names like AbstractHandler or
+        // LoggerInterface are demoted in the sort order.
     }
 
     public function parentConstructorSnippet(): void

src/completion/type_narrowing.rs

@@ -12,6 +12,7 @@
 ///   - `assert($var instanceof ClassName)` — unconditional narrowing
 ///   - `@phpstan-assert` / `@psalm-assert` — custom type guard functions
 ///   - `match(true) { $var instanceof Foo => … }` — match-arm narrowing
+///   - `$var instanceof Foo ? $var->method() : …` — ternary narrowing
 use mago_span::HasSpan;
 use mago_syntax::ast::*;
 
@@ -615,4 +616,104 @@ impl Backend {
             }
         }
     }
+
+    /// Apply `instanceof` narrowing inside ternary (`?:`) expressions.
+    ///
+    /// When the cursor falls inside a ternary whose condition is
+    /// `$var instanceof ClassName`:
+    ///   - **then-branch** → narrow to `ClassName`
+    ///   - **else-branch** → exclude `ClassName`
+    ///
+    /// Negated conditions (`!$var instanceof Foo ? … : …`) flip the
+    /// polarity, just like `if`/`else`.
+    ///
+    /// The function recursively walks the expression tree so that nested
+    /// ternaries and ternaries buried inside assignments, function
+    /// arguments, etc. are all handled.
+    pub(super) fn try_apply_ternary_instanceof_narrowing(
+        expr: &Expression<'_>,
+        ctx: &VarResolutionCtx<'_>,
+        results: &mut Vec<ClassInfo>,
+    ) {
+        match expr {
+            Expression::Conditional(cond_expr) => {
+                // Determine which branch (if any) the cursor is inside.
+                let in_then = cond_expr.then.is_some_and(|then_expr| {
+                    let span = then_expr.span();
+                    ctx.cursor_offset >= span.start.offset && ctx.cursor_offset <= span.end.offset
+                });
+                let in_else = {
+                    let span = cond_expr.r#else.span();
+                    ctx.cursor_offset >= span.start.offset && ctx.cursor_offset <= span.end.offset
+                };
+
+                if in_then {
+                    if let Some((cls_name, negated)) = Self::try_extract_instanceof_with_negation(
+                        cond_expr.condition,
+                        ctx.var_name,
+                    ) {
+                        if negated {
+                            Self::apply_instanceof_exclusion(&cls_name, ctx, results);
+                        } else {
+                            Self::apply_instanceof_inclusion(&cls_name, ctx, results);
+                        }
+                    }
+                } else if in_else
+                    && let Some((cls_name, negated)) = Self::try_extract_instanceof_with_negation(
+                        cond_expr.condition,
+                        ctx.var_name,
+                    )
+                {
+                    // Flip polarity for the else branch.
+                    if negated {
+                        Self::apply_instanceof_inclusion(&cls_name, ctx, results);
+                    } else {
+                        Self::apply_instanceof_exclusion(&cls_name, ctx, results);
+                    }
+                }
+
+                // Recurse into whichever branch contains the cursor so
+                // that nested ternaries are also narrowed.
+                if let Some(then_expr) = cond_expr.then {
+                    Self::try_apply_ternary_instanceof_narrowing(then_expr, ctx, results);
+                }
+                Self::try_apply_ternary_instanceof_narrowing(cond_expr.r#else, ctx, results);
+            }
+            // Recurse through common wrapper expressions so ternaries
+            // buried inside assignments, parentheses, binary ops, etc.
+            // are still discovered.
+            Expression::Parenthesized(inner) => {
+                Self::try_apply_ternary_instanceof_narrowing(inner.expression, ctx, results);
+            }
+            Expression::Assignment(assign) => {
+                Self::try_apply_ternary_instanceof_narrowing(assign.rhs, ctx, results);
+            }
+            Expression::Binary(bin) => {
+                Self::try_apply_ternary_instanceof_narrowing(bin.lhs, ctx, results);
+                Self::try_apply_ternary_instanceof_narrowing(bin.rhs, ctx, results);
+            }
+            Expression::UnaryPrefix(prefix) => {
+                Self::try_apply_ternary_instanceof_narrowing(prefix.operand, ctx, results);
+            }
+            Expression::UnaryPostfix(postfix) => {
+                Self::try_apply_ternary_instanceof_narrowing(postfix.operand, ctx, results);
+            }
+            Expression::Call(call) => {
+                let args = match call {
+                    Call::Function(fc) => &fc.argument_list.arguments,
+                    Call::Method(mc) => &mc.argument_list.arguments,
+                    Call::NullSafeMethod(mc) => &mc.argument_list.arguments,
+                    Call::StaticMethod(sc) => &sc.argument_list.arguments,
+                };
+                for arg in args.iter() {
+                    let arg_expr = match arg {
+                        Argument::Positional(pos) => pos.value,
+                        Argument::Named(named) => named.value,
+                    };
+                    Self::try_apply_ternary_instanceof_narrowing(arg_expr, ctx, results);
+                }
+            }
+            _ => {}
+        }
+    }
 }

src/completion/variable_resolution.rs

@@ -327,6 +327,16 @@ impl Backend {
 
                     // ── match(true) { $var instanceof Foo => … } narrowing ──
                     Self::try_apply_match_true_narrowing(expr_stmt.expression, ctx, results);
+
+                    // ── ternary instanceof narrowing ──
+                    // `$var instanceof Foo ? $var->method() : …`
+                    // When the cursor is inside a ternary whose condition
+                    // checks instanceof, narrow accordingly.
+                    Self::try_apply_ternary_instanceof_narrowing(
+                        expr_stmt.expression,
+                        ctx,
+                        results,
+                    );
                 }
                 // Recurse into blocks — these are just `{ … }` groupings,
                 // not conditional, so preserve the current `conditional` flag.