Lower memory use for method lookups

Author: AJenbo

docs/CHANGELOG.md

@@ -43,6 +43,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Property hover now shows effective types as a `var` detail line.** Property hovers now mirror method hovers by displaying the resolved/effective property type above the PHP snippet as `**var**`, while the snippet itself shows only the native PHP property declaration. This keeps docblock-inferred, virtual, and schema-derived property types out of the generated signature block. Contributed by @calebdw.
 - **Updated the bundled mago toolchain to 1.43.0.** The parser, docblock parser, formatter, and supporting crates are refreshed to the latest upstream release. Contributed by @enwi in https://github.com/PHPantom-dev/phpantom_lsp/pull/234.
 - **Lower memory use in the cross-file reference index.** The index backing Find References and the reference-count inlay hints now keeps only the distinct files and counts each symbol actually needs, instead of one entry per matching location plus never-read position data. On large projects this removes millions of short-lived allocations and shrinks the index to a fraction of its previous size, with no change to Find References or inlay hint results.
+- **Lower memory use for method lookups.** Each resolved class's method name index is now a sorted list searched with binary search instead of a hash map, using about a third of the memory for the same lookup speed. On large Laravel projects, where the resolved-class cache holds thousands of these indexes, this measurably shrinks total memory use.
 
 ### Removed
 

docs/todo.md

