Faster workspace symbol search

Author: AJenbo

docs/CHANGELOG.md

@@ -58,6 +58,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Faster `assert()`/type-guard narrowing during the forward walk.** Every statement used to build a fresh resolution context (including a scope clone) for each in-scope variable to check whether it was an `assert()` or `@phpstan-assert`/`@psalm-assert` call, even for statements that could never be one. Non-call statements now skip that work entirely, cutting a measurable share of the walk on methods with many locals and many statements.
 - **Faster diagnostics on method/function calls that resolve to no concrete class.** Checking whether such a call's result was actually a bare `object`/`?object` (still valid for member access) used to re-resolve the callee's whole receiver chain and method signature a second time from scratch. That check now reuses the resolution already performed, roughly halving diagnostics time on files with many unresolved or missing-method call chains.
 - **Argument checking no longer slows down quadratically with file size.** The argument-count and argument-type checks know the byte offset of every call they inspect, but used to convert it into an editor line/column position and immediately back again before looking up the called function. Each of those conversions re-read the file from the beginning to count characters, so the cost of checking one call grew with the size of the file around it and a file with thousands of calls spent nearly all its time on offset arithmetic. The offset is now used directly. On a 370 KB file containing 2200 calls the two checks together drop from 13.7 seconds to 0.2, taking the whole file from 16.7 seconds to 3.4, and analysing the project it belongs to is close to three times faster.
+- **Faster workspace symbol search.** Matching a symbol against the "Go to Symbol in Workspace" query no longer allocates a lowercased copy of every class, method, property, constant, and function name in the project on each keystroke; matching is now done byte-wise in place for the common case of ASCII identifiers.
 
 ### Removed
 

docs/todo.md

