static/$this return types are no longer flagged when passed where a

`Stringable` object is accepted

Author: AJenbo

docs/CHANGELOG.md

@@ -63,6 +63,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- **`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.
 - **Docblock navigation lands on the right name in types that mix a `*` wildcard with a non-ASCII name.** In a type such as `@return Map<Café, *, User>`, go-to-definition, find references, and rename measured every name after the accented one against the wrong bytes, so clicking `User` resolved nothing (or the wrong symbol). The PHPStan `*` wildcard is now read directly by the type grammar rather than rewritten to `mixed` beforehand, which removes the byte-offset bookkeeping that was corrupting the positions.

docs/todo.md

@@ -108,7 +108,6 @@ 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)**                                                                                                                                               |             |             |
-| B1  | [`static`/`$this` return types rejected where a `Stringable` object is accepted](todo/bugs.md#b1-staticthis-return-types-are-rejected-where-a-stringable-object-is-accepted) | Medium      | 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      |

docs/todo/bugs.md

@@ -7,37 +7,4 @@ pipeline so it produces correct data. Downstream consumers
 (diagnostics, hover, completion, definition) should never need
 to second-guess upstream output.
 
-## B1. `static`/`$this` return types are rejected where a `Stringable` object is accepted
-
-**Impact: Medium · Effort: Low**
-
-`type_mismatch_argument` flags passing a `static(Foo)` or `$this(Foo)`
-typed value to a `string` parameter even when `Foo` implements
-`Stringable`, which PHP accepts (it calls `__toString()`). Minimal
-reproduction:
-
-```php
-class Node implements Stringable {
-    private function __get($name): static {}
-    public function __toString(): string { return ''; }
-}
-$n = new Node();
-throw new \Exception($n->Body->Msg);
-// Argument 1 ($message) expects string, got static(Node)
-```
-
-The cause is `PhpType::is_object_like` in `src/php_type/mod.rs`: it
-answers `true` for `Named`, `Generic`, `ObjectShape` and `Nullable`, but
-`false` for `TypeKind::StaticType` and `TypeKind::ThisType`. The
-`Stringable` branch in
-`src/diagnostics/type_errors/compatibility.rs::is_type_compatible` is
-gated on `is_object_like()`, so it never runs for those two kinds and the
-check falls through to a mismatch. `base_name()` right next to it *does*
-handle both kinds, which is what makes the diagnostic message name the
-bound class correctly while the compatibility check ignores it.
-
-Every other consumer of `is_object_like` is affected the same way, so fix
-it there rather than in the diagnostic. Real-world hit: any use of
-`SimpleXMLElement`, whose stubbed `__get` returns `static`, so
-`(string) $xml->Body->Message` style code reports a false positive on
-every argument passed to a `string` parameter.
+No outstanding items.

src/php_type/mod.rs

@@ -1166,6 +1166,7 @@ impl PhpType {
             TypeKind::Named(s) => s.eq_ignore_ascii_case("object") || !is_scalar_name(s),
             TypeKind::Generic(g) => !is_scalar_name(&g.name),
             TypeKind::ObjectShape(_) => true,
+            TypeKind::StaticType(s) | TypeKind::ThisType(s) => !is_scalar_name(s),
             TypeKind::Nullable(inner) => inner.is_object_like(),
             _ => false,
         }

tests/integration/diagnostics_type_errors.rs

@@ -1426,6 +1426,28 @@ function test(): void {
     );
 }
 
+#[test]
+fn no_diagnostic_for_static_return_stringable_to_string() {
+    let php = r#"<?php
+class Node implements Stringable {
+    public function __get($name): static {
+        return $this;
+    }
+    public function __toString(): string { return ''; }
+}
+
+function test(): void {
+    $n = new Node();
+    throw new \Exception($n->Body);
+}
+"#;
+    let diags = collect(php);
+    assert!(
+        !has_type_error(&diags),
+        "Should not flag static(Stringable) object passed to string, got: {diags:?}"
+    );
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // New rules: PHP type juggling
 // ═══════════════════════════════════════════════════════════════════════════