if12is · Oct 21, 2026
@@ -126,6 +126,22 @@ lack this path. The merge runs after colliding ids are salted apart by path, so
 a half whose file stem collides with another file's (`Spec.cs` and `_Spec.cs`,
 `Cfg/Helpers.cs` and `Cfg_Helpers.cs`) still merges and keeps its members.
 
+PHP class names written in source (`Foo::class` and other `Foo::BAR` class
+constants, plus type hints) resolve with PHP's own name-resolution rules in
+`_resolve_php_type_references`: `use` alias, same namespace, or a leading-`\`
+FQCN, each tying the edge to the one declaration with that FQN (`EXTRACTED`).
+The extractor records the name as written on the edge (`_php_raw`, stripped
+before output) and `self`/`static` map to the enclosing class. A name imported
+from outside the corpus keeps the shared FQN-labelled external stub; a
+`::class` that resolves to neither is dropped, never guessed. Not covered:
+`Foo::class` in a method's parameter default, a `new \A\B()` or static call
+written with a qualified name (those still resolve by bare name), and
+`namespace` blocks that mix several namespaces in one file. `references_constant`
+is a generic relation when the graph collapses a node pair to one edge (like
+`references`), so a method naming its own class, or a file that both imports and
+`::class`-references a class, keeps its `method` / `imports` edge. The AST cache
+schema bump retires results without the written name.
+
 R extraction preserves symbol-only bindings such as `%||%` as separate nodes.
 When normal ID normalization removes an entire binding name, its UTF-8 bytes
 provide a deterministic operator suffix within the same lexical owner. Its double

@@ -158,7 +158,8 @@ def _renamed_present(node_id: str) -> bool:
 # be inventing a cross-axis judgement, whereas "specific beats generic" is the only
 # same-direction comparison this collapse needs. The one opposite-direction
 # exception is _STRUCTURAL_MEMBER_RELATIONS.
-_GENERIC_RELATIONS: frozenset[str] = frozenset({"references", "uses", "mentions"})
+_GENERIC_RELATIONS: frozenset[str] = frozenset(
+    {"references", "references_constant", "uses", "mentions"})
 # Membership of a type or file. On an undirected graph these share a node pair
 # with a `calls` edge in the opposite direction when a member calls or constructs
 # its owner (`static Report Fault() { return new Report(); }`). Last-write kept

@@ -37,7 +37,7 @@
     _EXTRACTOR_VERSION = "unknown"
 
 # Bump when AST cache-key semantics change independently of the package version.
-_AST_CACHE_SCHEMA = 20  # Obsidian `[[wikilink]]` targets that start with the scan root's own folder names now resolve to the real page (#4559), so cached markdown extractions re-run; prior (19): Dart `typedef` declarations are extracted as aliases (not variables of type `typedef`); C++ Metal/CUDA GPU qualifiers no longer mint sourceless god nodes (#4550); a `.h` header containing `extern "C"` routes to the C++ extractor; prior (18): Kotlin `typealias` (#4553), C# `delegate` (#4552), and Swift `macro` declarations (#4551) are now extracted so references stop minting sourceless stubs; Rust `use` rooted at a `mod` declared in the same scope carries `_rust_use_name` (#4564); prior (17): Python pytest-fixture markers (`_py_fixture`/`_python_fixture_param`, #4332) and module-level class-id collision salting (#2810); TS `this.field` typed from any method incl. static (#4473); Solidity callables carry `metadata.arity` + inherited-call/`super`/modifier raw calls (#4379); Go type-decl and Rust file-item case-distinct node ids (#4444); prior (16): Rust `use` edges carry the imported name as written (`_rust_use_name`, #4439); (15): Go generic receiver types normalized (`Box[T]` -> `Box`) so methods attach to the type node; prior (14): C# receiver resolution for nameless/`new X()`/`foreach` receivers (defer + receiver-chain markers) and `_`/case-distinct node ids (underscore-salted); prior (13): Kotlin/Scala/C++/Swift generic & template type params no longer mint sourceless stubs; Objective-C NS_ENUM/NS_OPTIONS extraction and `_callable`/`_callable_class` markers; Go and PHP receiver-typed member calls park cross-repo (`go_type_table`/`php_type_table`, receiver fields); prior (12): Java inherited-supertype (`receiver_unbound`) and chained/new/cast receiver typing (`java_receiver_chain`, `_java_ret`); C/C++ quoted cross-directory include provenance (`include_kind`); JS external imports anchored to the package, not the path leaf; prior (11): Python property-accessor decorators / `Self`, Swift `Self`, Go generic type params, Python forward type-hint file node, PowerShell dot-source, C# verbatim-interpolated string recovery; (10): C# partial types carry `type_path`; (9): Python property-read raw calls and `_py_property` nodes; (8): Rust `use`-group per-binding edges; (7): Python opaque-base/super(args) markers + nested-class enclosing ids.
+_AST_CACHE_SCHEMA = 21  # PHP `Foo::class`/type-hint edges carry the written name (`_php_raw`) for corpus-level name resolution, `self`/`static` types map to the enclosing class; prior (20): Obsidian `[[wikilink]]` targets that start with the scan root's own folder names now resolve to the real page (#4559), so cached markdown extractions re-run; prior (19): Dart `typedef` declarations are extracted as aliases (not variables of type `typedef`); C++ Metal/CUDA GPU qualifiers no longer mint sourceless god nodes (#4550); a `.h` header containing `extern "C"` routes to the C++ extractor; prior (18): Kotlin `typealias` (#4553), C# `delegate` (#4552), and Swift `macro` declarations (#4551) are now extracted so references stop minting sourceless stubs; Rust `use` rooted at a `mod` declared in the same scope carries `_rust_use_name` (#4564); prior (17): Python pytest-fixture markers (`_py_fixture`/`_python_fixture_param`, #4332) and module-level class-id collision salting (#2810); TS `this.field` typed from any method incl. static (#4473); Solidity callables carry `metadata.arity` + inherited-call/`super`/modifier raw calls (#4379); Go type-decl and Rust file-item case-distinct node ids (#4444); prior (16): Rust `use` edges carry the imported name as written (`_rust_use_name`, #4439); (15): Go generic receiver types normalized (`Box[T]` -> `Box`) so methods attach to the type node; prior (14): C# receiver resolution for nameless/`new X()`/`foreach` receivers (defer + receiver-chain markers) and `_`/case-distinct node ids (underscore-salted); prior (13): Kotlin/Scala/C++/Swift generic & template type params no longer mint sourceless stubs; Objective-C NS_ENUM/NS_OPTIONS extraction and `_callable`/`_callable_class` markers; Go and PHP receiver-typed member calls park cross-repo (`go_type_table`/`php_type_table`, receiver fields); prior (12): Java inherited-supertype (`receiver_unbound`) and chained/new/cast receiver typing (`java_receiver_chain`, `_java_ret`); C/C++ quoted cross-directory include provenance (`include_kind`); JS external imports anchored to the package, not the path leaf; prior (11): Python property-accessor decorators / `Self`, Swift `Self`, Go generic type params, Python forward type-hint file node, PowerShell dot-source, C# verbatim-interpolated string recovery; (10): C# partial types carry `type_path`; (9): Python property-read raw calls and `_py_property` nodes; (8): Rust `use`-group per-binding edges; (7): Python opaque-base/super(args) markers + nested-class enclosing ids.
 
 
 # Per-process memo: distributions() scans site-packages metadata, which is

@@ -10125,7 +10125,8 @@ def _learn(e: dict) -> None:
     if _php_sel:
         try:
             _resolve_php_type_references(
-                [r for r, _ in _php_sel], [p for _, p in _php_sel], all_nodes, all_edges
+                [r for r, _ in _php_sel], [p for _, p in _php_sel], all_nodes, all_edges,
+                resolution_context_nodes, root,
             )
         except Exception as exc:
             import logging
@@ -10820,7 +10821,15 @@ def _has_import_evidence(candidate_id: str) -> bool:
 
     # A Rust `use` group keeps one edge per binding; its v8 edge only served the calls above.
     all_edges[:] = [e for e in all_edges if not e.pop("_rust_use_group", False)]
+    # A PHP `Foo::class` the resolver could not tie to a declaration (or to an
+    # explicit `use` import) still carries its written name: drop it rather than
+    # keep a guessed edge. Unresolved type hints keep their legacy stub edge.
+    all_edges[:] = [
+        e for e in all_edges
+        if not (e.get("_php_raw") and e.get("relation") == "references_constant")
+    ]
     for e in all_edges:
+        e.pop("_php_raw", None)
         e.pop("_rust_use_binding", None)
         e.pop("_rust_use_name", None)