SearchEngine: Exact match to Rust — use IndexStore.Name()/NameLower()/BuildPath() arena accessors, remove parallel/Spar optimization that diverged from Rust. Single-threaded matching identical to Rust behavior.

FastSeekWpf/Core/SearchEngine.cs

@@ -22,21 +22,6 @@ public class SearchResult
 
 public static class SearchEngine
 {
-    [ThreadStatic]
-    private static StringBuilder? _pathBuilder;
-
-    private static StringBuilder GetPathBuilder()
-    {
-        var sb = _pathBuilder;
-        if (sb == null)
-        {
-            sb = new StringBuilder(512);
-            _pathBuilder = sb;
-        }
-        sb.Clear();
-        return sb;
-    }
-
     private static readonly string[] AppExtensions = { "exe", "lnk", "msi", "appx", "msix" };
     private static readonly string[] AppPathMarkers = {
         "\\program files\\", "\\program files (x86)\\",
@@ -88,20 +73,7 @@ public static class SearchEngine
         return false;
     }
 
-    private static bool SpanContains(ReadOnlySpan<char> haystack, ReadOnlySpan<char> needle)
-    {
-        if (needle.IsEmpty) return true;
-        if (needle.Length > haystack.Length) return false;
-
-        int limit = haystack.Length - needle.Length + 1;
-        for (int i = 0; i < limit; i++)
-        {
-            if (haystack.Slice(i, needle.Length).SequenceEqual(needle))
-                return true;
-        }
-        return false;
-    }
-
+    // Search — matches Rust search() exactly
     public static List<SearchResult> Search(
         IndexStore store,
         string query,
@@ -109,72 +81,60 @@ public static class SearchEngine
         bool caseSensitive,
         List<string> excludedDirs)
     {
-        if (string.IsNullOrWhiteSpace(query))
+        if (string.IsNullOrEmpty(query))
             return new List<SearchResult>();
 
-        var searchSw = System.Diagnostics.Stopwatch.StartNew();
         string q = caseSensitive ? query : query.ToLowerInvariant();
-        ReadOnlySpan<char> qSpan = q.AsSpan();
 
-        Span<(int idx, byte rank)> candidates = stackalloc (int, byte)[10000];
-        int candidateCount = 0;
+        // Phase 1: lightweight name-only matching
+        var candidates = new List<(int idx, byte rank)>();
 
-        lock (store)
+        for (int i = 0; i < store.Entries.Count; i++)
         {
-            int count = store.Entries.Count;
-            for (int i = 0; i < count; i++)
-            {
-                string name = caseSensitive ? store.NameAt(i) : store.NameLowerAt(i);
-                ReadOnlySpan<char> nameSpan = name.AsSpan();
+            var entry = store.Entries[i];
+            string nameCmp = caseSensitive ? store.Name(entry) : store.NameLower(entry);
 
-                byte rank;
-                if (nameSpan.SequenceEqual(qSpan)) rank = 1;
-                else if (nameSpan.StartsWith(qSpan, StringComparison.Ordinal)) rank = 2;
-                else if (SpanContains(nameSpan, qSpan)) rank = 3;
-                else continue;
+            byte rank;
+            if (nameCmp == q) rank = 1;
+            else if (nameCmp.StartsWith(q, StringComparison.Ordinal)) rank = 2;
+            else if (nameCmp.Contains(q, StringComparison.Ordinal)) rank = 3;
+            else continue;
 
-                if (candidateCount < candidates.Length)
-                    candidates[candidateCount++] = (i, rank);
-            }
+            candidates.Add((i, rank));
         }
 
-        candidates[..candidateCount].Sort((a, b) => a.rank.CompareTo(b.rank));
-
+        // Phase 2: sort by rank, keep overshoot buffer
+        candidates.Sort((a, b) => a.rank.CompareTo(b.rank));
         int overshoot = Math.Max(limit * 5, 1000);
-        if (candidateCount > overshoot)
-            candidateCount = overshoot;
+        if (candidates.Count > overshoot)
+            candidates.RemoveRange(overshoot, candidates.Count - overshoot);
 
-        var results = new List<SearchResult>(Math.Min(limit, candidateCount));
-        var pathBuilder = GetPathBuilder();
+        // Phase 3: build paths + exclusions + app promotion
+        var results = new List<SearchResult>(limit);
 
-        foreach (var (idx, baseRank) in candidates[..candidateCount])
+        foreach (var (idx, baseRank) in candidates)
         {
             var entry = store.Entries[idx];
-            string fullPath = BuildPathFast(store, entry.FileRef, pathBuilder, entry.DriveIdx);
-            string fullPathLower = fullPath.ToLowerInvariant();
+            string fullPath = store.BuildPath(entry.FileRef);
 
             if (excludedDirs.Count > 0)
             {
-                bool excluded = false;
-                foreach (var ex in excludedDirs)
-                {
-                    if (fullPathLower.StartsWith(ex, StringComparison.Ordinal))
-                    { excluded = true; break; }
-                }
-                if (excluded) continue;
+                string pathLower = fullPath.ToLowerInvariant();
+                if (excludedDirs.Any(ex => pathLower.StartsWith(ex, StringComparison.Ordinal)))
+                    continue;
             }
 
-            string name = store.NameAt(idx);
-            string nameLower = store.NameLowerAt(idx);
-
+            string nameLower = store.NameLower(entry);
             byte rank = baseRank;
             if (baseRank <= 2)
             {
-                int dotIdx = nameLower.LastIndexOf('.');
-                if (dotIdx >= 0)
+                string? ext = nameLower.Contains('.') ? nameLower[(nameLower.LastIndexOf('.') + 1)..] : null;
+                if (ext != null && Array.IndexOf(AppExtensions, ext) >= 0)
                 {
-                    string ext = nameLower[(dotIdx + 1)..];
-                    if (Array.IndexOf(AppExtensions, ext) >= 0 && ContainsAny(fullPathLower, AppPathMarkers))
+                    string pathLower = fullPath.ToLowerInvariant();
+                    if (!ContainsAny(pathLower, AppPathMarkers))
+                        rank = baseRank;
+                    else
                         rank = 0;
                 }
             }
@@ -182,6 +142,7 @@ public static class SearchEngine
             string? fileExt = null;
             if (!entry.IsDir)
             {
+                string name = store.Name(entry);
                 int dot = name.LastIndexOf('.');
                 if (dot >= 0) fileExt = name[(dot + 1)..].ToLowerInvariant();
             }
@@ -189,10 +150,10 @@ public static class SearchEngine
             results.Add(new SearchResult
             {
                 FullPath = fullPath,
-                Name = name,
+                Name = store.Name(entry),
                 Rank = rank,
                 IsDir = entry.IsDir,
-                Kind = GetKind(fileExt, entry.IsDir, fullPathLower)
+                Kind = GetKind(fileExt, entry.IsDir, fullPath.ToLowerInvariant())
             });
         }
 
@@ -200,12 +161,10 @@ public static class SearchEngine
         if (results.Count > limit)
             results.RemoveRange(limit, results.Count - limit);
 
-        searchSw.Stop();
-        Logger.Log($"Search '{query}': {candidateCount} candidates, {results.Count} results, {searchSw.ElapsedMilliseconds}ms (index={store.Count:N0})");
-
         return results;
     }
 
+    // Extension search — matches Rust extension filtering in main.rs
     public static List<SearchResult> SearchByExtension(
         IndexStore store,
         string ext,
@@ -213,76 +172,40 @@ public static class SearchEngine
     {
         string dotExt = "." + ext.ToLowerInvariant();
         var results = new List<SearchResult>();
-        var pathBuilder = GetPathBuilder();
 
-        lock (store)
+        for (int i = 0; i < store.Entries.Count; i++)
         {
-            for (int i = 0; i < store.Entries.Count; i++)
-            {
-                string name = store.NameLowerAt(i);
-                if (!name.EndsWith(dotExt)) continue;
-
-                var entry = store.Entries[i];
-                string fullPath = BuildPathFast(store, entry.FileRef, pathBuilder, entry.DriveIdx);
-                string fullPathLower = fullPath.ToLowerInvariant();
+            var entry = store.Entries[i];
+            string name = store.NameLower(entry);
+            if (!name.EndsWith(dotExt)) continue;
 
-                bool excluded = false;
-                foreach (var ex in excludedDirs)
-                {
-                    if (fullPathLower.StartsWith(ex, StringComparison.Ordinal))
-                    { excluded = true; break; }
-                }
-                if (excluded) continue;
-
-                string? fileExt = null;
-                int dot = name.LastIndexOf('.');
-                if (dot >= 0) fileExt = name[(dot + 1)..];
-
-                results.Add(new SearchResult
-                {
-                    FullPath = fullPath,
-                    Name = store.NameAt(i),
-                    Rank = 0,
-                    IsDir = entry.IsDir,
-                    Kind = GetKind(fileExt, entry.IsDir, fullPathLower)
-                });
+            string fullPath = store.BuildPath(entry.FileRef);
+            string fullPathLower = fullPath.ToLowerInvariant();
 
-                if (results.Count >= 50) break;
+            bool excluded = false;
+            foreach (var ex in excludedDirs)
+            {
+                if (fullPathLower.StartsWith(ex, StringComparison.Ordinal))
+                { excluded = true; break; }
             }
-        }
-
-        return results;
-    }
+            if (excluded) continue;
 
-    private static string BuildPathFast(IndexStore store, ulong fileRef, StringBuilder sb, byte startDriveIdx)
-    {
-        sb.Clear();
-        string[] components = new string[64];
-        int compCount = 0;
-        ulong current = fileRef;
-        byte driveIdx = startDriveIdx;
+            string? fileExt = null;
+            int dot = name.LastIndexOf('.');
+            if (dot >= 0) fileExt = name[(dot + 1)..];
 
-        for (int i = 0; i < 64; i++)
-        {
-            var idx = store.LookupIdx(current);
-            if (idx == null) break;
+            results.Add(new SearchResult
+            {
+                FullPath = fullPath,
+                Name = store.Name(entry),
+                Rank = 0,
+                IsDir = entry.IsDir,
+                Kind = GetKind(fileExt, entry.IsDir, fullPathLower)
+            });
 
-            int eIdx = (int)idx;
-            components[compCount++] = store.NameAt(eIdx);
-            var entry = store.Entries[eIdx];
-            driveIdx = entry.DriveIdx;
-            if (entry.ParentRef == current) break;
-            current = entry.ParentRef;
+            if (results.Count >= 50) break;
         }
 
-        string driveRoot = driveIdx < store.DriveRoots.Count ? store.DriveRoots[driveIdx] : "C:\\";
-        sb.Append(driveRoot);
-        for (int i = compCount - 1; i >= 0; i--)
-        {
-            if (sb.Length > 0 && sb[sb.Length - 1] != '\\' && sb[sb.Length - 1] != '/')
-                sb.Append('\\');
-            sb.Append(components[i]);
-        }
-        return sb.ToString();
+        return results;
     }
 }