use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::Arc;
use crate::domain::{ReferenceKind, ReferenceRecord};
use super::search::{
DEFAULT_MAX_PER_FILE, SymbolMatchTier, TextSearchError, TextSearchResult, compute_test_ranges,
current_code_search_keeps_file, search_symbols as base_search_symbols,
search_text as base_search_text, truncate_display_line,
};
use super::store::{IndexedFile, LiveIndex};
use crate::live_index::query::is_filtered_name;
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum CommitId {
Sha(String),
Dirtyless,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct BaseKey {
pub canonical_root: PathBuf,
pub commit: CommitId,
}
impl BaseKey {
pub fn new(canonical_root: impl Into<PathBuf>, commit: CommitId) -> Self {
Self {
canonical_root: canonical_root.into(),
commit,
}
}
}
#[derive(Clone)]
pub struct IndexBase {
pub key: BaseKey,
pub index: Arc<LiveIndex>,
pub base_generation: u64,
}
impl IndexBase {
pub fn new(key: BaseKey, index: Arc<LiveIndex>, base_generation: u64) -> Self {
Self {
key,
index,
base_generation,
}
}
}
#[derive(Clone)]
pub enum FileDelta {
Upsert(Arc<IndexedFile>),
Tombstone,
}
#[derive(Clone)]
pub struct Overlay {
pub base_key: BaseKey,
pub base_generation: u64,
pub deltas: HashMap<String, FileDelta>,
}
impl Overlay {
pub fn fresh(base: &IndexBase) -> Self {
Self {
base_key: base.key.clone(),
base_generation: base.base_generation,
deltas: HashMap::new(),
}
}
pub fn upsert(&mut self, rel_path: impl Into<String>, file: Arc<IndexedFile>) {
self.deltas.insert(rel_path.into(), FileDelta::Upsert(file));
}
pub fn tombstone(&mut self, rel_path: impl Into<String>) {
self.deltas.insert(rel_path.into(), FileDelta::Tombstone);
}
pub fn delta_count(&self) -> usize {
self.deltas.len()
}
pub fn is_valid_against(&self, base: &IndexBase) -> bool {
self.base_key == base.key && self.base_generation == base.base_generation
}
pub fn rebase(
&mut self,
new_base: &IndexBase,
still_dirty: &std::collections::HashSet<String>,
) {
self.deltas.retain(|path, _| still_dirty.contains(path));
self.base_key = new_base.key.clone();
self.base_generation = new_base.base_generation;
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct StaleOverlay {
pub base_generation: u64,
pub overlay_generation: u64,
}
impl std::fmt::Display for StaleOverlay {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"stale overlay: base generation {} != overlay generation {}",
self.base_generation, self.overlay_generation
)
}
}
impl std::error::Error for StaleOverlay {}
pub struct IndexView<'a> {
base: &'a LiveIndex,
overlay: Option<&'a Overlay>,
}
impl<'a> IndexView<'a> {
pub fn new(base: &'a IndexBase, overlay: Option<&'a Overlay>) -> Result<Self, StaleOverlay> {
if let Some(ov) = overlay {
if ov.base_generation != base.base_generation || ov.base_key != base.key {
return Err(StaleOverlay {
base_generation: base.base_generation,
overlay_generation: ov.base_generation,
});
}
}
Ok(Self {
base: base.index.as_ref(),
overlay,
})
}
pub fn base_only(base: &'a LiveIndex) -> Self {
Self {
base,
overlay: None,
}
}
pub fn get_file(&self, relative_path: &str) -> Option<&IndexedFile> {
if let Some(ov) = self.overlay
&& let Some(delta) = ov.deltas.get(relative_path)
{
return match delta {
FileDelta::Upsert(file) => Some(file.as_ref()),
FileDelta::Tombstone => None,
};
}
self.base.get_file(relative_path)
}
pub fn all_files(&self) -> Vec<(String, &IndexedFile)> {
match self.overlay {
None => self.base.all_files().map(|(p, f)| (p.clone(), f)).collect(),
Some(ov) => {
let mut out: Vec<(String, &IndexedFile)> = Vec::new();
for (path, file) in self.base.all_files() {
match ov.deltas.get(path) {
Some(FileDelta::Tombstone) => continue,
Some(FileDelta::Upsert(_)) => continue, None => out.push((path.clone(), file)),
}
}
for (path, delta) in &ov.deltas {
if let FileDelta::Upsert(file) = delta {
out.push((path.clone(), file.as_ref()));
}
}
out
}
}
}
fn overlay_deltas(&self) -> Option<&'a HashMap<String, FileDelta>> {
self.overlay.map(|ov| &ov.deltas)
}
pub fn search_symbols(&self, query: &str, kind_filter: Option<&str>) -> Vec<ViewSymbolHit> {
if self.overlay.is_none() {
let result = base_search_symbols(self.base, query, kind_filter, usize::MAX);
return result
.hits
.into_iter()
.map(|hit| ViewSymbolHit {
name: hit.name,
path: hit.path,
kind: hit.kind,
line: hit.line,
tier: hit.tier,
})
.collect();
}
let query_lower = query.to_lowercase();
let mut hits: Vec<ViewSymbolHit> = Vec::new();
let mut resolved = self.all_files();
resolved.sort_by(|a, b| a.0.cmp(&b.0));
for (path, file) in resolved {
for sym in &file.symbols {
if let Some(filter) = kind_filter
&& !filter.eq_ignore_ascii_case("all")
&& !symbol_kind_matches(filter, &sym.kind)
{
continue;
}
let name_lower = sym.name.to_lowercase();
if !name_lower.contains(&query_lower) {
continue;
}
let tier = if name_lower == query_lower {
SymbolMatchTier::Exact
} else if name_lower.starts_with(&query_lower) {
SymbolMatchTier::Prefix
} else {
SymbolMatchTier::Substring
};
hits.push(ViewSymbolHit {
name: sym.name.clone(),
path: path.clone(),
kind: sym.kind.to_string(),
line: sym.line_range.0 + 1,
tier,
});
}
}
hits.sort_by(|a, b| {
a.tier
.cmp(&b.tier)
.then(a.name.cmp(&b.name))
.then(a.path.cmp(&b.path))
});
hits
}
pub fn search_text(
&self,
query: Option<&str>,
terms: Option<&[String]>,
regex: bool,
) -> Result<TextSearchResult, TextSearchError> {
let mut result = base_search_text(self.base, query, terms, regex)?;
let Some(deltas) = self.overlay_deltas() else {
return Ok(result);
};
if deltas.is_empty() {
return Ok(result);
}
result.files.retain(|file| !deltas.contains_key(&file.path));
let matcher = overlay_text_matcher(query, terms, regex)?;
let mut overlay_suppressed = 0usize;
if let Some(matcher) = matcher {
let mut appended: Vec<super::search::TextFileMatches> = Vec::new();
for (path, delta) in deltas {
let FileDelta::Upsert(file) = delta else {
continue;
};
if !current_code_search_keeps_file(path, &file.classification) {
continue;
}
let scan = scan_file_lines(file, &matcher);
overlay_suppressed += scan.suppressed;
if !scan.matches.is_empty() {
appended.push(super::search::TextFileMatches {
path: path.clone(),
matches: scan.matches,
rendered_lines: None,
callers: None,
});
}
}
appended.sort_by(|a, b| a.path.cmp(&b.path));
result.files.extend(appended);
}
result.total_matches = result.files.iter().map(|f| f.matches.len()).sum();
result.overflow_count = 0;
result.suppressed_by_noise = overlay_suppressed;
Ok(result)
}
pub fn find_references(
&self,
name: &str,
kind_filter: Option<ReferenceKind>,
include_filtered: bool,
) -> Vec<(String, &'a ReferenceRecord)> {
let mut out: Vec<(String, &'a ReferenceRecord)> = self
.base
.find_references_for_name(name, kind_filter, include_filtered)
.into_iter()
.map(|(path, reference)| (path.to_string(), reference))
.collect();
let Some(deltas) = self.overlay_deltas() else {
return out;
};
if deltas.is_empty() {
return out;
}
out.retain(|(path, _)| !deltas.contains_key(path));
let is_qualified = name.contains("::") || name.contains('.');
let mut appended: Vec<(String, &'a ReferenceRecord)> = Vec::new();
for (path, delta) in deltas {
let FileDelta::Upsert(file) = delta else {
continue;
};
if !current_code_search_keeps_file(path, &file.classification) {
continue;
}
for reference in &file.references {
let name_matches = if is_qualified {
reference.qualified_name.as_deref() == Some(name)
} else {
reference.name == name
};
if !name_matches {
continue;
}
if let Some(kf) = kind_filter
&& reference.kind != kf
{
continue;
}
if !include_filtered && is_filtered_name(&reference.name, &file.language) {
continue;
}
appended.push((path.clone(), reference));
}
}
appended.sort_by(|a, b| a.0.cmp(&b.0));
out.extend(appended);
out
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ViewSymbolHit {
pub name: String,
pub path: String,
pub kind: String,
pub line: u32,
pub tier: SymbolMatchTier,
}
fn symbol_kind_matches(filter: &str, kind: &crate::domain::SymbolKind) -> bool {
if kind.to_string().eq_ignore_ascii_case(filter) {
return true;
}
matches!(
(filter.to_ascii_lowercase().as_str(), kind),
("variable", crate::domain::SymbolKind::Variable)
| ("function", crate::domain::SymbolKind::Function)
| ("method", crate::domain::SymbolKind::Method)
| ("module", crate::domain::SymbolKind::Module)
| ("constant", crate::domain::SymbolKind::Constant)
)
}
enum OverlayTextMatcher {
Terms { terms: Vec<String>, fold: bool },
Regex(regex::Regex),
}
impl OverlayTextMatcher {
fn is_match(&self, line: &str) -> bool {
match self {
Self::Terms { terms, fold } => {
if *fold {
let line_lower = line.to_lowercase();
terms.iter().any(|t| line_lower.contains(&t.to_lowercase()))
} else {
terms.iter().any(|t| line.contains(t))
}
}
Self::Regex(re) => re.is_match(line),
}
}
}
fn overlay_text_matcher(
query: Option<&str>,
terms: Option<&[String]>,
regex: bool,
) -> Result<Option<OverlayTextMatcher>, TextSearchError> {
if regex {
let pattern = query
.map(str::trim)
.filter(|text| !text.is_empty())
.unwrap_or("");
if pattern.is_empty() {
return Err(TextSearchError::EmptyRegexQuery);
}
let re = regex::RegexBuilder::new(pattern)
.case_insensitive(true)
.build()
.map_err(|error| TextSearchError::InvalidRegex {
pattern: pattern.to_string(),
error: error.to_string(),
})?;
return Ok(Some(OverlayTextMatcher::Regex(re)));
}
let collected: Vec<String> = match terms {
Some(raw) if !raw.is_empty() => raw
.iter()
.map(|t| t.trim())
.filter(|t| !t.is_empty())
.map(ToOwned::to_owned)
.collect(),
_ => query
.map(str::trim)
.filter(|text| !text.is_empty())
.map(|text| vec![text.to_string()])
.unwrap_or_default(),
};
if collected.is_empty() {
return Ok(None);
}
Ok(Some(OverlayTextMatcher::Terms {
terms: collected,
fold: true,
}))
}
struct OverlayFileScan {
matches: Vec<super::search::TextLineMatch>,
suppressed: usize,
}
fn scan_file_lines(file: &IndexedFile, matcher: &OverlayTextMatcher) -> OverlayFileScan {
let test_ranges: Vec<(u32, u32)> = if file.language == crate::domain::LanguageId::Rust {
compute_test_ranges(file)
} else {
Vec::new()
};
let content = String::from_utf8_lossy(&file.content);
let mut matches = Vec::new();
let mut suppressed = 0usize;
for (line_idx, line) in content.lines().enumerate() {
let line = line.trim_end_matches('\r');
if !matcher.is_match(line) {
continue;
}
if !test_ranges.is_empty() {
let line_num = line_idx as u32;
if test_ranges
.iter()
.any(|&(start, end)| line_num >= start && line_num <= end)
{
suppressed += 1;
continue;
}
}
if matches.len() < DEFAULT_MAX_PER_FILE {
matches.push(super::search::TextLineMatch {
line_number: line_idx + 1,
line: truncate_display_line(line),
enclosing_symbol: None,
});
}
}
OverlayFileScan {
matches,
suppressed,
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Targets {
One(String),
Subset(Vec<String>),
All,
}
impl Targets {
fn selects(&self, project_id: &str) -> bool {
match self {
Self::One(id) => id == project_id,
Self::Subset(ids) => ids.iter().any(|id| id == project_id),
Self::All => true,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ProjectHit<T> {
pub project_id: String,
pub hit: T,
}
#[derive(Clone)]
pub struct WorkingSetEntry {
pub project_id: String,
pub base: Arc<IndexBase>,
pub overlay: Overlay,
}
#[derive(Clone, Default)]
pub struct WorkingSet {
entries: Vec<WorkingSetEntry>,
}
impl WorkingSet {
pub fn new() -> Self {
Self {
entries: Vec::new(),
}
}
pub fn add(&mut self, project_id: impl Into<String>, base: Arc<IndexBase>) {
let project_id = project_id.into();
let overlay = Overlay::fresh(&base);
let entry = WorkingSetEntry {
project_id: project_id.clone(),
base,
overlay,
};
if let Some(slot) = self.entries.iter_mut().find(|e| e.project_id == project_id) {
*slot = entry;
} else {
self.entries.push(entry);
}
}
pub fn remove(&mut self, project_id: &str) -> Option<WorkingSetEntry> {
let pos = self
.entries
.iter()
.position(|e| e.project_id == project_id)?;
Some(self.entries.remove(pos))
}
pub fn get(&self, project_id: &str) -> Option<&WorkingSetEntry> {
self.entries.iter().find(|e| e.project_id == project_id)
}
pub fn get_mut(&mut self, project_id: &str) -> Option<&mut WorkingSetEntry> {
self.entries.iter_mut().find(|e| e.project_id == project_id)
}
pub fn iter(&self) -> impl Iterator<Item = &WorkingSetEntry> {
self.entries.iter()
}
pub fn len(&self) -> usize {
self.entries.len()
}
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
pub fn shares_base_with(&self, project_a: &str, project_b: &str) -> bool {
match (self.get(project_a), self.get(project_b)) {
(Some(a), Some(b)) => Arc::ptr_eq(&a.base, &b.base),
_ => false,
}
}
fn view_for<'a>(entry: &'a WorkingSetEntry) -> Result<IndexView<'a>, StaleOverlay> {
IndexView::new(&entry.base, Some(&entry.overlay))
}
pub fn search_symbols(
&self,
targets: &Targets,
query: &str,
kind_filter: Option<&str>,
) -> Vec<ProjectHit<ViewSymbolHit>> {
let mut out = Vec::new();
for entry in self
.entries
.iter()
.filter(|e| targets.selects(&e.project_id))
{
let Ok(view) = Self::view_for(entry) else {
continue;
};
for hit in view.search_symbols(query, kind_filter) {
out.push(ProjectHit {
project_id: entry.project_id.clone(),
hit,
});
}
}
out
}
pub fn search_text(
&self,
targets: &Targets,
query: Option<&str>,
terms: Option<&[String]>,
regex: bool,
) -> Result<Vec<ProjectHit<TextSearchResult>>, TextSearchError> {
let mut out = Vec::new();
for entry in self
.entries
.iter()
.filter(|e| targets.selects(&e.project_id))
{
let Ok(view) = Self::view_for(entry) else {
continue;
};
let result = view.search_text(query, terms, regex)?;
out.push(ProjectHit {
project_id: entry.project_id.clone(),
hit: result,
});
}
Ok(out)
}
pub fn find_references(
&self,
targets: &Targets,
name: &str,
kind_filter: Option<ReferenceKind>,
include_filtered: bool,
) -> Vec<ProjectHit<(String, ReferenceRecord)>> {
let mut out = Vec::new();
for entry in self
.entries
.iter()
.filter(|e| targets.selects(&e.project_id))
{
let Ok(view) = Self::view_for(entry) else {
continue;
};
for (path, reference) in view.find_references(name, kind_filter, include_filtered) {
out.push(ProjectHit {
project_id: entry.project_id.clone(),
hit: (path, reference.clone()),
});
}
}
out
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::domain::{FileClassification, LanguageId};
use crate::live_index::store::{IndexedFile, LiveIndex, ParseStatus};
use std::collections::HashSet;
use std::time::Instant;
fn make_file(path: &str, content: &str) -> IndexedFile {
IndexedFile {
relative_path: path.to_string(),
language: LanguageId::Rust,
classification: FileClassification::for_code_path(path),
content: content.as_bytes().to_vec(),
symbols: Vec::new(),
parse_status: ParseStatus::Parsed,
parse_diagnostic: None,
byte_len: content.len() as u64,
content_hash: format!("h:{}", content.len()),
references: Vec::new(),
alias_map: HashMap::new(),
mtime_secs: 0,
}
}
fn synthetic_index(n: usize) -> LiveIndex {
let mut idx = LiveIndex::empty_live_index();
idx.is_empty = false;
idx.loaded_at = Instant::now();
let mut files: HashMap<String, Arc<IndexedFile>> = HashMap::with_capacity(n);
for i in 0..n {
let path = format!("f{i}.rs");
let file = make_file(&path, &format!("fn f{i}() {{}}"));
files.insert(path, Arc::new(file));
}
idx.files = files;
idx
}
fn base_key(commit: &str) -> BaseKey {
BaseKey::new("/repo/root", CommitId::Sha(commit.to_string()))
}
#[test]
fn proof2_overlay_isolation() {
let live = synthetic_index(3); let base = Arc::new(IndexBase::new(base_key("c0"), Arc::new(live), 1));
let mut overlay_a = Overlay::fresh(&base);
overlay_a.upsert("f0.rs", Arc::new(make_file("f0.rs", "A_EDITED")));
overlay_a.tombstone("f1.rs");
let overlay_b = Overlay::fresh(&base);
let view_a = IndexView::new(&base, Some(&overlay_a)).expect("A view");
let view_b = IndexView::new(&base, Some(&overlay_b)).expect("B view");
assert_eq!(view_a.get_file("f0.rs").unwrap().content, b"A_EDITED");
assert!(view_a.get_file("f1.rs").is_none(), "tombstone hides for A");
assert_eq!(view_b.get_file("f0.rs").unwrap().content, b"fn f0() {}");
assert!(
view_b.get_file("f1.rs").is_some(),
"A's tombstone must not affect B"
);
assert_eq!(view_b.get_file("f1.rs").unwrap().content, b"fn f1() {}");
}
#[test]
fn proof1_shared_base_no_clone() {
let live = synthetic_index(100);
let probe = Arc::clone(live.files.get("f0.rs").expect("f0"));
let inner_count_baseline = Arc::strong_count(&probe);
let base = Arc::new(IndexBase::new(base_key("c0"), Arc::new(live), 1));
let overlay_1 = Overlay::fresh(&base);
let base_2 = Arc::clone(&base);
let overlay_2 = Overlay::fresh(&base_2);
assert!(
Arc::ptr_eq(&base, &base_2),
"consumers must share one IndexBase allocation"
);
assert!(Arc::ptr_eq(&base.index, &base_2.index));
let _view_1 = IndexView::new(&base, Some(&overlay_1)).expect("v1");
let _view_2 = IndexView::new(&base_2, Some(&overlay_2)).expect("v2");
let inner_count_after = Arc::strong_count(&probe);
assert_eq!(
inner_count_after, inner_count_baseline,
"adding consumer #2 must not clone the base files map \
(inner file Arc strong_count must not increase): {inner_count_baseline} -> {inner_count_after}"
);
}
#[test]
fn proof3_no_forced_reload() {
let live = synthetic_index(3);
let base_v1 = Arc::new(IndexBase::new(base_key("c0"), Arc::new(live), 1));
let overlay_b = Overlay::fresh(&base_v1);
let view_b = IndexView::new(&base_v1, Some(&overlay_b)).expect("B view v1");
assert_eq!(view_b.get_file("f0.rs").unwrap().content, b"fn f0() {}");
let mut live_v2 = synthetic_index(3);
live_v2.files.insert(
"f0.rs".to_string(),
Arc::new(make_file("f0.rs", "REINDEXED")),
);
let _base_v2 = Arc::new(IndexBase::new(base_key("c1"), Arc::new(live_v2), 2));
assert_eq!(
view_b.get_file("f0.rs").unwrap().content,
b"fn f0() {}",
"B's view over the prior snapshot must be unaffected by A's reindex"
);
}
#[test]
fn proof4_stale_fence() {
let live = synthetic_index(2);
let base_v1 = IndexBase::new(base_key("c0"), Arc::new(live), 1);
let overlay = Overlay::fresh(&base_v1);
assert!(overlay.is_valid_against(&base_v1));
let base_v2 = IndexBase::new(
base_key("c1"),
Arc::clone(&base_v1.index),
base_v1.base_generation + 1,
);
match IndexView::new(&base_v2, Some(&overlay)) {
Err(err) => assert_eq!(
err,
StaleOverlay {
base_generation: 2,
overlay_generation: 1
},
"reading a gen-1 overlay against a gen-2 base must be StaleOverlay"
),
Ok(_) => panic!("expected StaleOverlay, got a valid view"),
}
assert!(!overlay.is_valid_against(&base_v2));
}
#[test]
fn proof5_falsifier_rebase_is_ok_not_on() {
let ns = [1_000usize, 10_000usize];
let ks = [1usize, 8usize, 64usize];
let mut table: Vec<(usize, usize, f64)> = Vec::new();
for &n in &ns {
for &k in &ks {
let per_rebase_ns = bench_rebase_steady_state(n, k);
table.push((n, k, per_rebase_ns));
}
}
println!("\n=== Proof 5 falsifier: steady-state overlay rebase cost ===");
println!("{:>8} {:>6} {:>16}", "N", "K", "rebase (ns/op)");
for &(n, k, t) in &table {
println!("{n:>8} {k:>6} {t:>16.1}");
}
for &k in &ks {
let t_1k = lookup(&table, 1_000, k).max(0.1);
let t_10k = lookup(&table, 10_000, k);
let ratio = t_10k / t_1k;
println!("K={k}: t(10k)/t(1k) = {ratio:.2} (PASS if < 2.5 -> independent of N)");
assert!(
ratio < 2.5,
"FALSIFIER TRIPPED: rebase scaled with N for K={k} \
(t_1k={t_1k:.1}ns, t_10k={t_10k:.1}ns, ratio={ratio:.2}); \
rebase is NOT O(K) -> revisit the primitive design"
);
}
for &n in &ns {
let t_k1 = lookup(&table, n, 1).max(0.1);
let t_k64 = lookup(&table, n, 64);
let ratio = t_k64 / t_k1;
println!("N={n}: t(K=64)/t(K=1) = {ratio:.2} (cost lives in K, linear-ish)");
assert!(
t_k64 > t_k1,
"rebase cost should grow with the dirty set K (N={n}): \
t(K=1)={t_k1:.1}ns, t(K=64)={t_k64:.1}ns"
);
assert!(
ratio < 200.0,
"rebase cost should be near-linear in K, not super-linear (N={n}): \
t(K=1)={t_k1:.1}ns, t(K=64)={t_k64:.1}ns, ratio={ratio:.2}"
);
}
assert_rebase_semantics();
}
fn lookup(table: &[(usize, usize, f64)], n: usize, k: usize) -> f64 {
table
.iter()
.find(|&&(nn, kk, _)| nn == n && kk == k)
.map(|&(_, _, t)| t)
.expect("table cell")
}
fn bench_rebase_steady_state(n: usize, k: usize) -> f64 {
use std::time::Instant as TInstant;
let base_v1 = IndexBase::new(base_key("c0"), Arc::new(synthetic_index(n)), 1);
let base_v2 = IndexBase::new(base_key("c1"), Arc::new(synthetic_index(n)), 2);
let mut pristine = Overlay::fresh(&base_v1);
for i in 0..k {
pristine.upsert(
format!("f{i}.rs"),
Arc::new(make_file(&format!("f{i}.rs"), "DIRTY")),
);
}
let still_dirty: HashSet<String> = (0..k)
.filter(|i| i % 2 == 0)
.map(|i| format!("f{i}.rs"))
.collect();
const ITERS: usize = 2_000;
{
let mut o = pristine.clone();
o.rebase(&base_v2, &still_dirty);
std::hint::black_box(&o);
}
let mut overlays: Vec<Overlay> = (0..ITERS).map(|_| pristine.clone()).collect();
let start = TInstant::now();
for o in overlays.iter_mut() {
o.rebase(&base_v2, &still_dirty);
std::hint::black_box(&*o);
}
let total = start.elapsed().as_nanos() as f64;
std::hint::black_box(&overlays);
debug_assert!(overlays[ITERS - 1].is_valid_against(&base_v2));
debug_assert_eq!(overlays[ITERS - 1].delta_count(), still_dirty.len());
total / ITERS as f64
}
fn assert_rebase_semantics() {
let live = synthetic_index(10);
let base_v1 = IndexBase::new(base_key("c0"), Arc::new(live), 1);
let mut overlay = Overlay::fresh(&base_v1);
overlay.upsert("f0.rs", Arc::new(make_file("f0.rs", "DIRTY0")));
overlay.upsert("f1.rs", Arc::new(make_file("f1.rs", "DIRTY1")));
overlay.tombstone("f2.rs");
assert_eq!(overlay.delta_count(), 3);
let live_v2 = synthetic_index(10);
let base_v2 = IndexBase::new(base_key("c1"), Arc::new(live_v2), 2);
let still_dirty: HashSet<String> = ["f0.rs".to_string(), "f2.rs".to_string()]
.into_iter()
.collect();
overlay.rebase(&base_v2, &still_dirty);
assert_eq!(
overlay.delta_count(),
2,
"absorbed delta f1.rs must be dropped"
);
assert!(overlay.deltas.contains_key("f0.rs"));
assert!(overlay.deltas.contains_key("f2.rs"));
assert!(!overlay.deltas.contains_key("f1.rs"));
assert!(overlay.is_valid_against(&base_v2), "re-fenced to new base");
let view = IndexView::new(&base_v2, Some(&overlay)).expect("view");
assert_eq!(view.get_file("f0.rs").unwrap().content, b"DIRTY0");
assert!(
view.get_file("f2.rs").is_none(),
"tombstone survives rebase"
);
assert_eq!(view.get_file("f1.rs").unwrap().content, b"fn f1() {}");
}
#[test]
fn all_files_merges_overlay() {
let live = synthetic_index(3); let base = IndexBase::new(base_key("c0"), Arc::new(live), 1);
let mut overlay = Overlay::fresh(&base);
overlay.upsert("f0.rs", Arc::new(make_file("f0.rs", "EDIT")));
overlay.tombstone("f1.rs");
overlay.upsert("new.rs", Arc::new(make_file("new.rs", "NEW")));
let view = IndexView::new(&base, Some(&overlay)).expect("view");
let mut paths: Vec<String> = view.all_files().into_iter().map(|(p, _)| p).collect();
paths.sort();
assert_eq!(paths, vec!["f0.rs", "f2.rs", "new.rs"]);
let base_view = IndexView::base_only(base.index.as_ref());
let mut base_paths: Vec<String> =
base_view.all_files().into_iter().map(|(p, _)| p).collect();
base_paths.sort();
assert_eq!(base_paths, vec!["f0.rs", "f1.rs", "f2.rs"]);
}
use crate::domain::{ReferenceKind, ReferenceRecord, SymbolKind, SymbolRecord};
fn make_file_with_symbol(path: &str, symbol_name: &str, content: &str) -> IndexedFile {
let mut file = make_file(path, content);
file.symbols = vec![SymbolRecord {
name: symbol_name.to_string(),
kind: SymbolKind::Function,
depth: 0,
sort_order: 0,
byte_range: (0, content.len() as u32),
line_range: (0, 0),
doc_byte_range: None,
item_byte_range: None,
}];
file
}
fn base_with_symbol(
root: &str,
commit: &str,
symbol_name: &str,
content: &str,
) -> Arc<IndexBase> {
let mut idx = LiveIndex::empty_live_index();
idx.is_empty = false;
idx.loaded_at = Instant::now();
let mut files: HashMap<String, Arc<IndexedFile>> = HashMap::new();
files.insert(
"f.rs".to_string(),
Arc::new(make_file_with_symbol("f.rs", symbol_name, content)),
);
idx.trigram_index = crate::live_index::trigram::TrigramIndex::build_from_files(&files);
idx.files = files;
idx.rebuild_reverse_index();
Arc::new(IndexBase::new(
BaseKey::new(root, CommitId::Sha(commit.to_string())),
Arc::new(idx),
1,
))
}
#[test]
fn working_set_add_remove_get() {
let mut ws = WorkingSet::new();
assert!(ws.is_empty());
let base_a = base_with_symbol("/a", "c0", "alpha_fn", "fn alpha_fn() {}");
let base_b = base_with_symbol("/b", "c0", "beta_fn", "fn beta_fn() {}");
ws.add("A", Arc::clone(&base_a));
ws.add("B", Arc::clone(&base_b));
assert_eq!(ws.len(), 2);
assert!(ws.get("A").is_some());
assert!(ws.get("B").is_some());
assert!(ws.get("missing").is_none());
let removed = ws.remove("A").expect("A present");
assert_eq!(removed.project_id, "A");
assert!(ws.get("A").is_none());
assert_eq!(ws.len(), 1);
assert!(ws.remove("A").is_none());
let ids: Vec<&str> = ws.iter().map(|e| e.project_id.as_str()).collect();
assert_eq!(ids, vec!["B"]);
}
#[test]
fn working_set_add_replaces_existing_id() {
let mut ws = WorkingSet::new();
let base_v1 = base_with_symbol("/a", "c0", "old_fn", "fn old_fn() {}");
ws.add("A", base_v1);
ws.get_mut("A")
.unwrap()
.overlay
.upsert("dirty.rs", Arc::new(make_file("dirty.rs", "X")));
assert_eq!(ws.get("A").unwrap().overlay.delta_count(), 1);
let base_v2 = base_with_symbol("/a", "c1", "new_fn", "fn new_fn() {}");
ws.add("A", base_v2);
assert_eq!(ws.len(), 1, "re-add same id must replace, not duplicate");
assert_eq!(
ws.get("A").unwrap().overlay.delta_count(),
0,
"re-add resets the overlay"
);
}
#[test]
fn cross_project_search_is_source_attributed() {
let mut ws = WorkingSet::new();
ws.add(
"A",
base_with_symbol("/a", "c0", "shared_a", "fn shared_a() {}"),
);
ws.add(
"B",
base_with_symbol("/b", "c0", "shared_b", "fn shared_b() {}"),
);
ws.add(
"C",
base_with_symbol("/c", "c0", "shared_c", "fn shared_c() {}"),
);
let hits = ws.search_symbols(&Targets::All, "shared", None);
assert_eq!(hits.len(), 3, "one hit per project");
let mut by_project: HashMap<&str, &str> = HashMap::new();
for h in &hits {
by_project.insert(h.project_id.as_str(), h.hit.name.as_str());
}
assert_eq!(by_project.get("A"), Some(&"shared_a"));
assert_eq!(by_project.get("B"), Some(&"shared_b"));
assert_eq!(by_project.get("C"), Some(&"shared_c"));
}
#[test]
fn cross_project_search_respects_targets() {
let mut ws = WorkingSet::new();
ws.add(
"A",
base_with_symbol("/a", "c0", "shared_a", "fn shared_a() {}"),
);
ws.add(
"B",
base_with_symbol("/b", "c0", "shared_b", "fn shared_b() {}"),
);
ws.add(
"C",
base_with_symbol("/c", "c0", "shared_c", "fn shared_c() {}"),
);
let one = ws.search_symbols(&Targets::One("B".to_string()), "shared", None);
assert_eq!(one.len(), 1);
assert_eq!(one[0].project_id, "B");
assert_eq!(one[0].hit.name, "shared_b");
let subset = ws.search_symbols(
&Targets::Subset(vec!["A".to_string(), "C".to_string()]),
"shared",
None,
);
let projects: std::collections::BTreeSet<&str> =
subset.iter().map(|h| h.project_id.as_str()).collect();
assert_eq!(
projects,
["A", "C"]
.into_iter()
.collect::<std::collections::BTreeSet<_>>()
);
let none = ws.search_symbols(&Targets::One("Z".to_string()), "shared", None);
assert!(none.is_empty());
}
#[test]
fn working_set_shares_base_arc() {
let mut ws = WorkingSet::new();
let shared = base_with_symbol("/repo", "c0", "f", "fn f() {}");
ws.add("view1", Arc::clone(&shared));
ws.add("view2", Arc::clone(&shared));
let a = ws.get("view1").unwrap();
let b = ws.get("view2").unwrap();
assert!(
Arc::ptr_eq(&a.base, &b.base),
"two entries on the same shared Arc<IndexBase> must be one allocation (SC-002)"
);
assert!(Arc::ptr_eq(&a.base.index, &b.base.index));
assert!(ws.shares_base_with("view1", "view2"));
ws.add("other", base_with_symbol("/other", "c0", "g", "fn g() {}"));
assert!(!ws.shares_base_with("view1", "other"));
}
#[test]
fn view_search_text_reflects_overlay_deltas() {
let base = base_with_symbol("/a", "c0", "f", "let NEEDLE = 1;");
let mut overlay = Overlay::fresh(&base);
let base_view = IndexView::new(&base, None).unwrap();
let base_hits = base_view
.search_text(Some("NEEDLE"), None, false)
.expect("base text search");
assert_eq!(base_hits.total_matches, 1);
assert_eq!(base_hits.files.len(), 1);
assert_eq!(base_hits.files[0].path, "f.rs");
overlay.upsert("f.rs", Arc::new(make_file("f.rs", "let other = 2;")));
overlay.upsert("new.rs", Arc::new(make_file("new.rs", "let NEEDLE = 3;")));
let view = IndexView::new(&base, Some(&overlay)).unwrap();
let result = view
.search_text(Some("NEEDLE"), None, false)
.expect("overlay text search");
let paths: std::collections::BTreeSet<&str> =
result.files.iter().map(|f| f.path.as_str()).collect();
assert!(
!paths.contains("f.rs"),
"dirty edit's stale base hit must not be returned"
);
assert!(
paths.contains("new.rs"),
"an upserted file's fresh hit must be returned"
);
assert_eq!(result.total_matches, 1, "only the live overlay hit remains");
}
#[test]
fn view_search_text_tombstone_drops_base_hit() {
let base = base_with_symbol("/a", "c0", "f", "let NEEDLE = 1;");
let mut overlay = Overlay::fresh(&base);
overlay.tombstone("f.rs");
let view = IndexView::new(&base, Some(&overlay)).unwrap();
let result = view
.search_text(Some("NEEDLE"), None, false)
.expect("text search");
assert_eq!(
result.total_matches, 0,
"a tombstoned file contributes no text hits"
);
assert!(result.files.is_empty());
}
#[test]
fn view_find_references_reflects_overlay_deltas() {
let mut idx = LiveIndex::empty_live_index();
idx.is_empty = false;
idx.loaded_at = Instant::now();
let mut caller = make_file("caller.rs", "fn use_it() { target_fn(); }");
caller.references = vec![ReferenceRecord {
name: "target_fn".to_string(),
qualified_name: None,
kind: ReferenceKind::Call,
byte_range: (14, 23),
line_range: (0, 0),
enclosing_symbol_index: None,
}];
let mut files: HashMap<String, Arc<IndexedFile>> = HashMap::new();
files.insert("caller.rs".to_string(), Arc::new(caller));
idx.files = files;
idx.rebuild_reverse_index();
let base = Arc::new(IndexBase::new(
BaseKey::new("/a", CommitId::Sha("c0".to_string())),
Arc::new(idx),
1,
));
let base_view = IndexView::new(&base, None).unwrap();
let base_refs = base_view.find_references("target_fn", None, true);
assert_eq!(base_refs.len(), 1);
assert_eq!(base_refs[0].0, "caller.rs");
let mut overlay = Overlay::fresh(&base);
overlay.upsert(
"caller.rs",
Arc::new(make_file("caller.rs", "fn use_it() { /* removed */ }")),
);
let mut new_caller = make_file("new_caller.rs", "fn n() { target_fn(); }");
new_caller.references = vec![ReferenceRecord {
name: "target_fn".to_string(),
qualified_name: None,
kind: ReferenceKind::Call,
byte_range: (9, 18),
line_range: (0, 0),
enclosing_symbol_index: None,
}];
overlay.upsert("new_caller.rs", Arc::new(new_caller));
let view = IndexView::new(&base, Some(&overlay)).unwrap();
let refs = view.find_references("target_fn", None, true);
let paths: std::collections::BTreeSet<&str> =
refs.iter().map(|(p, _)| p.as_str()).collect();
assert!(
!paths.contains("caller.rs"),
"dirty edit's stale base reference must not be returned"
);
assert!(
paths.contains("new_caller.rs"),
"an upserted file's reference must be returned"
);
assert_eq!(refs.len(), 1);
}
#[test]
fn view_search_text_overlay_caps_and_truncates() {
let base = base_with_symbol("/a", "c0", "f", "fn f() {}");
let mut overlay = Overlay::fresh(&base);
let mut body = String::new();
for i in 0..10 {
body.push_str(&format!("let NEEDLE_{i} = {i};\n"));
}
body.push_str(&format!("let NEEDLE_long = \"{}\";\n", "x".repeat(5000)));
overlay.upsert("added.rs", Arc::new(make_file("added.rs", &body)));
let view = IndexView::new(&base, Some(&overlay)).unwrap();
let result = view
.search_text(Some("NEEDLE"), None, false)
.expect("overlay text search");
let added = result
.files
.iter()
.find(|f| f.path == "added.rs")
.expect("added.rs present");
assert_eq!(
added.matches.len(),
5,
"overlay scan must cap retained matches at DEFAULT_MAX_PER_FILE like the base"
);
for m in &added.matches {
assert!(
m.line.chars().count() <= super::super::search::MAX_DISPLAY_LINE_CHARS + 64,
"retained overlay line must be truncated, not raw: len={}",
m.line.chars().count()
);
}
assert_eq!(result.total_matches, added.matches.len());
assert_eq!(result.overflow_count, 0);
assert_eq!(result.suppressed_by_noise, 0);
}
#[test]
fn view_search_text_overlay_suppresses_test_classified_file() {
let base = base_with_symbol("/a", "c0", "f", "let NEEDLE = 1;");
let mut overlay = Overlay::fresh(&base);
overlay.upsert(
"tests/foo.rs",
Arc::new(make_file("tests/foo.rs", "let NEEDLE = 99;")),
);
overlay.upsert(
"src/added.rs",
Arc::new(make_file("src/added.rs", "let NEEDLE = 2;")),
);
let view = IndexView::new(&base, Some(&overlay)).unwrap();
let result = view
.search_text(Some("NEEDLE"), None, false)
.expect("overlay text search");
let paths: std::collections::BTreeSet<&str> =
result.files.iter().map(|f| f.path.as_str()).collect();
assert!(
!paths.contains("tests/foo.rs"),
"an upserted test-classified file must not leak hits the base would suppress"
);
assert!(
paths.contains("src/added.rs"),
"an upserted code file's hit is returned"
);
}
#[test]
fn view_search_text_overlay_suppresses_cfg_test_block() {
let base = base_with_symbol("/a", "c0", "f", "fn f() {}");
let mut overlay = Overlay::fresh(&base);
let content = "let NEEDLE = 0;\nmod tests {\nlet NEEDLE = 1;\nlet NEEDLE = 2;\n}\n";
let mut file = make_file("src/code.rs", content);
file.symbols = vec![SymbolRecord {
name: "tests".to_string(),
kind: SymbolKind::Module,
depth: 0,
sort_order: 0,
byte_range: (0, content.len() as u32),
line_range: (1, 4),
doc_byte_range: None,
item_byte_range: None,
}];
overlay.upsert("src/code.rs", Arc::new(file));
let view = IndexView::new(&base, Some(&overlay)).unwrap();
let result = view
.search_text(Some("NEEDLE"), None, false)
.expect("overlay text search");
let code = result
.files
.iter()
.find(|f| f.path == "src/code.rs")
.expect("src/code.rs present");
assert_eq!(
code.matches.len(),
1,
"only the non-test-module NEEDLE match should be visible"
);
assert_eq!(code.matches[0].line_number, 1);
assert_eq!(
result.suppressed_by_noise, 2,
"the two #[cfg(test)]-module matches are counted as suppressed"
);
}
#[test]
fn view_find_references_overlay_honors_include_filtered() {
let mut idx = LiveIndex::empty_live_index();
idx.is_empty = false;
idx.loaded_at = Instant::now();
idx.rebuild_reverse_index();
let base = Arc::new(IndexBase::new(
BaseKey::new("/a", CommitId::Sha("c0".to_string())),
Arc::new(idx),
1,
));
let mut overlay = Overlay::fresh(&base);
let mut added = make_file("src/added.rs", "fn n<T>() -> T { todo!() }");
added.references = vec![ReferenceRecord {
name: "T".to_string(),
qualified_name: None,
kind: ReferenceKind::TypeUsage,
byte_range: (0, 1),
line_range: (0, 0),
enclosing_symbol_index: None,
}];
overlay.upsert("src/added.rs", Arc::new(added));
let view = IndexView::new(&base, Some(&overlay)).unwrap();
let hidden = view.find_references("T", None, false);
assert!(
hidden.is_empty(),
"with include_filtered=false an overlay single-letter generic ref must be filtered"
);
let shown = view.find_references("T", None, true);
assert_eq!(
shown.len(),
1,
"with include_filtered=true the overlay ref is returned"
);
assert_eq!(shown[0].0, "src/added.rs");
}
#[test]
fn view_overlay_appended_files_are_path_sorted() {
let base = base_with_symbol("/a", "c0", "f", "fn f() {}");
let mut overlay = Overlay::fresh(&base);
let names = ["src/zeta.rs", "src/alpha.rs", "src/mike.rs", "src/bravo.rs"];
for n in names {
overlay.upsert(n, Arc::new(make_file(n, "let NEEDLE = 1;")));
}
let view = IndexView::new(&base, Some(&overlay)).unwrap();
let result = view
.search_text(Some("NEEDLE"), None, false)
.expect("overlay text search");
let ordered: Vec<&str> = result.files.iter().map(|f| f.path.as_str()).collect();
let mut expected = names.to_vec();
expected.sort();
assert_eq!(
ordered, expected,
"appended overlay text files must be path-sorted (deterministic, Principle V)"
);
let mut ref_overlay = Overlay::fresh(&base);
for n in names {
let mut f = make_file(n, "fn u() { target(); }");
f.references = vec![ReferenceRecord {
name: "target".to_string(),
qualified_name: None,
kind: ReferenceKind::Call,
byte_range: (0, 6),
line_range: (0, 0),
enclosing_symbol_index: None,
}];
ref_overlay.upsert(n, Arc::new(f));
}
let ref_view = IndexView::new(&base, Some(&ref_overlay)).unwrap();
let refs = ref_view.find_references("target", None, true);
let ref_order: Vec<&str> = refs.iter().map(|(p, _)| p.as_str()).collect();
assert_eq!(
ref_order, expected,
"appended overlay reference files must be path-sorted (deterministic, Principle V)"
);
}
#[test]
fn cross_project_text_search_attribution() {
let mut ws = WorkingSet::new();
ws.add("A", base_with_symbol("/a", "c0", "f", "let NEEDLE = 1;"));
ws.add("B", base_with_symbol("/b", "c0", "g", "let other = 2;"));
ws.add("C", base_with_symbol("/c", "c0", "h", "let NEEDLE = 3;"));
let results = ws
.search_text(&Targets::All, Some("NEEDLE"), None, false)
.expect("cross-project text search");
let with_matches: Vec<&str> = results
.iter()
.filter(|r| r.hit.total_matches > 0)
.map(|r| r.project_id.as_str())
.collect();
assert_eq!(with_matches, vec!["A", "C"]);
}
#[test]
fn working_set_skips_stale_overlay_entry() {
let mut ws = WorkingSet::new();
ws.add(
"A",
base_with_symbol("/a", "c0", "shared_a", "fn shared_a() {}"),
);
ws.get_mut("A").unwrap().overlay.base_generation = 999;
let hits = ws.search_symbols(&Targets::All, "shared", None);
assert!(
hits.is_empty(),
"a stale-overlay entry must be skipped, not served"
);
}
}