@@ -208,7 +208,6 @@ unlikely to move the needle for most users.
 | P18 | [Subtype result caching](todo/performance.md#p18-subtype-result-caching) (per-request HashMap for hierarchy walks)                                                          | Medium      | Low         |
 | P20 | [Content-hash gated resolution cache persistence](todo/performance.md#p20-content-hash-gated-resolution-cache-persistence)                                                  | Medium      | Medium      |
 | P21 | [Offset-shifting for cached diagnostics on partial edits](todo/performance.md#p21-offset-shifting-for-cached-diagnostics-on-partial-edits)                                  | Medium      | Medium      |
-| P23 | [`workspace/symbol` lowercases every symbol name per request](todo/performance.md#p23-workspacesymbol-allocates-a-lowercase-copy-of-every-symbol-name-per-request)          | Low-Medium  | Low         |
 |     | **[Indexing](todo/indexing.md)**                                                                                                                                            |             |             |
 | X3  | Completion item detail on demand (`completionItem/resolve`)                                                                                                                 | Medium      | Medium      |
 | X7  | [Recency tracking](todo/indexing.md#x7-recency-tracking)                                                                                                                    | Medium      | Medium      |

docs/todo/performance.md

@@ -561,37 +561,6 @@ the blast radius of an edit.
 
 ---
 
-## P23. `workspace/symbol` allocates a lowercase copy of every symbol name per request
-
-**Impact: Low-Medium · Effort: Low**
-
-`match_tier` (`src/workspace_symbols.rs:64-72`) calls
-`name.to_lowercase()` on every candidate symbol, and each symbol
-is tested against up to two or three name forms (FQN, short name,
-display name — call sites at lines 144, 232, 318, 401, 471). A
-`workspace/symbol` request walks every class, method, property,
-constant, and function in `uri_classes_index` and
-`global_functions`, so each keystroke in the editor's symbol
-picker performs O(total symbols × name length) heap allocations
-just for case folding, then throws them away.
-
-### Fix
-
-Match case-insensitively without allocating: a byte-wise
-`eq_ignore_ascii_case`-style prefix/substring scan (PHP
-identifiers are ASCII; a non-ASCII fallback can keep the old
-path), or store a pre-lowercased name alongside each symbol if
-the tiering logic needs real substring search. Note B25
-(case-insensitive index keys) will make lowercased names
-available on the index side anyway — implementing that first
-makes this nearly free.
-
-Related: full background indexing already populates a dedicated
-workspace-symbol index; this fix is independent and worth taking
-regardless since it is a few lines.
-
----
-
 ## P46. `mago-phpdoc-syntax` cannot parse `@method static (…) name()`
 
 **Impact: Low · Effort: Low (upstream)**

src/workspace_symbols.rs

@@ -61,22 +61,65 @@ struct RankedSymbol {
 ///
 /// `query_lower` must already be lowercased.  Returns `None` when
 /// there is no match at all.
+///
+/// PHP identifiers are ASCII, so the common case is matched byte-wise
+/// with `eq_ignore_ascii_case` and never allocates.  Non-ASCII names
+/// (e.g. a class in a file using non-ASCII identifiers) fall back to
+/// the allocating `to_lowercase()` path.
 fn match_tier(name: &str, query_lower: &str) -> Option<MatchTier> {
     if query_lower.is_empty() {
         // Empty query matches everything at the lowest tier so that
         // alphabetical ordering is the only tiebreaker.
         return Some(MatchTier::Substring);
     }
-    let name_lower = name.to_lowercase();
-    if name_lower == query_lower {
-        Some(MatchTier::Exact)
-    } else if name_lower.starts_with(query_lower) {
-        Some(MatchTier::Prefix)
-    } else if name_lower.contains(query_lower) {
-        Some(MatchTier::Substring)
+
+    if name.is_ascii() {
+        if ascii_eq_ignore_case(name, query_lower) {
+            Some(MatchTier::Exact)
+        } else if ascii_starts_with_ignore_case(name, query_lower) {
+            Some(MatchTier::Prefix)
+        } else if ascii_contains_ignore_case(name, query_lower) {
+            Some(MatchTier::Substring)
+        } else {
+            None
+        }
     } else {
-        None
+        let name_lower = name.to_lowercase();
+        if name_lower == query_lower {
+            Some(MatchTier::Exact)
+        } else if name_lower.starts_with(query_lower) {
+            Some(MatchTier::Prefix)
+        } else if name_lower.contains(query_lower) {
+            Some(MatchTier::Substring)
+        } else {
+            None
+        }
+    }
+}
+
+/// Case-insensitive equality for ASCII strings, without allocating.
+fn ascii_eq_ignore_case(s: &str, lower: &str) -> bool {
+    s.as_bytes().eq_ignore_ascii_case(lower.as_bytes())
+}
+
+/// Case-insensitive prefix check for ASCII strings, without allocating.
+fn ascii_starts_with_ignore_case(s: &str, prefix_lower: &str) -> bool {
+    s.len() >= prefix_lower.len()
+        && s.as_bytes()[..prefix_lower.len()].eq_ignore_ascii_case(prefix_lower.as_bytes())
+}
+
+/// Case-insensitive substring check for ASCII strings, without allocating.
+fn ascii_contains_ignore_case(s: &str, needle_lower: &str) -> bool {
+    let s = s.as_bytes();
+    let needle = needle_lower.as_bytes();
+    if needle.is_empty() {
+        return true;
+    }
+    if s.len() < needle.len() {
+        return false;
     }
+    s.windows(needle.len())
+        .any(|w| w.eq_ignore_ascii_case(needle))
 }
 
 /// Extract the short name from a symbol name for relevance ranking.
@@ -606,4 +649,35 @@ mod tests {
         assert!(MatchTier::Exact < MatchTier::Prefix);
         assert!(MatchTier::Prefix < MatchTier::Substring);
     }
+
+    #[test]
+    fn match_tier_non_ascii_name_falls_back() {
+        // Non-ASCII names (e.g. Turkish "İ") don't lowercase byte-for-byte,
+        // so they must go through the `to_lowercase()` fallback path.
+        assert_eq!(match_tier("Naïve", "naïve"), Some(MatchTier::Exact));
+        assert_eq!(match_tier("NaïveBar", "naïve"), Some(MatchTier::Prefix));
+        assert_eq!(
+            match_tier("MyNaïveBar", "naïve"),
+            Some(MatchTier::Substring)
+        );
+    }
+
+    #[test]
+    fn ascii_eq_ignore_case_matches() {
+        assert!(ascii_eq_ignore_case("Foo", "foo"));
+        assert!(!ascii_eq_ignore_case("FooBar", "foo"));
+    }
+
+    #[test]
+    fn ascii_starts_with_ignore_case_matches() {
+        assert!(ascii_starts_with_ignore_case("FooBar", "foo"));
+        assert!(!ascii_starts_with_ignore_case("Foo", "foobar"));
+    }
+
+    #[test]
+    fn ascii_contains_ignore_case_matches() {
+        assert!(ascii_contains_ignore_case("MyFooBar", "foo"));
+        assert!(!ascii_contains_ignore_case("MyBar", "foo"));
+        assert!(ascii_contains_ignore_case("Anything", ""));
+    }
 }