phpantom_lsp

Highlights

New command-line tools

• phpantom_lsp format formats a whole project's PHP and Blade files with the same formatter your editor uses. --check makes it a CI gate.
• phpantom_lsp move moves a class or a whole namespace. It updates declarations, imports, references, and PSR-4 paths, and lists any leftover mentions it couldn't rewrite. (@calebdw)
• analyze accepts multiple paths, so a pre-commit hook can pass only the files that changed.
• phpantom_lsp init is interactive. It asks about the settings people change most often and writes a .phpantom.toml with only what you changed.

New editor features

• Call hierarchy. See who calls a function or method, and what it calls. (@sidux)
• Reference and implementation CodeLens. Clickable counts above declarations open the references or implementations list. (@sidux)
• Convert qualified names to imports, for one name or for a whole namespace at once, with aliases added automatically when names collide. (@calebdw)
• Navigate to PHP classes from YAML and XML files. Ctrl+Click a class name or Class::member in config files to open it. (@sidux)
• PHPUnit data providers and @depends are navigable. Renaming a provider method also updates the attributes and annotations that point to it.
• PHPMD integration. Mess Detector findings appear in the editor using your project's existing config.

Blade

• Blade templates can be formatted. Optionally the PHP inside them is formatted too, and Pint is used if your project relies on it.
• Document outline and folding for .blade.php files.
• Custom directives registered with Blade::directive() / Blade::if() are recognised.
• "Create missing view" quick fix.
• Diagnostics for unbalanced component tags.
• Named slots are scoped correctly, and anonymous components without @props get attribute completion.

Laravel