@@ -27,7 +27,6 @@ within the same impact tier.
 | --- | --------------------------------------------------------------------------------------------------------------------- | ---------- | ------ |
 | P36 | [Diagnostic-path call sites re-merge inheritance per call](todo/performance.md#p36-diagnostic-path-call-sites-re-merge-inheritance-per-call-instead-of-reading-the-resolved-class-cache)          | Medium      | Low         |
 | P38 | [Resolved type values are duplicated ~34x](todo/performance.md#p38-resolved-type-values-are-duplicated-34x)                                                          | High        | High        |
-| P40 | [`method_index` is a per-class `HashMap` even when the member vec is shared](todo/performance.md#p40-method_index-is-a-per-class-hashmap-even-when-the-member-vec-is-shared) | Low-Medium  | Low         |
 | P41 | [3.8 M live allocations cost ~170 MB in allocator overhead](todo/performance.md#p41-38-m-live-allocations-cost-170-mb-in-allocator-overhead)                          | Medium      | Medium      |
 | P43 | [`MemberAccess.subject_text` still allocates a `String` per span](todo/performance.md#p43-memberaccesssubject_text-still-allocates-a-string-per-span) | Low-Medium  | Medium      |
 | P33 | [Workspace diagnostics leaves the whole project fully resolved in memory](todo/performance.md#p33-workspace-diagnostics-leaves-the-whole-project-fully-resolved-in-memory) | High        | Medium-High |

docs/todo/performance.md

@@ -1156,33 +1156,6 @@ should keep owned payloads or use a separate bounded cache.
 
 ---
 
-## P40. `method_index` is a per-class `HashMap` even when the member vec is shared
-
-**Impact: Low-Medium · Effort: Low**
-
-`ClassInfo::method_index` is an `AtomMap<u32>` rebuilt per resolved
-class: 11 MB across 2 K classes on the mid-size app, 20 MB across 3.3 K
-on the large one — roughly 6 KB per class. At ~214 members a class the
-hashbrown bucket array rounds to 512 slots of 16 B plus control bytes,
-while the data it indexes is 214 entries of 12 B.
-
-The flattened member vectors are already shared between classes (only
-8.6 MB of slot vectors back 3.3 K classes), but each class still builds
-its own index over them.
-
-Two options, either of which is small:
-
-1. **Sorted `Vec<(Atom, u32)>` with binary search.** Roughly a third of
-   the memory (20 MB to ~7 MB) and better cache behaviour at these
-   sizes. Lookup goes from O(1) to O(log n) on ~200 entries, which is
-   3-4 comparisons of `Copy` pointer-sized keys.
-2. **Share the index alongside the member vector.** When two classes
-   share a `SharedVec` of methods they can share one `Arc` of its index,
-   which keeps O(1) lookup and removes the duplication instead of
-   shrinking it.
-
----
-
 ## P41. 3.8 M live allocations cost ~170 MB in allocator overhead
 
 **Impact: Medium · Effort: Medium**
@@ -1209,11 +1182,10 @@ trimmed live figure, confirming arena count was never the lever.
 
 What is left is allocation *count* itself: at ~45 B of overhead per
 live allocation, each allocation avoided is worth more than its own
-`size_of`. P39 and P40 each remove hundreds of thousands of allocations
-as a side effect (interning `SymbolKind` strings; sharing
-`method_index`), so re-measure this line after those land. If a
-meaningful gap remains afterward, the next lever is arena-allocating
-the member metadata (bump-allocate `MethodInfo`/`PropertyInfo`/
+`size_of`. P39 removes hundreds of thousands of allocations as a side
+effect (interning `SymbolKind` strings), so re-measure this line after
+it lands. If a meaningful gap remains afterward, the next lever is
+arena-allocating the member metadata (bump-allocate `MethodInfo`/`PropertyInfo`/
 `ParameterInfo` per resolved class instead of one `Box`/`Arc` per
 member) — a much larger change than anything else in this list, so only
 worth it if the per-allocation overhead is still the dominant cost once

src/mem_audit.rs

@@ -736,7 +736,9 @@ impl Audit {
             z.add(ARC + VEC_HDR + c.constants.audit_capacity() * size_of::<Arc<ConstantInfo>>());
             self.cls_slots += z;
         }
-        self.cls_index += map_buckets::<Atom, u32>(c.method_index.capacity());
+        let mut idx = Sz::default();
+        idx.add(VEC_HDR + c.method_index.capacity() * size_of::<(Atom, u32)>());
+        self.cls_index += idx;
 
         let mut names = Sz::default();
         names.add(c.interfaces.capacity() * size_of::<Atom>());
@@ -948,11 +950,6 @@ impl Audit {
             self.n_paramvecs,
             mb(self.empty_param_vecs * (ARC + VEC_HDR)),
         );
-        eprintln!(
-            "    method_index as sorted Vec<(Atom,u32)>: {:.1} MB → ~{:.1} MB",
-            mb(self.cls_index.bytes),
-            mb(self.cls_index.bytes / 3),
-        );
     }
 }
 

src/types/mod.rs

@@ -1579,15 +1579,22 @@ pub struct ClassInfo {
     /// The outer [`SharedVec`] makes cloning the entire `ClassInfo`
     /// O(1) (Arc refcount bump on the Vec itself).
     pub methods: SharedVec<Arc<MethodInfo>>,
-    /// O(1) index from lowercased method name → position in `methods`
-    /// (PHP method names are case-insensitive).
+    /// Index from lowercased method name → position in `methods`
+    /// (PHP method names are case-insensitive), sorted by name for
+    /// binary search.
+    ///
+    /// A sorted `Vec` costs about a third of the equivalent `AtomMap`
+    /// (hashbrown rounds its bucket array up to the next power of two,
+    /// so a class with ~200 methods pays for 512 slots) while a lookup
+    /// only costs a handful of `Atom` comparisons, which are `Copy`
+    /// pointer-sized values.
     ///
     /// Rebuilt by [`rebuild_method_index`] after bulk mutations
     /// (inheritance merge, parsing). The `get_method*` and `has_method`
-    /// helpers use this for O(1) lookup instead of linear scan.
+    /// helpers use this for `O(log n)` lookup instead of linear scan.
     /// When empty or stale (detected via `indexed_method_count`),
     /// the helpers fall back to linear scan.
-    pub method_index: AtomMap<u32>,
+    pub method_index: Vec<(Atom, u32)>,
     /// The `methods.len()` at the time `method_index` was last built.
     /// Used to detect staleness: if `methods.len() != indexed_method_count`,
     /// the index is stale and the helpers fall back to linear scan.
@@ -1889,13 +1896,16 @@ impl ClassInfo {
         self.method_index.clear();
         self.method_index.reserve(self.methods.len());
         for (i, method) in self.methods.iter().enumerate() {
-            // First-writer-wins: matches the semantics of
-            // `.iter().find(|m| m.name == name)` which returns the
-            // first match when duplicate names exist.
             self.method_index
-                .entry(crate::atom::ascii_lowercase_atom(&method.name))
-                .or_insert(i as u32);
+                .push((crate::atom::ascii_lowercase_atom(&method.name), i as u32));
         }
+        // Sort by name (then by original index) so lookups can binary
+        // search. Sorting the index pairs is stable per name, and
+        // deduping keeps the lowest index for each name, matching the
+        // first-writer-wins semantics of the old `.iter().find(...)`
+        // linear scan when duplicate names exist.
+        self.method_index.sort_unstable();
+        self.method_index.dedup_by_key(|&mut (name, _)| name);
         self.indexed_method_count = self.methods.len() as u32;
     }
 
@@ -1909,16 +1919,17 @@ impl ClassInfo {
     /// Look up a method by name, ignoring ASCII case (PHP method names
     /// are case-insensitive).
     ///
-    /// Uses the `method_index` for O(1) lookup when available,
-    /// falling back to linear scan otherwise.
+    /// Uses the `method_index` for `O(log n)` binary search when
+    /// available, falling back to linear scan otherwise.
     #[inline]
     pub fn get_method(&self, name: &str) -> Option<&MethodInfo> {
         if self.method_index_valid() {
             let atom = crate::atom::ascii_lowercase_atom(name);
             return self
                 .method_index
-                .get(&atom)
-                .and_then(|&idx| self.methods.get(idx as usize))
+                .binary_search_by_key(&atom, |&(n, _)| n)
+                .ok()
+                .and_then(|pos| self.methods.get(self.method_index[pos].1 as usize))
                 .map(|arc| arc.as_ref());
         }
         self.methods
@@ -1940,7 +1951,10 @@ impl ClassInfo {
     pub fn has_method(&self, name: &str) -> bool {
         if self.method_index_valid() {
             let atom = crate::atom::ascii_lowercase_atom(name);
-            return self.method_index.contains_key(&atom);
+            return self
+                .method_index
+                .binary_search_by_key(&atom, |&(n, _)| n)
+                .is_ok();
         }
         self.methods
             .iter()
@@ -1959,8 +1973,9 @@ impl ClassInfo {
             let atom = crate::atom::ascii_lowercase_atom(name);
             return self
                 .method_index
-                .get(&atom)
-                .and_then(|&idx| self.methods.get(idx as usize))
+                .binary_search_by_key(&atom, |&(n, _)| n)
+                .ok()
+                .and_then(|pos| self.methods.get(self.method_index[pos].1 as usize))
                 .map(Arc::clone);
         }
         self.methods