From 34c00243d1f6a7d65908682f1fa494ca9e4b8cf1 Mon Sep 17 00:00:00 2001 From: NianJiuZst <3235467914@qq.com> Date: Sun, 1 Nov 2026 05:19:13 -0600 Subject: [PATCH 1/5] fix: resolve module exports and preserve receiver type evidence --- crates/cg-core/src/brand.rs | 2 +- crates/cg-extract/src/facts/js.rs | 107 ++++++++ crates/cg-extract/src/facts/mod.rs | 11 +- crates/cg-extract/src/facts/rust.rs | 123 ++++++++- crates/cg-extract/src/facts/util.rs | 8 +- crates/cg-resolve/src/engine.rs | 33 ++- crates/cg-resolve/src/frameworks/routes.rs | 9 + crates/cg-resolve/src/modules.rs | 68 +++-- crates/cg-resolve/src/project.rs | 15 +- crates/cg-resolve/src/resolve.rs | 290 +++++++++++++++++---- crates/cg-resolve/src/shape.rs | 2 +- crates/cg-sync/src/sync.rs | 22 +- 12 files changed, 597 insertions(+), 93 deletions(-) diff --git a/crates/cg-core/src/brand.rs b/crates/cg-core/src/brand.rs index 3489294..fc26f20 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 = 2; +pub const ENGINE_VERSION: u32 = 3; /// 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-extract/src/facts/js.rs b/crates/cg-extract/src/facts/js.rs index 580c7da..f69dd6d 100644 --- a/crates/cg-extract/src/facts/js.rs +++ b/crates/cg-extract/src/facts/js.rs @@ -21,6 +21,12 @@ fn walk(cx: &mut Cx, n: Node, scope: u32) { export_stmt(cx, n); walk_children(cx, n, scope); } + "assignment_expression" => { + if scope == 0 { + commonjs_export(cx, n); + } + walk_children(cx, n, scope); + } "function_declaration" | "generator_function_declaration" => { if scope != 0 { if let Some(name) = n.child_by_field_name("name") { @@ -280,7 +286,108 @@ fn export_stmt(cx: &mut Cx, n: Node) { } } +fn commonjs_export(cx: &mut Cx, n: Node) { + let Some(left) = n.child_by_field_name("left") else { return }; + let target = cx.text(left); + let root = target.split('.').next().unwrap_or(target); + if cx.lookup_binding(0, root).is_some() { + return; // A user variable named module/exports shadows CommonJS globals. + } + let name = if target == "module.exports" { + "default" + } else if let Some(name) = target.strip_prefix("module.exports.").or_else(|| target.strip_prefix("exports.")) { + if name.is_empty() || name.contains(['.', '[', ']']) { + return; + } + name + } else { + return; + }; + let Some(value) = n.child_by_field_name("right") else { return }; + commonjs_value(cx, name, value); +} + +fn commonjs_value(cx: &mut Cx, name: &str, value: Node) { + if let Some(spec) = require_target(cx, value) { + let line = cx.line(value); + cx.add_import(ImportFact { + local: String::new(), + imported: "*".into(), + spec: spec.clone(), + kind: ImportKind::SideEffect, + type_only: false, + scope: 0, + line, + }); + if name == "default" { + cx.facts.exports.push(ExportFact { name: "*".into(), node_row: NONE, from_spec: spec.clone(), from_name: "*".into(), star: true }); + } + cx.facts.exports.push(ExportFact { name: name.to_owned(), node_row: NONE, from_spec: spec, from_name: "default".into(), star: false }); + return; + } + let (node_row, from_spec, from_name) = match value.kind() { + "identifier" | "member_expression" => { + let text = cx.text(value); + let (root, member) = text.split_once('.').map_or((text, None), |(a, b)| (a, Some(b))); + if let Some(imp) = cx.facts.imports.iter().find(|i| i.scope == 0 && i.local == root) { + let imported = member.unwrap_or(if imp.imported == "*" { "default" } else { &imp.imported }); + (NONE, imp.spec.clone(), imported.to_owned()) + } else if member.is_none() { + (NONE, String::new(), text.to_owned()) + } else { + return; + } + } + "function_expression" | "function" | "generator_function" | "arrow_function" | "class" => { + (cx.row_at(cx.start(value)).unwrap_or(NONE), String::new(), String::new()) + } + "object" if name == "default" => { + for prop in kids(value) { + if prop.kind() == "pair" { + if let (Some(key), Some(val)) = (prop.child_by_field_name("key"), prop.child_by_field_name("value")) { + let key = unquote(cx.text(key)).to_owned(); + commonjs_value(cx, &key, val); + } + } else if prop.kind() == "shorthand_property_identifier" { + commonjs_value(cx, cx.text(prop), prop); + } + } + return; + } + "shorthand_property_identifier" => (NONE, String::new(), cx.text(value).to_owned()), + _ => return, + }; + cx.facts.exports.push(ExportFact { name: name.to_owned(), node_row, from_spec, from_name, star: false }); +} + fn function(cx: &mut Cx, n: Node, scope: u32) { + // The kernel labels `obj.method = function method() {}` as a Function. Keep + // evidence of the member assignment so an unknown receiver cannot match an + // unrelated, plain function with the same name. + if let Some(parent) = n.parent() { + let member = match parent.kind() { + "object" if n.kind() == "method_definition" => n.child_by_field_name("name"), + "assignment_expression" if parent.child_by_field_name("right") == Some(n) => parent + .child_by_field_name("left") + .filter(|left| matches!(left.kind(), "member_expression" | "subscript_expression")) + .and_then(|left| left.child_by_field_name("property").or_else(|| left.child_by_field_name("index").filter(|index| index.kind() == "string"))), + "pair" if parent.child_by_field_name("value") == Some(n) => parent.child_by_field_name("key"), + _ => None, + }; + if let Some(member) = member { + if let Some(row) = cx.row_at(cx.start(n)) { + cx.facts.bindings.push(BindingFact { + scope, + name: cx.text(member).trim_matches(['\'', '"']).to_owned(), + kind: BindKind::MemberFn, + decl_type: String::new(), + init_ctor: String::new(), + line: cx.line(n), + node_row: row, + }); + } + } + } let sc = cx.push_scope(ScopeKind::Function, scope, n); let line = cx.line(n); if let Some(p) = n.child_by_field_name("parameter") { diff --git a/crates/cg-extract/src/facts/mod.rs b/crates/cg-extract/src/facts/mod.rs index 2817c6b..37e8355 100644 --- a/crates/cg-extract/src/facts/mod.rs +++ b/crates/cg-extract/src/facts/mod.rs @@ -101,6 +101,12 @@ pub enum BindKind { Field = 3, /// The file's declared package (Go `package x`, Java/Kotlin `package a.b`); `name` is the package. Package = 4, + /// Function assigned to a JavaScript object member, rather than a free function. + /// This is declaration metadata and must not participate in lexical lookup. + MemberFn = 5, + /// Raw Rust return annotation, keyed by the function's node. This metadata + /// preserves generic return types the upstream kernel intentionally reduces. + ReturnType = 6, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -108,9 +114,10 @@ pub struct BindingFact { pub scope: u32, pub name: String, pub kind: BindKind, - /// Declared type as written (`Foo`, `Foo` reduced to `Foo` by the extractor), or empty. + /// Declared type, usually reduced to its head (`Foo` -> `Foo`). Rust Result/Option + /// retain their arguments so the resolver does not mistake the container for its value. pub decl_type: String, - /// Constructor name when initialised by `new Foo()` / `Foo()` / `Foo{}`, or empty. + /// Constructor or bounded initializer call path (`Foo::new().build()`), or empty. pub init_ctor: String, /// 1-based declaration line; the binding is visible from here on (hoisted functions /// are visible throughout their scope and use line 0). diff --git a/crates/cg-extract/src/facts/rust.rs b/crates/cg-extract/src/facts/rust.rs index d38d255..5a3e805 100644 --- a/crates/cg-extract/src/facts/rust.rs +++ b/crates/cg-extract/src/facts/rust.rs @@ -5,7 +5,80 @@ use super::util::*; use super::*; pub fn extract(cx: &mut Cx, root: Node) { - walk(cx, root, 0); + // Conditional item wrappers such as Tokio's cfg_rt! hide `pub use` from + // tree-sitter. Reparse a position-preserving view with just those wrappers + // blanked out. Never expand arbitrary macros or change the kernel's nodes. + if let Some(tree) = conditional_items(cx.src, root) { + walk(cx, tree.root_node(), 0); + } else { + walk(cx, root, 0); + } +} + +fn conditional_items(src: &str, root: Node) -> Option { + use std::time::{Duration, Instant}; + use tree_sitter::{ParseOptions, Parser}; + + if src.len() > 1024 * 1024 || !src.contains("cfg_") { + return None; + } + fn wrapper(name: &str) -> bool { + name.starts_with("cfg_") && name != "cfg_if" && name.bytes().all(|c| c.is_ascii_alphanumeric() || c == b'_') + } + fn blank(bytes: &mut [u8]) { + for b in bytes { + if *b != b'\n' && *b != b'\r' { + *b = b' '; + } + } + } + fn collect(n: Node, src: &str, ranges: &mut Vec<(usize, usize)>, depth: usize) { + if depth > 128 || n.kind() == "macro_definition" { + return; + } + if matches!(n.kind(), "macro_invocation" | "token_tree") { + let mut c = n.walk(); + let children: Vec<_> = n.children(&mut c).collect(); + let mut i = 0; + while i < children.len() { + if i + 2 < children.len() && children[i + 1].kind() == "!" && children[i + 2].kind() == "token_tree" { + let name = &src[children[i].byte_range()]; + let body = children[i + 2]; + if wrapper(name) && src.as_bytes().get(body.start_byte()) == Some(&b'{') { + ranges.push((children[i].start_byte(), body.start_byte() + 1)); + ranges.push((body.end_byte() - 1, body.end_byte())); + collect(body, src, ranges, depth + 1); + } + // An unknown macro's tokens are not ordinary Rust items. + i += 3; + } else { + collect(children[i], src, ranges, depth + 1); + i += 1; + } + } + } else { + for ch in kids(n) { + collect(ch, src, ranges, depth + 1); + } + } + } + let mut ranges = Vec::new(); + collect(root, src, &mut ranges, 0); + if ranges.is_empty() { + return None; + } + let mut masked = src.as_bytes().to_vec(); + for (start, end) in ranges { + blank(&mut masked[start..end]); + } + let mut parser = Parser::new(); + parser.set_language(&cg_kernel::hooks::language("rust")?).ok()?; + let deadline = Instant::now() + Duration::from_millis(100); + let mut cancel = |_: &tree_sitter::ParseState| Instant::now() >= deadline; + let tree = + parser.parse_with_options(&mut |offset, _| masked.get(offset..).unwrap_or_default(), None, Some(ParseOptions::new().progress_callback(&mut cancel)))?; + // Non-item wrappers (cfg_if!, DSLs, malformed syntax) are left opaque. + (!tree.root_node().has_error()).then_some(tree) } fn walk_children(cx: &mut Cx, n: Node, scope: u32) { @@ -47,7 +120,14 @@ fn walk(cx: &mut Cx, n: Node, scope: u32) { fn rust_type_name(cx: &Cx, n: Node) -> String { match n.kind() { "type_identifier" | "scoped_type_identifier" => cx.text(n).to_owned(), - "generic_type" => n.child_by_field_name("type").map(|c| rust_type_name(cx, c)).unwrap_or_default(), + "generic_type" => { + let base = n.child_by_field_name("type").map(|c| rust_type_name(cx, c)).unwrap_or_default(); + if matches!(base.rsplit("::").next(), Some("Result" | "Option")) { + cx.text(n).to_owned() + } else { + base + } + } "reference_type" | "pointer_type" => n.child_by_field_name("type").map(|c| rust_type_name(cx, c)).unwrap_or_default(), "abstract_type" | "dynamic_type" | "bounded_type" => { n.child_by_field_name("trait").or_else(|| n.named_child(0)).map(|c| rust_type_name(cx, c)).unwrap_or_default() @@ -78,15 +158,29 @@ fn bind_pattern(cx: &mut Cx, p: Node, scope: u32, kind: BindKind) { } fn value_info(cx: &Cx, v: Node) -> String { + value_path(cx, v, 0) +} + +fn value_path(cx: &Cx, v: Node, depth: u8) -> String { + if depth >= 16 || v.end_byte() - v.start_byte() > 4096 { + return String::new(); + } match v.kind() { + "identifier" | "scoped_identifier" => cx.text(v).to_owned(), + "generic_function" => v.child_by_field_name("function").map(|f| value_path(cx, f, depth + 1)).unwrap_or_default(), "struct_expression" => v.child_by_field_name("name").map(|n| cx.text(n).to_owned()).unwrap_or_default(), - "call_expression" => match v.child_by_field_name("function") { - Some(f) if matches!(f.kind(), "identifier" | "scoped_identifier") => format!("{}()", cx.text(f)), - _ => String::new(), - }, - "try_expression" | "await_expression" | "reference_expression" | "parenthesized_expression" => { - v.named_child(0).map(|c| value_info(cx, c)).unwrap_or_default() + "call_expression" => { + v.child_by_field_name("function").map(|f| value_path(cx, f, depth + 1)).filter(|p| !p.is_empty()).map(|p| format!("{p}()")).unwrap_or_default() + } + "field_expression" => { + let base = v.child_by_field_name("value").map(|v| value_path(cx, v, depth + 1)).unwrap_or_default(); + match v.child_by_field_name("field") { + Some(field) if !base.is_empty() => format!("{base}.{}", cx.text(field)), + _ => String::new(), + } } + "try_expression" => v.named_child(0).map(|c| value_path(cx, c, depth + 1)).filter(|p| !p.is_empty()).map(|p| format!("{p}?")).unwrap_or_default(), + "await_expression" | "reference_expression" | "parenthesized_expression" => v.named_child(0).map(|c| value_path(cx, c, depth + 1)).unwrap_or_default(), _ => String::new(), } } @@ -136,6 +230,19 @@ fn params(cx: &mut Cx, list: Node, sc: u32) { } fn function(cx: &mut Cx, n: Node, scope: u32) { + if let (Some(name), Some(ret)) = (n.child_by_field_name("name"), n.child_by_field_name("return_type")) { + if let Some(row) = cx.row_at(cx.start(n)) { + cx.facts.bindings.push(BindingFact { + scope, + name: cx.text(name).to_owned(), + kind: BindKind::ReturnType, + decl_type: cx.text(ret).to_owned(), + init_ctor: String::new(), + line: cx.line(n), + node_row: row, + }); + } + } if cx.facts.scopes[scope as usize].kind == ScopeKind::Function { if let Some(name) = n.child_by_field_name("name") { let nm = cx.text(name).to_owned(); diff --git a/crates/cg-extract/src/facts/util.rs b/crates/cg-extract/src/facts/util.rs index 6c89170..2102387 100644 --- a/crates/cg-extract/src/facts/util.rs +++ b/crates/cg-extract/src/facts/util.rs @@ -93,7 +93,13 @@ impl<'a> Cx<'a> { pub fn lookup_binding(&self, mut scope: u32, name: &str) -> Option<(String, String)> { loop { if self.facts.scopes[scope as usize].kind != ScopeKind::Class { - if let Some(b) = self.facts.bindings.iter().rev().find(|b| b.scope == scope && b.name == name) { + if let Some(b) = self + .facts + .bindings + .iter() + .rev() + .find(|b| b.scope == scope && b.name == name && !matches!(b.kind, BindKind::MemberFn | BindKind::ReturnType)) + { return Some((b.decl_type.clone(), b.init_ctor.clone())); } } diff --git a/crates/cg-resolve/src/engine.rs b/crates/cg-resolve/src/engine.rs index 74f6871..12ccf89 100644 --- a/crates/cg-resolve/src/engine.rs +++ b/crates/cg-resolve/src/engine.rs @@ -43,6 +43,10 @@ pub struct Engine<'v> { pub pkg_defs: Vec>>, /// Direct supertypes (`extends` / `implements` resolved in round 1). pub supers: FxHashMap>, + /// JavaScript functions with syntax evidence that they implement an object member. + pub member_functions: FxHashMap<&'v str, SmallVec<[NodeIdx; 2]>>, + pub return_types: FxHashMap, + pub django_model: Option, pub n_files: usize, } @@ -85,6 +89,12 @@ impl<'v> Engine<'v> { for (i, t) in computed { imp_targets[i] = t; } + let mut member_functions: FxHashMap<&'v str, SmallVec<[NodeIdx; 2]>> = FxHashMap::default(); + for &f in &files { + for b in view.bindings_of(f).iter().filter(|b| b.kind == BindKind::MemberFn as u8 && b.node.is_some()) { + member_functions.entry(view.text_str(b.name)).or_default().push(b.node); + } + } let mut e = Engine { budget, @@ -96,9 +106,26 @@ impl<'v> Engine<'v> { stars: vec![Vec::new(); n_files], pkg_defs: Vec::new(), supers: FxHashMap::default(), + member_functions, + return_types: files + .iter() + .flat_map(|&f| view.bindings_of(f)) + .filter(|b| b.kind == BindKind::ReturnType as u8 && b.node.is_some()) + .map(|b| (b.node, view.text_str(b.decl_type))) + .collect(), + django_model: None, n_files, }; e.build_exports(&files); + if project.py_deps.contains("django") { + if let Some(f) = files.iter().copied().find(|f| view.file(*f).lang() == Lang::Python) { + if let ImportTarget::File(base) = e.modules.resolve_import(Lang::Python, "django.db.models.base", f) { + if let Some(Bound::Node(n)) = e.lookup_export(base, "Model", 0) { + e.django_model = Some(n); + } + } + } + } e.build_pkg_defs(&files); e } @@ -336,14 +363,10 @@ impl<'v> Engine<'v> { return Bound::Module(tf); } if imp.kind == ImportKind::Require as u8 { - // CommonJS: any top-level definition counts if let Some(b) = self.lookup_export(tf, imported, 0) { return b; } - return match self.lookup_top_level(tf, imported) { - Some(n) => Bound::Node(n), - None => Bound::Module(tf), - }; + return Bound::Unknown; } if let Some(b) = self.lookup_export(tf, imported, 0) { return b; diff --git a/crates/cg-resolve/src/frameworks/routes.rs b/crates/cg-resolve/src/frameworks/routes.rs index 1dc391f..8ecf579 100644 --- a/crates/cg-resolve/src/frameworks/routes.rs +++ b/crates/cg-resolve/src/frameworks/routes.rs @@ -431,6 +431,15 @@ pub fn scan_next(rel: &str, src: &str) -> Vec { } pub fn scan(fw: Framework, lang: Lang, rel: &str, src: &str) -> Vec { + // Framework repositories contain route examples in API comments. Those + // snippets are documentation, not registrations in the program's graph. + let code; + let src = if matches!(fw, Framework::Express | Framework::Gin) { + code = cg_extract::post::strip_js_comments(src); + code.as_str() + } else { + src + }; match fw { Framework::Express => scan_express(src), Framework::Flask | Framework::FastApi => scan_python_decorators(src), diff --git a/crates/cg-resolve/src/modules.rs b/crates/cg-resolve/src/modules.rs index 8aa2f56..b3cfef5 100644 --- a/crates/cg-resolve/src/modules.rs +++ b/crates/cg-resolve/src/modules.rs @@ -189,18 +189,38 @@ impl<'v> Modules<'v> { } fn index_rust(&mut self, f: FileId, path: &str) { - let (crate_idx, src_dir): (u32, String) = match self.project.crates.iter().position(|c| path.starts_with(&format!("{}/", c.dir)) || c.dir.is_empty()) { - Some(i) => { - let c = &self.project.crates[i]; - (i as u32, if c.dir.is_empty() { "src".to_owned() } else { format!("{}/src", c.dir) }) - } - None => match path.rfind("/src/") { - Some(i) => (NONE, path[..i + 4].to_owned()), - None if path.starts_with("src/") => (NONE, "src".to_owned()), - None => (NONE, dir_of(path).to_owned()), - }, - }; - let modpath = match path.strip_prefix(&format!("{src_dir}/")) { + // Auxiliary Cargo targets are independent crates. In particular, a bench + // sorted before src/lib.rs must never become the library's root module. + let separate = self.project.crates.len() as u32 + f.0; + let (crate_idx, src_dir, root): (u32, String, Option<&str>) = + match self.project.crates.iter().position(|c| path.starts_with(&format!("{}/", c.dir)) || c.dir.is_empty()) { + Some(i) => { + let c = &self.project.crates[i]; + let root = c.roots.iter().find(|r| self.path_to_file.contains_key(r.as_str())).map(String::as_str); + let src_dir = + root.map(dir_of).map(str::to_owned).unwrap_or_else(|| if c.dir.is_empty() { "src".to_owned() } else { format!("{}/src", c.dir) }); + let rel = path.strip_prefix(&format!("{}/", c.dir)).unwrap_or(path); + let auxiliary = rel.starts_with("tests/") + || rel.starts_with("examples/") + || rel.starts_with("benches/") + || rel.starts_with("src/bin/") + || rel == "build.rs"; + let in_source = src_dir.is_empty() || path.starts_with(&format!("{src_dir}/")); + if !in_source || auxiliary || (c.roots.iter().any(|r| r == path) && root != Some(path)) { + (separate, dir_of(path).to_owned(), Some(path)) + } else { + (i as u32, src_dir, root) + } + } + None => match path.rfind("/src/") { + Some(i) => (NONE, path[..i + 4].to_owned(), None), + None if path.starts_with("src/") => (NONE, "src".to_owned(), None), + None => (separate, dir_of(path).to_owned(), Some(path)), + }, + }; + let rel = if src_dir.is_empty() { Some(path) } else { path.strip_prefix(&format!("{src_dir}/")) }; + let modpath = match rel { + _ if root == Some(path) => String::new(), Some(rel) => { let stem = rel.strip_suffix(".rs").unwrap_or(rel); let mut segs: Vec<&str> = stem.split('/').collect(); @@ -222,7 +242,11 @@ impl<'v> Modules<'v> { } None => String::new(), // tests/, examples/, benches/, build.rs: separate roots }; - self.rs_mod_to_file.entry((crate_idx, modpath.clone())).or_insert(f); + if root == Some(path) { + self.rs_mod_to_file.insert((crate_idx, modpath.clone()), f); + } else { + self.rs_mod_to_file.entry((crate_idx, modpath.clone())).or_insert(f); + } self.rs_file_mod.insert(f, (crate_idx, modpath)); } @@ -463,9 +487,16 @@ impl<'v> Modules<'v> { // ---- Rust fn resolve_rust(&self, spec: &str, from: FileId) -> ImportTarget { - let Some((crate_idx, modpath)) = self.rs_file_mod.get(&from) else { return ImportTarget::External }; + self.resolve_rust_path(spec, from).0 + } + + /// The longest module prefix and the number of trailing declaration/member + /// segments. Returning the tail prevents `crate::api::Type` being mistaken + /// for the module itself when resolving a qualified type or return value. + pub fn resolve_rust_path(&self, spec: &str, from: FileId) -> (ImportTarget, usize) { + let Some((crate_idx, modpath)) = self.rs_file_mod.get(&from) else { return (ImportTarget::External, 0) }; let segs: Vec<&str> = spec.split("::").filter(|s| !s.is_empty()).collect(); - let Some(first) = segs.first().copied() else { return ImportTarget::External }; + let Some(first) = segs.first().copied() else { return (ImportTarget::External, 0) }; let (target_crate, mut path): (u32, Vec) = match first { "crate" => (*crate_idx, segs[1..].iter().map(|s| s.to_string()).collect()), "self" => (*crate_idx, modpath.split("::").filter(|s| !s.is_empty()).map(str::to_owned).chain(segs[1..].iter().map(|s| s.to_string())).collect()), @@ -492,20 +523,21 @@ impl<'v> Modules<'v> { full.extend(segs.iter().map(|s| s.to_string())); (*crate_idx, full) } else { - return ImportTarget::External; + return (ImportTarget::External, 0); } } } }; + let full_len = path.len(); // longest module prefix that exists while !path.is_empty() || self.rs_mod_to_file.contains_key(&(target_crate, String::new())) { if let Some(f) = self.rs_mod_to_file.get(&(target_crate, path.join("::"))) { - return ImportTarget::File(*f); + return (ImportTarget::File(*f), full_len - path.len()); } if path.pop().is_none() { break; } } - ImportTarget::NotFound + (ImportTarget::NotFound, 0) } } diff --git a/crates/cg-resolve/src/project.rs b/crates/cg-resolve/src/project.rs index f348f4e..c7c2d3b 100644 --- a/crates/cg-resolve/src/project.rs +++ b/crates/cg-resolve/src/project.rs @@ -178,23 +178,20 @@ impl ProjectInfo { v.push(name); } }; - add(self.packages.iter().any(|p| p.deps.contains("express")), "express"); - add(self.packages.iter().any(|p| p.deps.contains("react") || p.deps.contains("react-dom")), "react"); - add(self.packages.iter().any(|p| p.deps.contains("next")), "next"); + let npm = |name: &str| self.packages.iter().any(|p| p.name.as_deref() == Some(name) || p.deps.contains(name)); + add(npm("express"), "express"); + add(npm("react") || npm("react-dom"), "react"); + add(npm("next"), "next"); add(self.py_deps.contains("fastapi"), "fastapi"); add(self.py_deps.contains("flask"), "flask"); add(self.py_deps.contains("django"), "django"); - add(self.go_deps_contain("gin-gonic/gin"), "gin"); + add(self.go_mod_deps.iter().any(|d| d == "github.com/gin-gonic/gin") || self.go_mods.iter().any(|m| m.module == "github.com/gin-gonic/gin"), "gin"); add(self.jvm_deps_text.contains("spring-boot") || self.jvm_deps_text.contains("springframework"), "spring"); - add(self.crates.iter().any(|c| c.deps.contains("axum")), "axum"); + add(self.crates.iter().any(|c| c.name == "axum" || c.deps.contains("axum")), "axum"); v.sort(); v.dedup(); v.into_iter().map(str::to_owned).collect() } - - fn go_deps_contain(&self, needle: &str) -> bool { - self.go_mod_deps.iter().any(|d| d.contains(needle)) - } } fn parse_package(dir: &str, v: &Value) -> PackageJson { diff --git a/crates/cg-resolve/src/resolve.rs b/crates/cg-resolve/src/resolve.rs index 2de5e18..6a6d332 100644 --- a/crates/cg-resolve/src/resolve.rs +++ b/crates/cg-resolve/src/resolve.rs @@ -100,6 +100,29 @@ pub enum TypeRes { Unknown, } +#[derive(Clone, Copy, PartialEq, Eq)] +enum StdWrapper { + Result, + Option, +} + +/// A known project type, possibly still inside a standard Rust container. +/// Keep the container until an operation such as `unwrap` actually removes it. +struct ValueType { + node: NodeIdx, + wrappers: SmallVec<[StdWrapper; 2]>, +} + +impl ValueType { + fn plain(node: NodeIdx) -> Self { + Self { node, wrappers: SmallVec::new() } + } + + fn receiver(self) -> Option { + self.wrappers.is_empty().then_some(self.node) + } +} + /// Per-file lookup structures, built once per file and reused for all its references. pub struct FileCx<'e, 'v> { pub e: &'e Engine<'v>, @@ -310,7 +333,7 @@ impl<'e, 'v> FileCx<'e, 'v> { if let Some(list) = self.bindings.get(&(s, name)) { let mut best = None; for b in list { - if b.kind == BindKind::Package as u8 { + if b.kind == BindKind::Package as u8 || b.kind == BindKind::MemberFn as u8 || b.kind == BindKind::ReturnType as u8 { continue; } if b.line == 0 || b.line <= line { @@ -403,7 +426,7 @@ impl<'e, 'v> FileCx<'e, 'v> { cur = match cur { Bound::Module(m) => match self.e.lookup_export(m, seg, 0) { Some(b) => b, - None => match self.e.lookup_top_level(m, seg) { + None => match (self.view.file(m).lang().family() != LangFamily::Js).then(|| self.e.lookup_top_level(m, seg)).flatten() { Some(n) => Bound::Node(n), None => Bound::Module(self.e.submodule(m, seg)?), }, @@ -438,6 +461,13 @@ impl<'e, 'v> FileCx<'e, 'v> { } fn qualified_type(&self, wcx: &mut WorkerCx<'e, 'v>, head: &str, rest: &str, full: &str) -> TypeRes { + if self.family == LangFamily::Rust { + if let Some(Bound::Node(n)) = self.rust_path_bound(full) { + if kind_of(self.view, n).is_type() { + return TypeRes::Node(n); + } + } + } let segs: Vec<&str> = rest.split(['.', ':']).filter(|s| !s.is_empty()).collect(); match self.resolve_name(wcx, head, Accept::Any, 0, u32::MAX, None, false) { NameRes::Module(tf) => match self.walk_path(Bound::Module(tf), &segs) { @@ -478,69 +508,198 @@ impl<'e, 'v> FileCx<'e, 'v> { TypeRes::Node(n) } + fn rust_path_bound(&self, name: &str) -> Option { + // A module and a value can share a Rust name (`mod once; pub use + // once::once`). Resolve the parent, then consult its exports before + // treating the final segment as a module filename. + let (prefix, last) = name.rsplit_once("::").unwrap_or((name, "")); + let (target, tail) = self.e.modules.resolve_rust_path(prefix, self.file); + let ImportTarget::File(file) = target else { return None }; + let mut segs: Vec<_> = prefix.split("::").filter(|s| !s.is_empty()).collect(); + let start = segs.len().checked_sub(tail)?; + if !last.is_empty() { + segs.push(last); + } + self.walk_path(Bound::Module(file), &segs[start..]) + } + /// The type a binding holds, from its declared type or initialiser. pub fn binding_type(&self, wcx: &mut WorkerCx<'e, 'v>, b: &BindingRec) -> Option { + self.binding_value(wcx, b, 0)?.receiver() + } + + fn binding_value(&self, wcx: &mut WorkerCx<'e, 'v>, b: &BindingRec, depth: u8) -> Option { + if depth >= 16 { + return None; + } let dt = self.view.text_str(b.decl_type); if !dt.is_empty() { - return match self.lookup_type(wcx, dt) { - TypeRes::Node(n) => Some(n), - _ => None, - }; + return self.type_value(wcx, dt, None, depth + 1); } let init = self.view.text_str(b.init_ctor); if init.is_empty() || init == "embedded" { return None; } + let scope = b.scope.0.wrapping_sub(self.scope_base); + // The new variable is not in scope in its own initializer (`let rt = rt()`). + let shadows = init.split(['.', ':', '(']).next() == Some(self.view.text_str(b.name)); + let line = if shadows { b.line.saturating_sub(1) } else { b.line }; + self.expression_value(wcx, init, scope, line, depth + 1) + } + + fn expression_value(&self, wcx: &mut WorkerCx<'e, 'v>, init: &str, scope: u32, line: u32, depth: u8) -> Option { + if depth >= 16 { + return None; + } + if let Some(inner) = init.strip_suffix('?') { + let mut value = self.expression_value(wcx, inner, scope, line, depth + 1)?; + value.wrappers.pop()?; + return Some(value); + } if let Some(call) = init.strip_suffix("()") { - return self.call_result_type(wcx, call); + return self.call_value(wcx, call, scope, line, depth + 1); } - match self.lookup_type(wcx, init) { - TypeRes::Node(n) => Some(n), - _ => None, + if self.family == LangFamily::Rust { + if let Some(other) = self.lookup_binding(init, scope, line, false) { + return self.binding_value(wcx, other, depth + 1); + } } + self.type_value(wcx, init, None, depth + 1) } - /// Type produced by calling `callee` (a constructor, or a function with a return type). - fn call_result_type(&self, wcx: &mut WorkerCx<'e, 'v>, callee: &str) -> Option { - // `Type::new` / `Type.create`: assume factory methods of a type produce that type - if let Some((head, rest)) = split_head(callee) { - if let TypeRes::Node(t) = self.lookup_type(wcx, head) { - if self.view.node(t).kind().is_type() { - if let Some(m) = self.e.find_member(t, rest.rsplit(['.', ':']).next().unwrap_or(rest)) { - if let Some(rt) = self.view.node(m).return_type() { - let rt_name = rt.trim(); - if rt_name != "Self" && rt_name != "self" { - let owner = self.e.modules.view.hot(m).file; - let cx = wcx.file_cx(self.e, owner); - if let TypeRes::Node(n) = cx.lookup_type(wcx, rt_name) { - return Some(n); - } - } + fn std_wrapper(&self, wcx: &mut WorkerCx<'e, 'v>, name: &str) -> Option { + let (prefix, leaf) = name.rsplit_once("::").unwrap_or(("", name)); + let wrapper = match leaf { + "Result" => StdWrapper::Result, + "Option" => StdWrapper::Option, + _ => return None, + }; + let standard = match prefix { + "std::result" | "core::result" | "std::io" => wrapper == StdWrapper::Result, + "std::option" | "core::option" => wrapper == StdWrapper::Option, + "" => matches!(self.lookup_type(wcx, name), TypeRes::Builtin), + "io" if wrapper == StdWrapper::Result => self.visible_import("io", 0).is_some_and(|i| { + let imp = &self.imports[i as usize]; + self.view.text_str(imp.spec) == "std" && self.view.text_str(imp.imported) == "io" + }), + _ => false, + }; + standard.then_some(wrapper) + } + + fn type_value(&self, wcx: &mut WorkerCx<'e, 'v>, name: &str, receiver: Option, depth: u8) -> Option { + if depth >= 16 || name.len() > 4096 { + return None; + } + let name = name.trim(); + let name = name.strip_prefix("&mut ").or_else(|| name.strip_prefix('&')).unwrap_or(name).trim(); + if matches!(name, "Self" | "self" | "this") { + return receiver.map(ValueType::plain); + } + if self.family == LangFamily::Rust { + if let Some(open) = name.find('<') { + let base = name[..open].trim(); + let Some(wrapper) = self.std_wrapper(wcx, base) else { + return match self.lookup_type(wcx, base) { + TypeRes::Node(t) => Some(ValueType::plain(t)), + _ => None, + }; + }; + let args = name[open + 1..].strip_suffix('>')?; + let mut nesting = 0u32; + let mut end = args.len(); + for (i, c) in args.char_indices() { + match c { + '<' | '(' | '[' => nesting += 1, + '>' | ')' | ']' => nesting = nesting.checked_sub(1)?, + ',' if nesting == 0 => { + end = i; + break; } + _ => {} } - return Some(t); } + let mut inner = self.type_value(wcx, &args[..end], receiver, depth + 1)?; + inner.wrappers.push(wrapper); + return Some(inner); } } - let scope = 0; - match self.resolve_name(wcx, callee, Accept::Callable, scope, u32::MAX, None, true) { - NameRes::Found(n, ..) => { - let node = self.view.node(n); - if node.kind().is_type() { - return Some(n); - } - let rt = node.return_type()?; - let owner = self.view.hot(n).file; - let cx = wcx.file_cx(self.e, owner); - match cx.lookup_type(wcx, rt) { - TypeRes::Node(t) => Some(t), - _ => None, + match self.lookup_type(wcx, name) { + TypeRes::Node(t) => Some(ValueType::plain(t)), + _ => None, + } + } + + fn returned_value(&self, wcx: &mut WorkerCx<'e, 'v>, n: NodeIdx, receiver: Option, depth: u8) -> Option { + let node = self.view.node(n); + if node.kind().is_type() { + return Some(ValueType::plain(n)); + } + let cx = wcx.file_cx(self.e, node.file()); + let rt = self.e.return_types.get(&n).copied().or_else(|| node.return_type())?; + cx.type_value(wcx, rt, receiver, depth + 1) + } + + /// Follow declared return types through a bounded chain. Static methods do + /// not implicitly return their owner, and Result is not treated as T. + fn call_value(&self, wcx: &mut WorkerCx<'e, 'v>, callee: &str, scope: u32, line: u32, depth: u8) -> Option { + if depth >= 16 || callee.len() > 4096 { + return None; + } + if let Some((inner, method)) = callee.rsplit_once("().") { + let receiver = self.call_value(wcx, inner, scope, line, depth + 1)?; + return self.member_return(wcx, receiver, method, depth + 1); + } + if let Some((inner, method)) = callee.rsplit_once('.') { + if inner.ends_with('?') { + let receiver = self.expression_value(wcx, inner, scope, line, depth + 1)?; + return self.member_return(wcx, receiver, method, depth + 1); + } + } + let split = callee.rsplit_once("::").or_else(|| callee.rsplit_once('.')); + if let Some((owner, method)) = split { + // Django's default manager returns the concrete model for these + // operations. Require the actual Model base in the resolved + // hierarchy; a coincidentally named `.objects.create` is insufficient. + if self.family == LangFamily::Python && matches!(method, "create" | "get" | "first" | "last" | "earliest" | "latest") { + if let (Some(base), Some(model)) = (self.e.django_model, owner.strip_suffix(".objects")) { + if let TypeRes::Node(t) = self.lookup_type(wcx, model) { + if t == base || self.e.ancestors(t).contains(&base) { + return Some(ValueType::plain(t)); + } + } } } + let receiver = if let Some(b) = self.lookup_binding(owner, scope, line, false) { + self.binding_value(wcx, b, depth + 1) + } else { + self.type_value(wcx, owner, None, depth + 1) + }; + if let Some(t) = receiver { + return self.member_return(wcx, t, method, depth + 1); + } + } + match self.resolve_name(wcx, callee, Accept::Callable, scope, line, None, true) { + NameRes::Found(n, ..) => self.returned_value(wcx, n, self.enclosing_type(n), depth + 1), _ => None, } } + fn member_return(&self, wcx: &mut WorkerCx<'e, 'v>, mut receiver: ValueType, method: &str, depth: u8) -> Option { + if !receiver.wrappers.is_empty() { + return match method { + "unwrap" | "expect" | "unwrap_or" | "unwrap_or_else" | "unwrap_or_default" => { + receiver.wrappers.pop(); + Some(receiver) + } + "as_ref" | "as_mut" => Some(receiver), + _ => None, + }; + } + let m = self.e.find_member(receiver.node, method)?; + self.returned_value(wcx, m, Some(receiver.node), depth + 1) + } + /// Declared type of field `name` of type `t` (through the hierarchy). pub fn field_type(&self, wcx: &mut WorkerCx<'e, 'v>, t: NodeIdx, name: &str) -> Option { if let Some(list) = wcx.field_cache.get(&t) { @@ -742,9 +901,23 @@ impl<'e, 'v> FileCx<'e, 'v> { // imported value used as a namespace (rare) return NameRes::Found(n, by::IMPORT, 80); } - Bound::Module(m) => return NameRes::Module(m), + Bound::Module(m) => { + // `require('./factory')()` invokes module.exports. Keep the + // module namespace for member calls; never substitute its + // default function for a missing property such as .static. + let imp = &self.imports[i as usize]; + if self.family == LangFamily::Js && imp.kind == ImportKind::Require as u8 { + if let Some(Bound::Node(n)) = e.lookup_export(m, "default", 0) { + if accept.ok(kind_of(view, n)) { + return NameRes::Found(n, by::IMPORT, 95); + } + } + } + return NameRes::Module(m); + } Bound::Pkg(p) => return NameRes::Pkg(p), Bound::External => return NameRes::External, + Bound::Unknown if self.family == LangFamily::Js => return NameRes::NotFound, Bound::Unknown => {} } } @@ -845,11 +1018,18 @@ impl<'e, 'v> FileCx<'e, 'v> { return Outcome::st(status::NO_CANDIDATE); } let mut found: SmallVec<[NodeIdx; 2]> = SmallVec::new(); - for cand in self.view.by_name(method) { + let assigned = self.e.member_functions.get(method).map(|v| v.as_slice()).unwrap_or_default(); + for cand in self.view.by_name(method).chain(assigned.iter().copied()) { + if found.contains(&cand) { + continue; + } let node = self.view.node(cand); if !matches!(node.kind(), NodeKind::Method | NodeKind::Function | NodeKind::Property | NodeKind::Field) { continue; } + if node.kind() == NodeKind::Function && !assigned.contains(&cand) { + continue; + } if self.view.file(node.file()).lang().family() != self.family || !self.visible(cand, method) { continue; } @@ -923,16 +1103,20 @@ impl<'e, 'v> FileCx<'e, 'v> { // (a) a local variable, parameter or field if let Some(b) = self.lookup_binding(root, scope, r.line, false) { if b.kind != BindKind::LocalFn as u8 { - return match self.binding_type(wcx, b) { - Some(t) => { - let o = self.member_of(wcx, t, path, method, 90); + return match self.binding_value(wcx, b, 0) { + Some(t) if t.wrappers.is_empty() => { + let o = self.member_of(wcx, t.node, path, method, 90); if o.status == status::RESOLVED { o } else { Outcome::st(status::NO_CANDIDATE) } } + Some(_) => Outcome::st(status::NO_CANDIDATE), None => { + if !self.view.text_str(b.decl_type).is_empty() { + return Outcome::st(status::NO_CANDIDATE); + } let o = self.fallback_method(method); if o.status == status::RESOLVED && path.is_empty() { o @@ -983,11 +1167,22 @@ impl<'e, 'v> FileCx<'e, 'v> { return Outcome::st(status::NO_CANDIDATE); } Bound::External => return Outcome::st(status::EXTERNAL), + Bound::Unknown if self.family == LangFamily::Js => return Outcome::st(status::NO_CANDIDATE), Bound::Unknown => {} } } // (c) a type (static member) or, in Rust, a child module if self.family == LangFamily::Rust { + let mut qualified = root.to_owned(); + for seg in path.iter().copied().chain(std::iter::once(method)) { + qualified.push_str("::"); + qualified.push_str(seg); + } + if let Some(Bound::Node(n)) = self.rust_path_bound(&qualified) { + if Accept::Callable.ok(kind_of(view, n)) { + return Outcome::found(n, by::IMPORT, 92); + } + } if let Some(mf) = self.e.submodule(self.file, root) { return self.in_module(wcx, mf, path, method); } @@ -1036,7 +1231,8 @@ impl<'e, 'v> FileCx<'e, 'v> { } } } - return self.fallback_method(method); + // A known receiver constrains member lookup to its own hierarchy. + return Outcome::st(status::NO_CANDIDATE); } Outcome::st(status::NO_CANDIDATE) } @@ -1054,7 +1250,7 @@ impl<'e, 'v> FileCx<'e, 'v> { fn call_result(&self, wcx: &mut WorkerCx<'e, 'v>, r: &RefRec, inner: &str, method: &str) -> Outcome { // type produced by calling `inner` - let t = match self.call_result_type(wcx, inner) { + let t = match self.call_value(wcx, inner, self.scope_at(r.line, r.col), r.line, 0).and_then(ValueType::receiver) { Some(t) => t, None => { // `inner` may be a method of a typed receiver: resolve it as a call first diff --git a/crates/cg-resolve/src/shape.rs b/crates/cg-resolve/src/shape.rs index 1017318..4eee8cb 100644 --- a/crates/cg-resolve/src/shape.rs +++ b/crates/cg-resolve/src/shape.rs @@ -63,7 +63,7 @@ pub fn parse_shape(name: &str) -> Shape<'_> { } return Shape::Bare(rest.trim()); } - if let Some(i) = name.find("().") { + if let Some(i) = name.rfind("().") { let inner = name[..i].trim(); let method = last_segment(&name[i + 3..]); return if inner == "super" { Shape::Super { method } } else { Shape::CallResult { inner, method } }; diff --git a/crates/cg-sync/src/sync.rs b/crates/cg-sync/src/sync.rs index 0b7f071..c220c0d 100644 --- a/crates/cg-sync/src/sync.rs +++ b/crates/cg-sync/src/sync.rs @@ -16,7 +16,7 @@ use crate::detect::{diff_view, Diff}; use cg_core::budget::MemBudget; use cg_core::config::ProjectConfig; use cg_core::{brand, CgError, EdgeKind, FileId, NodeIdx, RefKind, Result, StrId, NONE}; -use cg_extract::{fileflags, try_extract_stream, ExtractConfig, FileBatch}; +use cg_extract::{fileflags, try_extract_stream, BindKind, ExtractConfig, FileBatch}; use cg_resolve::driver::{make_edge, round_of, update_of, FNREF_META}; use cg_resolve::{hooks_for, index_with_guard, resolve_refs, Engine, IndexOptions, Outcome, ProjectInfo, Round_}; use cg_scan::{scan, ScanOptions}; @@ -256,6 +256,18 @@ fn defs_of(view: &View, f: FileId) -> BTreeMap> { type ExportSig = Vec<(String, String, String, u8)>; +type ResolverFactSig = BTreeSet<(u8, String, String, String)>; + +/// These facts change resolution even when the kernel's declaration identity +/// stays the same (e.g. `obj.old = function internal` -> `obj.new = ...`). +fn resolver_fact_sig(view: &View, f: FileId) -> ResolverFactSig { + view.bindings_of(f) + .iter() + .filter(|b| (b.kind == BindKind::MemberFn as u8 || b.kind == BindKind::ReturnType as u8) && b.node.is_some()) + .map(|b| (b.kind, view.text_str(b.name).to_owned(), view.node(b.node).qname().to_owned(), view.text_str(b.decl_type).to_owned())) + .collect() +} + /// What a file declares as exports (re-exports, aliases, default exports, star exports). Exported /// definitions are covered by the definition diff and by dead-target handling. fn export_sig(view: &View, f: FileId) -> ExportSig { @@ -511,6 +523,13 @@ pub fn sync_locked(store: &Store, guard: &WriteGuard, root: &Path, opts: &SyncOp let old = if states[i] == DeltaState::Replaced { defs_of(&base_view, *f) } else { BTreeMap::new() }; let new = defs_of(&view1, *f); definitions_changed |= old != new; + let old_facts = if states[i] == DeltaState::Replaced { resolver_fact_sig(&base_view, *f) } else { BTreeSet::new() }; + let new_facts = resolver_fact_sig(&view1, *f); + if old_facts != new_facts { + definitions_changed = true; + d_names.extend(old_facts.iter().chain(&new_facts).map(|fact| fact.1.clone())); + export_changed.push(*f); + } for (k, details) in &new { if (old.get(k) != Some(details)) && !old.contains_key(k) { d_names.insert(k.name.clone()); @@ -529,6 +548,7 @@ pub fn sync_locked(store: &Store, guard: &WriteGuard, root: &Path, opts: &SyncOp } } for f in &removed { + d_names.extend(resolver_fact_sig(&base_view, *f).into_iter().map(|fact| fact.1)); for k in defs_of(&base_view, *f).keys() { d_names.insert(k.name.clone()); } From ba0f2e628aab2f89637780d68f38c6af4beb358c Mon Sep 17 00:00:00 2001 From: NianJiuZst <3235467914@qq.com> Date: Sun, 1 Nov 2026 05:22:27 -0600 Subject: [PATCH 2/5] docs: record resolution root causes and fixed-corpus verification --- docs/BENCHMARKS.md | 3 + docs/RESOLUTION-QUALITY.md | 187 ++++ .../2026-11-01-resolution-quality.json | 975 ++++++++++++++++++ 3 files changed, 1165 insertions(+) create mode 100644 docs/RESOLUTION-QUALITY.md create mode 100644 docs/benchmarks/2026-11-01-resolution-quality.json diff --git a/docs/BENCHMARKS.md b/docs/BENCHMARKS.md index e2b4952..027d5f8 100644 --- a/docs/BENCHMARKS.md +++ b/docs/BENCHMARKS.md @@ -6,6 +6,9 @@ agreement are separate results: a faster engine does not by itself establish equ Exact timing samples, graph intersections, definitions, query lists and exclusions are in the [machine-readable evidence](benchmarks/2026-11-01-main-retest.json). +The subsequent [resolution-quality investigation and fixes](RESOLUTION-QUALITY.md) report +new graph comparisons for engine version 3. The timing results below remain tied to `b827b1d`. + ## Revisions and environment | Component | Pinned version / setting | diff --git a/docs/RESOLUTION-QUALITY.md b/docs/RESOLUTION-QUALITY.md new file mode 100644 index 0000000..214c7b5 --- /dev/null +++ b/docs/RESOLUTION-QUALITY.md @@ -0,0 +1,187 @@ +# Resolution quality investigation / 解析质量排查与修复 + +## 结论与版本 + +这次排查发现了真实的漏连、误连,也发现了图模型和上游错误带来的对比偏差。 +主要缺口位于自研的 facts、模块解析、类型传播及框架层。四个仓库的非路由节点身份 +在修复前后均与上游完全一致;问题并不是 Rust 语法提取器整体提取不出符号。 + +修复运行时:`34c0024`,引擎规则版本从 **2 升到 3**,存储格式仍为 **2**。 +基线为 `9c610ba`,其运行时代码与之前性能复测的 `b827b1d` 相同。 +上游仍固定为 `d2e0389b519be398f9bc616b6f7bea8a7edfbc6a`,package 版本 1.6.2。 +未更换上游版本、仓库快照、包含范围或比较键。 + +[完整机器可读结果](benchmarks/2026-11-01-resolution-quality.json)包含二进制 SHA-256、 +源代码版本、逐边种类统计、验证结果及独立 SQL 交集计数。 +[此前的性能报告](BENCHMARKS.md)继续描述其明确标注的被测版本;本轮没有产生新的性能加速比。 + +## 已修复的根因 + +### 1. CommonJS 导出链缺失 + +`require()` 原先主要绑定到模块文件,没有完整追踪可调用的 `module.exports`、 +转导出、导出别名与对象字面量导出。Express 的入口再导出 `lib/express.js`, +后者导出 `createApplication`;这条链断开,直接导致 **678 次 `express()` 调用漏连**。 + +现在在语法 facts 中记录这些导出,并沿原有、有深度上限的导出闭包解析。 +调用 CommonJS 模块时使用其默认导出,成员访问则使用成员导出。 +ES namespace import 不会因此被当作可调用的默认函数。 +未导出的 JS 私有函数不再作为模块成员的后备答案,缺失的显式 JS 导入也不会继续 +退化成全项目同名匹配。显式声明的 `module` / `exports` 局部变量会阻止相应的导出事实。 + +相关实现:`cg-extract/src/facts/js.rs`、`cg-resolve/src/engine.rs`、`cg-resolve/src/resolve.rs`。 + +### 2. 接收者约束过弱 + +旧的成员兜底把普通函数也纳入候选。例如,Express 的 +`examples/content-negotiation/index.js:36` 调用 `res.format()`,却被连到同文件 +第 33 行定义的普通包装函数 `format(path)`,形成错误的自调用。 + +现在只有真实成员声明,或有对象成员赋值语法证据的 JS 函数,才进入成员兜底。 +成员的对外属性名与函数的内部名称分别记录,静态字符串下标可以识别,动态下标不会 +被当作字面属性名。已知类型的 `this/self` 查找限制在其类型层次内;显式类型注解 +解析失败时,也不会改连到其他类型的唯一同名成员。 +成员元数据、返回类型元数据均排除在普通词法变量查找之外。 + +未知、未注解的动态接收者仍可能采用低置信度的唯一成员候选;这不是完整类型检查。 + +### 3. Rust 模块根与限定路径不完整 + +库、主程序、bench、test、example 原先可能共用空模块路径。 +按路径排序靠前的辅助文件可能抢占库根;自定义 `[lib] path` 也没有用于确定模块目录。 +简单样例中,全局同名兜底会掩盖这些错误。 + +现在优先使用实际存在的 Cargo 根文件,隔离辅助目标,按声明的库路径确定目录。 +限定路径解析保留模块后面的声明、成员部分,能解析返回注解中的 +`tokio::runtime::Runtime`,并处理模块与值同名时的导出查找,例如 `tokio_stream::once`。 +回归检查使用重复声明及导入别名,并核对目标文件,避免只凭名称相同判定成功。 + +### 4. Rust 条件宏中的导出与返回类型丢失 + +Tokio 的部分 `pub use` 位于 `cfg_* ! { ... }` 中,tree-sitter 将宏体视为 token tree。 +旧 facts 遍历看不到这些导入、重导出,`Builder`、`Runtime` 等名称容易变成歧义或漏连。 +内核的兼容性行为还会简化返回注解,导致泛型返回信息不足。 + +现在为条件 item 包装宏建立保持字节长度、换行及原始位置的遮罩视图,补充 facts。 +只有发现相应宏才增加一次解析,源文件限 **1 MiB**,补充解析有 **100 ms** 取消期限, +遍历有深度上限;重解析失败或产生语法错误则回退。普通宏、宏定义及 `cfg_if!` 保持不透明, +不会执行宏或项目代码,也不改变内核产生的节点与引用。 + +另外保存原始 Rust 返回注解,按声明类型逐段传播链式调用、`Self`、标准 +`Result/Option`、解包操作与 `?` 的值类型。标准容器在解包前不会被视为内部对象; +自定义同名 `Result` 不套用标准容器规则。静态方法不再被一律假定返回其所属类型。 +传播限制为 16 层及 4 KiB 表达式路径,不做无限递归或逐引用源文件扫描。 + +### 5. 框架检测漏掉框架自身,路由扫描误读注释 + +旧检测主要查依赖列表,Express/Gin 自身通常不会依赖自身,所以对应规则没有启用。 +现在同时识别精确的项目包名、Go module 身份;Express/Gin 路由扫描先遮罩注释, +避免把文档中的示例注册成真实路由。 + +这补齐了功能,但也暴露出两套图模型的差异:cgr 的路由 ID 与上游格式不同, +cgr 还产生上游没有的文件到路由 `contains` 边。因此本轮保留全部边时,Gin 的 +上游相对 P 会下降,不能把新增边全部判成语义错误。 + +### 6. Django 默认 Manager 的返回对象需要框架证据 + +移除“静态工厂都返回所属类型”的宽泛猜测后,部分原本猜对的 ORM 调用也会丢失。 +现在仅在实际解析到 Django `Model` 基类、且目标位于其继承层次中时,识别默认 +`.objects` 的 `create/get/first/last/earliest/latest` 返回模型实例的约定。 +不会仅因为出现 `.objects.create` 就把任意类当成 Django Model,也不把返回 tuple +或 QuerySet 的其他操作当成模型实例。 + +这个规则要求图中存在可解析的 Django Model 基类;外部依赖未索引、自定义 manager、 +动态用户模型和动态生成的类仍有缺口。 + +### 7. 新增语义 facts 必须参与增量失效 + +只修改成员的对外名称、保留内部函数名称时,内核声明可能完全不变。 +如果只比较内核符号,消费者会保留旧连线。 + +现在成员事实与原始返回注解也参与差异检测,触发相关名称、导入消费者的重新解析。 +42 文件的定向复现中,修改 1 个成员别名后只重新解析 **2 个文件**,结果与完整重建一致。 +规则版本提升后,旧版本索引在下一次 `sync` 时自动完整重建;已经实测从版本 2 升级。 + +## 同口径复测 + +比较键始终为 `(source stable ID, target stable ID, kind, line, column)`。 +NULL 位置保持 NULL,包含全部边、路由、包含关系和有提取错误的文件,不按结果删样本。 +四个快照的索引文件数分别为 142、99、814、2,984,复测及编辑还原后逐文件源字节一致。 +独立 SQLite `INTERSECT` 再次复核了下列交集。 + +这里的 **P = 共有边 / cgr 边**,**R = 共有边 / 上游边**,均是对指定上游的相对一致性, +不是人工语义标注下的准确率。上游自身不被定义为语义真值。 + +| 项目 | 共有边:修复前 → 后 | 相对 P:前 → 后 | 相对 R:前 → 后 | +|---|---:|---:|---:| +| Express | 1,384 → 2,063 | 54.77% → 58.96% | 59.30% → 88.39% | +| Gin | 7,626 → 7,678 | 96.28% → 93.45% | 94.46% → 95.11% | +| Tokio | 31,541 → 33,638 | 86.39% → 87.14% | 79.48% → 84.77% | +| Django | 173,752 → 174,016 | 93.66% → 94.07% | 89.51% → 89.65% | + +四仓合计新增 **3,224 条**与上游相同的边,同时减少 **132 条**原有共有边, +净增 **3,092 条**。被移除的共有边不能全部称为误连:其中也有保守类型推断带来的真实漏连, +仍需继续处理。所有非路由节点的身份一致性保持 **100%**。 + +为避免大量 `contains` 掩盖调用解析,单独列出 `calls`,但不改变全图比较分母: + +| 项目 | 共有调用:修复前 → 后 | 调用相对 P:前 → 后 | 调用相对 R:前 → 后 | +|---|---:|---:|---:| +| Express | 419 → 1,097 | 27.03% → 49.26% | 32.73% → 85.70% | +| Gin | 3,430 → 3,482 | 99.42% → 99.66% | 90.10% → 91.46% | +| Tokio | 8,345 → 10,058 | 90.20% → 91.35% | 53.48% → 64.45% | +| Django | 43,533 → 43,829 | 90.10% → 91.11% | 76.61% → 77.13% | + +**仍未全面达到原设计 P ≥ 97%、R ≥ 95% 的门槛。** 不应据此声称已经完全兼容上游, +也不应把所有上游独有边当作 cgr 的错误。已核对的反例是 `express.urlencoded`: +上游将它连到 `createApplication`,而该版本源码实际把它赋给 `bodyParser.urlencoded`。 +类似地,cgr 的某些真实 `app.use` 调用与路由包含边,在上游没有对应边。 + +## 验证与剩余工作 + +- 35 项仓库外定向语义检查:旧版通过 16 项,修复版通过 **35 项**,包含正例与拒绝误连的负例。 +- 现有工作区测试:**137 通过,1 项原有 ignored**;随机编辑按 6 组 × 100 次执行。 +- 四个真实仓库共 **24 项**检查:初始完整比较、编辑后同步与完整比较、还原后同步与完整比较、严格索引校验。 +- 成员别名变更的增量复现、旧规则版本索引升级均通过。 +- Rust 1.99 Clippy `-D warnings`、格式检查、锁定依赖的 release 构建通过。 +- 新增的一次性脚本、测试项目、SQLite 数据库与逐边日志保存在仓库外;仓库只提交运行时代码和报告数据。 + +后续优先补齐 Rust 泛型/trait/Deref 与更复杂宏的静态建模,Python 跨方法字段与动态工厂, +以及 JS 接收者、动态导出和 mixin 的类型证据。路由协议的 ID、边种类和包含关系需要另行明确 +兼容性约定,再决定是否迁移;不在比较脚本里悄悄归一化。 +下一轮性能复测必须针对补齐能力后的运行时,继续采用相同的受控配对方法。 +本次增加了解析工作量,没有把旧 README 的性能结果改标为新版本结果。 + +## English summary + +The low agreement exposed both real resolver defects and differences between graph models. +Non-route symbol identities already matched upstream completely; most gaps were in the +Rust implementation's facts, export/module resolution, type propagation and framework rules. + +Runtime commit **`34c0024`** fixes callable CommonJS exports and re-exports, enforces JS +export boundaries, distinguishes assigned property names from internal function names, +and constrains member lookup using receiver evidence. Rust fixes select the declared Cargo +root, isolate auxiliary targets, resolve qualified type paths and value/module name collisions, +recover conditional-wrapper export facts, and preserve raw return annotations for bounded +call-chain and standard Result/Option inference. Framework detection recognizes a framework's +own package/module; Express/Gin route scans ignore comments. Django default-manager inference +requires the resolved Model hierarchy. New semantic facts participate in incremental invalidation. + +The tables above use the **unchanged strict edge key and complete edge sets** against the +same pinned upstream snapshot. Shared edges increase by **3,092 net**: 3,224 additions and +132 removals. The remaining shared-edge removals include genuine coverage gaps as well as +heuristic differences; they are not all claimed as correctness improvements. All non-route +node identities still match. P/R describe agreement with this upstream version, which is not +semantic ground truth. Gin's relative P declines partly because cgr now emits route containment +edges absent from upstream. The original global 97%/95% agreement gate is **not fully met**. + +Validation: **35/35** external focused checks, **137** existing workspace tests passed with +one existing ignored test, **600** random edit steps, **24** checks across four real repositories, +an independently checked SQL intersection for every graph, and the targeted incremental alias +and old-engine upgrade checks. Release build, strict Clippy and formatting pass. Engine version +is **3**; format version stays **2**, and `sync` rebuilds older indexes automatically. + +Remaining work includes richer generics/trait/Deref inference, dynamic factories and field +flow, dynamic exports/mixins, auxiliary Rust target module trees, and an explicit route +compatibility contract. The README's previously pinned performance measurements are retained +as historical measurements. This quality run makes **no new performance claim**. diff --git a/docs/benchmarks/2026-11-01-resolution-quality.json b/docs/benchmarks/2026-11-01-resolution-quality.json new file mode 100644 index 0000000..92b22a0 --- /dev/null +++ b/docs/benchmarks/2026-11-01-resolution-quality.json @@ -0,0 +1,975 @@ +{ + "dateUtc": "2026-11-01T11:17:18.318943+00:00", + "baselineCommit": "9c610ba3d99e1d18e5e0595b6268af1a0e85a03c", + "upstreamCommit": "d2e0389b519be398f9bc616b6f7bea8a7edfbc6a", + "comparisonKey": [ + "sourceStableId", + "targetStableId", + "kind", + "line", + "column" + ], + "nullLocationsPreserved": true, + "allEdgesIncluded": true, + "upstreamIsSemanticGroundTruth": false, + "beforeBinarySha256": "47f134691da3eec3ee60a444d86ce22dc8e0b5dc2a0e8d7f35c447e0dc2de171", + "afterBinarySha256": "724d46024a032c626172c4137e9e89181c7d109cbb7fbaa421f52e79e91ea161", + "engineVersion": 3, + "formatVersion": 2, + "newPerformanceBenchmark": false, + "checks": { + "focusedBefore": 16, + "focusedAfter": 35, + "focusedTotal": 35, + "workspacePassed": 137, + "workspaceIgnored": 1, + "randomEditSequences": 6, + "randomEditsPerSequence": 100, + "clippy": "Rust 1.99, -D warnings, passed", + "format": "passed", + "realRepositorySyncChecks": 24, + "independentSql": [ + { + "repo": "express", + "sqliteIntersect": 2063, + "sourceFiles": 142, + "sourceBytesUnchanged": true + }, + { + "repo": "gin", + "sqliteIntersect": 7678, + "sourceFiles": 99, + "sourceBytesUnchanged": true + }, + { + "repo": "tokio", + "sqliteIntersect": 33638, + "sourceFiles": 814, + "sourceBytesUnchanged": true + }, + { + "repo": "django", + "sqliteIntersect": 174016, + "sourceFiles": 2984, + "sourceBytesUnchanged": true + } + ], + "oldEngineAutoRebuild": true, + "memberAliasIncrementalMatchesFull": true + }, + "projects": [ + { + "repo": "express", + "sourceFiles": 142, + "before": { + "strictStableIdSite": { + "cgr": 2527, + "oracle": 2334, + "intersection": 1384, + "cgrOnly": 1143, + "oracleOnly": 950, + "precision": 0.5476850019786308, + "recall": 0.5929734361610969, + "f1": 0.5694301584036205, + "jaccard": 0.39804429105550765 + }, + "byKind": { + "calls": { + "cgr": 1550, + "oracle": 1280, + "intersection": 419, + "cgrOnly": 1131, + "oracleOnly": 861, + "precision": 0.2703225806451613, + "recall": 0.32734375, + "f1": 0.29611307420494704, + "jaccard": 0.17378681045209457 + }, + "contains": { + "cgr": 724, + "oracle": 724, + "intersection": 724, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + }, + "imports": { + "cgr": 142, + "oracle": 154, + "intersection": 142, + "cgrOnly": 0, + "oracleOnly": 12, + "precision": 1.0, + "recall": 0.922077922077922, + "f1": 0.9594594594594594, + "jaccard": 0.922077922077922 + }, + "instantiates": { + "cgr": 23, + "oracle": 84, + "intersection": 23, + "cgrOnly": 0, + "oracleOnly": 61, + "precision": 1.0, + "recall": 0.27380952380952384, + "f1": 0.4299065420560748, + "jaccard": 0.27380952380952384 + }, + "references": { + "cgr": 88, + "oracle": 92, + "intersection": 76, + "cgrOnly": 12, + "oracleOnly": 16, + "precision": 0.8636363636363636, + "recall": 0.8260869565217391, + "f1": 0.8444444444444444, + "jaccard": 0.7307692307692307 + } + }, + "nonRouteNodesCanonical": { + "cgr": 866, + "oracle": 866, + "intersection": 866, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + } + }, + "after": { + "strictStableIdSite": { + "cgr": 3499, + "oracle": 2334, + "intersection": 2063, + "cgrOnly": 1436, + "oracleOnly": 271, + "precision": 0.5895970277222063, + "recall": 0.8838903170522708, + "f1": 0.707354705983199, + "jaccard": 0.5472148541114058 + }, + "byKind": { + "calls": { + "cgr": 2227, + "oracle": 1280, + "intersection": 1097, + "cgrOnly": 1130, + "oracleOnly": 183, + "precision": 0.49259092950157163, + "recall": 0.85703125, + "f1": 0.6256059309951526, + "jaccard": 0.45518672199170124 + }, + "contains": { + "cgr": 992, + "oracle": 724, + "intersection": 724, + "cgrOnly": 268, + "oracleOnly": 0, + "precision": 0.7298387096774194, + "recall": 1.0, + "f1": 0.8438228438228438, + "jaccard": 0.7298387096774194 + }, + "imports": { + "cgr": 143, + "oracle": 154, + "intersection": 143, + "cgrOnly": 0, + "oracleOnly": 11, + "precision": 1.0, + "recall": 0.9285714285714286, + "f1": 0.962962962962963, + "jaccard": 0.9285714285714286 + }, + "instantiates": { + "cgr": 23, + "oracle": 84, + "intersection": 23, + "cgrOnly": 0, + "oracleOnly": 61, + "precision": 1.0, + "recall": 0.27380952380952384, + "f1": 0.4299065420560748, + "jaccard": 0.27380952380952384 + }, + "references": { + "cgr": 114, + "oracle": 92, + "intersection": 76, + "cgrOnly": 38, + "oracleOnly": 16, + "precision": 0.6666666666666666, + "recall": 0.8260869565217391, + "f1": 0.7378640776699029, + "jaccard": 0.5846153846153846 + } + }, + "nonRouteNodesCanonical": { + "cgr": 866, + "oracle": 866, + "intersection": 866, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + } + }, + "changes": { + "added": 1001, + "removed": 29, + "addedMatchingOracle": 679, + "removedMatchingOracle": 0, + "byKind": { + "calls": { + "added": 694, + "removed": 17, + "addedMatchingOracle": 678, + "removedMatchingOracle": 0 + }, + "contains": { + "added": 268, + "removed": 0, + "addedMatchingOracle": 0, + "removedMatchingOracle": 0 + }, + "imports": { + "added": 1, + "removed": 0, + "addedMatchingOracle": 1, + "removedMatchingOracle": 0 + }, + "references": { + "added": 38, + "removed": 12, + "addedMatchingOracle": 0, + "removedMatchingOracle": 0 + } + } + }, + "corpusCommit": "1c6f1b0fe4000977b9a7b4f34097e4d527dd9824" + }, + { + "repo": "gin", + "sourceFiles": 99, + "before": { + "strictStableIdSite": { + "cgr": 7921, + "oracle": 8073, + "intersection": 7626, + "cgrOnly": 295, + "oracleOnly": 447, + "precision": 0.9627572276227749, + "recall": 0.944630248978075, + "f1": 0.9536076028510693, + "jaccard": 0.9113288718929254 + }, + "byKind": { + "calls": { + "cgr": 3450, + "oracle": 3807, + "intersection": 3430, + "cgrOnly": 20, + "oracleOnly": 377, + "precision": 0.9942028985507246, + "recall": 0.9009718938796953, + "f1": 0.945294198704699, + "jaccard": 0.8962633916906193 + }, + "contains": { + "cgr": 2731, + "oracle": 2767, + "intersection": 2731, + "cgrOnly": 0, + "oracleOnly": 36, + "precision": 1.0, + "recall": 0.9869895193350199, + "f1": 0.9934521644234268, + "jaccard": 0.9869895193350199 + }, + "extends": { + "cgr": 13, + "oracle": 11, + "intersection": 11, + "cgrOnly": 2, + "oracleOnly": 0, + "precision": 0.8461538461538461, + "recall": 1.0, + "f1": 0.9166666666666666, + "jaccard": 0.8461538461538461 + }, + "implements": { + "cgr": 81, + "oracle": 93, + "intersection": 78, + "cgrOnly": 3, + "oracleOnly": 15, + "precision": 0.9629629629629629, + "recall": 0.8387096774193549, + "f1": 0.896551724137931, + "jaccard": 0.8125 + }, + "imports": { + "cgr": 31, + "oracle": 0, + "intersection": 0, + "cgrOnly": 31, + "oracleOnly": 0, + "precision": 0.0, + "recall": 0.0, + "f1": 0.0, + "jaccard": 0.0 + }, + "instantiates": { + "cgr": 833, + "oracle": 833, + "intersection": 833, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + }, + "references": { + "cgr": 782, + "oracle": 562, + "intersection": 543, + "cgrOnly": 239, + "oracleOnly": 19, + "precision": 0.6943734015345269, + "recall": 0.9661921708185054, + "f1": 0.8080357142857144, + "jaccard": 0.6779026217228464 + } + }, + "nonRouteNodesCanonical": { + "cgr": 2436, + "oracle": 2436, + "intersection": 2436, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + } + }, + "after": { + "strictStableIdSite": { + "cgr": 8216, + "oracle": 8073, + "intersection": 7678, + "cgrOnly": 538, + "oracleOnly": 395, + "precision": 0.9345180136319376, + "recall": 0.9510714728106032, + "f1": 0.9427220823868868, + "jaccard": 0.8916502148414819 + }, + "byKind": { + "calls": { + "cgr": 3494, + "oracle": 3807, + "intersection": 3482, + "cgrOnly": 12, + "oracleOnly": 325, + "precision": 0.996565540927304, + "recall": 0.9146309429997374, + "f1": 0.9538419394603479, + "jaccard": 0.911757004451427 + }, + "contains": { + "cgr": 2972, + "oracle": 2767, + "intersection": 2731, + "cgrOnly": 241, + "oracleOnly": 36, + "precision": 0.9189098250336474, + "recall": 0.9869895193350199, + "f1": 0.9517337515246559, + "jaccard": 0.9079122340425532 + }, + "extends": { + "cgr": 13, + "oracle": 11, + "intersection": 11, + "cgrOnly": 2, + "oracleOnly": 0, + "precision": 0.8461538461538461, + "recall": 1.0, + "f1": 0.9166666666666666, + "jaccard": 0.8461538461538461 + }, + "implements": { + "cgr": 81, + "oracle": 93, + "intersection": 78, + "cgrOnly": 3, + "oracleOnly": 15, + "precision": 0.9629629629629629, + "recall": 0.8387096774193549, + "f1": 0.896551724137931, + "jaccard": 0.8125 + }, + "imports": { + "cgr": 31, + "oracle": 0, + "intersection": 0, + "cgrOnly": 31, + "oracleOnly": 0, + "precision": 0.0, + "recall": 0.0, + "f1": 0.0, + "jaccard": 0.0 + }, + "instantiates": { + "cgr": 833, + "oracle": 833, + "intersection": 833, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + }, + "references": { + "cgr": 792, + "oracle": 562, + "intersection": 543, + "cgrOnly": 249, + "oracleOnly": 19, + "precision": 0.6856060606060606, + "recall": 0.9661921708185054, + "f1": 0.8020679468242246, + "jaccard": 0.6695437731196054 + } + }, + "nonRouteNodesCanonical": { + "cgr": 2436, + "oracle": 2436, + "intersection": 2436, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + } + }, + "changes": { + "added": 307, + "removed": 12, + "addedMatchingOracle": 52, + "removedMatchingOracle": 0, + "byKind": { + "calls": { + "added": 52, + "removed": 8, + "addedMatchingOracle": 52, + "removedMatchingOracle": 0 + }, + "contains": { + "added": 241, + "removed": 0, + "addedMatchingOracle": 0, + "removedMatchingOracle": 0 + }, + "references": { + "added": 14, + "removed": 4, + "addedMatchingOracle": 0, + "removedMatchingOracle": 0 + } + } + }, + "corpusCommit": "0f09c3a9b4626d9fe9979cf4d0521d6ae32ab646" + }, + { + "repo": "tokio", + "sourceFiles": 814, + "before": { + "strictStableIdSite": { + "cgr": 36511, + "oracle": 39682, + "intersection": 31541, + "cgrOnly": 4970, + "oracleOnly": 8141, + "precision": 0.8638766399167375, + "recall": 0.7948440098785343, + "f1": 0.8279238250232961, + "jaccard": 0.7063737346591418 + }, + "byKind": { + "calls": { + "cgr": 9252, + "oracle": 15605, + "intersection": 8345, + "cgrOnly": 907, + "oracleOnly": 7260, + "precision": 0.9019671422395158, + "recall": 0.5347644985581544, + "f1": 0.671440640463451, + "jaccard": 0.505390019379845 + }, + "contains": { + "cgr": 17053, + "oracle": 17053, + "intersection": 17053, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + }, + "extends": { + "cgr": 2, + "oracle": 2, + "intersection": 2, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + }, + "implements": { + "cgr": 127, + "oracle": 132, + "intersection": 127, + "cgrOnly": 0, + "oracleOnly": 5, + "precision": 1.0, + "recall": 0.9621212121212122, + "f1": 0.9806949806949807, + "jaccard": 0.9621212121212122 + }, + "imports": { + "cgr": 3067, + "oracle": 2326, + "intersection": 1808, + "cgrOnly": 1259, + "oracleOnly": 518, + "precision": 0.5895011411803065, + "recall": 0.7773000859845228, + "f1": 0.6704987947339144, + "jaccard": 0.5043235704323571 + }, + "instantiates": { + "cgr": 945, + "oracle": 818, + "intersection": 774, + "cgrOnly": 171, + "oracleOnly": 44, + "precision": 0.819047619047619, + "recall": 0.9462102689486552, + "f1": 0.8780487804878048, + "jaccard": 0.782608695652174 + }, + "references": { + "cgr": 6065, + "oracle": 3746, + "intersection": 3432, + "cgrOnly": 2633, + "oracleOnly": 314, + "precision": 0.5658697444352844, + "recall": 0.9161772557394554, + "f1": 0.6996228722862092, + "jaccard": 0.538015362909547 + } + }, + "nonRouteNodesCanonical": { + "cgr": 14460, + "oracle": 14460, + "intersection": 14460, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + } + }, + "after": { + "strictStableIdSite": { + "cgr": 38603, + "oracle": 39682, + "intersection": 33638, + "cgrOnly": 4965, + "oracleOnly": 6044, + "precision": 0.8713830531305857, + "recall": 0.8476891285721486, + "f1": 0.8593728044963914, + "jaccard": 0.7534212825049835 + }, + "byKind": { + "calls": { + "cgr": 11010, + "oracle": 15605, + "intersection": 10058, + "cgrOnly": 952, + "oracleOnly": 5547, + "precision": 0.9135331516802907, + "recall": 0.6445370073694329, + "f1": 0.755814390381364, + "jaccard": 0.607477199975841 + }, + "contains": { + "cgr": 17053, + "oracle": 17053, + "intersection": 17053, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + }, + "extends": { + "cgr": 2, + "oracle": 2, + "intersection": 2, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + }, + "implements": { + "cgr": 132, + "oracle": 132, + "intersection": 132, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + }, + "imports": { + "cgr": 3329, + "oracle": 2326, + "intersection": 2080, + "cgrOnly": 1249, + "oracleOnly": 246, + "precision": 0.6248122559327125, + "recall": 0.8942390369733448, + "f1": 0.735632183908046, + "jaccard": 0.5818181818181818 + }, + "instantiates": { + "cgr": 945, + "oracle": 818, + "intersection": 774, + "cgrOnly": 171, + "oracleOnly": 44, + "precision": 0.819047619047619, + "recall": 0.9462102689486552, + "f1": 0.8780487804878048, + "jaccard": 0.782608695652174 + }, + "references": { + "cgr": 6132, + "oracle": 3746, + "intersection": 3539, + "cgrOnly": 2593, + "oracleOnly": 207, + "precision": 0.577136333985649, + "recall": 0.9447410571276028, + "f1": 0.7165418100830127, + "jaccard": 0.5582899510963875 + } + }, + "nonRouteNodesCanonical": { + "cgr": 14460, + "oracle": 14460, + "intersection": 14460, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + } + }, + "changes": { + "added": 2440, + "removed": 348, + "addedMatchingOracle": 2148, + "removedMatchingOracle": 51, + "byKind": { + "calls": { + "added": 2023, + "removed": 265, + "addedMatchingOracle": 1764, + "removedMatchingOracle": 51 + }, + "implements": { + "added": 5, + "removed": 0, + "addedMatchingOracle": 5, + "removedMatchingOracle": 0 + }, + "imports": { + "added": 283, + "removed": 21, + "addedMatchingOracle": 272, + "removedMatchingOracle": 0 + }, + "references": { + "added": 129, + "removed": 62, + "addedMatchingOracle": 107, + "removedMatchingOracle": 0 + } + } + }, + "corpusCommit": "b499257ef62bd631b83a988d371f4330f545670c" + }, + { + "repo": "django", + "sourceFiles": 2984, + "before": { + "strictStableIdSite": { + "cgr": 185506, + "oracle": 194105, + "intersection": 173752, + "cgrOnly": 11754, + "oracleOnly": 20353, + "precision": 0.9366381680376915, + "recall": 0.8951443806187372, + "f1": 0.9154213128702803, + "jaccard": 0.8440340232877843 + }, + "byKind": { + "calls": { + "cgr": 48315, + "oracle": 56826, + "intersection": 43533, + "cgrOnly": 4782, + "oracleOnly": 13293, + "precision": 0.9010245265445513, + "recall": 0.7660753880266076, + "f1": 0.8280879961194967, + "jaccard": 0.7066127775613557 + }, + "contains": { + "cgr": 59676, + "oracle": 58931, + "intersection": 58931, + "cgrOnly": 745, + "oracleOnly": 0, + "precision": 0.98751591929754, + "recall": 1.0, + "f1": 0.9937187518443262, + "jaccard": 0.98751591929754 + }, + "decorates": { + "cgr": 261, + "oracle": 536, + "intersection": 260, + "cgrOnly": 1, + "oracleOnly": 276, + "precision": 0.9961685823754789, + "recall": 0.48507462686567165, + "f1": 0.6524466750313677, + "jaccard": 0.48417132216014896 + }, + "extends": { + "cgr": 9384, + "oracle": 9359, + "intersection": 9283, + "cgrOnly": 101, + "oracleOnly": 76, + "precision": 0.9892369991474851, + "recall": 0.9918794743028101, + "f1": 0.9905564744171158, + "jaccard": 0.9812896405919662 + }, + "imports": { + "cgr": 19854, + "oracle": 24349, + "intersection": 19844, + "cgrOnly": 10, + "oracleOnly": 4505, + "precision": 0.9994963231590611, + "recall": 0.8149821347899298, + "f1": 0.8978576114743342, + "jaccard": 0.8146475635288805 + }, + "instantiates": { + "cgr": 30943, + "oracle": 31205, + "intersection": 30482, + "cgrOnly": 461, + "oracleOnly": 723, + "precision": 0.9851016384965905, + "recall": 0.9768306361160071, + "f1": 0.9809487030958358, + "jaccard": 0.9626097391524032 + }, + "references": { + "cgr": 17073, + "oracle": 12899, + "intersection": 11419, + "cgrOnly": 5654, + "oracleOnly": 1480, + "precision": 0.6688338311954548, + "recall": 0.8852624234436778, + "f1": 0.7619778459895902, + "jaccard": 0.6154799762841588 + } + }, + "nonRouteNodesCanonical": { + "cgr": 61915, + "oracle": 61915, + "intersection": 61915, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + } + }, + "after": { + "strictStableIdSite": { + "cgr": 184981, + "oracle": 194105, + "intersection": 174016, + "cgrOnly": 10965, + "oracleOnly": 20089, + "precision": 0.9407236418875452, + "recall": 0.896504469230571, + "f1": 0.918081912811341, + "jaccard": 0.8485687813917199 + }, + "byKind": { + "calls": { + "cgr": 48105, + "oracle": 56826, + "intersection": 43829, + "cgrOnly": 4276, + "oracleOnly": 12997, + "precision": 0.9111111111111111, + "recall": 0.7712842712842712, + "f1": 0.8353870638800736, + "jaccard": 0.7173087623973029 + }, + "contains": { + "cgr": 59676, + "oracle": 58931, + "intersection": 58931, + "cgrOnly": 745, + "oracleOnly": 0, + "precision": 0.98751591929754, + "recall": 1.0, + "f1": 0.9937187518443262, + "jaccard": 0.98751591929754 + }, + "decorates": { + "cgr": 261, + "oracle": 536, + "intersection": 260, + "cgrOnly": 1, + "oracleOnly": 276, + "precision": 0.9961685823754789, + "recall": 0.48507462686567165, + "f1": 0.6524466750313677, + "jaccard": 0.48417132216014896 + }, + "extends": { + "cgr": 9384, + "oracle": 9359, + "intersection": 9283, + "cgrOnly": 101, + "oracleOnly": 76, + "precision": 0.9892369991474851, + "recall": 0.9918794743028101, + "f1": 0.9905564744171158, + "jaccard": 0.9812896405919662 + }, + "imports": { + "cgr": 19854, + "oracle": 24349, + "intersection": 19844, + "cgrOnly": 10, + "oracleOnly": 4505, + "precision": 0.9994963231590611, + "recall": 0.8149821347899298, + "f1": 0.8978576114743342, + "jaccard": 0.8146475635288805 + }, + "instantiates": { + "cgr": 30943, + "oracle": 31205, + "intersection": 30482, + "cgrOnly": 461, + "oracleOnly": 723, + "precision": 0.9851016384965905, + "recall": 0.9768306361160071, + "f1": 0.9809487030958358, + "jaccard": 0.9626097391524032 + }, + "references": { + "cgr": 16758, + "oracle": 12899, + "intersection": 11387, + "cgrOnly": 5371, + "oracleOnly": 1512, + "precision": 0.6794963599474878, + "recall": 0.8827816109775951, + "f1": 0.7679131402367063, + "jaccard": 0.6232621784345922 + } + }, + "nonRouteNodesCanonical": { + "cgr": 61915, + "oracle": 61915, + "intersection": 61915, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + } + }, + "changes": { + "added": 471, + "removed": 996, + "addedMatchingOracle": 345, + "removedMatchingOracle": 81, + "byKind": { + "calls": { + "added": 387, + "removed": 597, + "addedMatchingOracle": 345, + "removedMatchingOracle": 49 + }, + "references": { + "added": 84, + "removed": 399, + "addedMatchingOracle": 0, + "removedMatchingOracle": 32 + } + } + }, + "corpusCommit": "a05e16a7230fe33d3f43f4a3aaed103cebb42efc" + } + ], + "runtimeCommit": "34c00243d1f6a7d65908682f1fa494ca9e4b8cf1", + "rustCompiler": "rustc 1.94.1 (e408947bf 2026-03-25)", + "vendoredKernelBase": "9d3abb843a84d7610bf987bda7a1db4a6fe3eee3" +} From d45151d92172c42bdaae6451c4735fca01c5c847 Mon Sep 17 00:00:00 2001 From: NianJiuZst <3235467914@qq.com> Date: Sun, 1 Nov 2026 05:33:47 -0600 Subject: [PATCH 3/5] fix: distinguish CommonJS module values from default properties --- crates/cg-extract/src/facts/js.rs | 12 +++++++----- crates/cg-extract/src/facts/mod.rs | 4 ++++ crates/cg-resolve/src/engine.rs | 10 ++++++++++ crates/cg-resolve/src/resolve.rs | 3 ++- 4 files changed, 23 insertions(+), 6 deletions(-) diff --git a/crates/cg-extract/src/facts/js.rs b/crates/cg-extract/src/facts/js.rs index f69dd6d..0c58978 100644 --- a/crates/cg-extract/src/facts/js.rs +++ b/crates/cg-extract/src/facts/js.rs @@ -294,7 +294,7 @@ fn commonjs_export(cx: &mut Cx, n: Node) { return; // A user variable named module/exports shadows CommonJS globals. } let name = if target == "module.exports" { - "default" + COMMONJS_MODULE } else if let Some(name) = target.strip_prefix("module.exports.").or_else(|| target.strip_prefix("exports.")) { if name.is_empty() || name.contains(['.', '[', ']']) { return; @@ -319,10 +319,11 @@ fn commonjs_value(cx: &mut Cx, name: &str, value: Node) { scope: 0, line, }); - if name == "default" { + if name == COMMONJS_MODULE { cx.facts.exports.push(ExportFact { name: "*".into(), node_row: NONE, from_spec: spec.clone(), from_name: "*".into(), star: true }); + cx.facts.exports.push(ExportFact { name: "default".into(), node_row: NONE, from_spec: spec.clone(), from_name: "default".into(), star: false }); } - cx.facts.exports.push(ExportFact { name: name.to_owned(), node_row: NONE, from_spec: spec, from_name: "default".into(), star: false }); + cx.facts.exports.push(ExportFact { name: name.to_owned(), node_row: NONE, from_spec: spec, from_name: COMMONJS_MODULE.into(), star: false }); return; } let (node_row, from_spec, from_name) = match value.kind() { @@ -330,7 +331,7 @@ fn commonjs_value(cx: &mut Cx, name: &str, value: Node) { let text = cx.text(value); let (root, member) = text.split_once('.').map_or((text, None), |(a, b)| (a, Some(b))); if let Some(imp) = cx.facts.imports.iter().find(|i| i.scope == 0 && i.local == root) { - let imported = member.unwrap_or(if imp.imported == "*" { "default" } else { &imp.imported }); + let imported = member.unwrap_or(if imp.imported == "*" { COMMONJS_MODULE } else { &imp.imported }); (NONE, imp.spec.clone(), imported.to_owned()) } else if member.is_none() { (NONE, String::new(), text.to_owned()) @@ -341,7 +342,8 @@ fn commonjs_value(cx: &mut Cx, name: &str, value: Node) { "function_expression" | "function" | "generator_function" | "arrow_function" | "class" => { (cx.row_at(cx.start(value)).unwrap_or(NONE), String::new(), String::new()) } - "object" if name == "default" => { + "object" if name == COMMONJS_MODULE => { + cx.facts.exports.push(ExportFact { name: name.to_owned(), node_row: NONE, from_spec: String::new(), from_name: "*".into(), star: false }); for prop in kids(value) { if prop.kind() == "pair" { if let (Some(key), Some(val)) = (prop.child_by_field_name("key"), prop.child_by_field_name("value")) { diff --git a/crates/cg-extract/src/facts/mod.rs b/crates/cg-extract/src/facts/mod.rs index 37e8355..bec5766 100644 --- a/crates/cg-extract/src/facts/mod.rs +++ b/crates/cg-extract/src/facts/mod.rs @@ -15,6 +15,10 @@ mod rust; mod util; pub use util::Cx; +/// Internal export key for the module value itself, distinct from a named/ES +/// `default` export. The leading NUL keeps it out of ordinary source identifiers. +pub const COMMONJS_MODULE: &str = "\0cjs:module.exports"; + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] #[repr(u8)] pub enum ImportKind { diff --git a/crates/cg-resolve/src/engine.rs b/crates/cg-resolve/src/engine.rs index 12ccf89..f7a08fd 100644 --- a/crates/cg-resolve/src/engine.rs +++ b/crates/cg-resolve/src/engine.rs @@ -5,6 +5,7 @@ use crate::modules::{ImportTarget, Modules, PkgId}; use crate::project::ProjectInfo; use cg_core::{EdgeKind, FileId, Lang, LangFamily, NodeIdx, NodeKind, StrId, NONE}; +use cg_extract::facts::COMMONJS_MODULE; use cg_extract::{BindKind, ImportKind}; use cg_store::{outkind, status, View}; use rayon::prelude::*; @@ -171,6 +172,10 @@ impl<'v> Engine<'v> { for ex in view.exports_of(f) { let name = view.text_str(ex.name); let spec = view.text_str(ex.from_spec); + if name == COMMONJS_MODULE && spec.is_empty() && view.text_str(ex.from_name) == "*" { + map.insert(name, ExportEntry::Module(f)); + continue; + } if ex.star != 0 { if let Some(ImportTarget::File(tf)) = Some(self.modules.resolve_import(lang, spec, f)) { stars.push(tf); @@ -359,6 +364,11 @@ impl<'v> Engine<'v> { ImportTarget::Node(n) => Bound::Node(n), ImportTarget::Pkg(p) => Bound::Pkg(p), ImportTarget::File(tf) => { + if imp.kind == ImportKind::Default as u8 && imported == "default" { + if let Some(value) = self.lookup_export(tf, COMMONJS_MODULE, 0) { + return value; + } + } if imp.kind == ImportKind::Namespace as u8 || imported == "*" { return Bound::Module(tf); } diff --git a/crates/cg-resolve/src/resolve.rs b/crates/cg-resolve/src/resolve.rs index 6a6d332..6ba3d60 100644 --- a/crates/cg-resolve/src/resolve.rs +++ b/crates/cg-resolve/src/resolve.rs @@ -8,6 +8,7 @@ use crate::engine::{Bound, Engine}; use crate::modules::{ImportTarget, PkgId}; use crate::shape::{parse_shape, split_head, Shape}; use cg_core::{text::pack_pos, EdgeKind, FileId, Lang, LangFamily, NodeIdx, NodeKind, RefKind, Visibility, NONE}; +use cg_extract::facts::COMMONJS_MODULE; use cg_extract::{BindKind, ImportKind, ScopeKind}; use cg_store::{status, BindingRec, ImportRec, RefRec, ScopeRec, View}; use rustc_hash::{FxHashMap, FxHashSet}; @@ -907,7 +908,7 @@ impl<'e, 'v> FileCx<'e, 'v> { // default function for a missing property such as .static. let imp = &self.imports[i as usize]; if self.family == LangFamily::Js && imp.kind == ImportKind::Require as u8 { - if let Some(Bound::Node(n)) = e.lookup_export(m, "default", 0) { + if let Some(Bound::Node(n)) = e.lookup_export(m, COMMONJS_MODULE, 0) { if accept.ok(kind_of(view, n)) { return NameRes::Found(n, by::IMPORT, 95); } From a4ed311715db180992d1388704e38eb1e993fca8 Mon Sep 17 00:00:00 2001 From: NianJiuZst <3235467914@qq.com> Date: Sun, 1 Nov 2026 05:35:17 -0600 Subject: [PATCH 4/5] docs: include CommonJS module-value regression verification --- docs/RESOLUTION-QUALITY.md | 15 +++++++++------ .../benchmarks/2026-11-01-resolution-quality.json | 12 ++++++------ 2 files changed, 15 insertions(+), 12 deletions(-) diff --git a/docs/RESOLUTION-QUALITY.md b/docs/RESOLUTION-QUALITY.md index 214c7b5..102dd1d 100644 --- a/docs/RESOLUTION-QUALITY.md +++ b/docs/RESOLUTION-QUALITY.md @@ -6,7 +6,7 @@ 主要缺口位于自研的 facts、模块解析、类型传播及框架层。四个仓库的非路由节点身份 在修复前后均与上游完全一致;问题并不是 Rust 语法提取器整体提取不出符号。 -修复运行时:`34c0024`,引擎规则版本从 **2 升到 3**,存储格式仍为 **2**。 +修复运行时:`d45151d`,引擎规则版本从 **2 升到 3**,存储格式仍为 **2**。 基线为 `9c610ba`,其运行时代码与之前性能复测的 `b827b1d` 相同。 上游仍固定为 `d2e0389b519be398f9bc616b6f7bea8a7edfbc6a`,package 版本 1.6.2。 未更换上游版本、仓库快照、包含范围或比较键。 @@ -24,7 +24,8 @@ 后者导出 `createApplication`;这条链断开,直接导致 **678 次 `express()` 调用漏连**。 现在在语法 facts 中记录这些导出,并沿原有、有深度上限的导出闭包解析。 -调用 CommonJS 模块时使用其默认导出,成员访问则使用成员导出。 +调用 CommonJS 模块时使用其模块值,成员访问则使用成员导出。 +模块值、ES 默认导出和名为 `default` 的对象属性分别处理,避免把仅含 `default` 属性的对象误当作可调用函数。 ES namespace import 不会因此被当作可调用的默认函数。 未导出的 JS 私有函数不再作为模块成员的后备答案,缺失的显式 JS 导入也不会继续 退化成全项目同名匹配。显式声明的 `module` / `exports` 局部变量会阻止相应的导出事实。 @@ -139,7 +140,7 @@ NULL 位置保持 NULL,包含全部边、路由、包含关系和有提取错 ## 验证与剩余工作 -- 35 项仓库外定向语义检查:旧版通过 16 项,修复版通过 **35 项**,包含正例与拒绝误连的负例。 +- 40 项仓库外定向语义检查:旧版通过 18 项,修复版通过 **40 项**,包含正例与拒绝误连的负例。 - 现有工作区测试:**137 通过,1 项原有 ignored**;随机编辑按 6 组 × 100 次执行。 - 四个真实仓库共 **24 项**检查:初始完整比较、编辑后同步与完整比较、还原后同步与完整比较、严格索引校验。 - 成员别名变更的增量复现、旧规则版本索引升级均通过。 @@ -158,9 +159,11 @@ The low agreement exposed both real resolver defects and differences between gra Non-route symbol identities already matched upstream completely; most gaps were in the Rust implementation's facts, export/module resolution, type propagation and framework rules. -Runtime commit **`34c0024`** fixes callable CommonJS exports and re-exports, enforces JS +Runtime commit **`d45151d`** fixes callable CommonJS exports and re-exports, enforces JS export boundaries, distinguishes assigned property names from internal function names, -and constrains member lookup using receiver evidence. Rust fixes select the declared Cargo +and constrains member lookup using receiver evidence. The module value is tracked separately +from ES default exports and object properties named `default`, so exporting an object does not +make the module callable. Rust fixes select the declared Cargo root, isolate auxiliary targets, resolve qualified type paths and value/module name collisions, recover conditional-wrapper export facts, and preserve raw return annotations for bounded call-chain and standard Result/Option inference. Framework detection recognizes a framework's @@ -175,7 +178,7 @@ node identities still match. P/R describe agreement with this upstream version, semantic ground truth. Gin's relative P declines partly because cgr now emits route containment edges absent from upstream. The original global 97%/95% agreement gate is **not fully met**. -Validation: **35/35** external focused checks, **137** existing workspace tests passed with +Validation: **40/40** external focused checks, **137** existing workspace tests passed with one existing ignored test, **600** random edit steps, **24** checks across four real repositories, an independently checked SQL intersection for every graph, and the targeted incremental alias and old-engine upgrade checks. Release build, strict Clippy and formatting pass. Engine version diff --git a/docs/benchmarks/2026-11-01-resolution-quality.json b/docs/benchmarks/2026-11-01-resolution-quality.json index 92b22a0..782711c 100644 --- a/docs/benchmarks/2026-11-01-resolution-quality.json +++ b/docs/benchmarks/2026-11-01-resolution-quality.json @@ -1,5 +1,5 @@ { - "dateUtc": "2026-11-01T11:17:18.318943+00:00", + "dateUtc": "2026-11-01T11:34:36.180799+00:00", "baselineCommit": "9c610ba3d99e1d18e5e0595b6268af1a0e85a03c", "upstreamCommit": "d2e0389b519be398f9bc616b6f7bea8a7edfbc6a", "comparisonKey": [ @@ -13,14 +13,14 @@ "allEdgesIncluded": true, "upstreamIsSemanticGroundTruth": false, "beforeBinarySha256": "47f134691da3eec3ee60a444d86ce22dc8e0b5dc2a0e8d7f35c447e0dc2de171", - "afterBinarySha256": "724d46024a032c626172c4137e9e89181c7d109cbb7fbaa421f52e79e91ea161", + "afterBinarySha256": "3a4b08edcd2e447f4af77416ece3d288351c316f3175b0460e3aea193eb2f3b0", "engineVersion": 3, "formatVersion": 2, "newPerformanceBenchmark": false, "checks": { - "focusedBefore": 16, - "focusedAfter": 35, - "focusedTotal": 35, + "focusedBefore": 18, + "focusedAfter": 40, + "focusedTotal": 40, "workspacePassed": 137, "workspaceIgnored": 1, "randomEditSequences": 6, @@ -969,7 +969,7 @@ "corpusCommit": "a05e16a7230fe33d3f43f4a3aaed103cebb42efc" } ], - "runtimeCommit": "34c00243d1f6a7d65908682f1fa494ca9e4b8cf1", + "runtimeCommit": "d45151d92172c42bdaae6451c4735fca01c5c847", "rustCompiler": "rustc 1.94.1 (e408947bf 2026-03-25)", "vendoredKernelBase": "9d3abb843a84d7610bf987bda7a1db4a6fe3eee3" } From 9f1c1c351488bd3ac27388823889bff0f2305584 Mon Sep 17 00:00:00 2001 From: NianJiuZst <3235467914@qq.com> Date: Sun, 1 Nov 2026 05:41:13 -0600 Subject: [PATCH 5/5] ci: consume version output without closing the smoke-test pipe --- docs/RESOLUTION-QUALITY.md | 3 ++- scripts/smoke.sh | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/docs/RESOLUTION-QUALITY.md b/docs/RESOLUTION-QUALITY.md index 102dd1d..34ab267 100644 --- a/docs/RESOLUTION-QUALITY.md +++ b/docs/RESOLUTION-QUALITY.md @@ -145,7 +145,8 @@ NULL 位置保持 NULL,包含全部边、路由、包含关系和有提取错 - 四个真实仓库共 **24 项**检查:初始完整比较、编辑后同步与完整比较、还原后同步与完整比较、严格索引校验。 - 成员别名变更的增量复现、旧规则版本索引升级均通过。 - Rust 1.99 Clippy `-D warnings`、格式检查、锁定依赖的 release 构建通过。 -- 新增的一次性脚本、测试项目、SQLite 数据库与逐边日志保存在仓库外;仓库只提交运行时代码和报告数据。 +- 现有端到端冒烟脚本通过;版本输出的过滤器会消费完整管道,避免提前关闭管道导致 musl 进程退出。 +- 新增的一次性脚本、测试项目、SQLite 数据库与逐边日志保存在仓库外;仓库包含运行时代码、现有 CI 冒烟脚本的修正及报告数据。 后续优先补齐 Rust 泛型/trait/Deref 与更复杂宏的静态建模,Python 跨方法字段与动态工厂, 以及 JS 接收者、动态导出和 mixin 的类型证据。路由协议的 ID、边种类和包含关系需要另行明确 diff --git a/scripts/smoke.sh b/scripts/smoke.sh index 0ee833d..bcb001c 100755 --- a/scripts/smoke.sh +++ b/scripts/smoke.sh @@ -86,7 +86,8 @@ func Total(xs []int) int { EOF echo "== version" -"$BIN" version --verbose | head -3 +# Consume all output: head can close the pipe while the musl binary is still writing. +"$BIN" version --verbose | sed -n '1,3p' echo "== init" out="$("$BIN" init)"; echo "$out"