diff --git a/README.md b/README.md index debac86..1d83d22 100644 --- a/README.md +++ b/README.md @@ -232,7 +232,8 @@ and project configuration; this is a static code graph rather than a full compil ### Framework and dynamic-dispatch rules -Route hooks are implemented for **Express, Flask, FastAPI, Django, Gin, Spring, Axum and Next.js**. +Route hooks are implemented for **Express, Flask, FastAPI, Django, Gin, Spring, Axum, Next.js, +NestJS, React Router and TanStack Router**. Framework detection uses project manifests, so route coverage can differ when dependencies are absent or when indexing a framework's own repository. The benchmark documents observed gaps. @@ -241,6 +242,15 @@ event-emitter handlers, React re-render links and JSX parent/child links. These heuristics with recorded provenance; they cover specific patterns rather than arbitrary runtime behavior. +For NestJS, literal `RouterModule.register` paths and a literal `setGlobalPrefix` on a +recognizable `NestFactory.create` application are composed for HTTP-client matching, including +statically readable exclusions. Route node names remain controller-local. For React Router, +exported route-object arrays can be consumed across imports and re-exports, including literal +parent routes and `children` arrays. Candidate route nodes are retained for exported arrays; +only arrays reached from a recognized router call participate in navigation matching. Dynamic +route configuration remains outside this cross-file rule. Go interface dispatch includes unambiguous promoted methods; +method-set inference remains a bounded static approximation. + C/C++, C#, PHP, Ruby, Swift and the other upstream language families are outside this version's supported extraction set. Vue/Svelte-specific extraction is also outside the current scope. diff --git a/README.zh-CN.md b/README.zh-CN.md index 56a97a8..c6c9c90 100644 --- a/README.zh-CN.md +++ b/README.zh-CN.md @@ -209,12 +209,19 @@ MCP 服务运行且启用监听时,会在防抖后自动同步源码变化。 ### 框架与动态分派规则 -已实现 **Express、Flask、FastAPI、Django、Gin、Spring、Axum、Next.js** 的路由提取 hook。 +已实现 **Express、Flask、FastAPI、Django、Gin、Spring、Axum、Next.js、NestJS、React Router 和 TanStack Router** 的路由提取 hook。 框架检测依赖项目清单,因此缺失依赖声明或索引框架自身仓库时,路由覆盖可能不同;实测文档记录了已观察到的差异。 合成边规则覆盖接口与实现分派、Go 结构化接口、事件发射器处理函数、React 重新渲染、JSX 父子组件关系等模式。 这些规则带有来源信息和数量限制,属于针对特定模式的启发式分析,不覆盖任意运行时行为。 +NestJS 中,可静态读取的 `RouterModule.register` 路径和由 `NestFactory.create` 创建的应用上的字面量 +`setGlobalPrefix`(包括可读取的排除项)会参与 HTTP 客户端匹配;路由节点名称仍使用控制器内的路径。 +React Router 支持通过导入和转导出使用其他文件中的导出路由数组,包括字面量父路由和 `children` 数组。 +索引会保留导出数组的候选路由节点,但只有被已识别的路由器调用使用的数组才参与导航匹配。 +动态路由配置不在此跨文件规则的覆盖范围内。 +Go 接口分派包含无歧义的提升方法;方法集推断仍是有界的静态近似。 + 当前版本暂不支持 C/C++、C#、PHP、Ruby、Swift 等上游语言,也不包含 Vue/Svelte 专用提取逻辑。 ## 命令行参考 diff --git a/crates/cg-core/src/brand.rs b/crates/cg-core/src/brand.rs index 8740215..ea99859 100644 --- a/crates/cg-core/src/brand.rs +++ b/crates/cg-core/src/brand.rs @@ -17,7 +17,7 @@ pub const UPSTREAM_CONFIG_FILE: &str = "codegraph.json"; pub const CONFIG_FILE: &str = "cgr.json"; /// Version of the resolution rules: changing resolver behaviour bumps this, which /// marks older indexes as "built by an older engine" (design doc 5.8). -pub const ENGINE_VERSION: u32 = 5; +pub const ENGINE_VERSION: u32 = 6; /// Version of the on-disk segment format; a mismatch forces a full rebuild. pub const FORMAT_VERSION: u32 = 2; /// The upstream commit whose kernel is vendored (see crates/cg-kernel/UPSTREAM_COMMIT). diff --git a/crates/cg-resolve/src/frameworks/jsroutes.rs b/crates/cg-resolve/src/frameworks/jsroutes.rs index 58e9f39..a7518a5 100644 --- a/crates/cg-resolve/src/frameworks/jsroutes.rs +++ b/crates/cg-resolve/src/frameworks/jsroutes.rs @@ -366,6 +366,10 @@ re!(capital_tag_re, r"<\s*([A-Z][\w.]*)"); re!(wrapper_re, r"^(?:Suspense|ErrorBoundary|\w*(?:Guard|Provider|Wrapper|Route)|(?:Protected|Private|Auth|Require\w*)\w*)$"); re!(router_element_re, r"^(?:Browser|Hash|Memory|Native|Static|History|unstable_History)?Router$"); re!(router_call_re, r"\b(?:createBrowserRouter|createHashRouter|createMemoryRouter|createRoutesFromElements|useRoutes)\b"); +re!(route_array_re, r"\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)(?:\s*:\s*[^=;\n]+)?\s*=\s*\["); +re!(default_route_array_re, r"\bexport\s+default\s*\["); +re!(route_table_call_re, r"\b(?:createBrowserRouter|createHashRouter|createMemoryRouter|useRoutes)\s*\("); +re!(route_table_name_re, r"^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)?$"); /// The component an `element` renders: the first tag that is no guard, provider or outlet. fn element_component(value: &str) -> Option { @@ -411,7 +415,11 @@ impl<'a> RrScan<'a> { while j > 0 && self.b[j - 1].is_ascii_whitespace() { j -= 1; } - &self.s[j.saturating_sub(12)..j] + let mut start = j.saturating_sub(12); + while !self.s.is_char_boundary(start) { + start += 1; + } + &self.s[start..j] } /// One syntactic unit starting at `at`: a string, a JSX element, a bracketed group or one @@ -438,16 +446,22 @@ impl<'a> RrScan<'a> { return at + 1; } b'{' | b'[' | b'(' => {} - _ => return at + 1, + _ => return at + self.s[at..].chars().next().map_or(1, char::len_utf8), } let close = match c { b'{' => b'}', b'[' => b']', _ => b')', }; - let routers_call = c == b'(' && self.s[at.saturating_sub(48)..at].trim_end().ends_with(|ch: char| ch.is_alphanumeric()) && { - let before = self.s[at.saturating_sub(48)..at].trim_end(); - before.ends_with("createRoutesFromElements") || before.ends_with("createRoutesFromChildren") + let mut before_start = at.saturating_sub(48); + while !self.s.is_char_boundary(before_start) { + before_start += 1; + } + let routers_call = c == b'(' && self.s[before_start..at].trim_end().ends_with(|ch: char| ch.is_alphanumeric()) && { + let before = self.s[before_start..at].trim_end(); + ["createRoutesFromElements", "createRoutesFromChildren", "createBrowserRouter", "createHashRouter", "createMemoryRouter", "useRoutes"] + .iter() + .any(|name| before.ends_with(name)) }; let mut fields: Vec<(&'a str, &'a str, usize)> = Vec::new(); let mut i = at + 1; @@ -650,6 +664,10 @@ impl<'a> RrScan<'a> { } i += 1; while i < self.b.len() { + if !self.s.is_char_boundary(i) { + i += 1; + continue; + } if self.s[i..].starts_with("').map_or(self.b.len(), |e| i + 2 + e + 1); return close(self, end); @@ -670,6 +688,10 @@ impl<'a> RrScan<'a> { /// The routes a file's own text declares (upstream `scanRoutes` for one file). pub fn scan_react_router(rel: &str, src: &str) -> Vec { + scan_react_router_detailed(rel, src).into_iter().map(|(route, _)| route).collect() +} + +fn scan_react_router_detailed(rel: &str, src: &str) -> Vec<(Route, bool)> { let objects = router_call_re().is_match(src); if !objects && !src.contains(" Vec { } let line = line_at(src, s.at); let handlers = s.component.iter().map(|c| Handler { name: c.clone(), line, col: 0 }).collect(); - out.push(Route { method: String::new(), path, line, handlers, ref_kind: RefKind::Edge(EdgeKind::References), router: Some("react-router") }); + let absolute = around(s.start, s.end).into_iter().chain(std::iter::once(*s)).any(|o| o.part.as_deref().is_some_and(|p| p.starts_with('/'))); + out.push(( + Route { method: String::new(), path, line, handlers, ref_kind: RefKind::Edge(EdgeKind::References), router: Some("react-router") }, + absolute, + )); + } + out.sort_by_key(|r| r.0.line); + out.dedup_by(|a, b| a.0.path == b.0.path && a.0.line == b.0.line); + out +} + +/// Route-object arrays declared separately from the router that consumes them. The nodes are +/// candidates: navigation uses them only after an actual router call resolves to this binding. +fn route_arrays(src: &str) -> Vec<(String, usize, usize)> { + let mut arrays = Vec::new(); + for cap in route_array_re().captures_iter(src) { + let open = cap.get(0).unwrap().end() - 1; + if let Some(close) = match_bracket(src, open) { + arrays.push((cap[1].to_owned(), open, close)); + } + } + for hit in default_route_array_re().find_iter(src) { + let open = hit.end() - 1; + if let Some(close) = match_bracket(src, open) { + arrays.push(("#default".to_owned(), open, close)); + } + } + arrays +} + +pub fn scan_react_tables(rel: &str, src: &str) -> Vec<(String, Route, bool)> { + if !src.contains("export") { + return Vec::new(); + } + let mut out = Vec::new(); + for (name, open, close) in route_arrays(src) { + let wrapped = format!("createBrowserRouter({})", &src[open..=close]); + let line_offset = line_at(src, open) - 1; + for (mut route, absolute) in scan_react_router_detailed(rel, &wrapped) { + route.line += line_offset; + for handler in &mut route.handlers { + handler.line += line_offset; + } + route.router = Some("react-router-table"); + out.push((name.clone(), route, absolute)); + } + } + out +} + +/// A reference to an array used as the router's input or a route object's children. +pub struct ReactTableUse { + pub owner: String, + pub name: String, + pub prefix: String, + pub absolute: bool, +} + +fn react_refs(expr: &str, owner: &str, prefix: &str, absolute: bool, out: &mut Vec, depth: u8) { + if depth > 16 { + return; + } + let expr = expr.trim(); + let name = expr.strip_prefix("...").unwrap_or(expr).trim(); + if route_table_name_re().is_match(name) { + out.push(ReactTableUse { owner: owner.to_owned(), name: name.to_owned(), prefix: prefix.to_owned(), absolute }); + return; + } + if expr.starts_with('[') && match_bracket(expr, 0) == Some(expr.len() - 1) { + let body = &expr[1..expr.len() - 1]; + let mut start = 0; + while start < body.len() { + let end = super::href::index_at_depth0(body, b',', start).unwrap_or(body.len()); + react_refs(&body[start..end], owner, prefix, absolute, out, depth + 1); + start = end + 1; + } + } else if expr.starts_with('{') && match_bracket(expr, 0) == Some(expr.len() - 1) { + let part = match object_field(expr, "path") { + Some(p) => match literal(p) { + Some(p) => p, + None => return, + }, + None => String::new(), + }; + let is_absolute = absolute || part.starts_with('/'); + let path = compose_route_path(&[prefix, &part]); + if let Some(children) = object_field(expr, "children") { + react_refs(children, owner, &path, is_absolute, out, depth + 1); + } + } +} + +pub fn react_table_uses(src: &str) -> Vec { + let mut out = Vec::new(); + for m in route_table_call_re().find_iter(src) { + if let Some(first) = crate::synth::scan::call_args(src, m.end() - 1).and_then(|args| args.first().copied()) { + react_refs(first, "", "", false, &mut out, 0); + } + } + if src.contains("export") { + for (name, open, close) in route_arrays(src) { + react_refs(&src[open..=close], &name, "", false, &mut out, 0); + } } - out.sort_by_key(|r| r.line); - out.dedup_by(|a, b| a.path == b.path && a.line == b.line); out } diff --git a/crates/cg-resolve/src/frameworks/mod.rs b/crates/cg-resolve/src/frameworks/mod.rs index 436c1eb..22f1fea 100644 --- a/crates/cg-resolve/src/frameworks/mod.rs +++ b/crates/cg-resolve/src/frameworks/mod.rs @@ -4,6 +4,7 @@ pub mod href; pub mod jsroutes; pub mod nav; +pub mod nest; pub mod routes; use crate::project::ProjectInfo; @@ -29,6 +30,9 @@ pub fn hooks(project: &ProjectInfo) -> Vec> { if frameworks.iter().any(|f| f == "next") { v.push(Arc::new(nav::ProxyScanner)); } + if frameworks.iter().any(|f| f == "nestjs") { + v.push(Arc::new(nest::NestScanner)); + } for name in frameworks { let fw = match name.as_str() { "express" => Framework::Express, @@ -48,3 +52,24 @@ pub fn hooks(project: &ProjectInfo) -> Vec> { } v } + +/// Resolve a JS binding using the project's import/export tables, including barrel exports. +pub(crate) fn js_symbol(e: &crate::engine::Engine<'_>, file: cg_core::FileId, name: &str) -> Option { + use crate::engine::Bound; + let view = e.view; + let (head, tail) = name.split_once('.').map_or((name, None), |(h, t)| (h, Some(t))); + if head.is_empty() || !head.chars().all(|c| c.is_alphanumeric() || c == '_' || c == '$') { + return None; + } + if let Some(i) = view.imports_of(file).iter().position(|imp| view.text_str(imp.local) == head) { + return match (e.bind_import(file, i), tail) { + (Bound::Node(n), None) => Some(n), + (Bound::Module(f), Some(member)) if !member.contains('.') => match e.lookup_export(f, member, 0) { + Some(Bound::Node(n)) => Some(n), + _ => None, + }, + _ => None, + }; + } + tail.is_none().then(|| e.lookup_top_level(file, head)).flatten() +} diff --git a/crates/cg-resolve/src/frameworks/nav.rs b/crates/cg-resolve/src/frameworks/nav.rs index aae1592..772924b 100644 --- a/crates/cg-resolve/src/frameworks/nav.rs +++ b/crates/cg-resolve/src/frameworks/nav.rs @@ -15,7 +15,7 @@ use super::href::{self, app_root_for, match_bracket, object_field, parse_href_ex use super::jsroutes::next_route_of; use crate::engine::Engine; use crate::synth::scan::{call_args, enclosing_row, is_minified, local_initializer, mid_chain, LineIndex, FN_KINDS}; -use crate::synth::sites::{PASS_NAV, PASS_PROXY}; +use crate::synth::sites::{PASS_NAV, PASS_PROXY, PASS_REACT_TABLE}; use crate::synth::Out; use cg_core::{EdgeKind, FileId, Lang, LangFamily, NodeIdx, NodeKind, NONE}; use cg_extract::{FileHook, HookCtx, HookOut, SiteFact}; @@ -162,6 +162,45 @@ struct Tables { tanstack: RootedTables, } +/// An anonymous `export default [...]` has no kernel symbol. Follow export aliases to its +/// persisted table sites instead of guessing a same-named declaration in another file. +fn exported_react_table(e: &Engine<'_>, f: FileId, name: &str, depth: u8) -> Option<(FileId, String)> { + use crate::engine::{Bound, ExportEntry}; + if depth > 8 { + return None; + } + let view = e.view; + if let Some(Bound::Node(n)) = e.lookup_export(f, name, 0) { + let node = view.node(n); + return Some((node.file(), node.name().to_owned())); + } + if let Some(ExportEntry::Re(target, from)) = e.exports.get(f.idx())?.get(name) { + return exported_react_table(e, *target, view.text_str(*from), depth + 1); + } + if name == "default" + && view.sites_of(f).iter().any(|s| { + s.pass == PASS_REACT_TABLE + && ((s.role == 0 && view.text_str(cg_core::StrId(s.key_a)) == "#default") + || (s.role == 1 && view.text_str(cg_core::StrId(s.key_b)) == "#default")) + }) + { + return Some((f, "#default".to_owned())); + } + None +} + +fn react_table_binding(e: &Engine<'_>, f: FileId, name: &str) -> Option<(FileId, String)> { + if let Some(n) = super::js_symbol(e, f, name) { + let node = e.view.node(n); + return Some((node.file(), node.name().to_owned())); + } + let (head, member) = name.split_once('.').map_or((name, None), |(a, b)| (a, Some(b))); + let (index, import) = e.view.imports_of(f).iter().enumerate().find(|(_, imp)| e.view.text_str(imp.local) == head)?; + let target = e.modules.target_file(*e.imp_targets.get(f.idx())?.get(index)?)?; + let imported = member.unwrap_or_else(|| e.view.text_str(import.imported)); + exported_react_table(e, target, imported, 0) +} + fn route_tables(e: &Engine<'_>) -> Tables { let view = e.view; let mut t = Tables { next: RouteTable::default(), next_roots: Vec::new(), react: RootedTables::default(), tanstack: RootedTables::default() }; @@ -203,6 +242,48 @@ fn route_tables(e: &Engine<'_>) -> Tables { } } } + // Resolve the table argument through imports and re-exports. Candidate arrays that are + // never passed to a router do not become navigation targets. + let mut queue = Vec::new(); + for f in view.files() { + for site in view.sites_of(f).iter().filter(|s| s.pass == PASS_REACT_TABLE && s.role == 1 && view.text_str(cg_core::StrId(s.key_b)).is_empty()) { + let name = view.text_str(cg_core::StrId(site.key_a)); + let payload = view.text_str(site.payload); + queue.push((f, name.to_owned(), app_root_for(view.file(f).path()).to_owned(), payload.get(1..).unwrap_or("").to_owned(), 0u8)); + } + } + let mut activated = FxHashSet::default(); + while let Some((f, name, root, prefix, depth)) = queue.pop() { + if depth > 16 { + continue; + } + let Some((decl_file, decl_name)) = react_table_binding(e, f, &name) else { continue }; + if !activated.insert((decl_file, decl_name.clone(), root.clone(), prefix.clone())) { + continue; + } + for site in view.sites_of(decl_file).iter().filter(|s| s.pass == PASS_REACT_TABLE) { + let name = view.text_str(cg_core::StrId(site.key_a)); + let payload = view.text_str(site.payload); + if site.role == 1 && view.text_str(cg_core::StrId(site.key_b)) == decl_name { + let sub = payload.get(1..).unwrap_or(""); + let path = if payload.starts_with('a') { sub.to_owned() } else { href::compose_route_path(&[&prefix, sub.trim_start_matches('/')]) }; + queue.push((decl_file, name.to_owned(), root.clone(), path, depth + 1)); + } else if site.role == 0 && name == decl_name { + let node = view.node(site.node); + if node.kind() != NodeKind::Route || node.name().ends_with('*') { + continue; + } + let path = if payload == "a" { node.name().to_owned() } else { href::compose_route_path(&[&prefix, node.name().trim_start_matches('/')]) }; + let p = if path.len() > 1 { path.trim_end_matches('/') } else { &path }; + t.react.add(&root, p, site.node); + let mut segs: Vec<&str> = p.split('/').skip(1).collect(); + while segs.len() > 1 && segs.last().is_some_and(|s| s.starts_with(':') && s.ends_with('?')) { + segs.pop(); + optional.push((root.clone(), format!("/{}", segs.join("/")), site.node)); + } + } + } + } for (root, path, n) in optional { if t.react.for_file(&root).is_some_and(|tb| !tb.exact.contains_key(&path)) { t.react.add(&root, &path, n); diff --git a/crates/cg-resolve/src/frameworks/nest.rs b/crates/cg-resolve/src/frameworks/nest.rs new file mode 100644 index 0000000..38844c1 --- /dev/null +++ b/crates/cg-resolve/src/frameworks/nest.rs @@ -0,0 +1,402 @@ +//! Cross-file NestJS module registrations and bootstrap prefixes. The original route nodes +//! retain their controller-local identity; HTTP matching uses their effective mounted paths. + +use super::href::{index_at_depth0, match_bracket, object_field, read_string_at, HOLE}; +use crate::engine::Engine; +use crate::synth::scan::call_args; +use crate::synth::sites::PASS_NEST; +use cg_core::{FileId, Lang, LangFamily, NodeIdx, NodeKind, NONE}; +use cg_extract::{FileHook, HookCtx, HookOut, SiteFact}; +use regex::Regex; +use rustc_hash::{FxHashMap, FxHashSet}; +use serde::{Deserialize, Serialize}; +use std::sync::OnceLock; + +const MODULE: u8 = 0; +const MOUNT: u8 = 1; +const BOOT: u8 = 2; + +#[derive(Default, Serialize, Deserialize)] +struct Module { + name: String, + controllers: Vec, + imports: Vec, +} +#[derive(Serialize, Deserialize)] +struct Mount { + module: String, + path: String, +} +#[derive(Serialize, Deserialize)] +struct Exclusion { + path: String, + method: Option, +} +#[derive(Serialize, Deserialize)] +struct Boot { + root: String, + prefix: String, + exclude: Vec, +} + +macro_rules! re { + ($name:ident, $pat:expr) => { + fn $name() -> &'static Regex { + static R: OnceLock = OnceLock::new(); + R.get_or_init(|| Regex::new($pat).expect("static regex")) + } + }; +} +re!(module_re, r"@Module\s*\("); +re!(class_re, r"\bclass\s+([A-Za-z_$][\w$]*)\b"); +re!(mount_re, r"\b([A-Za-z_$][\w$]*)\s*\.\s*register\s*\("); +re!(boot_re, r"\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)(?:\s*:\s*[^=;]+)?\s*=\s*(?:await\s+)?([A-Za-z_$][\w$]*)\s*\.\s*create(?:\s*<[^>]+>)?\s*\("); +re!(prefix_re, r"\b([A-Za-z_$][\w$]*)\s*\.\s*setGlobalPrefix\s*\("); +re!(ident_re, r"^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)?$"); + +fn ident(s: &str) -> Option { + let s = s.trim(); + ident_re().is_match(s).then(|| s.to_owned()) +} + +fn literal(s: &str) -> Option { + let s = s.trim(); + let value = read_string_at(s, 0)?; + let end = match s.as_bytes().first()? { + b'`' => super::href::template_end(s, 0)?, + _ => super::href::string_end(s, 0)?, + }; + (end + 1 == s.len() && !value.contains(HOLE)).then_some(value) +} + +fn items(s: &str) -> Option> { + let s = s.trim(); + if !s.starts_with('[') || match_bracket(s, 0)? + 1 != s.len() { + return None; + } + let body = &s[1..s.len() - 1]; + let mut out = Vec::new(); + let mut at = 0; + while at < body.len() { + let end = index_at_depth0(body, b',', at).unwrap_or(body.len()); + let item = body[at..end].trim(); + if !item.is_empty() { + out.push(item); + } + at = end + 1; + } + Some(out) +} + +fn names(value: Option<&str>) -> Vec { + value.and_then(items).unwrap_or_default().into_iter().filter_map(ident).collect() +} + +fn join(prefix: &str, path: &str) -> String { + let parts: Vec<_> = [prefix, path].iter().map(|s| s.trim_matches('/')).filter(|s| !s.is_empty()).collect(); + format!("/{}", parts.join("/")) +} + +fn mounts(value: &str, parent: &str, out: &mut Vec, depth: usize) { + if depth > 16 { + return; + } + for item in items(value).unwrap_or_default() { + if !item.starts_with('{') || match_bracket(item, 0) != Some(item.len() - 1) { + continue; + } + // Unknown paths must not be treated as an empty prefix. + let Some(path) = object_field(item, "path").and_then(literal) else { continue }; + let path = join(parent, &path); + if let Some(module) = object_field(item, "module").and_then(ident) { + out.push(Mount { module, path: path.clone() }); + } + if let Some(children) = object_field(item, "children") { + mounts(children, &path, out, depth + 1); + } + } +} + +fn exclusions(options: &str) -> Option> { + let options = options.trim(); + if !options.starts_with('{') || match_bracket(options, 0)? + 1 != options.len() { + return None; + } + let Some(exclude) = object_field(options, "exclude") else { return Some(Vec::new()) }; + let mut out = Vec::new(); + for item in items(exclude)? { + if let Some(path) = literal(item) { + out.push(Exclusion { path, method: None }); + } else { + let path = object_field(item, "path").and_then(literal)?; + let method = object_field(item, "method").map(|m| m.trim().strip_prefix("RequestMethod.").map(str::to_owned)).transpose_option()?; + out.push(Exclusion { path, method }); + } + } + Some(out) +} + +// Like Option::transpose, but an absent field is valid and a present unknown field is not. +trait TransposeOption { + fn transpose_option(self) -> Option>; +} +impl TransposeOption for Option> { + fn transpose_option(self) -> Option> { + match self { + None => Some(None), + Some(Some(x)) => Some(Some(x)), + Some(None) => None, + } + } +} + +pub struct NestScanner; +impl FileHook for NestScanner { + fn name(&self) -> &'static str { + "nest-module-sites" + } + fn applies(&self, lang: Lang, _: &str) -> bool { + lang.family() == LangFamily::Js + } + fn triggers(&self) -> &'static [&'static str] { + &["@Module", "RouterModule", "setGlobalPrefix"] + } + fn run(&self, ctx: &HookCtx<'_>, out: &mut HookOut) { + let source = cg_extract::post::strip_js_comments(ctx.src); + let src = source.as_str(); + let aliases = |original: &str| -> Vec<&str> { + ctx.facts.imports.iter().filter(|i| i.spec == "@nestjs/core" && i.imported == original).map(|i| i.local.as_str()).collect() + }; + let routers = aliases("RouterModule"); + let factories = aliases("NestFactory"); + let mut add = |role, payload: String| { + out.sites.push(SiteFact { pass: PASS_NEST, role, key_kind: 0, key_a: String::new(), key_b: String::new(), node_row: NONE, line: 0, payload }) + }; + for hit in module_re().find_iter(src) { + let Some(end) = match_bracket(src, hit.end() - 1) else { continue }; + let body = src[hit.end()..end].trim(); + if !body.starts_with('{') || match_bracket(body, 0).is_none_or(|i| i + 1 != body.len()) { + continue; + } + let rest = &src[end + 1..]; + let Some(class) = class_re().captures(rest).filter(|c| c.get(0).unwrap().start() < 512) else { continue }; + let module = + Module { name: class[1].to_owned(), controllers: names(object_field(body, "controllers")), imports: names(object_field(body, "imports")) }; + add(MODULE, serde_json::to_string(&module).unwrap()); + } + for hit in mount_re().captures_iter(src).filter(|hit| &hit[1] == "RouterModule" || routers.contains(&&hit[1])) { + let Some(args) = call_args(src, hit.get(0).unwrap().end() - 1) else { continue }; + let mut found = Vec::new(); + if let Some(first) = args.first() { + mounts(first, "", &mut found, 0); + } + for mount in found { + add(MOUNT, serde_json::to_string(&mount).unwrap()); + } + } + let roots: Vec<_> = boot_re() + .captures_iter(src) + .filter(|hit| &hit[2] == "NestFactory" || factories.contains(&&hit[2])) + .filter_map(|hit| { + let args = call_args(src, hit.get(0)?.end() - 1)?; + Some((ident(args.first()?)?, hit[1].to_owned())) + }) + .collect(); + // If multiple apps are bootstrapped in one file, do not guess which receives a prefix. + if roots.len() == 1 { + for hit in prefix_re().captures_iter(src).filter(|hit| hit[1] == roots[0].1) { + let Some(args) = call_args(src, hit.get(0).unwrap().end() - 1) else { continue }; + let Some(prefix) = args.first().and_then(|s| literal(s)) else { continue }; + let exclude = match args.get(1) { + Some(options) => match exclusions(options) { + Some(v) => v, + None => continue, + }, + None => Vec::new(), + }; + let boot = Boot { root: roots[0].0.clone(), prefix, exclude }; + add(BOOT, serde_json::to_string(&boot).unwrap()); + } + } + } +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] +pub(crate) struct EffectivePath { + pub path: String, + pub method: Option, + /// (optional method, path) excluded from this effective path. + pub excluded: Vec<(Option, String)>, +} + +/// Exclusions can cover only one value or method of a route. Retain the normal prefixed +/// route for other requests, but remove the intersection from it and add it unprefixed. +fn boot_paths(boot: &Boot, method: &str, path: &str) -> Vec { + let mut out = Vec::new(); + let mut fully_excluded = false; + let mut denied = Vec::new(); + for x in &boot.exclude { + let method_filter = x.method.as_ref().filter(|m| *m != "ALL").cloned(); + if method != "ALL" && method != "ANY" && method_filter.as_ref().is_some_and(|m| m != method) { + continue; + } + let a: Vec<_> = x.path.trim_matches('/').split('/').collect(); + let b: Vec<_> = path.trim_matches('/').split('/').collect(); + if a.len() != b.len() { + continue; + } + let mut partial = false; + let mut intersection = Vec::new(); + for (excluded, route) in a.iter().zip(&b) { + if excluded == route || excluded.starts_with(':') { + intersection.push(*route); + } else if route.starts_with(':') { + intersection.push(*excluded); + partial = true; + } else { + intersection.clear(); + break; + } + } + if intersection.len() == b.len() { + let intersection = format!("/{}", intersection.join("/")); + let applies_to_all = method_filter.is_none() || (method != "ALL" && method != "ANY"); + fully_excluded |= !partial && applies_to_all; + denied.push((method_filter.clone(), join(&boot.prefix, &intersection))); + out.push(EffectivePath { path: intersection, method: if method == "ALL" || method == "ANY" { method_filter } else { None }, excluded: Vec::new() }); + } + } + if !fully_excluded { + out.push(EffectivePath { path: join(&boot.prefix, path), method: None, excluded: denied }); + } + out +} + +/// Effective HTTP paths for Nest route nodes. Unresolved symbols are left unmounted rather +/// than connected by matching class names in unrelated files. +pub(crate) fn effective_paths(e: &Engine<'_>) -> FxHashMap> { + let v = e.view; + let mut modules: FxHashMap = FxHashMap::default(); + let mut pending_mounts: Vec<(FileId, Mount)> = Vec::new(); + let mut boots: Vec<(FileId, Boot)> = Vec::new(); + for f in v.files() { + for site in v.sites_of(f).iter().filter(|s| s.pass == PASS_NEST) { + let data = v.text_str(site.payload); + match site.role { + MODULE => { + if let Ok(m) = serde_json::from_str::(data) { + if let Some(n) = super::js_symbol(e, f, &m.name) { + modules.insert(n, (f, m)); + } + } + } + MOUNT => { + if let Ok(m) = serde_json::from_str::(data) { + pending_mounts.push((f, m)); + } + } + BOOT => { + if let Ok(b) = serde_json::from_str::(data) { + boots.push((f, b)); + } + } + _ => {} + } + } + } + let mut mounts_by_module: FxHashMap, String)>> = FxHashMap::default(); + for (file, mount) in pending_mounts { + let Some(target) = super::js_symbol(e, file, &mount.module) else { continue }; + let mut owners = modules.iter().filter(|(_, (f, _))| *f == file).map(|(n, _)| *n); + let first = owners.next(); + let origin = if owners.next().is_none() { first } else { None }; + mounts_by_module.entry(target).or_default().push((origin, mount.path)); + } + let mut contexts: FxHashMap> = FxHashMap::default(); + let mut reachable = Vec::new(); + for (index, (file, boot)) in boots.iter().enumerate() { + let mut visited = FxHashSet::default(); + let Some(root) = super::js_symbol(e, *file, &boot.root) else { continue }; + let mut queue = vec![root]; + while let Some(module) = queue.pop() { + if !visited.insert(module) { + continue; + } + contexts.entry(module).or_default().push(index); + if let Some((f, m)) = modules.get(&module) { + queue.extend(m.imports.iter().filter_map(|name| super::js_symbol(e, *f, name))); + } + } + reachable.push((index, visited)); + } + let mut controller_modules: FxHashMap> = FxHashMap::default(); + for (module, (file, m)) in &modules { + for controller in m.controllers.iter().filter_map(|name| super::js_symbol(e, *file, name)) { + controller_modules.entry(controller).or_default().push(*module); + } + } + let mut result = FxHashMap::default(); + for f in v.files() { + for n in v.nodes_in_file(f).map(NodeIdx) { + let route = v.node(n); + if route.kind() != NodeKind::Route || route.signature() != Some("nestjs") { + continue; + } + let Some((method, local_path)) = route.name().split_once(' ') else { continue }; + if !local_path.starts_with('/') { + continue; + } + let class = v + .nodes_in_file(f) + .map(NodeIdx) + .filter(|c| { + let c = v.node(*c); + c.kind() == NodeKind::Class && c.start_line() <= route.start_line() && c.end_line() >= route.start_line() + }) + .min_by_key(|c| v.node(*c).end_line() - v.node(*c).start_line()); + let Some(owners) = class.and_then(|c| controller_modules.get(&c)) else { continue }; + let mut paths = Vec::new(); + for owner in owners { + if let Some(indices) = contexts.get(owner) { + for index in indices { + let boot = &boots[*index].1; + let reaches = reachable.iter().find(|(i, _)| i == index).map(|(_, set)| set); + let mut prefixes: Vec<&str> = mounts_by_module + .get(owner) + .into_iter() + .flatten() + .filter_map(|(origin, path)| { + (origin.is_some_and(|n| reaches.is_some_and(|set| set.contains(&n))) || (origin.is_none() && boots.len() == 1)) + .then_some(path.as_str()) + }) + .collect(); + if prefixes.is_empty() { + prefixes.push(""); + } + for mount in prefixes { + for full in boot_paths(boot, method, &join(mount, local_path)) { + if !paths.contains(&full) { + paths.push(full); + } + } + } + } + } else { + let mut prefixes: Vec<&str> = mounts_by_module.get(owner).into_iter().flatten().map(|(_, path)| path.as_str()).collect(); + if prefixes.is_empty() { + prefixes.push(""); + } + for mount in prefixes { + let path = EffectivePath { path: join(mount, local_path), method: None, excluded: Vec::new() }; + if !paths.contains(&path) { + paths.push(path); + } + } + } + } + paths.sort(); + result.insert(n, paths); + } + } + result +} diff --git a/crates/cg-resolve/src/frameworks/routes.rs b/crates/cg-resolve/src/frameworks/routes.rs index 2cff8e1..d59033c 100644 --- a/crates/cg-resolve/src/frameworks/routes.rs +++ b/crates/cg-resolve/src/frameworks/routes.rs @@ -513,12 +513,43 @@ impl FileHook for RouteHook { "@EventPattern", "@SubscribeMessage", ], - Framework::ReactRouter => &[" &[ + " &["createFileRoute", "createLazyFileRoute", "createRoute", "createRootRoute"], } } fn run(&self, ctx: &HookCtx<'_>, out: &mut HookOut) { - let routes = scan(self.fw, ctx.lang, ctx.rel, ctx.src); + let mut routes: Vec<(Option<(String, bool)>, Route)> = scan(self.fw, ctx.lang, ctx.rel, ctx.src).into_iter().map(|r| (None, r)).collect(); + if self.fw == Framework::ReactRouter { + let code = cg_extract::post::strip_js_comments(ctx.src); + let candidates = super::jsroutes::scan_react_tables(ctx.rel, &code); + // The ordinary scanner sees every object when the file also creates a router. + // Keep array declarations as candidates so only the consumed table is active. + routes.retain(|(_, r)| !candidates.iter().any(|(_, c, _)| c.line == r.line && c.path == r.path)); + routes.extend(candidates.into_iter().map(|(name, r, absolute)| (Some((name, absolute)), r))); + for usage in super::jsroutes::react_table_uses(&code) { + out.sites.push(cg_extract::SiteFact { + pass: crate::synth::sites::PASS_REACT_TABLE, + role: 1, + key_kind: 0, + key_a: usage.name, + key_b: usage.owner, + node_row: cg_core::NONE, + line: 0, + payload: format!("{}{}", if usage.absolute { "a" } else { "r" }, usage.prefix), + }); + } + } if self.fw == Framework::Express && ctx.src.contains(".use(") { let code = cg_extract::post::strip_js_comments(ctx.src); for (prefix, target, line) in express_mounts(&code) { @@ -535,7 +566,10 @@ impl FileHook for RouteHook { } } let kcount = ctx.rows.node_count() as u32; - for r in routes { + for (table, mut r) in routes { + if self.fw == Framework::Nest { + r.router = Some("nestjs"); + } // a page is named by its path alone; a server route by its method and path let (name, qname) = if r.method.is_empty() { (r.path.clone(), format!("{}::route:{}", ctx.rel, r.path)) @@ -559,6 +593,18 @@ impl FileHook for RouteHook { parent_row: 0, exported: None, }); + if let Some((table, absolute)) = table { + out.sites.push(cg_extract::SiteFact { + pass: crate::synth::sites::PASS_REACT_TABLE, + role: 0, + key_kind: 0, + key_a: table, + key_b: String::new(), + node_row: row, + line: r.line, + payload: if absolute { "a" } else { "r" }.to_owned(), + }); + } for h in r.handlers { out.refs.push(ExtraRef { from_row: row, kind: r.ref_kind, name: h.name, line: h.line, col: h.col }); } diff --git a/crates/cg-resolve/src/synth/dynamic.rs b/crates/cg-resolve/src/synth/dynamic.rs index 8d6d981..2e9b513 100644 --- a/crates/cg-resolve/src/synth/dynamic.rs +++ b/crates/cg-resolve/src/synth/dynamic.rs @@ -765,6 +765,7 @@ struct HttpRoute { node: NodeIdx, method: String, segs: Vec, + excluded: Vec<(Option, Vec)>, } const HTTP_VERBS: &[&str] = &["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "ALL", "ANY"]; @@ -833,6 +834,7 @@ fn mount_prefixes(e: &Engine<'_>) -> FxHashMap { fn http_routes(e: &Engine<'_>) -> Vec { let view = e.view; let prefixes = mount_prefixes(e); + let nest_paths = crate::frameworks::nest::effective_paths(e); let mut out = Vec::new(); for f in view.files() { let prefix = prefixes.get(&f).map(String::as_str).filter(|p| *p != "/"); @@ -847,11 +849,22 @@ fn http_routes(e: &Engine<'_>) -> Vec { if !HTTP_VERBS.contains(&method.as_str()) || !path.trim().starts_with('/') { continue; } - let path = match prefix { - Some(p) => join_paths(p, path.trim()), - None => path.trim().to_owned(), - }; - out.push(HttpRoute { node: n, method, segs: path.split('/').filter(|s| !s.is_empty()).map(str::to_owned).collect() }); + let paths = nest_paths.get(&n).cloned().unwrap_or_else(|| { + let path = match prefix { + Some(p) => join_paths(p, path.trim()), + None => path.trim().to_owned(), + }; + vec![crate::frameworks::nest::EffectivePath { path, method: None, excluded: Vec::new() }] + }); + for path in paths { + let segments = |p: &str| p.split('/').filter(|s| !s.is_empty()).map(str::to_owned).collect(); + out.push(HttpRoute { + node: n, + method: path.method.unwrap_or_else(|| method.clone()), + segs: segments(&path.path), + excluded: path.excluded.into_iter().map(|(method, path)| (method, segments(&path))).collect(), + }); + } } } out @@ -956,6 +969,18 @@ fn match_http<'r>(method: &str, segs: &[String], suffix: bool, routes: &'r [Http if r.method != "ALL" && r.method != "ANY" && r.method != method { continue; } + if r.excluded.iter().any(|(m, path)| { + if m.as_ref().is_some_and(|m| m != method) { + return false; + } + if suffix { + path.len() >= segs.len() && score_path(segs, &path[path.len() - segs.len()..]).is_some() + } else { + score_path(segs, path).is_some() + } + }) { + continue; + } let score = if suffix { // a base URL hides a prefix the route may spell out: two segments of tail at least, // two of hidden prefix at most @@ -969,7 +994,8 @@ fn match_http<'r>(method: &str, segs: &[String], suffix: bool, routes: &'r [Http let Some(score) = score else { continue }; match best { Some((_, b)) if score < b => {} - Some((_, b)) if score == b => tied = true, + Some((current, b)) if score == b && current.node != r.node => tied = true, + Some((_, b)) if score == b => {} _ => { best = Some((r, score)); tied = false; @@ -1495,10 +1521,10 @@ mod tests { #[test] fn http_paths() { let routes = vec![ - HttpRoute { node: NodeIdx(1), method: "GET".into(), segs: vec!["api".into(), "users".into()] }, - HttpRoute { node: NodeIdx(2), method: "GET".into(), segs: vec!["api".into(), "users".into(), ":id".into()] }, - HttpRoute { node: NodeIdx(3), method: "GET".into(), segs: vec!["api".into(), "users".into(), "top".into()] }, - HttpRoute { node: NodeIdx(4), method: "POST".into(), segs: vec!["api".into(), "users".into()] }, + HttpRoute { node: NodeIdx(1), method: "GET".into(), segs: vec!["api".into(), "users".into()], excluded: vec![] }, + HttpRoute { node: NodeIdx(2), method: "GET".into(), segs: vec!["api".into(), "users".into(), ":id".into()], excluded: vec![] }, + HttpRoute { node: NodeIdx(3), method: "GET".into(), segs: vec!["api".into(), "users".into(), "top".into()], excluded: vec![] }, + HttpRoute { node: NodeIdx(4), method: "POST".into(), segs: vec!["api".into(), "users".into()], excluded: vec![] }, ]; let m = |method: &str, raw: &str, base: Option<&str>| { client_path(raw, base).and_then(|(s, suffix)| match_http(method, &s, suffix, &routes)).map(|r| r.node) diff --git a/crates/cg-resolve/src/synth/go.rs b/crates/cg-resolve/src/synth/go.rs index 7c0141a..fcb53a6 100644 --- a/crates/cg-resolve/src/synth/go.rs +++ b/crates/cg-resolve/src/synth/go.rs @@ -150,15 +150,18 @@ fn method_types(sig: &str) -> Option<(usize, usize, Sig)> { /// What a method matches an interface method by: its name, plus its package when unexported. fn method_key(view: &cg_store::View, m: NodeIdx) -> String { let node = view.node(m); - let name = node.name(); + name_key(view, node.file(), node.name()) +} + +fn name_key(view: &cg_store::View, file: cg_core::FileId, name: &str) -> String { if name.chars().next().is_some_and(char::is_uppercase) { name.to_owned() } else { - format!("{}\0{name}", parent_dir(view.file(node.file()).path())) + format!("{}\0{name}", parent_dir(view.file(file).path())) } } -pub(super) fn go_implements(e: &Engine<'_>, out: &mut Out) -> Vec<(NodeIdx, NodeIdx)> { +pub(super) fn go_implements(e: &Engine<'_>, out: &mut Out) { let view = e.view; let mut implementers: Vec = Vec::new(); let mut interfaces: Vec = Vec::new(); @@ -208,6 +211,12 @@ pub(super) fn go_implements(e: &Engine<'_>, out: &mut Out) -> Vec<(NodeIdx, Node } } } + let stable_key = |n: &NodeIdx| { + let node = view.node(*n); + (view.file(node.file()).path(), node.start_line(), node.start_col(), node.name()) + }; + implementers.sort_by_key(stable_key); + interfaces.sort_by_key(stable_key); // a type's own methods: those in its body (interfaces) and the receiver methods its // package declares anywhere for &t in &interfaces { @@ -225,6 +234,20 @@ pub(super) fn go_implements(e: &Engine<'_>, out: &mut Out) -> Vec<(NodeIdx, Node } } } + // A field at the same or a shallower embedding depth also blocks a promoted method. + let mut fields_of: FxHashMap> = FxHashMap::default(); + for &t in &implementers { + let node = view.node(t); + let f = node.file(); + let start = cg_core::text::pack_pos(node.start_line(), node.start_col()); + let Some((scope, _)) = view.scopes_of(f).iter().enumerate().find(|(_, s)| s.kind == cg_extract::ScopeKind::Class as u8 && s.start == start) else { + continue; + }; + let scope = view.scope_base(f) + scope as u32; + for b in view.bindings_of(f).iter().filter(|b| b.scope.0 == scope && b.kind == cg_extract::BindKind::Field as u8) { + fields_of.entry(t).or_default().push(name_key(view, f, view.text_str(b.name))); + } + } // embedding: Go records it as `extends` let embeds = |t: NodeIdx| -> Vec { e.direct_supers(t).iter().copied().filter(|s| is_go_type.contains(s)).collect() }; let closure = |t: NodeIdx| -> Vec { @@ -240,17 +263,58 @@ pub(super) fn go_implements(e: &Engine<'_>, out: &mut Out) -> Vec<(NodeIdx, Node } seen }; - // method set: key -> the signatures declared for it (None: a signature that doesn't read) - type MethodSet = FxHashMap>>; - let method_set = |t: NodeIdx| -> MethodSet { + // For interfaces retain declarations from embedded interfaces. For concrete types, Go + // selects the shallowest embedded method; two paths at that depth are ambiguous even if + // they eventually lead to the same declaration (a diamond). + type MethodSet = FxHashMap)>>; + let interface_methods = |t: NodeIdx| -> MethodSet { let mut set: MethodSet = FxHashMap::default(); for ty in closure(t) { for &m in methods_of.get(&ty).map(Vec::as_slice).unwrap_or(&[]) { - set.entry(method_key(view, m)).or_default().push(view.node(m).signature().and_then(method_types)); + set.entry(method_key(view, m)).or_default().push((m, view.node(m).signature().and_then(method_types))); } } set }; + let concrete_methods = |t: NodeIdx| -> MethodSet { + let mut selected: FxHashMap, bool)> = FxHashMap::default(); + let mut frontier = vec![(t, vec![t])]; + for depth in 0..10 { + if frontier.is_empty() { + break; + } + if frontier.len() > 1024 { + return MethodSet::default(); + } + let mut next = Vec::new(); + for (ty, path) in frontier { + for &m in methods_of.get(&ty).map(Vec::as_slice).unwrap_or(&[]) { + let entry = selected.entry(method_key(view, m)).or_insert_with(|| (depth, Vec::new(), false)); + if entry.0 == depth { + entry.1.push(m); + } + } + for key in fields_of.get(&ty).into_iter().flatten() { + let entry = selected.entry(key.clone()).or_insert_with(|| (depth, Vec::new(), false)); + if entry.0 == depth { + entry.2 = true; + } + } + for embedded in embeds(ty) { + if !path.contains(&embedded) { + let mut child = path.clone(); + child.push(embedded); + next.push((embedded, child)); + } + } + } + frontier = next; + } + selected + .into_iter() + .filter_map(|(k, (_, ms, field))| (ms.len() == 1 && !field).then(|| (k, vec![(ms[0], view.node(ms[0]).signature().and_then(method_types))]))) + .collect() + }; let open = |t: &Option| -> bool { match t { None => true, @@ -263,17 +327,16 @@ pub(super) fn go_implements(e: &Engine<'_>, out: &mut Out) -> Vec<(NodeIdx, Node let (Some(h), Some(w)) = (have, want) else { return true }; h.0 == w.0 && h.1 == w.1 && h.2.iter().zip(&w.2).all(|(a, b)| a == b || open(a) || open(b)) }; - let sets: Vec<(NodeIdx, MethodSet)> = implementers.iter().map(|&t| (t, method_set(t))).filter(|(_, s)| !s.is_empty()).collect(); - let mut pairs = Vec::new(); + let sets: Vec<(NodeIdx, MethodSet)> = implementers.iter().map(|&t| (t, concrete_methods(t))).filter(|(_, s)| !s.is_empty()).collect(); for &iface in &interfaces { - let want = method_set(iface); + let want = interface_methods(iface); if want.is_empty() { continue; // `any` would match everything } let mut direct = Vec::new(); let mut promoted = Vec::new(); for (t, have) in &sets { - let covers = want.iter().all(|(key, wanted)| have.get(key).is_some_and(|got| wanted.iter().any(|w| got.iter().any(|g| fits(g, w))))); + let covers = want.iter().all(|(key, wanted)| have.get(key).is_some_and(|got| wanted.iter().all(|(_, w)| got.iter().any(|(_, g)| fits(g, w))))); if !covers || embeds(*t).contains(&iface) { continue; } @@ -297,10 +360,37 @@ pub(super) fn go_implements(e: &Engine<'_>, out: &mut Out) -> Vec<(NodeIdx, Node Some(("via", view.node(iface).name())), super::order_of("go-implements"), ); - pairs.push((t, iface)); + // Link the interface method to the actual declaration selected by Go's embedded + // method set, including methods declared in another file or embedded type. + if let Some((_, have)) = sets.iter().find(|(ty, _)| *ty == t) { + let mut added = 0; + let mut wanted_methods: Vec<_> = want.iter().collect(); + wanted_methods.sort_by_key(|(key, _)| *key); + for (key, wanted) in wanted_methods { + for (bm, _) in wanted { + for (m, _) in have.get(key).into_iter().flatten() { + if added >= super::MAX_IMPLS_PER_PAIR || bm == m { + continue; + } + let method = view.node(*m); + let at = format!("{}:{}", view.file(method.file()).path(), method.start_line()); + out.push( + EdgeKind::Calls, + *bm, + *m, + view.node(*bm).start_line(), + "interface-impl", + Some(at), + Some(("via", method.name())), + super::order_of("interface-impl"), + ); + added += 1; + } + } + } + } } } - pairs } #[cfg(test)] diff --git a/crates/cg-resolve/src/synth/mod.rs b/crates/cg-resolve/src/synth/mod.rs index 77f674e..f27be97 100644 --- a/crates/cg-resolve/src/synth/mod.rs +++ b/crates/cg-resolve/src/synth/mod.rs @@ -179,24 +179,24 @@ fn overrides_of(e: &Engine<'_>, base: NodeIdx, impls: &[NodeIdx]) -> Vec, go_pairs: &[(NodeIdx, NodeIdx)], out: &mut Out) { +/// links to the type's own methods of that name, overloads paired by their parameters, +/// a JS static only to a static. Capped per (type, supertype) pair. Go's structural and +/// promoted method dispatch is handled together by `go_implements`. +fn interface_impl(e: &Engine<'_>, out: &mut Out) { let view = e.view; let mut sups: FxHashMap> = FxHashMap::default(); for (sub, list) in &e.supers { sups.entry(*sub).or_default().extend(list.iter().copied()); } - for (sub, sup) in go_pairs { - sups.entry(*sub).or_default().push(*sup); - } let mut types: Vec = sups.keys().copied().collect(); types.sort(); for cls in types { let cn = view.node(cls); let lang = view.file(cn.file()).lang(); + // Go structural matching and dispatch share the same promoted method set. + if lang == Lang::Go { + continue; + } let concrete = matches!(cn.kind(), NodeKind::Class | NodeKind::Struct | NodeKind::Union) || (lang == Lang::Go && cn.kind() == NodeKind::TypeAlias) || (lang == Lang::Rust && cn.kind() == NodeKind::Enum); @@ -396,8 +396,8 @@ fn jsx_render<'e, 'v>(e: &'e Engine<'v>, out: &mut Out, wcx: &mut WorkerCx<'e, ' pub fn run_all(e: &Engine<'_>) -> SynthOutput { let mut out = Out { edges: Vec::new(), emeta: Vec::new(), meta_ids: FxHashMap::default() }; let mut wcx = WorkerCx::new(); - let go_pairs = go::go_implements(e, &mut out); - interface_impl(e, &go_pairs, &mut out); + go::go_implements(e, &mut out); + interface_impl(e, &mut out); event_emitter(e, &mut out, &mut wcx, None); react_render(e, &mut out, None); jsx_render(e, &mut out, &mut wcx, None); @@ -546,8 +546,8 @@ pub fn run_incremental(e: &Engine<'_>, previous: &View, changed: &FxHashSet } } let mut wcx = WorkerCx::new(); - let go_pairs = go::go_implements(e, &mut out); - interface_impl(e, &go_pairs, &mut out); + go::go_implements(e, &mut out); + interface_impl(e, &mut out); event_emitter(e, &mut out, &mut wcx, Some(&keys)); react_render(e, &mut out, Some(changed)); jsx_render(e, &mut out, &mut wcx, Some(changed)); diff --git a/crates/cg-resolve/src/synth/sites.rs b/crates/cg-resolve/src/synth/sites.rs index 57a4c17..ce2fb02 100644 --- a/crates/cg-resolve/src/synth/sites.rs +++ b/crates/cg-resolve/src/synth/sites.rs @@ -30,6 +30,10 @@ pub const PASS_BUS: u16 = 11; pub const PASS_CELERY: u16 = 12; /// Spring application events (`dynamic::spring_events`). pub const PASS_SPRING: u16 = 13; +/// React Router arrays and the router calls that consume them. +pub const PASS_REACT_TABLE: u16 = 14; +/// Nest modules, router registrations and application bootstrap configuration. +pub const PASS_NEST: u16 = 15; pub const ROLE_EMIT: u8 = 0; pub const ROLE_ON: u8 = 1; diff --git a/crates/cg-resolve/tests/cross_file_gaps.rs b/crates/cg-resolve/tests/cross_file_gaps.rs new file mode 100644 index 0000000..fdd2397 --- /dev/null +++ b/crates/cg-resolve/tests/cross_file_gaps.rs @@ -0,0 +1,211 @@ +use cg_core::EdgeKind; +use cg_resolve::{build_seg, IndexOptions}; +use cg_store::{dump, View}; +use std::sync::Arc; + +fn project(files: &[(&str, &str)]) -> (tempfile::TempDir, View) { + let dir = tempfile::tempdir().unwrap(); + for (path, contents) in files { + let dest = dir.path().join(path); + std::fs::create_dir_all(dest.parent().unwrap()).unwrap(); + std::fs::write(dest, contents).unwrap(); + } + let seg = build_seg(dir.path(), &IndexOptions { threads: Some(2), ..Default::default() }).unwrap().seg; + let view = View::new(Arc::new(seg)).with_root(dir.path().to_path_buf()); + (dir, view) +} + +#[test] +fn go_promoted_dispatch_respects_shadowing_and_ambiguity() { + let (_dir, view) = project(&[ + ("go.mod", "module example.com/test\n\ngo 1.21\n"), + ( + "p/types.go", + r#"package p + +type Closer interface { Close() error } +type Base struct{} +type Middle struct { Base } +type Wrapped struct { Middle } +type Other struct{} +type Ambiguous struct { Base; Other } +type Override struct { Base } +type BadOverride struct { Base } +type Service interface { Open(); Close() error } +type ServiceWrapper struct { Base } +type FieldShadow struct { Base; Close string } +"#, + ), + ( + "p/methods.go", + r#"package p +func (Base) Close() error { return nil } +func (Other) Close() error { return nil } +func (Override) Close() error { return nil } +func (BadOverride) Close(n int) error { return nil } +func (ServiceWrapper) Open() {} +"#, + ), + ]); + let edges = dump::dump_edges(&view); + let has = |s: &str| edges.iter().any(|e| e == s); + assert!(has("p/types.go::Wrapped -implements-> p/types.go::Closer"), "{edges:#?}"); + assert!(has("p/types.go::Closer::Close -calls-> p/methods.go::Base::Close"), "{edges:#?}"); + assert!(has("p/types.go::Closer::Close -calls-> p/methods.go::Override::Close"), "{edges:#?}"); + assert!(!has("p/types.go::Ambiguous -implements-> p/types.go::Closer"), "{edges:#?}"); + assert!(!has("p/types.go::BadOverride -implements-> p/types.go::Closer"), "{edges:#?}"); + assert!(!has("p/types.go::FieldShadow -implements-> p/types.go::Closer"), "a field shadows a promoted method: {edges:#?}"); + assert!(!has("p/types.go::Closer::Close -calls-> p/methods.go::BadOverride::Close"), "{edges:#?}"); + // Base alone does not implement Service; this edge exists only because ServiceWrapper + // combines its own Open with Base's promoted Close. + assert!(has("p/types.go::ServiceWrapper -implements-> p/types.go::Service"), "{edges:#?}"); + assert!(has("p/types.go::Service::Close -calls-> p/methods.go::Base::Close"), "{edges:#?}"); + assert!(has("p/types.go::Service::Open -calls-> p/methods.go::ServiceWrapper::Open"), "{edges:#?}"); + // Keep the test's expectation explicitly about call edges, not containment. + assert!(view.files().flat_map(|f| view.nodes_in_file(f)).any(|n| view.out_edges(cg_core::NodeIdx(n)).any(|e| e.kind == EdgeKind::Calls))); +} + +#[test] +fn react_router_uses_imported_route_tables_and_ignores_unregistered_arrays() { + let (_dir, view) = project(&[ + ("package.json", r#"{"dependencies":{"react":"19","react-router-dom":"6"}}"#), + ("src/pages.tsx", "export function Home() { return null; }\nexport function Team() { return null; }\nexport function Ghost() { return null; }\n"), + ("src/routes.tsx", r#"import { Home, Team, Ghost } from './pages'; +export const routes = [ + { path: '/', element: }, + { path: '/teams', children: [ + { path: ':id', element: }, + ] }, +]; +export const menu = [{ path: '/ghost', element: }]; +"#), + ("src/barrel.ts", "export { routes as appRoutes } from './routes';\n"), + ("src/app.tsx", "import { createBrowserRouter } from 'react-router-dom';\nimport { appRoutes as table } from './barrel';\nexport const router = createBrowserRouter(table);\n"), + ("src/nav.tsx", r#"import { Link } from 'react-router-dom'; +export function Nav() { + return <>teamghost; +} +"#), + ]); + let edges = dump::dump_edges(&view); + let has = |s: &str| edges.iter().any(|e| e == s); + assert!(has("src/routes.tsx::src/routes.tsx::route:/teams/:id -references-> src/pages.tsx::Team"), "{edges:#?}"); + assert!(has("src/nav.tsx::Nav -navigates-> src/routes.tsx::src/routes.tsx::route:/teams/:id"), "{edges:#?}"); + assert!(!edges.iter().any(|e| e.starts_with("src/nav.tsx::Nav -navigates->") && e.contains("/ghost")), "unregistered array must not be active: {edges:#?}"); +} + +#[test] +fn nest_module_mount_and_global_prefix_reach_http_routes() { + let (_dir, view) = project(&[ + ("package.json", r#"{"dependencies":{"@nestjs/core":"10","@nestjs/common":"10"}}"#), + ("src/users.controller.ts", r#"import { Controller, Get, Post } from '@nestjs/common'; +@Controller('users') +export class UsersController { + @Get(':id') + one() {} + @Post('health') + health() {} +} +"#), + ("src/users.module.ts", "import { Module } from '@nestjs/common';\nimport { UsersController } from './users.controller';\n@Module({ controllers: [UsersController] })\nexport class UsersModule {}\n"), + ("src/admin.module.ts", "import { Module } from '@nestjs/common';\nimport { UsersModule } from './users.module';\n@Module({ imports: [UsersModule] })\nexport class AdminModule {}\n"), + ("src/app.module.ts", r#"import { Module } from '@nestjs/common'; +import { RouterModule as Routes } from '@nestjs/core'; +import { AdminModule } from './admin.module'; +import { UsersModule as Users } from './users.module'; +@Module({ imports: [AdminModule, Routes.register([ + { path: 'admin', module: AdminModule, children: [ + { path: 'v2', module: Users }, + ] }, +])] }) +export class AppModule {} +"#), + ("src/main.ts", r#"import { NestFactory as Factory } from '@nestjs/core'; +import { AppModule } from './app.module'; +async function bootstrap() { + const app = await Factory.create(AppModule); + app.setGlobalPrefix('api', { exclude: [{ path: 'admin/v2/users/health', method: RequestMethod.POST }] }); +} +"#), + ("client/api.ts", r#"export function one() { + return fetch('/api/admin/v2/users/7'); +} +export function old() { + return fetch('/users/7'); +} +export function health() { + return fetch('/admin/v2/users/health', { method: 'POST' }); +} +"#), + ]); + let edges = dump::dump_edges(&view); + let has = |s: &str| edges.iter().any(|e| e == s); + assert!(has("client/api.ts::one -calls-> src/users.controller.ts::src/users.controller.ts::GET:/users/:id"), "{edges:#?}"); + assert!(!edges.iter().any(|e| e.starts_with("client/api.ts::old -calls-> src/users.controller.ts")), "old unmounted path: {edges:#?}"); + assert!(has("client/api.ts::health -calls-> src/users.controller.ts::src/users.controller.ts::POST:/users/health"), "excluded global prefix: {edges:#?}"); +} + +#[test] +fn react_router_composes_imported_children_across_multiple_files() { + let (_dir, view) = project(&[ + ("package.json", r#"{"dependencies":{"react-router-dom":"6"}}"#), + ("src/pages.tsx", "export function Profile() { return null }\nexport function Settings() { return null }\n"), + ("src/child.tsx", "import { Profile, Settings } from './pages';\nexport const childRoutes = [\n { path: 'profile', element:
你好
},\n { path: 'settings', element: },\n];\n"), + ("src/parent.ts", "import { childRoutes } from './child';\nimport { createMemoryRouter } from 'react-router-dom';\nexport const adminRoutes = [\n { path: 'admin', children: childRoutes },\n];\nexport const preview = createMemoryRouter([{ path: '/preview', Component: Preview }]);\nfunction Preview() {}\n"), + ("src/app.ts", "import { createBrowserRouter } from 'react-router-dom';\nimport { adminRoutes } from './parent';\nexport const router = createBrowserRouter([{ path: '/dashboard', children: adminRoutes }]);\n"), + ("src/nav.tsx", "import { Link } from 'react-router-dom';\nexport function Nav() {\n return <>yesno;\n}\n"), + ]); + let edges = dump::dump_edges(&view); + let target = "src/nav.tsx::Nav -navigates-> src/child.tsx::src/child.tsx::route:/profile"; + assert!(edges.iter().any(|e| e == target), "nested imported route: {edges:#?}"); + let metas: Vec<_> = view + .files() + .flat_map(|f| view.nodes_in_file(f)) + .flat_map(|n| view.out_edges(cg_core::NodeIdx(n))) + .filter_map(|e| view.edge_meta(e.eid)) + .filter(|m| m.contains("react-router-link") && m.contains("profile")) + .collect(); + assert_eq!(metas.len(), 1, "only the mounted path should match: {metas:#?}"); + assert!(metas[0].contains("/dashboard/admin/profile"), "{metas:#?}"); +} + +#[test] +fn nest_separates_two_bootstraps_and_partial_exclusions() { + let (_dir, view) = project(&[ + ("package.json", r#"{"dependencies":{"@nestjs/core":"10","@nestjs/common":"10"}}"#), + ("src/users.ts", "import { Controller, Get, All, Module } from '@nestjs/common';\n@Controller('users')\nexport class UsersController {\n @Get(':id')\n one() {}\n @All('hooks')\n hooks() {}\n}\n@Module({ controllers: [UsersController] })\nexport class UsersModule {}\n"), + ("src/a.ts", "import { Module } from '@nestjs/common';\nimport { RouterModule } from '@nestjs/core';\nimport { UsersModule } from './users';\n@Module({ imports: [UsersModule, RouterModule.register([{ path: 'a', module: UsersModule }])] })\nexport class AppA {}\n"), + ("src/b.ts", "import { Module } from '@nestjs/common';\nimport { RouterModule } from '@nestjs/core';\nimport { UsersModule } from './users';\n@Module({ imports: [UsersModule, RouterModule.register([{ path: 'b', module: UsersModule }])] })\nexport class AppB {}\n"), + ("src/main-a.ts", "import { NestFactory } from '@nestjs/core';\nimport { AppA } from './a';\nasync function start() {\n const app = await NestFactory.create(AppA);\n app.setGlobalPrefix('v1', { exclude: ['a/users/health', { path: 'a/users/hooks', method: RequestMethod.POST }] });\n}\n"), + ("src/main-b.ts", "import { NestFactory } from '@nestjs/core';\nimport { AppB } from './b';\nasync function start() {\n const app = await NestFactory.create(AppB);\n app.setGlobalPrefix('v2');\n}\n"), + ("client.ts", "export function a() { return fetch('/v1/a/users/7'); }\nexport function b() { return fetch('/v2/b/users/7'); }\nexport function health() { return fetch('/a/users/health'); }\nexport function wrong() { return fetch('/v1/b/users/7'); }\nexport function unprefixed() { return fetch('/a/users/7'); }\nexport function prefixedHealth() { return fetch('/v1/a/users/health'); }\nexport function getHooks() { return fetch('/v1/a/users/hooks'); }\nexport function postHooks() { return fetch('/a/users/hooks', { method: 'POST' }); }\nexport function badPost() { return fetch('/v1/a/users/hooks', { method: 'POST' }); }\n"), + ]); + let edges = dump::dump_edges(&view); + for name in ["a", "b", "health"] { + assert!(edges.iter().any(|e| e.starts_with(&format!("client.ts::{name} -calls-> src/users.ts"))), "{name}: {edges:#?}"); + } + for name in ["wrong", "unprefixed", "prefixedHealth"] { + assert!(!edges.iter().any(|e| e.starts_with(&format!("client.ts::{name} -calls-> src/users.ts"))), "{name}: {edges:#?}"); + } + for name in ["getHooks", "postHooks"] { + assert!(edges.iter().any(|e| e.starts_with(&format!("client.ts::{name} -calls->")) && e.contains("ALL:/users/hooks")), "{name}: {edges:#?}"); + } + assert!(!edges.iter().any(|e| e.starts_with("client.ts::badPost -calls->") && e.contains("src/users.ts")), "{edges:#?}"); +} + +#[test] +fn react_router_accepts_default_exported_route_arrays() { + let (_dir, view) = project(&[ + ("package.json", r#"{"dependencies":{"react-router-dom":"6"}}"#), + ("src/pages.tsx", "export function Home() { return null; }\n"), + ("src/routes.tsx", "import { Home } from './pages';\nexport default [\n { path: '/default', element: },\n];\n"), + ("src/barrel.ts", "export { default as routeTable } from './routes';\n"), + ( + "src/app.ts", + "import { useRoutes } from 'react-router-dom';\nimport { routeTable } from './barrel';\nexport function App() { return useRoutes(routeTable); }\n", + ), + ("src/nav.tsx", "import { Link } from 'react-router-dom';\nexport function Nav() { return go }\n"), + ]); + let edges = dump::dump_edges(&view); + assert!(edges.iter().any(|e| e == "src/nav.tsx::Nav -navigates-> src/routes.tsx::src/routes.tsx::route:/default"), "{edges:#?}"); +} diff --git a/crates/cg-sync/tests/cross_file_gaps.rs b/crates/cg-sync/tests/cross_file_gaps.rs new file mode 100644 index 0000000..58dc195 --- /dev/null +++ b/crates/cg-sync/tests/cross_file_gaps.rs @@ -0,0 +1,114 @@ +//! A change on either side of a cross-file link must agree with a fresh index. +use cg_resolve::{index_project, IndexOptions}; +use cg_store::{dump, Store}; +use cg_sync::{sync, SyncOptions}; +use std::path::Path; +use std::time::{Duration, SystemTime}; + +const FILES: &[(&str, &str)] = &[ + ("package.json", r#"{"dependencies":{"@nestjs/core":"10","@nestjs/common":"10","react-router-dom":"6"}}"#), + ("src/users.controller.ts", "import { Controller, Get } from '@nestjs/common';\n@Controller('users')\nexport class UsersController {\n @Get(':id')\n one() {}\n}\n"), + ("src/users.module.ts", "import { Module } from '@nestjs/common';\nimport { UsersController } from './users.controller';\n@Module({ controllers: [UsersController] })\nexport class UsersModule {}\n"), + ("src/app.module.ts", "import { Module } from '@nestjs/common';\nimport { RouterModule } from '@nestjs/core';\nimport { UsersModule } from './users.module';\n@Module({ imports: [UsersModule, RouterModule.register([{ path: 'admin', module: UsersModule }])] })\nexport class AppModule {}\n"), + ("src/main.ts", "import { NestFactory } from '@nestjs/core';\nimport { AppModule } from './app.module';\nasync function bootstrap() {\n const app = await NestFactory.create(AppModule);\n app.setGlobalPrefix('api');\n}\n"), + ("client/api.ts", "export function load() {\n return fetch('/api/admin/users/1');\n}\n"), + ("web/src/pages.tsx", "export function Home() { return null }\nexport function Other() { return null }\n"), + ("web/src/routes.tsx", "import { Home, Other } from './pages';\nexport const routes = [{ path: '/home', element: }];\nexport const otherRoutes = [{ path: '/other', element: }];\nexport default [{ path: '/special', element: }];\n"), + ("web/src/barrel.ts", "export { default as defaultRoutes } from './routes';\n"), + ("web/src/app.tsx", "import { createBrowserRouter } from 'react-router-dom';\nimport { routes, otherRoutes } from './routes';\nimport { defaultRoutes } from './barrel';\nexport const router = createBrowserRouter(routes);\n"), + ("web/src/nav.tsx", "import { Link } from 'react-router-dom';\nexport function Nav() {\n return home;\n}\n"), + ("go/go.mod", "module example.com/test\n\ngo 1.21\n"), + ("go/x/types.go", "package x\ntype Service interface { Open(); Close() error }\ntype Base struct{}\ntype Wrapper struct { Base }\n"), + ("go/x/methods.go", "package x\nfunc (Base) Close() error { return nil }\nfunc (Wrapper) Open() {}\n"), +]; + +fn opts() -> IndexOptions { + IndexOptions { threads: Some(2), ..Default::default() } +} +fn write(root: &Path, rel: &str, text: &str, step: u64) { + let path = root.join(rel); + std::fs::create_dir_all(path.parent().unwrap()).unwrap(); + std::fs::write(&path, text).unwrap(); + let stamp = SystemTime::UNIX_EPOCH + Duration::from_secs(1_700_000_000 + step); + std::fs::OpenOptions::new().write(true).open(path).unwrap().set_modified(stamp).unwrap(); +} +fn graph(root: &Path) -> Vec { + let snap = Store::locate(root).unwrap().open_snapshot().unwrap(); + dump::canonical(&snap.view) +} +fn edges(root: &Path) -> Vec { + let snap = Store::locate(root).unwrap().open_snapshot().unwrap(); + dump::dump_edges(&snap.view) +} +fn fresh(root: &Path) -> Vec { + let temp = tempfile::tempdir().unwrap(); + for (rel, _) in FILES { + let text = std::fs::read_to_string(root.join(rel)).unwrap(); + write(temp.path(), rel, &text, 1); + } + index_project(temp.path(), &opts()).unwrap(); + graph(temp.path()) +} + +#[test] +fn cross_file_edits_remain_equal_to_full_rebuild() { + let temp = tempfile::tempdir().unwrap(); + let root = temp.path(); + for (i, (rel, contents)) in FILES.iter().enumerate() { + write(root, rel, contents, i as u64); + } + index_project(root, &opts()).unwrap(); + let contains = |needle: &str| edges(root).iter().any(|e| e.contains(needle)); + assert!(contains("client/api.ts::load -calls-> src/users.controller.ts")); + assert!(contains("web/src/nav.tsx::Nav -navigates-> web/src/routes.tsx::web/src/routes.tsx::route:/home")); + assert!(contains("go/x/types.go::Service::Close -calls-> go/x/methods.go::Base::Close")); + let changes = [ + ("src/main.ts", "setGlobalPrefix('api')", "setGlobalPrefix('v2')"), + ("client/api.ts", "/api/admin/users/1", "/v2/admin/users/1"), + ("src/app.module.ts", "path: 'admin'", "path: 'private'"), + ("web/src/app.tsx", "createBrowserRouter(routes)", "createBrowserRouter(otherRoutes)"), + ("web/src/nav.tsx", "/home", "/other"), + ("web/src/routes.tsx", "path: '/other'", "path: 'changed'"), + ("go/x/methods.go", "Close() error", "Close(n int) error"), + ("go/x/methods.go", "Close(n int) error", "Close() error"), + ("src/users.module.ts", "controllers: [UsersController]", "controllers: []"), + ("web/src/app.tsx", "createBrowserRouter(otherRoutes)", "createBrowserRouter([{ path: '/admin', children: otherRoutes }])"), + ("web/src/nav.tsx", "/other", "/admin/changed"), + ("web/src/app.tsx", "path: '/admin'", "path: '/private'"), + ("go/x/types.go", "struct { Base }", "struct { Base; Close string }"), + ("go/x/types.go", "struct { Base; Close string }", "struct { Base }"), + ("web/src/app.tsx", "createBrowserRouter([{ path: '/private', children: otherRoutes }])", "createBrowserRouter(defaultRoutes)"), + ("web/src/nav.tsx", "/admin/changed", "/special"), + ("web/src/routes.tsx", "path: '/special'", "path: '/new'"), + ("src/users.module.ts", "controllers: []", "controllers: [UsersController]"), + ("client/api.ts", "/v2/admin/users/1", "/v2/private/users/health"), + ("src/main.ts", "setGlobalPrefix('v2')", "setGlobalPrefix('v2', { exclude: ['private/users/health'] })"), + ("client/api.ts", "/v2/private/users/health", "/private/users/health"), + ]; + for (i, (file, from, to)) in changes.iter().enumerate() { + let current = std::fs::read_to_string(root.join(file)).unwrap(); + assert!(current.contains(from)); + write(root, file, ¤t.replacen(from, to, 1), 100 + i as u64); + let report = sync(root, &SyncOptions { index: opts(), ..Default::default() }).unwrap(); + assert!(report.full_rebuild.is_none(), "step {i} used a full rebuild: {:?}", report.full_rebuild); + let (inc, full) = (graph(root), fresh(root)); + assert_eq!(inc, full, "incremental graph differs at step {i}: {file}"); + match i { + 0 | 2 | 8 => assert!(!contains("client/api.ts::load -calls-> src/users.controller.ts"), "stale HTTP edge at step {i}"), + 1 => assert!(contains("client/api.ts::load -calls-> src/users.controller.ts")), + 3 | 5 => assert!(!contains("web/src/nav.tsx::Nav -navigates->"), "stale navigation at step {i}"), + 4 => assert!(contains("web/src/nav.tsx::Nav -navigates-> web/src/routes.tsx::web/src/routes.tsx::route:/other")), + 6 => assert!(!contains("go/x/types.go::Service::Close -calls-> go/x/methods.go::Base::Close")), + 7 => assert!(contains("go/x/types.go::Service::Close -calls-> go/x/methods.go::Base::Close")), + 10 => assert!(contains("web/src/nav.tsx::Nav -navigates-> web/src/routes.tsx::web/src/routes.tsx::route:/changed")), + 11 => assert!(!contains("web/src/nav.tsx::Nav -navigates->")), + 12 => assert!(!contains("go/x/types.go::Service::Close -calls-> go/x/methods.go::Base::Close")), + 13 => assert!(contains("go/x/types.go::Service::Close -calls-> go/x/methods.go::Base::Close")), + 15 => assert!(contains("web/src/nav.tsx::Nav -navigates-> web/src/routes.tsx::web/src/routes.tsx::route:/special")), + 16 => assert!(!contains("web/src/nav.tsx::Nav -navigates->")), + 18 | 20 => assert!(contains("client/api.ts::load -calls-> src/users.controller.ts")), + 19 => assert!(!contains("client/api.ts::load -calls-> src/users.controller.ts")), + _ => {} + } + } +}