• builder-of, collection-of, factory-of, and relation-of PHPDoc types resolve to the model's real Eloquent classes, including custom builders and dotted relation paths. They also work inside Closure(…) parameter types. (@calebdw)
• view-string parameters complete template names and report unknown views. (@calebdw)
• Storage disks and other configured service names (log channels, cache stores, auth guards, and more) get completion, hover, go-to-definition, references, and typo diagnostics. (@shuvroroy)
• UUID/ULID primary keys are typed as string. (@shuvroroy)
• Custom pivot accessors (->as('participation')) are understood. (@shuvroroy, #381)

Configuration and indexing

• Exclude paths and add PHP file extensions with [indexing] in .phpantom.toml, for example Drupal's .module and .inc. (@syntlyx)
• VS Code and Cursor users get this automatically from files.exclude and files.associations, and changes apply without a restart.
• Symlinked directories are indexed with the rest of the project. (@liudashuang, #383)
• Nullable-only argument mismatches can be downgraded to warnings. (@iz-ahmad)

Performance

• Find References and the reference CodeLens are much faster on large projects. Searches run in parallel, skip files that can't match, and reuse earlier results. Opening a large Laravel controller went from about 13 s of background work to well under a second on repeat visits.
• Hover and completion no longer slow down in long functions with many local variables (4.3 s → 0.8 s on one test file).
• Analysis of very large files is faster (2.1 s → 0.7 s on php-parser's generated parser).
• Editing a file and searching for workspace symbols do much less work.

Other

• New semantic-export library feature for headless tools that need declarations, references, and diagnostics without running an LSP. (@aaaaaandrew)
• Bundled mago toolchain updated to 1.47.5. (@nguyentranchung)
• Extract interface is only offered in editors that can cre

What's Changed

Added

Whole-project analysis

• Full workspace indexing. PHPantom now parses every PHP file in your project in the background after startup by default, building complete symbol data and a cross-file reference index. Find References, Rename, Go to Implementation, and Type Hierarchy resolve against the whole project instead of only the files you have opened, and scan only the files known to reference the symbol. Lighter modes remain available for projects that prefer a smaller footprint. Contributed by @sidux in https://github.com/PHPantom-dev/phpantom_lsp/pull/186.
• Workspace-wide diagnostics. Problems can now be surfaced across the whole project rather than only in open files. Set workspace = true under [diagnostics] in .phpantom.toml and, once startup and the background index finish, diagnostics run over every file and stream into the editor's problems panel as they are found, so issues in files you have not opened are already visible when you navigate to them. Configured external tools (PHPStan, PHPCS, Mago) also run once over the whole project afterwards. Both passes are deferred until after startup so they never slow down the time it takes the editor to become usable. It is off by default: a project-wide sweep is real work on every session, and it is worth asking for rather than paying for unasked.

Blade templates

• A Blade template's variables come from a declared priority chain. What a template has in scope is now resolved rather than guessed at. A @bladestan-signature docblock is the template's contract; @props and @aware fill in what it leaves out; a component's own class, and Livewire's $this, supply their members; View::share() and View::composer() registrations in your service providers are read wherever they are written; a layout's declarations reach every template that extends it; and anything still undeclared is inferred from the call sites that render the template. Completion, hover, go-to-definition, and undefined-variable diagnostics all read the same set, alongside the variables Blade itself injects ($attributes, $slot, $componentName, $errors, $loop). Each source only fills in what the ones above it did not declare, so a template that documents its own contract keeps it. Closes #296.
• Every way of rendering a Blade template is a render site. view(), View::make(), Route::view(), Response::view(), the view factory's first(), renderWhen(), renderUnless(), and renderEach(), a mailable's new Content(view: …) and $this->view(), and Blade's own @include family, @extends, and @each all navigate, hover, complete, and hand the template the data they pass. A render is recognised by its receiver's type rather than by how it is spelled, so a view factory injected into a constructor and a mailable held in a local count too, and a data argument that names nothing (view('page', $data), ->with($extra), array_merge(…)) is read off its type when that type is a single array shape. Contributed by @shuvroroy (#337).
• A view() call is checked against the Blade template's contract. A template that declares what it needs now holds its callers to it, the same way a function call is held to a signature: a variable the render does not pass, one whose type the declaration does not accept, and a key nothing in the template reads are each reported where the mistake is. This is the editor half of the rule Bladestan (the PHPStan extension for Blade) enforces in CI, so one annotation produces the same errors live while typing and on the build. A template that declares nothing is not checked at all, which is what makes this opt-in, and the checks stand down wherever the data stops being readable. A declaration that widens what its layout declared is reported on the template that writes it rather than at every call site.
• Blade components are first-class. <x-alert>, <x-forms.date-picker>, and `<livewir

Added

• Macro hover shows origin and inferred return types. Hovering on a macro method call now displays a "macro" indicator instead of the generic "virtual" label, distinguishing ::macro() registrations from @method/@mixin synthesized members. When the closure has no explicit return type hint, the return type is inferred from the closure body and shown with an "(inferred)" annotation. Bare $this / self / static returns preserve their keyword form, and method chains like $this->transform(...) use the last method's declared return type directly, preserving $this, static, and generic parameters that the general resolver would flatten to a bare class name. Regular (non-macro) methods with inferred return types also show the "(inferred)" annotation on hover. Contributed by @calebdw.
• Return type mismatch diagnostics (type_mismatch_return). Functions and methods with a declared return type are now checked against their return statements. Incompatible return values are flagged as errors. Void functions returning a value and bare return; in non-void functions are also flagged. Generators (functions using yield) are skipped. Uses the same conservative is_type_compatible policy as argument type checking to avoid false positives. Contributed by @calebdw.
• Property type assignment diagnostics (type_mismatch_property). Assignments to typed properties ($this->prop = expr and self::$prop = expr) are checked against the declared property type. Incompatible values are flagged as errors. Only plain = assignments are checked; compound operators (+=, .=, etc.) are skipped. Untyped and mixed properties are not flagged. Contributed by @calebdw.
• Conditional return types keep an intersection with the matched class. A @return ($x is class-string<T> ? T&SomeInterface : SomeInterface) annotation now resolves the matched branch to the concrete class intersected with the interface, instead of collapsing it to the bare class. Mock factories such as Mockery's mock(Foo::class) and Laravel's $this->mock(Foo::class) therefore resolve to Foo&MockInterface, so their members complete and assigning the result to a Foo-typed property or returning it from a Foo&MockInterface method no longer reports a spurious type mismatch.
• PSR-4 mismatch diagnostics and rename-based moves. Files now warn when the declared namespace or primary class name does not match the PSR-4 path or filename, with quick fixes to correct them. Renaming a class from its declaration now opens the full FQCN so you can move it between namespaces in one step, and renaming a namespace can rewrite multiple segments at once while moving PSR-4 directories and updating references across the project. Contributed by @calebdw.
• Case-sensitive autoloading diagnostic. A class reference whose casing differs from the class's actual declaration is now flagged, with a quick fix to correct it. This catches the bug where code loads on a case-insensitive filesystem (macOS, Windows) but fails with a class-not-found error on Linux, because PSR-4 maps the name to a file path and path lookups are case-sensitive there. It covers use imports and inline references to autoloaded classes; built-in classes and same-file references, which never reach the autoloader, are left alone.
• Completion candidates ranked by dependency provenance. Class, function, and constant completions are now sorted by origin tier: project code first, then core/stub symbols, then explicit Composer dependencies (require / require-dev), then transitive vendor dependencies last. The provenance is inferred from composer.json and installed.json during indexing. Contributed by @calebdw.
• analyze and fix work without composer.json. Both commands now treat a directory that has no composer.json (a WordPress site, a legacy codebase) as a plain PHP project: classes are indexed by scanning the tree and files are discovered by walking the roo

Added

• Blade template support. Completion, hover, go-to-definition, diagnostics, semantic tokens, and inlay hints work inside .blade.php files. Contributed by @MingJen in https://github.com/AJenbo/phpantom_lsp/pull/100.
• Blade keyword highlighting. Blade directives, echo delimiters, PHP keywords, cast types, comments, and PHPDoc tags inside .blade.php files now receive semantic tokens for proper syntax coloring.
• Blade view directive navigation. Go-to-definition works on view names inside Blade directives (@include, @extends, @includeIf, @includeWhen, @includeUnless, @includeFirst, @component, @each), jumping to the referenced template file.
• Replace FQCN with import. A refactoring code action on any fully-qualified class name (\Foo\Bar) inserts a use statement and replaces all occurrences of the same FQCN throughout the file with the short name. Detects existing imports and short-name conflicts. A separate "Replace all FQCNs with imports" action appears when the file contains multiple distinct FQCNs, replacing all of them at once (skipping those with import conflicts).
• Broader type narrowing. instanceof, type-guard functions, in_array() strict mode, assert(), @phpstan-assert-if-true/-if-false, and compound &&/|| conditions now narrow types in if/else branches, guard clauses, while-loop bodies, ternary expressions, and match(true) arms.
• Argument type mismatch diagnostics. Flags function and method calls where an argument's resolved type is incompatible with the declared parameter type.
• Invalid class-like kind diagnostics. Flags class-like names used in positions where their kind is guaranteed to fail at runtime: new on abstract classes, interfaces, traits, or enums; extends on a final class, interface, or trait; implements with a non-interface; trait use with a non-trait; instanceof with a trait; catch with a non-Throwable type; and traits in type-hint positions.
• Unused variable diagnostics. Variables assigned but never read are flagged with hint severity and rendered as dimmed text. Variables named $_ or prefixed with $_ are exempt.
• Mago diagnostic proxy. Mago lint and analyze diagnostics are surfaced as LSP diagnostics with quick-fix code actions. Configurable under [mago] in .phpantom.toml.
• Laravel Pint formatting. Projects with laravel/pint in require-dev automatically use Pint for formatting via stdin. Configurable under [formatting] in .phpantom.toml with pint = "path" or pint = "" to disable.
• PHPCS diagnostic proxy. PHP_CodeSniffer violations are surfaced as LSP diagnostics with severity mapping. Configurable under [phpcs] in .phpantom.toml.
• Return type inference from method bodies. Methods without a declared return type or @return docblock now have their return type inferred from return statements, improving completion, hover, and diagnostics for untyped code.
• Closure and arrow function parameter inference. Untyped closure parameters are inferred from the enclosing call's callable signature, including through method chains that return static. Generic type substitution flows through to inferred parameters.
• Closure and arrow function inlay hints. When a closure or arrow function is passed to a callable-typed parameter, inlay hints show inferred parameter types and the return type derived from the enclosing callable signature.
• Generics. @mixin tags referencing a template parameter now resolve through the template bound. new $var() where $var is class-string<T> resolves to T. SPL collection classes now carry @template parameters so iteration methods resolve to concrete type arguments.
• Namespace renaming. Renaming a namespace segment updates all declarations, use statements, and fully-qualified references across the workspace. When a PSR-4 autoload mapping exists, the corresponding directory is moved automatically.