Clean up old references to renamed maps

Author: AJenbo

docs/todo.md

@@ -171,7 +171,7 @@ unlikely to move the needle for most users.
 | P5  | `memmap2` for file reads during scanning                                                                                                                                    | Low         | Low         |
 | P6  | O(n²) transitive eviction in `evict_fqn`                                                                                                                                    | Low         | Low         |
 | P7  | `diag_pending_uris` uses `Vec::contains` for dedup                                                                                                                          | Low         | Low         |
-| P8  | `find_class_in_ast_map` linear fallback scan                                                                                                                                | Low         | Low         |
+| P8  | `find_class_in_uri_classes_index` linear fallback scan                                                                                                                       | Low         | Low         |
 | P12 | [`find_or_load_function` Phase 1.75 serial bottleneck](todo/performance.md#p12-find_or_load_function-phase-175-serial-bottleneck)                                           | Low         | Low         |
 | P17 | [`mago-names` resolution on the parse hot path](todo/performance.md#p17-mago-names-resolution-on-the-parse-hot-path)                                                        | Medium      | Low         |
 | P18 | [Subtype result caching](todo/performance.md#p18-subtype-result-caching) (per-request HashMap for hierarchy walks)                                                          | Medium      | Low         |

docs/todo/indexing.md

@@ -93,7 +93,7 @@ editing `composer.json` dependencies.
 
 Background-parse every PHP file in the project. Uses Composer data to
 guide file discovery when available, falls back to scanning all PHP
-files in the workspace when it is not. Populates the ast_map,
+files in the workspace when it is not. Populates the uri_classes_index,
 symbol_maps, and all derived indices. Enables workspace symbols, fast
 find-references without on-demand scanning, and rich hover on
 completion items. Memory usage grows proportionally to project size.
@@ -157,7 +157,7 @@ join before the function returns). The thread count is capped at
 cores). Batches of 2 or fewer files skip threading overhead.
 
 Transient entry eviction after GTI and find references has been
-removed. Parsed files stay cached in `ast_map`, `symbol_maps`,
+removed. Parsed files stay cached in `uri_classes_index`, `symbol_maps`,
 `use_map`, and `namespace_map` so that subsequent operations benefit
 from the work already done. This trades a small amount of memory for
 faster repeat queries and simpler code.
@@ -235,7 +235,7 @@ user scrolls.
 ### Approach: "what's already discovered"
 
 Use `completionItem/resolve` to populate `detail` and
-`documentation` fields. If the class is already in the ast_map (parsed
+`documentation` fields. If the class is already in the uri_classes_index (parsed
 during a prior resolution), return the full signature and docblock.
 If not, return just the item label with no extra detail.
 
@@ -282,7 +282,7 @@ Full mode is not a separate discovery system. It works exactly like
    name completion and O(1) file lookup.
 2. **Second pass:** Iterate every file path in the now-populated
    in-memory classmap and call `update_ast` on each one at Low
-   priority. This populates ast_map, symbol_maps, class_index,
+   priority. This populates uri_classes_index, symbol_maps, fqn_uri_index,
    global_functions, and global_defines.
 
 No new file discovery logic is needed. The classmap from the first
@@ -329,14 +329,14 @@ sizes over time. The aim is to stay under 512 MB for a full project.
 
 The performance prerequisites above (P1 `Arc<ClassInfo>`,
 `Arc<String>`, `Arc<SymbolMap>`) directly reduce memory usage by
-sharing data across the ast_map, caches, and snapshot copies instead
+sharing data across the uri_classes_index, caches, and snapshot copies instead
 of deep-cloning each. These should be measured before and after to
 validate the 512 MB target.
 
 ### Workspace symbols
 
 With the full index populated, `workspace/symbol` becomes a simple
-filter over the ast_map and global_functions maps. No additional
+filter over the uri_classes_index and global_functions maps. No additional
 infrastructure needed.
 
 In other modes, workspace symbols still works but only returns results
@@ -370,7 +370,7 @@ three areas:
 3. **Go to Implementation and Find References.** These report
    begin/end only. The underlying scans (`find_implementors`,
    `find_member_references`, `find_class_references`) iterate over
-   classmap files, ast_map entries, and PSR-4 directories, all of
+   classmap files, uri_classes_index entries, and PSR-4 directories, all of
    which have known or discoverable totals.
 
 ### Design
@@ -498,10 +498,10 @@ better.
 **Impact: Medium · Effort: Medium**
 
 The current lazy-loading design provides an implicit recency signal:
-classes in `ast_map` were loaded because the developer interacted with
+classes in `uri_classes_index` were loaded because the developer interacted with
 their file during this session (hovered, navigated, completed). Source
 tiers 0 (use-imported) and 1 (same-namespace) already capture this
-for the current file's neighborhood. The `class_index` source captures
+for the current file's neighborhood. The `fqn_uri_index` source captures
 cross-file interactions (go-to-definition, hover, or completion that
 triggered a load).
 

docs/todo/lsp-features.md

@@ -29,9 +29,9 @@ instantly instead of blocking until every source has been scanned.
 `find_implementors` already runs five sequential phases (see
 `docs/ARCHITECTURE.md` § Go-to-Implementation):
 
-1. **Phase 1 — ast_map** (already-parsed classes in memory) — essentially
+1. **Phase 1 — uri_classes_index** (already-parsed classes in memory) — essentially
    free. Flush results immediately.
-2. **Phase 2 — class_index** (FQN → URI entries not yet in ast_map) —
+2. **Phase 2 — fqn_uri_index** (FQN → URI entries not yet in uri_classes_index) —
    loads individual files. Flush after each batch.
 3. **Phase 3 — classmap files** (Composer classmap, user + vendor mixed)
    — iterates unique file paths, applies string pre-filter, parses

docs/todo/performance.md

@@ -36,7 +36,7 @@ Split Phase 3 into two sub-phases:
    only the paths that pass the filter along with their content.
 
 2. **Sequential parse.** For the (few) files that pass, call
-   `parse_and_cache_file` sequentially. This step mutates `ast_map`
+   `parse_and_cache_file` sequentially. This step mutates `uri_classes_index`
    and calls `class_loader`, which may re-lock shared state.
 
 The same pattern applies to Phase 5 (PSR-4 directory walk for files
@@ -166,12 +166,12 @@ not important and a plain `HashSet` suffices.
 
 ---
 
-## P8. `find_class_in_ast_map` linear fallback scan
+## P8. `find_class_in_uri_classes_index` linear fallback scan
 
 **Impact: Low · Effort: Low**
 
-The fast O(1) `fqn_index` lookup in `find_class_in_ast_map` covers
-the common case. The slow fallback iterates every file in `ast_map`
+The fast O(1) `fqn_index` lookup in `find_class_in_uri_classes_index` covers
+the common case. The slow fallback iterates every file in `uri_classes_index`
 linearly. The comment says this covers "race conditions during
 initial indexing" and anonymous classes.
 
@@ -385,7 +385,7 @@ The 630 phpstorm-stubs PHP files are embedded as raw source via
    classes extend built-in types.
 
 3. **Duplicate data.** After parsing, the `Arc<ClassInfo>` lives in
-   `ast_map` and `fqn_index`, but the raw PHP source stays resident
+   `uri_classes_index` and `fqn_index`, but the raw PHP source stays resident
    in `.rodata` forever. Both copies exist simultaneously.
 
 ### Indexing order: stubs → vendor → user
@@ -456,7 +456,7 @@ serializes as `Vec<T>` and deserializes into `SharedVec::from(vec)`.
 **What gets removed:**
 
 - The `STUB_FILES` array (raw PHP source embedding)
-- The `phpantom-stub://` URI scheme and associated `ast_map` entries
+- The `phpantom-stub://` URI scheme and associated `uri_classes_index` entries
 - The `parse_and_cache_content_versioned` path for stubs
 - The `is_stub_function_removed` / `is_stub_class_removed` byte
   scanners (replaced by version fields on deserialized structs)

docs/todo/type-inference.md

@@ -58,9 +58,9 @@ supports glob patterns like `**/vendor/composer/autoload_*.php`.
 
 - On change notification, re-run the same parsing logic from
   `initialized` for the affected artifact.
-- Invalidate `class_index` entries that came from vendor files (their
+- Invalidate `fqn_uri_index` entries that came from vendor files (their
   parsed AST may have changed).
-- Clear and re-populate `classmap` from the new `autoload_classmap.php`.
+- Clear and re-populate `fqn_uri_index` from the new `autoload_classmap.php`.
 - Log the reload to the output panel so the user knows it happened.
 - Debounce rapid changes (Composer writes multiple files in sequence)
   with a short delay (e.g. 500ms) to avoid redundant reloads.

src/analyse.rs

@@ -163,13 +163,13 @@ pub async fn run(options: AnalyseOptions) -> i32 {
     // ── 4. Two-phase parallel analysis ──────────────────────────────
     //
     // Phase 1 — **Parse**: run `update_ast` on every user file so that
-    // `fqn_index`, `ast_map`, `symbol_maps`, `use_map`, `namespace_map`
-    // and `class_index` are fully populated for the entire project.
+    // `fqn_index`, `uri_classes_index`, `symbol_maps`, `use_map`, `namespace_map`
+    // and `fqn_uri_index` are fully populated for the entire project.
     //
     // Phase 2 — **Diagnose**: collect diagnostics for every file.
     // Because all user classes are already in `fqn_index`, cross-file
     // references resolve via an O(1) hash lookup instead of falling
-    // through to classmap / PSR-4 lazy loading (which takes write
+    // through to fqn_uri_index / PSR-4 lazy loading (which takes write
     // locks and serialises threads).
     //
     // Splitting the work this way also means the diagnostic phase
@@ -247,12 +247,12 @@ pub async fn run(options: AnalyseOptions) -> i32 {
     // cached — eliminating the unbounded mutual recursion in
     // resolve_class_fully_inner that previously caused stack overflow.
     //
-    // We snapshot the toposorted FQN list while holding the ast_map
+    // We snapshot the toposorted FQN list while holding the uri_classes_index
     // read lock, then drop the lock before resolving.  Resolution may
-    // call find_or_load_class which takes write locks on ast_map.
+    // call find_or_load_class which takes write locks on uri_classes_index.
     let sorted_fqns = {
-        let ast_map = backend.uri_classes_index.read();
-        crate::toposort::toposort_from_ast_map(&ast_map)
+        let uri_classes_index = backend.uri_classes_index.read();
+        crate::toposort::toposort_from_uri_classes_index(&uri_classes_index)
     };
     // Run eager population on a large-stack thread.  `resolve_class_fully_inner`
     // can nest deeply when the toposort misses dependencies (stubs, dynamically

src/classmap_scanner.rs

@@ -21,7 +21,7 @@
 //!    directly (not by this module).  Functions and constants from
 //!    `autoload_files.php` are discovered by the full-scan during
 //!    initialization, populating `autoload_function_index`,
-//!    `autoload_constant_index`, and `class_index`.  Lazy
+//!    `autoload_constant_index`, and `fqn_uri_index`.  Lazy
 //!    `update_ast` on first access provides complete details.
 //!
 //! 2. **Composer self-scan** — the PSR-4 scanner builds a classmap

src/code_actions/change_visibility.rs

@@ -258,7 +258,7 @@ impl Backend {
         cursor_offset: u32,
         member_kind: &MemberKind,
     ) -> Option<u8> {
-        // Find the enclosing ClassInfo from the ast_map.
+        // Find the enclosing ClassInfo from the uri_classes_index.
         let local_classes: Vec<Arc<ClassInfo>> = self
             .uri_classes_index
             .read()

src/code_actions/import_class.rs

@@ -340,7 +340,7 @@ impl Backend {
         let mut candidates = Vec::new();
         let name_lower = name.to_lowercase();
 
-        // ── 1. class_index ──────────────────────────────────────────────
+        // ── 1. fqn_uri_index ──────────────────────────────────────────────
         {
             let idx = self.fqn_uri_index.read();
             for fqn in idx.keys() {
@@ -364,7 +364,7 @@ impl Backend {
             }
         }
 
-        // ── 3. ast_map (already-parsed files) ───────────────────────────
+        // ── 3. uri_classes_index (already-parsed files) ───────────────────────────
         {
             let amap = self.uri_classes_index.read();
             for (_file_uri, classes) in amap.iter() {
@@ -1460,7 +1460,7 @@ final class Foo extends Data
     // ── find_import_candidates smoke test ───────────────────────────────
 
     #[test]
-    fn find_candidates_from_class_index() {
+    fn find_candidates_from_fqn_uri_index() {
         let backend = crate::Backend::new_test();
         // Populate class index with a known class.
         {
@@ -1501,7 +1501,7 @@ final class Foo extends Data
     #[test]
     fn find_candidates_deduplicates() {
         let backend = crate::Backend::new_test();
-        // Add the same FQN to class_index — should only appear once.
+        // Add the same FQN to fqn_uri_index — should only appear once.
         {
             let mut idx = backend.fqn_uri_index.write();
             idx.insert("App\\Foo".to_string(), "file:///foo.php".to_string());
@@ -1999,19 +1999,19 @@ final class Foo extends Data
     }
 
     #[test]
-    fn import_action_offered_when_namespaced_class_in_ast_map() {
+    fn import_action_offered_when_namespaced_class_in_uri_classes_index() {
         // Reproduces issue #59: when a namespaced class like `Carbon\Carbon`
-        // is already parsed and in the ast_map, `find_or_load_class("Carbon")`
+        // is already parsed and in the uri_classes_index, `find_or_load_class("Carbon")`
         // must NOT match it — the bare name `"Carbon"` is a global-scope
         // lookup and should not resolve to `Carbon\Carbon`.
         //
-        // Without the fix, `find_class_in_ast_map("Carbon")` ignores the
+        // Without the fix, `find_class_in_uri_classes_index("Carbon")` ignores the
         // namespace filter when `expected_ns` is `None`, so ANY class with
         // short name `Carbon` matches.  The import action then skips it
         // thinking "this class resolves in global scope".
         let backend = crate::Backend::new_test();
 
-        // Parse the dependency file so Carbon\Carbon is in the ast_map.
+        // Parse the dependency file so Carbon\Carbon is in the uri_classes_index.
         let uri_dep = "file:///vendor/carbon.php";
         let content_dep = "<?php\nnamespace Carbon;\n\nclass Carbon {}\n";
         backend.update_ast(uri_dep, content_dep);
@@ -2052,7 +2052,7 @@ final class Foo extends Data
                     false
                 }
             }),
-            "expected an import action for Carbon\\Carbon when the namespaced class is in ast_map, got: {:?}",
+            "expected an import action for Carbon\\Carbon when the namespaced class is in uri_classes_index, got: {:?}",
             actions
                 .iter()
                 .map(|a| match a {

src/completion/context/catch_completion.rs

@@ -374,7 +374,7 @@ fn find_try_block_body(_content: &str, before_catch: &str) -> Option<String> {
 
 impl Backend {
     /// Check whether a class is a confirmed `\Throwable` descendant using
-    /// only already-loaded data from the `ast_map`.
+    /// only already-loaded data from the `uri_classes_index`.
     ///
     /// Returns `true` only when the full parent chain can be walked to
     /// one of the three Throwable root types (`Throwable`, `Exception`,
@@ -384,7 +384,7 @@ impl Backend {
     /// This is a strict check: the caller should only include the class
     /// when this returns `true`.
     ///
-    /// This never triggers disk I/O; it only consults `ast_map`.
+    /// This never triggers disk I/O; it only consults `uri_classes_index`.
     fn is_throwable_descendant(&self, class_name: &str, depth: u32) -> bool {
         if depth > 20 {
             return false; // prevent infinite loops
@@ -397,8 +397,8 @@ impl Backend {
             return true;
         }
 
-        // Look up ClassInfo from ast_map (no disk I/O).
-        match self.find_class_in_ast_map(class_name) {
+        // Look up ClassInfo from uri_classes_index (no disk I/O).
+        match self.find_class_in_uri_classes_index(class_name) {
             Some(ci) => {
                 // Walk the parent class chain first.
                 if let Some(parent) = &ci.parent_class
@@ -528,7 +528,7 @@ impl Backend {
         let classify = |fqn: &str, sn: &str| -> Option<(char, bool)> {
             // Check if loaded as a class or interface so we can verify
             // Throwable ancestry.
-            let loaded_info = self.find_class_in_ast_map(fqn);
+            let loaded_info = self.find_class_in_uri_classes_index(fqn);
             let is_loaded_class_or_interface = loaded_info
                 .as_ref()
                 .is_some_and(|c| matches!(c.kind, ClassLikeKind::Class | ClassLikeKind::Interface));