Argument checking no longer slows down quadratically with file size

Author: AJenbo

docs/CHANGELOG.md

@@ -57,13 +57,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Class origin classification no longer re-scans the whole classmap after the fact.** Startup used to look up each discovered class's completion-ranking origin (project, explicit dependency, transitive dependency, core stub) by re-reading and re-parsing `installed.json` a second time and prefix-matching every class's file path against the package list on a single thread. The origin is now attached to a class the moment it is discovered during the already-parallel vendor scan, the same way it already worked for functions and constants, removing both the duplicate parse and the serial pass.
 - **Faster `assert()`/type-guard narrowing during the forward walk.** Every statement used to build a fresh resolution context (including a scope clone) for each in-scope variable to check whether it was an `assert()` or `@phpstan-assert`/`@psalm-assert` call, even for statements that could never be one. Non-call statements now skip that work entirely, cutting a measurable share of the walk on methods with many locals and many statements.
 - **Faster diagnostics on method/function calls that resolve to no concrete class.** Checking whether such a call's result was actually a bare `object`/`?object` (still valid for member access) used to re-resolve the callee's whole receiver chain and method signature a second time from scratch. That check now reuses the resolution already performed, roughly halving diagnostics time on files with many unresolved or missing-method call chains.
+- **Argument checking no longer slows down quadratically with file size.** The argument-count and argument-type checks know the byte offset of every call they inspect, but used to convert it into an editor line/column position and immediately back again before looking up the called function. Each of those conversions re-read the file from the beginning to count characters, so the cost of checking one call grew with the size of the file around it and a file with thousands of calls spent nearly all its time on offset arithmetic. The offset is now used directly. On a 370 KB file containing 2200 calls the two checks together drop from 13.7 seconds to 0.2, taking the whole file from 16.7 seconds to 3.4, and analysing the project it belongs to is close to three times faster.
 
 ### Removed
 
 - **Bundled Zed extension.** PHPantom's plain-PHP wiring has merged into Zed's official PHP extension, so a separate PHPantom extension is no longer needed. See [Editor Setup](editor-setup.md) for the updated Zed configuration.
 
 ### Fixed
 
+- **Parameter-name inlay hints in Blade templates are no longer filtered against the wrong positions.** Deciding which hints fall inside the visible part of the file compared each argument's position in the compiled PHP against a viewport still measured in Blade coordinates, so hints could go missing or appear for arguments that were scrolled out of view. The already-translated viewport is now used.
 - **`static`/`$this` return types are no longer flagged when passed where a `Stringable` object is accepted.** Passing a value typed `static(Foo)` or `$this(Foo)` to a `string` parameter reported a type mismatch even when `Foo` implements `Stringable`, which PHP accepts by calling `__toString()`. This hit any use of `SimpleXMLElement`, whose magic `__get` returns `static`, so code like `(string) $xml->Body->Message` reported a false positive on every argument passed to a `string` parameter.
 - **Inline `{@see}` references nested inside other docblock text are now found.** An inline `{@see Foo}` written in the description of another tag (`@param Type $x see {@see Foo}`), or nested inside another inline tag (`{@deprecated use {@see Bar} instead}`), was invisible to go-to-definition, find references, and rename: the previous scan located a reference by searching for the next `}` after `{@see `, which stopped at the first brace it met rather than the one that actually closed the tag. Inline `{@see}` references are now read from the same PHPDoc parse tree as everything else in the docblock.
 - **Docblock navigation works in `@method` and `@property` tags written across several lines.** A tag whose type wrapped onto a continuation line, such as a `@method Collection<int, Item> fetchAll(Filter $filter)` broken after the `<`, only ever had its first line read. Everything after it was invisible: go-to-definition, find references, and rename did nothing on the method or property name, on the type arguments, or on the parameter types, and the truncated first line was reported as a class named `Collection<` that resolved to nothing. Docblock positions now come from the PHPDoc grammar itself, so every name in such a tag is navigable wherever it sits.

