Fix self / static from within macros

Author: AJenbo

docs/CHANGELOG.md

@@ -58,6 +58,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Eloquent models always expose their primary key.** A model whose table has no migration and no schema dump no longer reports a false `Property 'id' not found` on `$model->id`. The primary key is synthesized for every Eloquent model, honouring `$primaryKey` for the column name and `$keyType` for the type (`int` by default, `string` for UUID or ULID keys).
 - **Laravel virtual property hover and navigation prefer backing accessors.** Hover labels for accessor and computed Eloquent properties now describe the source without echoing the backing method name, and go-to-definition on accessor/computed properties prefers the backing accessor or legacy mutator before falling back to `$appends` or other Eloquent metadata arrays. Legacy `setXAttribute` mutators are shown alongside database, cast, attribute-default, accessor, or computed-property sources when they exist. Contributed by @calebdw.
 - **Laravel macro callbacks registered through facades now infer `$this` as the concrete facade target.** `$this` inside callbacks such as `Request::macro('shouldReturnJson', function () { ... })` and `Context::macro(...)` now resolves to the class behind the facade instead of the surrounding service provider. Contributed by @calebdw.
+- **`self::` and `static::` inside macro callbacks resolve to the macro target.** In a closure passed to a `macro()` registration (Laravel `Macroable` or Carbon), `self::` and `static::` now resolve to the class the macro is registered on instead of the service provider that lexically encloses the registration, matching how the closure is bound at runtime. Carbon's static macro idiom `self::this()->...` no longer reports a false unknown-method diagnostic, and completion after `self::` inside the callback offers the target's members.
 - **Find References and Rename no longer match unrelated same-named methods when a call's receiver type can't be resolved.** A call like `$x->find()` used to conservatively match every `find()` method in the project when `$x`'s type couldn't be determined, drowning results in unrelated matches for common method names. Find References on an interface method now also includes every implementing class; Rename Symbol stays scoped to the single concrete implementation being renamed, so it never rewrites unrelated same-named methods elsewhere. Contributed by @sidux in https://github.com/PHPantom-dev/phpantom_lsp/pull/186.
 - **Go-to-implementation and type hierarchy return the same results every time.** After the workspace finished indexing, these features listed only your project's implementing classes, but a class from a dependency could slip in if you happened to have viewed it earlier in the session, so the same query gave different results depending on what you'd looked at. Results are now consistently limited to your own code, matching what the workspace index actually covers.
 - **Blade files with raw `<?php ... ?>` tags no longer report false syntax errors.** PHP code embedded directly in a Blade template (outside `@php`/`@endphp`) is now recognized and passed through unmodified, so string literals that happen to start with `@` (e.g. a JSON-LD `'@context'` array key) are no longer misread as Blade directives.

docs/todo.md

@@ -106,7 +106,6 @@ unlikely to move the needle for most users.
 | D15 | [Unused parameter diagnostic](todo/diagnostics.md#d15-unused-parameter-diagnostic)                                                                                          | Low         | Low         |
 |     | **[Bug Fixes](todo/bugs.md)**                                                                                                                                               |             |             |
 | B1  | [`resolve_function_name` guesses a single namespace, missing same-file multi-namespace declarations](todo/bugs.md#b1-resolve_function_name-guesses-a-single-namespace-missing-same-file-multi-namespace-declarations) | Low-Medium  | Medium      |
-| B2  | [`self::`/`static::` inside macro closures resolve to the enclosing class, not the macro target](todo/bugs.md#b2-selfstatic-inside-macro-closures-resolve-to-the-enclosing-class-not-the-macro-target) | Medium      | Medium      |
 |     | **[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      |

docs/todo/bugs.md

@@ -40,32 +40,3 @@ Fixing this requires either threading the call expression's byte
 offset through to `resolve_function_name` or adding an offset-aware
 variant of the loader closure. Size the fix accordingly — this is not
 a one-line change.
-
-## B2. `self::`/`static::` inside macro closures resolve to the enclosing class, not the macro target
-
-Inside a closure passed to `Target::macro(...)` (Laravel `Macroable`
-or Carbon), `$this` correctly resolves to the macro target class via
-`laravel_macro_this_resolver` (`closure_this_from_static_receiver` in
-`src/completion/variable/closure_resolution.rs`). But `self::` and
-`static::` inside the same closure still resolve to the class that
-lexically encloses the registration (e.g. the service provider), so
-Carbon's static macro idiom
-
-```php
-CarbonImmutable::macro('diffFromYear', function (int $year): string {
-    return self::this()->diffForHumans(...);
-});
-```
-
-reports a false `Method 'this' not found on class
-'App\Providers\DemoServiceProvider'` (`unknown_member`). At runtime
-both `Macroable::__call`/`__callStatic` and Carbon bind the closure
-with the target as scope, so `self`/`static` refer to the target and
-protected members like `Carbon\Traits\Mixin::this()` are accessible.
-
-Subject resolution for `Self_`/`Static` needs the same "am I inside a
-macro registration closure?" awareness that `$this` resolution already
-has. The `self::this()` demo in
-`examples/laravel/app/Providers/DemoServiceProvider.php` was switched
-to the supported `$this->` form when this was discovered; restore the
-static idiom there once fixed.

examples/demo.php

@@ -3579,6 +3579,14 @@ public function demo(): void
         $router->extend('redis', function () {
             $this->getDefaultDriver();    // resolves Router::getDefaultDriver()
         });
+
+        // Macro-style registration: the closure is bound with the target
+        // class as its scope, so self:: and static:: inside it refer to
+        // ScaffoldingMacroTarget, not ParamClosureThisDemo.
+        ScaffoldingMacroTarget::macro('renderTwice', function (): string {
+            return self::make()->render()      // resolves MacroTarget::make()
+                . static::make()->render();    // static:: works the same way
+        });
     }
 }
 
@@ -5015,6 +5023,38 @@ public function group(\Closure $callback): void {}
     public function extend(string $driver, \Closure $callback): self { return $this; }
 }
 
+// ScaffoldingMacroTarget — a minimal Macroable-style class used by
+// ParamClosureThisDemo. `macro()` stores the closure and `__call` binds it
+// with this class as scope (like Laravel's Macroable / Carbon), so
+// `self::`/`static::` inside a registered closure refer to this class.
+class ScaffoldingMacroTarget
+{
+    /** @var array<string, callable> */
+    private static array $macros = [];
+
+    public static function make(): static { return new static(); }
+
+    public function render(): string { return 'rendered'; }
+
+    /**
+     * @param-closure-this static $macro
+     */
+    public static function macro(string $name, callable $macro): void
+    {
+        static::$macros[$name] = $macro;
+    }
+
+    /** @param array<int, mixed> $args */
+    public function __call(string $name, array $args): mixed
+    {
+        $macro = static::$macros[$name];
+        if ($macro instanceof \Closure) {
+            $macro = $macro->bindTo($this, static::class);
+        }
+        return $macro(...$args);
+    }
+}
+
 class ScaffoldingFirstClassCallable
 {
     public function dispatch(): Pen
@@ -7256,6 +7296,14 @@ function runDemoAssertions(): void
     $ctExt = $ctRouter->extend('redis', function () {});
     assert($ctExt instanceof ScaffoldingClosureThisRouter, 'Router::extend() must return self');
 
+    // Macro-style scope binding: self::/static:: inside a registered
+    // closure refer to the macro target class at runtime.
+    ScaffoldingMacroTarget::macro('renderTwice', function (): string {
+        return self::make()->render() . static::make()->render();
+    });
+    $macroTarget = new ScaffoldingMacroTarget();
+    assert($macroTarget->renderTwice() === 'renderedrendered', 'self::/static:: inside a macro closure must bind to ScaffoldingMacroTarget');
+
     // ── @mixin generic substitution scaffolding ─────────────────────────
     $mixinBuilder = new ScaffoldingMixinBuilder();
     assert($mixinBuilder->firstOrFail() === null, 'ScaffoldingMixinBuilder::firstOrFail() must return mixed');

examples/laravel/app/Providers/DemoServiceProvider.php

@@ -24,10 +24,11 @@ public function boot(): void
         Collection::mixin(new CollectionMixin());
 
         // Carbon supports the same `macro()` pattern as Laravel's Macroable.
-        // `$this` inside the closure is the CarbonImmutable instance the
-        // macro is called on:
+        // The closure is bound with the target as scope, so `self::`/`static::`
+        // refer to CarbonImmutable and protected helpers like `self::this()`
+        // (the instance the macro is called on) resolve:
         CarbonImmutable::macro('diffFromYear', function (int $year, bool $absolute = false): string {
-            return $this->diffForHumans(
+            return self::this()->diffForHumans(
                 CarbonImmutable::create($year, 1, 1),
                 ['syntax' => \Carbon\CarbonInterface::DIFF_ABSOLUTE]
             );

examples/laravel/assertions.php

@@ -320,6 +320,24 @@ class_uses_recursive(\App\Models\BlogPost::class),
     \App\Models\BlogPost::factory()->trashed() instanceof \Illuminate\Database\Eloquent\Factories\Factory
 );
 
+// ─── Carbon macro closure scope binding ──────────────────────────────────────
+
+// Carbon binds macro closures with the target class as scope, so `self::`
+// inside the closure refers to CarbonImmutable (not the class that lexically
+// encloses the registration) and the protected `Mixin::this()` helper — the
+// instance the macro is called on — is accessible.
+\Carbon\CarbonImmutable::macro('phpantomScopeProbe', function (): string {
+    return self::this()->format('Y');
+});
+check(
+    'self::this() inside a Carbon macro returns the bound instance',
+    \Carbon\CarbonImmutable::create(2020, 1, 1)->phpantomScopeProbe() === '2020'
+);
+check(
+    'Mixin::this() is protected static (only reachable via rebound scope)',
+    (new ReflectionMethod(\Carbon\CarbonImmutable::class, 'this'))->isProtected()
+);
+
 // ─── Summary ────────────────────────────────────────────────────────────────
 
 echo "\n";

src/completion/resolver/mod.rs

@@ -264,8 +264,8 @@ fn resolve_target_classes_expr_inner_impl(
 
             this_types
         }
-        SubjectExpr::SelfKw | SubjectExpr::StaticKw => current_class
-            .map(|cc| ResolvedType::from_class(cc.clone()))
+        SubjectExpr::SelfKw | SubjectExpr::StaticKw => resolve_self_static_class(ctx)
+            .map(ResolvedType::from_class)
             .into_iter()
             .collect(),
 
@@ -308,8 +308,8 @@ fn resolve_target_classes_expr_inner_impl(
             // class names, so find_class_by_name / class_loader won't
             // find them.
             let owner_classes: Vec<Arc<ClassInfo>> = if is_self_or_static(class) {
-                current_class
-                    .map(|cc| Arc::new(cc.clone()))
+                resolve_self_static_class(ctx)
+                    .map(Arc::new)
                     .into_iter()
                     .collect()
             } else if let Some(parent_name) = resolve_class_keyword(class, current_class) {
@@ -1304,6 +1304,20 @@ fn resolve_variable_fallback(
 
 // ── Static owner class resolution ───────────────────────────────────
 
+/// Resolve the class that a bare `self`/`static` keyword refers to at
+/// the cursor position.
+///
+/// Normally this is the lexically enclosing class, but inside a
+/// closure whose enclosing call site declares `@param-closure-this`
+/// (e.g. a Laravel `Macroable` or Carbon `macro()` registration), the
+/// runtime binds the closure with the target class as its scope
+/// (`Closure::bind`), so `self::` and `static::` refer to the bound
+/// target rather than the class that lexically encloses the closure.
+fn resolve_self_static_class(ctx: &ResolutionCtx<'_>) -> Option<ClassInfo> {
+    super::variable::closure_resolution::find_closure_this_override(ctx)
+        .or_else(|| ctx.current_class.cloned())
+}
+
 /// Resolve a static class reference (`self`, `static`, `parent`, or a
 /// class name) to its `ClassInfo`.
 ///
@@ -1314,7 +1328,7 @@ pub(in crate::completion) fn resolve_static_owner_class(
     rctx: &ResolutionCtx<'_>,
 ) -> Option<Arc<ClassInfo>> {
     if is_self_or_static(class) {
-        rctx.current_class.map(|cc| Arc::new(cc.clone()))
+        resolve_self_static_class(rctx).map(Arc::new)
     } else if let Some(resolved_name) = resolve_class_keyword(class, rctx.current_class) {
         // parent — load via class_loader so we get the full parent ClassInfo
         (rctx.class_loader)(&resolved_name)

tests/integration/completion_param_closure_this.rs

@@ -315,6 +315,124 @@ async fn test_param_closure_this_property_access() {
     );
 }
 
+// ─── self:: / static:: inside a rebound closure ─────────────────────────────
+
+/// Inside a closure rebound via `@param-closure-this` (e.g. a macro
+/// registration), the runtime binds the target class as the closure's
+/// scope, so `self::` refers to the macro target, not the class that
+/// lexically encloses the registration.
+#[tokio::test]
+async fn test_param_closure_this_self_keyword() {
+    let backend = create_test_backend();
+    let uri = Url::parse("file:///test/closure_self_kw.php").unwrap();
+
+    let src = concat!(
+        "<?php\n",
+        "class Macroable {\n",
+        "    public static function make(): static { return new static(); }\n",
+        "    /**\n",
+        "     * @param string $name\n",
+        "     * @param callable $macro\n",
+        "     * @param-closure-this static $macro\n",
+        "     */\n",
+        "    public static function macro(string $name, callable $macro): void {}\n",
+        "}\n",
+        "class App {\n",
+        "    public function run(): void {\n",
+        "        Macroable::macro('test', function () {\n",
+        "            self::\n",
+        "        });\n",
+        "    }\n",
+        "}\n",
+    );
+
+    // Line 13: `            self::` — cursor after `::`
+    let items = complete_at(&backend, &uri, src, 13, 18).await;
+    let names = method_names(&items);
+    assert!(
+        names.contains(&"make"),
+        "Expected 'make' from the macro target (Macroable) via self::, got: {:?}",
+        names,
+    );
+}
+
+/// Same as above for the `static::` keyword.
+#[tokio::test]
+async fn test_param_closure_this_static_keyword() {
+    let backend = create_test_backend();
+    let uri = Url::parse("file:///test/closure_static_kw.php").unwrap();
+
+    let src = concat!(
+        "<?php\n",
+        "class Macroable {\n",
+        "    public static function make(): static { return new static(); }\n",
+        "    /**\n",
+        "     * @param string $name\n",
+        "     * @param callable $macro\n",
+        "     * @param-closure-this static $macro\n",
+        "     */\n",
+        "    public static function macro(string $name, callable $macro): void {}\n",
+        "}\n",
+        "class App {\n",
+        "    public function run(): void {\n",
+        "        Macroable::macro('test', function () {\n",
+        "            static::\n",
+        "        });\n",
+        "    }\n",
+        "}\n",
+    );
+
+    // Line 13: `            static::` — cursor after `::`
+    let items = complete_at(&backend, &uri, src, 13, 20).await;
+    let names = method_names(&items);
+    assert!(
+        names.contains(&"make"),
+        "Expected 'make' from the macro target (Macroable) via static::, got: {:?}",
+        names,
+    );
+}
+
+/// `self::` outside the closure must still resolve to the lexically
+/// enclosing class, not the @param-closure-this type.
+#[tokio::test]
+async fn test_param_closure_this_self_keyword_does_not_leak() {
+    let backend = create_test_backend();
+    let uri = Url::parse("file:///test/closure_self_kw_no_leak.php").unwrap();
+
+    let src = concat!(
+        "<?php\n",
+        "class Macroable {\n",
+        "    public static function make(): static { return new static(); }\n",
+        "    /**\n",
+        "     * @param-closure-this static $macro\n",
+        "     */\n",
+        "    public static function macro(string $name, callable $macro): void {}\n",
+        "}\n",
+        "class App {\n",
+        "    public static function ownHelper(): string { return ''; }\n",
+        "    public function run(): void {\n",
+        "        Macroable::macro('test', function () {\n",
+        "        });\n",
+        "        self::\n",
+        "    }\n",
+        "}\n",
+    );
+
+    // Line 13: `        self::` — cursor OUTSIDE the closure
+    let items = complete_at(&backend, &uri, src, 13, 14).await;
+    let names = method_names(&items);
+    assert!(
+        names.contains(&"ownHelper"),
+        "Expected 'ownHelper' from lexical class App, got: {:?}",
+        names,
+    );
+    assert!(
+        !names.contains(&"make"),
+        "Should NOT see Macroable::make outside the closure, got: {:?}",
+        names,
+    );
+}
+
 // ─── @param-closure-this with FQN type ──────────────────────────────────────
 
 /// `@param-closure-this \App\Route $callback` with a leading backslash