docs/todo.md

@@ -108,6 +108,8 @@ unlikely to move the needle for most users.
 | D5  | [External tool diagnostic suppression actions](todo/diagnostics.md#d5-external-tool-diagnostic-suppression-actions)                                                         | Low         | Low         |
 | D15 | [Unused parameter diagnostic](todo/diagnostics.md#d15-unused-parameter-diagnostic)                                                                                          | Low         | Low         |
 |     | **[Bug Fixes](todo/bugs.md)**                                                                                                                                               |             |             |
+| B117 | [Per-file callable-target caches are keyed by call-expression text alone](todo/bugs.md#b117-per-file-callable-target-caches-are-keyed-by-call-expression-text-alone)         | Medium      | Low-Medium  |
+| B118 | [`analyze` on `examples/laravel` reports one error, but CI requires none](todo/bugs.md#b118-phpantom_lsp-analyze-on-exampleslaravel-reports-one-error-but-ci-requires-none)  | Low         | Low         |
 |     | **[Code Actions](todo/actions.md)**                                                                                                                                         |             |             |
 | A40 | [Generate method from call](todo/actions.md#a40-generate-method-from-call)                                                                                                  | Medium-High | Medium      |
 | A41 | [Create class from non-existing name](todo/actions.md#a41-create-class-from-non-existing-name)                                                                              | Medium      | Medium      |
@@ -199,7 +201,6 @@ unlikely to move the needle for most users.
 | P30 | [Evaluate migrating parse/resolve/docblock pipeline to `mago-hir`](todo/performance.md#p30-evaluate-migrating-parseresolvedocblock-pipeline-to-mago-hir) (parked — re-evaluated at mago 1.45.0, still no `mago-hir` consumers upstream) | Medium-High | High        |
 | P47 | [The resolved-class cache lock caps concurrent class resolution](todo/performance.md#p47-the-resolved-class-cache-lock-caps-concurrent-class-resolution)                     | Medium      | Medium-High |
 | P16 | [Pre-parsed stub format (eliminate raw PHP embedding)](todo/performance.md#p16-pre-parsed-stub-format-eliminate-raw-php-embedding)                                          | High        | Medium-High |
-| P25 | [`type_mismatch_argument` / `argument_count_mismatch` slow on large single files](todo/performance.md#p25-type_mismatch_argument-argument_count_mismatch-slow-on-large-single-files) | Medium      | Medium      |
 | P22 | [Signature change re-queues slow diagnostics for every open file](todo/performance.md#p22-signature-change-re-queues-slow-diagnostics-for-every-open-file)                  | Medium-High | Medium      |
 | P11 | [Uncached base-resolution in `build_scope_methods_for_builder`](todo/performance.md#p11-uncached-base-resolution-in-build_scope_methods_for_builder)                        | Low-Medium  | Low         |
 | P3  | Parallel pre-filter in `find_implementors`                                                                                                                                  | Low-Medium  | Medium      |

docs/todo/bugs.md

@@ -7,4 +7,58 @@ pipeline so it produces correct data. Downstream consumers
 (diagnostics, hover, completion, definition) should never need
 to second-guess upstream output.
 
-No outstanding items.
+## B117. Per-file callable-target caches are keyed by call-expression text alone
+
+**Impact: Medium · Effort: Low-Medium**
+
+Both argument diagnostic passes memoize `resolve_callable_target`
+in a per-file `HashMap<String, Option<ResolvedCallableTarget>>`
+keyed only on the call expression, then resolve the entry using
+whichever call site happened to be reached first. Callable-target
+resolution is position-dependent (it picks the enclosing class via
+`find_class_at_offset` and resolves receiver variables against the
+scope at the cursor), so any expression whose meaning varies within
+the file gets the wrong target at every site after the first:
+
+- `argument_count.rs` caches *every* expression, including
+  variable-based calls. Two methods that both call
+  `$parser->parse(…)` on different types share one cached
+  signature, so the argument count is checked against the wrong
+  method.
+- `type_errors/mod.rs` deliberately skips variable-based calls
+  (`expr.starts_with('$')`), but `self::`, `static::`, and
+  `parent::` do not start with `$` and are equally
+  position-dependent. In a file declaring two classes that each
+  have a zero-argument `self::make()`, the second class resolves
+  to the first class's method.
+
+Both are latent today because the wrong target usually has a
+compatible signature, and a wrong resolution can produce either a
+false positive or a silently missed diagnostic.
+
+The cache key must cover what resolution actually depends on.
+Restricting the cache to position-independent expressions (plain
+function calls and `Fqn::method` where the class part is not
+`self`/`static`/`parent`) is the smallest sound fix; keying on
+`(expr, enclosing_class_start_offset)` keeps more hits for the
+keyword forms. Note that per-site resolution is no longer
+expensive now that the offset round trip is gone, so dropping the
+unsound entries costs little.
+
+---
+
+## B118. `phpantom_lsp analyze` on `examples/laravel` reports one error, but CI requires none
+
+**Impact: Low · Effort: Low**
+
+`docs/CONTRIBUTING.md` lists
+`phpantom_lsp analyze --project-root examples/laravel --no-colour`
+as a required check and states it "must report `[OK] No errors`",
+but `examples/laravel/app/Demo.php` intentionally contains
+`Artisan::call('does:not-exist')` to demonstrate the
+`invalid_laravel_command` diagnostic, so the command reports
+`Found 1 error`. Either the demo needs a form that shows the
+diagnostic without failing the check (the way `examples/demo.php`
+keeps its intentional diagnostics out of the analyze gate), or the
+documented expectation needs to name the diagnostics the Laravel
+example is expected to produce.

docs/todo/performance.md

@@ -592,42 +592,6 @@ regardless since it is a few lines.
 
 ---
 
-## P25. `type_mismatch_argument` / `argument_count_mismatch` slow on large single files
-
-**Impact: Medium · Effort: Medium**
-
-On very large PHP files with thousands of call sites, the
-`type_mismatch_argument` and `argument_count_mismatch` diagnostic
-passes dominate the per-file time. On PDepend's
-`src/Source/Language/PHP/AbstractPHPParser.php` a single file spent
-~11.7s in `type_mismatch_argument` and ~2.9s in
-`argument_count_mismatch`:
-
-```
-⚠ slow file (15.6s): src/Source/Language/PHP/AbstractPHPParser.php
-  scope=1.9s, fast=0.0s, unknown_class=0.0s, unknown_member=0.1s,
-  unknown_function=0.0s, argument_count_mismatch=2.9s,
-  type_mismatch_argument=11.6s, deprecated_usage=0.1s,
-  unknown_variable=0.8s, invalid_class_kind=0.0s
-```
-
-Both passes walk every call site and call
-`resolve_callable_target_with_args` / `resolve_callable_target`
-per site. Variable-based calls and calls with argument text are
-resolved fresh at every site (only zero-arg static/function calls
-are cached), so a file with thousands of `$obj->method($args)`
-call sites re-resolves the receiver type once per site. Look at
-memoizing receiver-type resolution per (expression, offset) within
-a file, or sharing the forward-walk scope snapshot across both
-passes so the receiver type is computed once.
-
-A per-request callable-target cache now memoizes the
-class::method → target lookup, but it sits downstream of
-receiver-type resolution — the per-site receiver re-resolution
-this item describes is still unaddressed.
-
----
-
 ## P46. `mago-phpdoc-syntax` cannot parse `@method static (…) name()`
 
 **Impact: Low · Effort: Low (upstream)**

src/diagnostics/argument_count.rs

@@ -264,11 +264,12 @@ impl Backend {
             let resolved = call_cache
                 .entry(expr.clone())
                 .or_insert_with(|| {
-                    let position = crate::text_position::offset_to_position(
+                    self.resolve_callable_target_at_offset(
+                        expr,
                         content,
-                        call_site.args_start as usize,
-                    );
-                    self.resolve_callable_target(expr, content, position, &file_ctx)
+                        call_site.args_start,
+                        &file_ctx,
+                    )
                 })
                 .clone();
 

src/diagnostics/type_errors/mod.rs

@@ -543,26 +543,23 @@ impl Backend {
             // (method-level template subs depend on per-site args);
             // only zero-arg calls can be cached.
             let resolved = if is_variable_call || call_args_text.is_some() {
-                let position = crate::text_position::offset_to_position(
-                    content,
-                    call_site.args_start as usize,
-                );
-                self.resolve_callable_target_with_args(
+                self.resolve_callable_target_with_args_at_offset(
                     expr,
                     content,
-                    position,
+                    call_site.args_start,
                     &file_ctx,
                     call_args_text,
                 )
             } else {
                 call_cache
                     .entry(expr.clone())
                     .or_insert_with(|| {
-                        let position = crate::text_position::offset_to_position(
+                        self.resolve_callable_target_at_offset(
+                            expr,
                             content,
-                            call_site.args_start as usize,
-                        );
-                        self.resolve_callable_target(expr, content, position, &file_ctx)
+                            call_site.args_start,
+                            &file_ctx,
+                        )
                     })
                     .clone()
             };

src/inlay_hints.rs

@@ -82,7 +82,13 @@ impl Backend {
                 continue;
             }
 
-            self.emit_parameter_hints(call_site, content, range, &ctx, &mut hints);
+            self.emit_parameter_hints(
+                call_site,
+                content,
+                (range_start, range_end),
+                &ctx,
+                &mut hints,
+            );
         }
 
         // ── Closure / arrow function hints ──────────────────────────
@@ -408,22 +414,23 @@ impl Backend {
     }
 
     /// Emit parameter-name and by-reference hints for a single call site.
+    ///
+    /// `range` is the requested viewport as byte offsets, already
+    /// translated to virtual PHP coordinates by the caller so it can be
+    /// compared against the symbol map's argument offsets.
     fn emit_parameter_hints(
         &self,
         call_site: &CallSite,
         content: &str,
-        range: Range,
+        range: (u32, u32),
         ctx: &FileContext,
         hints: &mut Vec<InlayHint>,
     ) {
-        // Build a synthetic position from the call site's start so that
-        // resolve_callable_target has a cursor context.
-        let position = offset_to_position(content, call_site.args_start as usize);
-
-        let resolved = match self.resolve_callable_target(
+        // The call site's start offset gives the resolver its cursor context.
+        let resolved = match self.resolve_callable_target_at_offset(
             &call_site.call_expression,
             content,
-            position,
+            call_site.args_start,
             ctx,
         ) {
             Some(r) => r,
@@ -435,8 +442,7 @@ impl Backend {
             return;
         }
 
-        let range_start = position_to_offset(content, range.start);
-        let range_end = position_to_offset(content, range.end);
+        let (range_start, range_end) = range;
 
         // Build a set of parameter names consumed by named arguments so
         // positional arguments can be mapped to the remaining parameters.
@@ -616,11 +622,10 @@ impl Backend {
             // @template parameters are inferred from the sibling arguments
             // and substituted into parameter type hints (e.g. turning
             // `callable(T): T` into `callable(int): int`).
-            let position = offset_to_position(content, representative_offset.unwrap_or(0) as usize);
-            let resolved = match self.resolve_callable_target_with_args(
+            let resolved = match self.resolve_callable_target_with_args_at_offset(
                 &site.parent_call_expression,
                 content,
-                position,
+                representative_offset.unwrap_or(0),
                 ctx,
                 call_args_text,
             ) {