diff --git a/crates/cg-core/src/brand.rs b/crates/cg-core/src/brand.rs index fc26f20..8d42f0e 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 = 3; +pub const ENGINE_VERSION: u32 = 4; /// 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 0c58978..86d259e 100644 --- a/crates/cg-extract/src/facts/js.rs +++ b/crates/cg-extract/src/facts/js.rs @@ -32,6 +32,8 @@ fn walk(cx: &mut Cx, n: Node, scope: u32) { if let Some(name) = n.child_by_field_name("name") { let nm = cx.text(name).to_owned(); cx.add_binding(scope, &nm, BindKind::LocalFn, "", "", 0); + let row = cx.row_at(cx.start(n)); + cx.facts.bindings.last_mut().unwrap().node_row = row.unwrap_or(NONE); } } function(cx, n, scope); diff --git a/crates/cg-extract/src/facts/mod.rs b/crates/cg-extract/src/facts/mod.rs index bec5766..939f25b 100644 --- a/crates/cg-extract/src/facts/mod.rs +++ b/crates/cg-extract/src/facts/mod.rs @@ -108,8 +108,8 @@ pub enum BindKind { /// 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. + /// Return annotation or a bounded inferred return expression, keyed by the + /// function's node. Metadata only; not a lexical binding. ReturnType = 6, } @@ -118,8 +118,8 @@ pub struct BindingFact { pub scope: u32, pub name: String, pub kind: BindKind, - /// 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. + /// Declared type, usually reduced to its head (`Foo` -> `Foo`). Rust + /// retains generic arguments to distinguish containers and pointer targets. pub decl_type: String, /// Constructor or bounded initializer call path (`Foo::new().build()`), or empty. pub init_ctor: String, @@ -137,6 +137,21 @@ pub struct Facts { /// `scopes[0]` is the file scope. pub scopes: Vec, pub bindings: Vec, + /// Precise call paths lost by the compatibility kernel. Applied to matching + /// call references before storage; node identities and sites stay unchanged. + pub call_names: Vec, + /// A supplementary parse exhausted its deadline. The pipeline exposes this + /// as an incomplete file rather than silently advertising complete facts. + pub timed_out: bool, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CallNameFact { + pub line: u32, + pub col: u32, + pub tail: String, + pub kernel_name: String, + pub name: String, } impl Facts { @@ -158,7 +173,12 @@ impl Facts { /// Build the facts for one parsed file. `rows` are the kernel tables of the same parse. pub fn extract(lang: Lang, tree: &Tree, src: &str, rows: FileRows<'_>) -> Facts { + extract_with_timeout(lang, tree, src, rows, std::time::Duration::from_secs(5)) +} + +pub fn extract_with_timeout(lang: Lang, tree: &Tree, src: &str, rows: FileRows<'_>, timeout: std::time::Duration) -> Facts { let mut cx = Cx::new(src, rows); + cx.parse_timeout = timeout; let root = tree.root_node(); match lang { Lang::TypeScript | Lang::Tsx | Lang::JavaScript | Lang::Jsx => js::extract(&mut cx, root), diff --git a/crates/cg-extract/src/facts/python.rs b/crates/cg-extract/src/facts/python.rs index 3746fbf..8677686 100644 --- a/crates/cg-extract/src/facts/python.rs +++ b/crates/cg-extract/src/facts/python.rs @@ -77,7 +77,13 @@ pub fn py_type_name(text: &str) -> String { } if let Some((a, b)) = t.split_once('|') { let (a, b) = (a.trim(), b.trim()); - t = if a == "None" { b } else { a }; + t = if a == "None" { + b + } else if b == "None" { + a + } else { + return String::new(); + }; } let name = simple_type_name(t); match name.as_str() { @@ -196,10 +202,12 @@ fn param_names(cx: &mut Cx, params: Node, sc: u32) { } fn function(cx: &mut Cx, n: Node, scope: u32) { + let row = cx.row_at(cx.start(n)); if cx.facts.scopes[scope as usize].kind != ScopeKind::Class { if let Some(name) = n.child_by_field_name("name") { let nm = cx.text(name).to_owned(); cx.add_binding(scope, &nm, BindKind::LocalFn, "", "", 0); + cx.facts.bindings.last_mut().unwrap().node_row = row.unwrap_or(NONE); } } let sc = cx.push_scope(ScopeKind::Function, scope, n); @@ -208,12 +216,79 @@ fn function(cx: &mut Cx, n: Node, scope: u32) { } if let Some(body) = n.child_by_field_name("body") { walk(cx, body, sc); + if let (Some(row), Some(name)) = (row, n.child_by_field_name("name")) { + let (decl_type, init_ctor) = if let Some(ret) = n.child_by_field_name("return_type") { + let raw = cx.text(ret); + let ty = py_type_name(raw); + (if ty.is_empty() { raw.to_owned() } else { ty }, String::new()) + } else { + inferred_return(cx, n, body).unwrap_or_default() + }; + if !decl_type.is_empty() || !init_ctor.is_empty() { + cx.facts.bindings.push(BindingFact { + scope: sc, + name: cx.text(name).to_owned(), + kind: BindKind::ReturnType, + decl_type, + init_ctor, + line: cx.line(n), + node_row: row, + }); + } + } } if let Some(dec) = n.child_by_field_name("decorators") { walk(cx, dec, scope); } } +/// Infer only a uniform, explicit return expression. A final return rules out +/// implicit None; nested definitions, generators and arbitrary decorators must +/// not supply evidence for the enclosing function. +fn inferred_return(cx: &Cx, function: Node, body: Node) -> Option<(String, String)> { + if kids(function).any(|n| n.kind() == "async") || function.parent().is_some_and(|p| p.kind() == "decorated_definition") { + return None; + } + if kids(body).filter(|n| n.kind() != "comment").last()?.kind() != "return_statement" { + return None; + } + fn collect(cx: &Cx, n: Node, result: &mut Option<(String, String)>, depth: u8) -> Option<()> { + if depth >= 64 { + return None; + } + match n.kind() { + "function_definition" | "class_definition" | "lambda" => return Some(()), + "yield" => return None, + "return_statement" => { + let value = n.named_child(0)?; + let inferred = match value.kind() { + "call" => { + let callee = value.child_by_field_name("function")?; + if !matches!(callee.kind(), "identifier" | "attribute") || cx.text(callee).len() > 4096 { + return None; + } + (String::new(), format!("{}()", cx.text(callee))) + } + _ => return None, + }; + if result.as_ref().is_some_and(|previous| *previous != inferred) { + return None; + } + *result = Some(inferred); + return Some(()); + } + _ => {} + } + for child in kids(n) { + collect(cx, child, result, depth + 1)?; + } + Some(()) + } + let mut result = None; + collect(cx, body, &mut result, 0)?; + result +} + fn lambda(cx: &mut Cx, n: Node, scope: u32) { let sc = cx.push_scope(ScopeKind::Function, scope, n); if let Some(params) = n.child_by_field_name("parameters") { diff --git a/crates/cg-extract/src/facts/rust.rs b/crates/cg-extract/src/facts/rust.rs index 5a3e805..61aefbc 100644 --- a/crates/cg-extract/src/facts/rust.rs +++ b/crates/cg-extract/src/facts/rust.rs @@ -8,17 +8,18 @@ pub fn extract(cx: &mut Cx, root: Node) { // 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) { + if let Some(tree) = conditional_items(cx, 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}; +fn conditional_items(cx: &mut Cx, root: Node) -> Option { + use std::time::Instant; use tree_sitter::{ParseOptions, Parser}; + let src = cx.src; if src.len() > 1024 * 1024 || !src.contains("cfg_") { return None; } @@ -73,10 +74,22 @@ fn conditional_items(src: &str, root: Node) -> Option { } 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; + // Use the configured parsing budget, not a separate 100 ms cutoff which + // can silently change imports under normal indexing load. + if cx.parse_timeout.is_zero() { + cx.facts.timed_out = true; + return None; + } + let deadline = Instant::now() + cx.parse_timeout; + let mut expired = false; + let mut cancel = |_: &tree_sitter::ParseState| { + expired = Instant::now() >= deadline; + expired + }; let tree = - parser.parse_with_options(&mut |offset, _| masked.get(offset..).unwrap_or_default(), None, Some(ParseOptions::new().progress_callback(&mut cancel)))?; + parser.parse_with_options(&mut |offset, _| masked.get(offset..).unwrap_or_default(), None, Some(ParseOptions::new().progress_callback(&mut cancel))); + cx.facts.timed_out |= expired; + let tree = tree?; // Non-item wrappers (cfg_if!, DSLs, malformed syntax) are left opaque. (!tree.root_node().has_error()).then_some(tree) } @@ -101,6 +114,37 @@ fn walk(cx: &mut Cx, n: Node, scope: u32) { let_decl(cx, n, scope); walk_children(cx, n, scope); } + "call_expression" => { + if let Some(f) = n.child_by_field_name("function").filter(|f| f.kind() == "field_expression") { + if let Some(field) = f.child_by_field_name("field") { + let name = value_path(cx, f, 0); + if !name.is_empty() { + let pos = cx.start(n); + let mut kernel_name = String::new(); + let mut depth = 0u32; + for ch in name.chars() { + if ch == ')' { + depth = depth.saturating_sub(1); + } + if depth == 0 { + kernel_name.push(ch); + } + if ch == '(' { + depth += 1; + } + } + cx.facts.call_names.push(CallNameFact { + line: (pos >> 32) as u32, + col: pos as u32, + tail: cx.text(field).to_owned(), + kernel_name, + name, + }); + } + } + } + walk_children(cx, n, scope); + } "for_expression" => { if let Some(p) = n.child_by_field_name("pattern") { bind_pattern(cx, p, scope, BindKind::Local); @@ -120,14 +164,7 @@ 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" => { - 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 - } - } + "generic_type" => cx.text(n).to_owned(), "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() @@ -170,7 +207,22 @@ fn value_path(cx: &Cx, v: Node, depth: u8) -> String { "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" => { - 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() + let callee = v.child_by_field_name("function").map(|f| value_path(cx, f, depth + 1)).unwrap_or_default(); + if callee.is_empty() { + return String::new(); + } + if callee.ends_with("::new") { + if let Some(args) = v.child_by_field_name("arguments") { + let values: Vec<_> = kids(args).filter(|n| n.is_named() && !matches!(n.kind(), "comment" | "line_comment" | "block_comment")).collect(); + if values.len() == 1 { + let inner = value_path(cx, values[0], depth + 1); + if !inner.is_empty() { + return format!("{callee}({inner})"); + } + } + } + } + format!("{callee}()") } "field_expression" => { let base = v.child_by_field_name("value").map(|v| value_path(cx, v, depth + 1)).unwrap_or_default(); @@ -247,6 +299,8 @@ fn function(cx: &mut Cx, n: Node, scope: u32) { if let Some(name) = n.child_by_field_name("name") { let nm = cx.text(name).to_owned(); cx.add_binding(scope, &nm, BindKind::LocalFn, "", "", 0); + let row = cx.row_at(cx.start(n)); + cx.facts.bindings.last_mut().unwrap().node_row = row.unwrap_or(NONE); } } let sc = cx.push_scope(ScopeKind::Function, scope, n); diff --git a/crates/cg-extract/src/facts/util.rs b/crates/cg-extract/src/facts/util.rs index 2102387..074777d 100644 --- a/crates/cg-extract/src/facts/util.rs +++ b/crates/cg-extract/src/facts/util.rs @@ -8,6 +8,7 @@ pub struct Cx<'a> { pub src: &'a str, pub rows: FileRows<'a>, pub facts: Facts, + pub parse_timeout: std::time::Duration, line_starts: Vec, row_by_start: Option>, } @@ -17,7 +18,7 @@ impl<'a> Cx<'a> { let line_starts = text::line_starts(src); let end_line = line_starts.len() as u32; let facts = Facts::new(pack_pos(end_line + 1, 0)); - Cx { src, rows, facts, line_starts, row_by_start: None } + Cx { src, rows, facts, parse_timeout: std::time::Duration::from_secs(5), line_starts, row_by_start: None } } /// Kernel node row whose span starts exactly at `pos` (packed line / UTF-16 column), skipping diff --git a/crates/cg-extract/src/pipeline.rs b/crates/cg-extract/src/pipeline.rs index 905ac86..887b5bb 100644 --- a/crates/cg-extract/src/pipeline.rs +++ b/crates/cg-extract/src/pipeline.rs @@ -126,7 +126,7 @@ pub fn file_node_only(rel: &str, line_count: u32) -> EmitOut { } enum KernelOutcome { - Ok { emit: EmitOut, facts: Facts, had_error_tree: bool, facts_failed: bool }, + Ok { emit: EmitOut, facts: Box, had_error_tree: bool, facts_failed: bool }, TooDeep, TimedOut, Failed(String), @@ -161,7 +161,7 @@ fn run_kernel(rel: &str, src: &str, lang: Lang, cfg: &ExtractConfig) -> KernelOu let mut facts_failed = false; let facts = match &tree { Some(t) => { - let r = catch_unwind(AssertUnwindSafe(|| facts::extract(lang, t, src, FileRows::new(&emit)))); + let r = catch_unwind(AssertUnwindSafe(|| facts::extract_with_timeout(lang, t, src, FileRows::new(&emit), cfg.parse_timeout))); match r { Ok(f) => f, Err(_) => { @@ -172,7 +172,7 @@ fn run_kernel(rel: &str, src: &str, lang: Lang, cfg: &ExtractConfig) -> KernelOu } None => Facts::default(), }; - KernelOutcome::Ok { emit, facts, had_error_tree, facts_failed } + KernelOutcome::Ok { emit, facts: Box::new(facts), had_error_tree, facts_failed } } } } @@ -233,7 +233,11 @@ pub fn extract_bytes(rel: &str, bytes: &[u8], mtime_ns: i64, lang_hint: Lang, cf if facts_failed { errors.push("panic while building facts".to_owned()); } - (emit, facts) + if facts.timed_out { + flags |= fileflags::TIMED_OUT; + errors.push(format!("supplementary facts parse timed out after {:?}", cfg.parse_timeout)); + } + (emit, *facts) } KernelOutcome::TooDeep => { errors.push("nesting too deep for the walker".to_owned()); diff --git a/crates/cg-extract/tests/facts_langs.rs b/crates/cg-extract/tests/facts_langs.rs index f5e38b3..00347ce 100644 --- a/crates/cg-extract/tests/facts_langs.rs +++ b/crates/cg-extract/tests/facts_langs.rs @@ -161,7 +161,7 @@ impl Server { assert_eq!(bind(&f, "self").decl_type, "Self"); assert_eq!(bind(&f, "other").decl_type, "Other"); assert_eq!(bind(&f, "t").init_ctor, "T::new()"); - assert_eq!(bind(&f, "m").decl_type, "HashMap"); + assert_eq!(bind(&f, "m").decl_type, "HashMap"); assert_eq!(bind(&f, "s").init_ctor, "Server"); assert_eq!(bind(&f, "item").kind, BindKind::Local); assert_eq!(bind(&f, "x").decl_type, "Foo"); diff --git a/crates/cg-resolve/src/engine.rs b/crates/cg-resolve/src/engine.rs index f7a08fd..677e51c 100644 --- a/crates/cg-resolve/src/engine.rs +++ b/crates/cg-resolve/src/engine.rs @@ -46,7 +46,7 @@ pub struct Engine<'v> { 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 return_types: FxHashMap, pub django_model: Option, pub n_files: usize, } @@ -112,7 +112,7 @@ impl<'v> Engine<'v> { .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))) + .map(|b| (b.node, b)) .collect(), django_model: None, n_files, @@ -466,8 +466,8 @@ impl<'v> Engine<'v> { let mut best = None; for cand in self.view.by_qname(&q) { let cf = self.view.hot(cand).file; - // Go: same package; Rust: same crate. Others: unique qualified name. - if cf == tfile || (!tpkg.is_none() && self.modules.pkg_of(cf) == tpkg) || self.same_rust_crate(tfile, cf) { + // Go: same package; Rust: the owning module or a proved type import. + if cf == tfile || (!tpkg.is_none() && self.modules.pkg_of(cf) == tpkg) || self.rust_type_owner(t, cf) { return Some(cand); } best.get_or_insert(cand); @@ -475,11 +475,20 @@ impl<'v> Engine<'v> { best.filter(|_| tn.qname().contains("::") && self.view.file(tfile).lang().family() == LangFamily::Jvm) } - fn same_rust_crate(&self, a: FileId, b: FileId) -> bool { - match (self.modules.rust_module_of(a), self.modules.rust_module_of(b)) { - (Some((x, _)), Some((y, _))) => x == y, - _ => false, + /// Equal unqualified type names in different Rust modules are distinct. + /// An out-of-module impl needs an import that identifies this exact type. + pub fn rust_type_owner(&self, t: NodeIdx, file: FileId) -> bool { + let node = self.view.node(t); + match (self.modules.rust_module_of(node.file()), self.modules.rust_module_of(file)) { + (Some(a), Some(b)) if a == b => return true, + (Some((a, _)), Some((b, _))) if a == b => {} + _ => return false, } + self.view + .imports_of(file) + .iter() + .enumerate() + .any(|(i, import)| self.view.text_str(import.local) == node.qname() && self.bind_import(file, i) == Bound::Node(t)) } /// Member lookup through the hierarchy. diff --git a/crates/cg-resolve/src/resolve.rs b/crates/cg-resolve/src/resolve.rs index 6ba3d60..96418c9 100644 --- a/crates/cg-resolve/src/resolve.rs +++ b/crates/cg-resolve/src/resolve.rs @@ -105,6 +105,7 @@ pub enum TypeRes { enum StdWrapper { Result, Option, + Pointer, } /// A known project type, possibly still inside a standard Rust container. @@ -120,8 +121,61 @@ impl ValueType { } fn receiver(self) -> Option { + // The field cache stores one node, so it cannot preserve wrapper + // methods such as Arc::clone. Only method_receiver may autoderef. self.wrappers.is_empty().then_some(self.node) } + + fn method_receiver(&self, method: &str) -> Option { + if self.wrappers.contains(&StdWrapper::Pointer) && pointer_method(method) { + return None; + } + self.wrappers.iter().all(|w| *w == StdWrapper::Pointer).then_some(self.node) + } +} + +fn pointer_method(method: &str) -> bool { + matches!( + method, + "clone" + | "clone_from" + | "as_ref" + | "as_mut" + | "deref" + | "deref_mut" + | "get_mut" + | "make_mut" + | "into_inner" + | "try_unwrap" + | "downgrade" + | "strong_count" + | "weak_count" + | "ptr_eq" + ) +} + +/// Paths here contain no source arguments except bounded constructor paths. +/// Find the final complete call, allowing earlier calls in its receiver. +fn split_call(value: &str) -> Option<(&str, &str)> { + let (mut depth, mut open) = (0u32, 0usize); + for (i, byte) in value.bytes().enumerate() { + match byte { + b'(' => { + if depth == 0 { + open = i; + } + depth += 1; + } + b')' => { + depth = depth.checked_sub(1)?; + if depth == 0 && i + 1 == value.len() { + return Some((&value[..open], &value[open + 1..i])); + } + } + _ => {} + } + } + None } /// Per-file lookup structures, built once per file and reused for all its references. @@ -384,6 +438,12 @@ impl<'e, 'v> FileCx<'e, 'v> { if cf == self.file { return Some(cand); } + if self.family == LangFamily::Rust { + if self.e.rust_type_owner(cand, self.file) { + return Some(cand); + } + continue; + } // a candidate in the caller's package wins over earlier ones; otherwise the first stays if (self.pkg.0 != NONE && self.e.modules.pkg_of(cf) == self.pkg) || best.is_none() { best = Some(cand); @@ -554,9 +614,23 @@ impl<'e, 'v> FileCx<'e, 'v> { } if let Some(inner) = init.strip_suffix('?') { let mut value = self.expression_value(wcx, inner, scope, line, depth + 1)?; - value.wrappers.pop()?; + if !matches!(value.wrappers.pop()?, StdWrapper::Result | StdWrapper::Option) { + return None; + } return Some(value); } + if self.family == LangFamily::Rust { + if let Some((callee, args)) = split_call(init) { + if let Some(owner) = callee.strip_suffix("::new") { + if self.std_wrapper(wcx, owner) == Some(StdWrapper::Pointer) { + let mut value = self.expression_value(wcx, args, scope, line, depth + 1)?; + value.wrappers.push(StdWrapper::Pointer); + return Some(value); + } + } + return self.call_value(wcx, callee, scope, line, depth + 1); + } + } if let Some(call) = init.strip_suffix("()") { return self.call_value(wcx, call, scope, line, depth + 1); } @@ -570,14 +644,33 @@ impl<'e, 'v> FileCx<'e, 'v> { fn std_wrapper(&self, wcx: &mut WorkerCx<'e, 'v>, name: &str) -> Option { let (prefix, leaf) = name.rsplit_once("::").unwrap_or(("", name)); + if prefix.is_empty() { + if let Some(i) = self.visible_import(name, 0) { + let imp = &self.imports[i as usize]; + let spec = self.view.text_str(imp.spec); + let imported = self.view.text_str(imp.imported); + return match (spec, imported) { + ("std::sync" | "alloc::sync", "Arc") | ("std::rc" | "alloc::rc", "Rc") | ("std::boxed" | "alloc::boxed", "Box") => { + Some(StdWrapper::Pointer) + } + ("std::result" | "core::result" | "std::io", "Result") => Some(StdWrapper::Result), + ("std::option" | "core::option", "Option") => Some(StdWrapper::Option), + _ => None, + }; + } + } let wrapper = match leaf { "Result" => StdWrapper::Result, "Option" => StdWrapper::Option, + "Arc" | "Rc" | "Box" => StdWrapper::Pointer, _ => return None, }; let standard = match prefix { "std::result" | "core::result" | "std::io" => wrapper == StdWrapper::Result, "std::option" | "core::option" => wrapper == StdWrapper::Option, + "std::sync" | "alloc::sync" => leaf == "Arc", + "std::rc" | "alloc::rc" => leaf == "Rc", + "std::boxed" | "alloc::boxed" => leaf == "Box", "" => 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]; @@ -592,8 +685,14 @@ impl<'e, 'v> FileCx<'e, 'v> { 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(); + let mut name = name.trim(); + while let Some(rest) = name.strip_prefix('&') { + name = rest.trim_start(); + if name.starts_with('\'') { + name = name.split_once(char::is_whitespace)?.1.trim_start(); + } + name = name.strip_prefix("mut ").unwrap_or(name).trim_start(); + } if matches!(name, "Self" | "self" | "this") { return receiver.map(ValueType::plain); } @@ -637,8 +736,14 @@ impl<'e, 'v> FileCx<'e, 'v> { 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) + if let Some(b) = self.e.return_types.get(&n) { + let rt = self.view.text_str(b.decl_type); + if !rt.is_empty() { + return cx.type_value(wcx, rt, receiver, depth + 1); + } + return cx.expression_value(wcx, self.view.text_str(b.init_ctor), b.scope.0.wrapping_sub(cx.scope_base), u32::MAX, depth + 1); + } + cx.type_value(wcx, node.return_type()?, receiver, depth + 1) } /// Follow declared return types through a bounded chain. Static methods do @@ -647,12 +752,8 @@ impl<'e, 'v> FileCx<'e, 'v> { 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('?') { + if inner.ends_with(['?', ')']) { let receiver = self.expression_value(wcx, inner, scope, line, depth + 1)?; return self.member_return(wcx, receiver, method, depth + 1); } @@ -687,7 +788,7 @@ impl<'e, 'v> FileCx<'e, 'v> { } fn member_return(&self, wcx: &mut WorkerCx<'e, 'v>, mut receiver: ValueType, method: &str, depth: u8) -> Option { - if !receiver.wrappers.is_empty() { + if receiver.wrappers.last().is_some_and(|w| matches!(w, StdWrapper::Result | StdWrapper::Option)) { return match method { "unwrap" | "expect" | "unwrap_or" | "unwrap_or_else" | "unwrap_or_default" => { receiver.wrappers.pop(); @@ -697,6 +798,17 @@ impl<'e, 'v> FileCx<'e, 'v> { _ => None, }; } + if receiver.wrappers.last() == Some(&StdWrapper::Pointer) { + match method { + "clone" => return Some(receiver), + "as_ref" | "as_mut" | "deref" | "deref_mut" => { + receiver.wrappers.pop(); + return Some(receiver); + } + _ => {} + } + } + receiver.method_receiver(method)?; let m = self.e.find_member(receiver.node, method)?; self.returned_value(wcx, m, Some(receiver.node), depth + 1) } @@ -1105,7 +1217,7 @@ impl<'e, 'v> FileCx<'e, 'v> { if let Some(b) = self.lookup_binding(root, scope, r.line, false) { if b.kind != BindKind::LocalFn as u8 { return match self.binding_value(wcx, b, 0) { - Some(t) if t.wrappers.is_empty() => { + Some(t) if t.method_receiver(method).is_some() => { let o = self.member_of(wcx, t.node, path, method, 90); if o.status == status::RESOLVED { o @@ -1118,6 +1230,15 @@ impl<'e, 'v> FileCx<'e, 'v> { if !self.view.text_str(b.decl_type).is_empty() { return Outcome::st(status::NO_CANDIDATE); } + // An initializer rooted in an explicit external import + // does not justify guessing an unrelated project member. + let init = self.view.text_str(b.init_ctor); + let head = init.split(['.', ':', '(']).next().unwrap_or(""); + if let Some(i) = self.visible_import(head, scope).filter(|_| self.lookup_binding(head, scope, r.line, false).is_none()) { + if self.e.bind_import(self.file, i as usize) == Bound::External { + return Outcome::st(status::EXTERNAL); + } + } let o = self.fallback_method(method); if o.status == status::RESOLVED && path.is_empty() { o @@ -1251,8 +1372,8 @@ 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_value(wcx, inner, self.scope_at(r.line, r.col), r.line, 0).and_then(ValueType::receiver) { - Some(t) => t, + let value = match self.call_value(wcx, inner, self.scope_at(r.line, r.col), r.line, 0) { + Some(value) => Some(value), None => { // `inner` may be a method of a typed receiver: resolve it as a call first let o = self.resolve_call_name(wcx, r, inner); @@ -1260,20 +1381,10 @@ impl<'e, 'v> FileCx<'e, 'v> { return Outcome::st(status::NO_CANDIDATE); } let n = NodeIdx(o.target); - let node = self.view.node(n); - if node.kind().is_type() { - n - } else { - let Some(rt) = node.return_type() else { return Outcome::st(status::NO_CANDIDATE) }; - let owner = self.view.hot(n).file; - let cx = wcx.file_cx(self.e, owner); - match cx.lookup_type(wcx, rt) { - TypeRes::Node(t) => t, - _ => return Outcome::st(status::NO_CANDIDATE), - } - } + self.returned_value(wcx, n, self.enclosing_type(n), 0) } }; + let Some(t) = value.and_then(|v| v.method_receiver(method)) else { return Outcome::st(status::NO_CANDIDATE) }; self.member_of(wcx, t, &[], method, 85) } @@ -1289,6 +1400,13 @@ impl<'e, 'v> FileCx<'e, 'v> { _ => Outcome::st(status::NO_CANDIDATE), }, Shape::CallResult { inner, method } => self.call_result(wcx, r, inner, method), + Shape::ValueResult { inner, method } => { + let value = self.expression_value(wcx, inner, self.scope_at(r.line, r.col), r.line, 0); + match value.and_then(|v| v.method_receiver(method)) { + Some(t) => self.member_of(wcx, t, &[], method, 85), + None => Outcome::st(status::NO_CANDIDATE), + } + } } } diff --git a/crates/cg-resolve/src/shape.rs b/crates/cg-resolve/src/shape.rs index 4eee8cb..3e9a0d6 100644 --- a/crates/cg-resolve/src/shape.rs +++ b/crates/cg-resolve/src/shape.rs @@ -29,6 +29,10 @@ pub enum Shape<'a> { inner: &'a str, method: &'a str, }, + ValueResult { + inner: &'a str, + method: &'a str, + }, } fn split_segments(name: &str) -> SmallVec<[&str; 6]> { @@ -63,10 +67,13 @@ pub fn parse_shape(name: &str) -> Shape<'_> { } return Shape::Bare(rest.trim()); } - 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 } }; + if let Some((value, method)) = name.rsplit_once('.') { + if let Some(inner) = value.strip_suffix("()") { + return if inner == "super" { Shape::Super { method } } else { Shape::CallResult { inner, method } }; + } + if value.contains(')') || value.ends_with('?') { + return Shape::ValueResult { inner: value, method }; + } } if name == "super" { return Shape::Bare("super"); diff --git a/crates/cg-store/src/build.rs b/crates/cg-store/src/build.rs index 30fe87c..fda3ae2 100644 --- a/crates/cg-store/src/build.rs +++ b/crates/cg-store/src/build.rs @@ -8,7 +8,7 @@ use crate::part::Part; use crate::records::*; use crate::seg::{Seg, SegMeta, SegParts}; use crate::strpool::StrPool; -use cg_core::{brand, kinds::NodeKind, EdgeKind, FileId, ListId, NodeIdx, Provenance, ScopeId, StrId, NONE}; +use cg_core::{brand, kinds::NodeKind, EdgeKind, FileId, ListId, NodeIdx, Provenance, RefKind, ScopeId, StrId, NONE}; use cg_extract::FileBatch; use rayon::prelude::*; use rustc_hash::FxHashMap; @@ -435,10 +435,27 @@ pub fn build_draft_at(batches: &[FileBatch], delta: Option<(&[FileId], BuildBase }); // ---- references ---- + let mut call_names = rustc_hash::FxHashMap::default(); + for call in &b.facts.call_names { + for key in [call.tail.as_str(), call.kernel_name.as_str()] { + call_names + .entry((call.line, call.col, key)) + .and_modify(|name: &mut Option<&str>| { + if *name != Some(call.name.as_str()) { + *name = None; + } + }) + .or_insert(Some(call.name.as_str())); + } + } for r in rows.refs() { let from_row = r.from_row().filter(|x| *x < kcount as u32).or_else(|| row_by_id(&mut id_to_row, &rows, r.from_id()?)); let from = nstart + from_row.unwrap_or(0); - let name = r.name(); + let name = if r.kind() == RefKind::Edge(EdgeKind::Calls) { + call_names.get(&(r.line(), r.col(), r.name())).copied().flatten().unwrap_or_else(|| r.name()) + } else { + r.name() + }; let tail_src: &str = if r.kind().edge_kind() == EdgeKind::Imports && import_specs.contains(name) { arena.alloc(format!("module:{name}")) } else { tail_of(name) }; refs.push(RefRec { diff --git a/crates/cg-sync/src/sync.rs b/crates/cg-sync/src/sync.rs index c220c0d..c9c3df0 100644 --- a/crates/cg-sync/src/sync.rs +++ b/crates/cg-sync/src/sync.rs @@ -256,7 +256,7 @@ fn defs_of(view: &View, f: FileId) -> BTreeMap> { type ExportSig = Vec<(String, String, String, u8)>; -type ResolverFactSig = BTreeSet<(u8, String, String, String)>; +type ResolverFactSig = BTreeSet<(u8, String, 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 = ...`). @@ -264,7 +264,15 @@ 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())) + .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(), + view.text_str(b.init_ctor).to_owned(), + ) + }) .collect() } diff --git a/docs/RESOLUTION-QUALITY-V4.md b/docs/RESOLUTION-QUALITY-V4.md new file mode 100644 index 0000000..e0510f4 --- /dev/null +++ b/docs/RESOLUTION-QUALITY-V4.md @@ -0,0 +1,148 @@ +# Resolution quality v4 / 解析质量与评测口径改进 + +本轮接续已合并的 [PR #2](https://github.com/NianJiuZst/CodeGraph-Rust/pull/2)。 +运行时代码为 `0d48a07caa67791e64dccf015922a877ab3f9fee`,基线为合并后的 +`4090af1`(规则版本 3)。引擎规则升到 **4**,存储格式保持 **2**;旧索引在下次同步时重建。 + +同一批四仓库源码、同一个上游快照下,全图共有边净增 **877**:新增 980,移除 103。 +80 项定向断言由 **59/80 提升到 80/80**。这分别是上游一致性和定向语义检查, +不能把任一个分数解释为所有真实项目的语义准确率。 + +[机器可读证据](benchmarks/2026-11-01-resolution-quality-v4.json)记录逐种类计数、两种指标的 +完整前后结果、二进制哈希、源码哈希、断言明细及独立 SQL 复核。 +[v3 报告](RESOLUTION-QUALITY.md)和此前的性能结果继续保留原来的版本归属。 + +## 修复内容 + +### 同名声明与外部接收者 + +- JS、Python、Rust 的嵌套函数绑定保存实际声明节点。两个函数内部各有一个 `helper()` 时, + 不再都落到文件中出现的第一个同名声明。 +- Rust 成员查找区分同一 crate 内不同模块的同名类型;跨模块 impl 需要能确认所属类型的导入。 + 定向检查同时覆盖拒绝串用成员和保留合法的跨模块 impl。 +- 由明确的外部导入构造出的未知对象,不再用本仓库唯一的同名成员填空。例如 + `reflect.ValueOf(x).Type()` 的局部变量不应连到测试代码中的 `Local.Type`。 + +### Rust 调用链、泛型与标准指针 + +兼容内核会把部分链式调用简化成裸方法名,丢掉接收者。facts 层现在记录有界的完整调用路径, +在相同引用位置补回名称;内核代码、节点身份和调用位置不变。有歧义的同位置映射不覆盖原名称。 + +这补齐了 `make().unwrap().execute()`、`make()?.execute()` 等形式;链式返回也统一使用 +保存的原始返回信息,避免备用路径绕过容器约束。带生命周期的引用返回会先去掉引用与生命周期, +再解析目标类型。 + +Rust 类型 facts 保留泛型参数,可识别标准 `Box`、`Rc`、`Arc` 的内层类型和有界的单参数构造, +支持标准导入的别名。指针自身的已建模操作(例如 `Arc::clone`)不会被连到内层类型的 `clone`。 +自定义同名类型仍按自己的声明解析。字段缓存只保存单一类型节点,因此不会把指针包装直接擦除后 +用于字段方法查找;这部分保留保守行为。这里没有实现通用 `Deref` 或任意泛型替换。 + +### Python 工厂返回与增量失效 + +Python 的简单、带引号和受支持的可选返回注解参与解析。没有注解时,仅记录满足以下条件的返回: +末尾存在显式 `return`,所有显式返回都是同一个可追踪调用,且不属于生成器、异步函数或被装饰的函数。 +混合返回不会被任选一个分支当作确定类型,嵌套函数的返回也不参与外层函数推断。 + +因此 `make()` 明确返回 `Worker()` 时,局部变量以及 `self.worker = make()` 这样的字段可获得类型。 +返回表达式还参与增量语义签名:仅把 `return A()` 改成 `return B()`,消费者也会重新解析。 +63 文件的定向检查中只重新解析 **2 个文件**,前后目标正确,且与完整重建一致。 + +### 条件宏补充解析不能静默丢事实 + +本轮完整索引与重建对比曾发现 `tokio-stream/src/stream_ext.rs` 丢失 7 个导入和 2 个重导出。 +条件宏补充解析原有独立的 **100ms** 限时,会在负载下回退,改变同源代码的 facts。 + +补充解析现在遵守配置中的解析限时(默认每次解析 **5 秒**),仍有 1 MiB 源码大小限制和遍历深度限制。 +若耗尽限时,会标记文件 `TIMED_OUT` 并记录补充解析错误。不会继续把回退结果呈现为完整提取。 +修复后,四仓库的编辑、同步、还原和重建检查均通过;Tokio 在 1、2、4 个 worker 下的规范图相同。 + +## 指标:把目标一致性与参考覆盖范围分开 + +旧指标把上游没有的每一条边都计入相对 P 的分母。它适合检查严格兼容, +但上游并非完整语义真值。例如 v3 已能解析的许多 Express `app.use()` 调用,上游没有对应边。 +两套路由表示的差异也继续影响全图分数。 + +本轮保留旧指标,另外报告**上游已标注调用点的目标一致性**: + +```text +C = cgr 的完整 calls 边集合 +O = 固定上游的完整 calls 边集合 +site = (source stable ID, kind=calls, line, column) +E = C 中 site 在 O 里出现过的边 + +已标注点目标一致性 P* = |C ∩ O| / |E| +上游调用召回率 R = |C ∩ O| / |O| +额外未标注边数 = |C − E| +``` + +边的目标仍须精确相同;位置的 NULL 与 0 仍有区别。R 的分母没有缩小。 +`C − E` 单独列出,未获语义核验前既不算命中,也不直接判错。 +P* 是条件一致性,不是全体输出的语义精确率,也不能替代严格兼容门槛。 + +**改指标带来的分数变化与改代码带来的提升分别比较。** Express 基线在新口径下已经是 99.28%, +本轮代码没有再提高其调用点分数,不能把旧口径的 49.26% 到新口径的 99.28% 写成算法提升。 +上游在已标注点也可能错连,额外边也可能误连,仍需正负语义用例和后续人工抽样核验。 + +| 项目 | P*:v3 → v4 | 调用 R:v3 → v4 | v4 已标注点边数 / 全部调用边 | v4 额外未标注边 | +|---|---:|---:|---:|---:| +| Express | 99.28% → 99.28% | 85.70% → 85.70% | 1,105 / 2,227 | 1,122 | +| Gin | 99.86% → 99.86% | 91.46% → 91.46% | 3,487 / 3,491 | 4 | +| Tokio | 95.64% → 95.61% | 64.45% → 67.90% | 11,083 / 11,545 | 462 | +| Django | 97.42% → 97.80% | 77.13% → 77.44% | 44,998 / 48,128 | 3,130 | + +## 原口径全图结果 + +仍使用 `(source stable ID, target stable ID, kind, line, column)`,包含全部边、路由、包含关系 +和原有提取错误文件。索引源码文件的集合及字节与基线、上游完全一致。四仓文件数为 +142、99、814、2,984;上游固定为 `d2e0389b519be398f9bc616b6f7bea8a7edfbc6a`。 + +| 项目 | 共有边:v3 → v4 | 全图相对 P:v3 → v4 | 全图相对 R:v3 → v4 | +|---|---:|---:|---:| +| Express | 2,063 → 2,062 | 58.96% → 58.93% | 88.39% → 88.35% | +| Gin | 7,678 → 7,678 | 93.45% → 93.49% | 95.11% → 95.11% | +| Tokio | 33,638 → 34,176 | 87.14% → 87.38% | 84.77% → 86.12% | +| Django | 174,016 → 174,356 | 94.07% → 94.23% | 89.65% → 89.83% | + +移除的 103 条原有共有边包括同名声明重新绑定、外部对象误连的修正,也包括保守建模留下的覆盖缺口, +没有将其全部归为旧版错误。Express 减少的是一条回调函数引用;其共有调用数不变。 +所有非路由节点身份仍与上游 **100%** 一致。 + +原设计的全图 **P ≥ 97%、R ≥ 95% 仍未全面达到**。Tokio 的 P* 也略有下降, +其新增调用和剩余接收者歧义需要继续核验。后续优先处理 Rust trait、泛型与字段包装传播, +以及 Python 动态类、跨方法字段流和有分支的工厂返回。 + +## 验证范围 + +以下均为本地验证,针对上述运行时;本轮没有产生新的性能加速比。 + +- 80 项定向断言:正例由 **30/46 → 46/46**,拒绝误连的负例由 **28/33 → 33/33**;另有 1 项路由检查。 + 保留了上一轮 40 项检查,并加入同名干扰声明、错误目标拒绝和合法跨模块 impl 等检查。 + 这是定向回归结果,不是随机真实项目样本的精确率估计。 +- 工作区 **137 通过、1 项原有 ignored**;随机编辑按 **6 × 100** 次运行。 +- 四仓共 **24 项**完整图、编辑同步、还原同步和严格结构校验;索引源码字节已还原。 +- 63 文件工厂返回变更和规则版本 3 升级的定向增量检查通过。 +- 独立 SQLite 复核每仓严格共有边、已标注调用点边数和共有调用数;没有超时文件。 +- Tokio 在 1、2、4 个 worker 下重复比较规范图,全部相同;补充解析正常预算与零预算的 2 项定向检查通过。 +- 锁定依赖的 release 构建、Rust 1.99 严格 Clippy、CI 包列表格式检查和现有 CLI/MCP 冒烟检查通过。 + +一次性检查程序、测试项目、数据库和日志保留在仓库外。仓库只包含运行时代码、已有 facts 测试中 +泛型保留契约的更新,以及这份报告和结果数据。两个 README 和既有性能数字未改动。 + +## English summary + +Engine 4 fixes scoped nested-function bindings, cross-module Rust type-name collisions, +external-initializer member fallback, lost Rust call paths, lifetime returns, bounded standard +pointer inference, Python factory return facts, and return-expression invalidation. Supplementary +Rust parsing now honors the configured timeout and exposes deadline exhaustion instead of +silently returning incomplete facts. Format version remains 2; engine-3 indexes rebuild on sync. + +The unchanged strict oracle comparison gains **877 shared edges net** (980 added, 103 removed). +Not every removed shared edge is claimed to be a correctness improvement. The original global +97%/95% gate remains unmet. A separate, explicitly conditional metric evaluates target agreement +at upstream-labeled call sites and reports all additional unlabeled edges. Its higher denominator- +adjusted score is not presented as an algorithmic improvement or semantic ground truth. + +Validation: **80/80** focused assertions versus 59/80, **137** workspace tests with one existing +ignored test, 600 random edits, 24 real-repository checks, independent SQL counts, targeted +incremental/upgrade checks, repeated Tokio graph equality with 1/2/4 workers, release build, +strict Clippy, formatting and CLI/MCP smoke. No new performance claim is made. diff --git a/docs/RESOLUTION-QUALITY.md b/docs/RESOLUTION-QUALITY.md index 34ab267..2fc1e07 100644 --- a/docs/RESOLUTION-QUALITY.md +++ b/docs/RESOLUTION-QUALITY.md @@ -1,5 +1,8 @@ # Resolution quality investigation / 解析质量排查与修复 +后续 [v4 解析质量与指标改进](RESOLUTION-QUALITY-V4.md)继续修复调用解析和增量一致性, +并新增明确区分参考覆盖范围的调用点指标。本页保留 PR #2 的原始测量与版本归属。 + ## 结论与版本 这次排查发现了真实的漏连、误连,也发现了图模型和上游错误带来的对比偏差。 diff --git a/docs/benchmarks/2026-11-01-resolution-quality-v4.json b/docs/benchmarks/2026-11-01-resolution-quality-v4.json new file mode 100644 index 0000000..417dd5f --- /dev/null +++ b/docs/benchmarks/2026-11-01-resolution-quality-v4.json @@ -0,0 +1,1725 @@ +{ + "schemaVersion": 1, + "dateUtc": "2026-11-01T12:35:51.405787+00:00", + "baseCommit": "4090af13757edc0b079b87128eaaf78234d7b0c0", + "runtimeCommit": "0d48a07caa67791e64dccf015922a877ab3f9fee", + "upstreamCommit": "d2e0389b519be398f9bc616b6f7bea8a7edfbc6a", + "corpora": { + "express": { + "repository": "expressjs/express", + "commit": "1c6f1b0fe4000977b9a7b4f34097e4d527dd9824" + }, + "gin": { + "repository": "gin-gonic/gin", + "commit": "0f09c3a9b4626d9fe9979cf4d0521d6ae32ab646" + }, + "tokio": { + "repository": "tokio-rs/tokio", + "commit": "b499257ef62bd631b83a988d371f4330f545670c" + }, + "django": { + "repository": "django/django", + "commit": "a05e16a7230fe33d3f43f4a3aaed103cebb42efc" + } + }, + "engineVersion": 4, + "formatVersion": 2, + "build": { + "rustc": "rustc 1.94.1 (e408947bf 2026-03-25)", + "profile": "release", + "threads": 2, + "memoryMiB": 2048, + "beforeBinarySha256": "3a4b08edcd2e447f4af77416ece3d288351c316f3175b0460e3aea193eb2f3b0", + "afterBinarySha256": "07eca1a63e38f65df51334cdfd4ebeeedce0a07a8bc545c50105adc946ffc8b1" + }, + "definitions": { + "strictKey": [ + "sourceStableId", + "targetStableId", + "kind", + "line", + "column" + ], + "strictPrecision": "|C intersect O| / |C|", + "strictRecall": "|C intersect O| / |O|", + "callSiteKey": [ + "sourceStableId", + "kind=calls", + "line", + "column" + ], + "supportedCallSet": "E = cgr call edges whose callSiteKey occurs in an upstream call edge", + "supportedCallPrecision": "|C_calls intersect O_calls| / |E|", + "supportedCallRecall": "|C_calls intersect O_calls| / |O_calls|; unchanged full upstream call denominator", + "additionalUnlabeledEdges": "|C_calls minus E|; neither successes nor errors without semantic review", + "nullLocations": "preserved as NULL, distinct from zero", + "deduplication": "unique complete edge keys", + "macroAverage": "arithmetic mean over the four repositories; micro counts use repository-prefixed keys", + "upstreamIsSemanticGroundTruth": false, + "allEdgesRetainedInStrictMetric": true, + "newMetricChangeIsAnAlgorithmicGain": false + }, + "aggregates": { + "before": { + "strict": { + "cgr": 235299, + "oracle": 244194, + "intersection": 217395, + "precision": 0.9239095788762384, + "recall": 0.8902552888277353, + "macroPrecision": 0.8340554340930687, + "macroRecall": 0.8947888469163985 + }, + "oracleSupportedCalls": { + "cgr": 60100, + "oracle": 77518, + "intersection": 58466, + "precision": 0.9728119800332778, + "recall": 0.7542248252018886, + "macroPrecision": 0.9804811405513064, + "macroRecall": 0.7968708679133604 + } + }, + "after": { + "strict": { + "cgr": 235866, + "oracle": 244194, + "intersection": 218272, + "precision": 0.925406798775576, + "recall": 0.8938466956600081, + "macroPrecision": 0.8350463442494904, + "macroRecall": 0.8985090880774276 + }, + "oracleSupportedCalls": { + "cgr": 60673, + "oracle": 77518, + "intersection": 59181, + "precision": 0.975409160582137, + "recall": 0.763448489383111, + "macroPrecision": 0.981334922064601, + "macroRecall": 0.8062685931266466 + } + } + }, + "sharedEdgeChanges": { + "addedShared": 980, + "removedShared": 103, + "netShared": 877 + }, + "projects": [ + { + "repo": "express", + "sourceDigest": "c39abc479d71163b943ac64b92be04fe71520805fc8e0ffe6948d61d11e61603", + "files": 142, + "changes": { + "added": 12, + "removed": 12, + "addedShared": 0, + "removedShared": 1 + }, + "before": { + "strict": { + "cgr": 3499, + "oracle": 2334, + "intersection": 2063, + "cgrOnly": 1436, + "oracleOnly": 271, + "precision": 0.5895970277222063, + "recall": 0.8838903170522708, + "f1": 0.707354705983199, + "jaccard": 0.5472148541114058 + }, + "oracleSupportedCalls": { + "cgr": 1105, + "oracle": 1280, + "intersection": 1097, + "cgrOnly": 8, + "oracleOnly": 183, + "precision": 0.9927601809954751, + "recall": 0.85703125, + "f1": 0.9199161425576521, + "jaccard": 0.8517080745341615, + "allCgrCalls": 2227, + "additionalUnlabeledEdges": 1122 + }, + "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 + } + } + }, + "after": { + "strict": { + "cgr": 3499, + "oracle": 2334, + "intersection": 2062, + "cgrOnly": 1437, + "oracleOnly": 272, + "precision": 0.5893112317805087, + "recall": 0.8834618680377035, + "f1": 0.7070118292473856, + "jaccard": 0.5468045611243701 + }, + "oracleSupportedCalls": { + "cgr": 1105, + "oracle": 1280, + "intersection": 1097, + "cgrOnly": 8, + "oracleOnly": 183, + "precision": 0.9927601809954751, + "recall": 0.85703125, + "f1": 0.9199161425576521, + "jaccard": 0.8517080745341615, + "allCgrCalls": 2227, + "additionalUnlabeledEdges": 1122 + }, + "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": 75, + "cgrOnly": 39, + "oracleOnly": 17, + "precision": 0.6578947368421053, + "recall": 0.8152173913043478, + "f1": 0.7281553398058253, + "jaccard": 0.5725190839694656 + } + } + } + }, + { + "repo": "gin", + "sourceDigest": "62fea02b516804db33f5a7ed817a55b306d40d485847dcaeef87987ad8566b09", + "files": 99, + "changes": { + "added": 0, + "removed": 3, + "addedShared": 0, + "removedShared": 0 + }, + "before": { + "strict": { + "cgr": 8216, + "oracle": 8073, + "intersection": 7678, + "cgrOnly": 538, + "oracleOnly": 395, + "precision": 0.9345180136319376, + "recall": 0.9510714728106032, + "f1": 0.9427220823868868, + "jaccard": 0.8916502148414819 + }, + "oracleSupportedCalls": { + "cgr": 3487, + "oracle": 3807, + "intersection": 3482, + "cgrOnly": 5, + "oracleOnly": 325, + "precision": 0.998566102667049, + "recall": 0.9146309429997374, + "f1": 0.9547573347957226, + "jaccard": 0.9134312696747114, + "allCgrCalls": 3494, + "additionalUnlabeledEdges": 7 + }, + "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 + } + } + }, + "after": { + "strict": { + "cgr": 8213, + "oracle": 8073, + "intersection": 7678, + "cgrOnly": 535, + "oracleOnly": 395, + "precision": 0.934859369292585, + "recall": 0.9510714728106032, + "f1": 0.9428957386712513, + "jaccard": 0.8919609665427509 + }, + "oracleSupportedCalls": { + "cgr": 3487, + "oracle": 3807, + "intersection": 3482, + "cgrOnly": 5, + "oracleOnly": 325, + "precision": 0.998566102667049, + "recall": 0.9146309429997374, + "f1": 0.9547573347957226, + "jaccard": 0.9134312696747114, + "allCgrCalls": 3491, + "additionalUnlabeledEdges": 4 + }, + "byKind": { + "calls": { + "cgr": 3491, + "oracle": 3807, + "intersection": 3482, + "cgrOnly": 9, + "oracleOnly": 325, + "precision": 0.9974219421369235, + "recall": 0.9146309429997374, + "f1": 0.9542340367223897, + "jaccard": 0.9124737945492662 + }, + "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 + } + } + } + }, + { + "repo": "tokio", + "sourceDigest": "714f5d8b2c0dc196ff30e98fbeba0bc5efc48caf695cfeb3f4d1360296f2f30b", + "files": 814, + "changes": { + "added": 779, + "removed": 268, + "addedShared": 588, + "removedShared": 50 + }, + "before": { + "strict": { + "cgr": 38603, + "oracle": 39682, + "intersection": 33638, + "cgrOnly": 4965, + "oracleOnly": 6044, + "precision": 0.8713830531305857, + "recall": 0.8476891285721486, + "f1": 0.8593728044963914, + "jaccard": 0.7534212825049835 + }, + "oracleSupportedCalls": { + "cgr": 10516, + "oracle": 15605, + "intersection": 10058, + "cgrOnly": 458, + "oracleOnly": 5547, + "precision": 0.9564473183720046, + "recall": 0.6445370073694329, + "f1": 0.7701083419470924, + "jaccard": 0.6261594969806388, + "allCgrCalls": 11010, + "additionalUnlabeledEdges": 494 + }, + "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 + } + } + }, + "after": { + "strict": { + "cgr": 39114, + "oracle": 39682, + "intersection": 34176, + "cgrOnly": 4938, + "oracleOnly": 5506, + "precision": 0.8737536431968094, + "recall": 0.8612469129580163, + "f1": 0.8674552007716128, + "jaccard": 0.7659345584939489 + }, + "oracleSupportedCalls": { + "cgr": 11083, + "oracle": 15605, + "intersection": 10596, + "cgrOnly": 487, + "oracleOnly": 5009, + "precision": 0.9560588288369575, + "recall": 0.6790131368151233, + "f1": 0.7940647482014388, + "jaccard": 0.6584638329604773, + "allCgrCalls": 11545, + "additionalUnlabeledEdges": 462 + }, + "byKind": { + "calls": { + "cgr": 11545, + "oracle": 15605, + "intersection": 10596, + "cgrOnly": 949, + "oracleOnly": 5009, + "precision": 0.9177999133824166, + "recall": 0.6790131368151233, + "f1": 0.7805524861878453, + "jaccard": 0.6400869880391447 + }, + "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": 943, + "oracle": 818, + "intersection": 774, + "cgrOnly": 169, + "oracleOnly": 44, + "precision": 0.8207847295864263, + "recall": 0.9462102689486552, + "f1": 0.8790459965928449, + "jaccard": 0.78419452887538 + }, + "references": { + "cgr": 6110, + "oracle": 3746, + "intersection": 3539, + "cgrOnly": 2571, + "oracleOnly": 207, + "precision": 0.579214402618658, + "recall": 0.9447410571276028, + "f1": 0.7181412337662338, + "jaccard": 0.5602342884280513 + } + } + } + }, + { + "repo": "django", + "sourceDigest": "3d77c24c790cfce7a0ebd2b6b8adc0ac91fb6f7df15daf98bba248334ad915ff", + "files": 2984, + "changes": { + "added": 557, + "removed": 498, + "addedShared": 392, + "removedShared": 52 + }, + "before": { + "strict": { + "cgr": 184981, + "oracle": 194105, + "intersection": 174016, + "cgrOnly": 10965, + "oracleOnly": 20089, + "precision": 0.9407236418875452, + "recall": 0.896504469230571, + "f1": 0.918081912811341, + "jaccard": 0.8485687813917199 + }, + "oracleSupportedCalls": { + "cgr": 44992, + "oracle": 56826, + "intersection": 43829, + "cgrOnly": 1163, + "oracleOnly": 12997, + "precision": 0.974150960170697, + "recall": 0.7712842712842712, + "f1": 0.8609283230862912, + "jaccard": 0.7558157581610305, + "allCgrCalls": 48105, + "additionalUnlabeledEdges": 3113 + }, + "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 + } + } + }, + "after": { + "strict": { + "cgr": 185040, + "oracle": 194105, + "intersection": 174356, + "cgrOnly": 10684, + "oracleOnly": 19749, + "precision": 0.9422611327280588, + "recall": 0.8982560985033874, + "f1": 0.9197325561460655, + "jaccard": 0.8513933853869105 + }, + "oracleSupportedCalls": { + "cgr": 44998, + "oracle": 56826, + "intersection": 44006, + "cgrOnly": 992, + "oracleOnly": 12820, + "precision": 0.9779545757589226, + "recall": 0.7743990426917257, + "f1": 0.8643541797611565, + "jaccard": 0.761112456328479, + "allCgrCalls": 48128, + "additionalUnlabeledEdges": 3130 + }, + "byKind": { + "calls": { + "cgr": 48128, + "oracle": 56826, + "intersection": 44006, + "cgrOnly": 4122, + "oracleOnly": 12820, + "precision": 0.9143533909574468, + "recall": 0.7743990426917257, + "f1": 0.8385769003563465, + "jaccard": 0.7220253330708145 + }, + "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": 16794, + "oracle": 12899, + "intersection": 11550, + "cgrOnly": 5244, + "oracleOnly": 1349, + "precision": 0.6877456234369418, + "recall": 0.8954182494767036, + "f1": 0.7779611356211903, + "jaccard": 0.6366091605577909 + } + } + } + } + ], + "validation": { + "focusedBefore": { + "passed": 59, + "total": 80, + "positivePassed": 30, + "positiveTotal": 46, + "negativePassed": 28, + "negativeTotal": 33, + "otherChecks": 1 + }, + "focusedAfter": { + "passed": 80, + "total": 80, + "positivePassed": 46, + "positiveTotal": 46, + "negativePassed": 33, + "negativeTotal": 33, + "otherChecks": 1 + }, + "focusedResults": [ + { + "case": "js_member_not_free", + "source": "render", + "target": "format", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "js_member_not_free", + "source": "direct", + "target": "format", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "js_assigned_member", + "source": "invoke", + "target": "render", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "js_known_receiver", + "source": "A::run", + "target": "B::other", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "py_known_receiver", + "source": "A::run", + "target": "B::other", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "rs_reexport_macro", + "source": "main", + "target": "Worker::create", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_reexport_macro", + "source": "main", + "target": "Worker::run", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_library_root", + "source": "main", + "target": "helper", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_return_chain", + "source": "entry", + "target": "Runner::run", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_custom_library", + "source": "main", + "target": "Runner::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "js_cjs_reexports", + "source": "entry", + "target": "make", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "js_cjs_reexports", + "source": "entry", + "target": "handler", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "js_cjs_object", + "source": "entry", + "target": "internal", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "js_namespace_not_callable", + "source": "entry", + "target": "make", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "js_routes_comments", + "routes": [ + "GET /real" + ], + "pass": true + }, + { + "case": "rs_std_result", + "source": "good", + "target": "Runner::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_std_result", + "source": "bad", + "target": "Runner::execute", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "rs_custom_result", + "source": "entry", + "target": "Other::other", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_custom_result", + "source": "entry", + "target": "Runner::execute", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "js_member_alias", + "source": "right", + "target": "internal", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "js_member_alias", + "source": "wrong", + "target": "internal", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "js_private_export", + "source": "viaMember", + "target": "hidden", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "js_private_export", + "source": "viaName", + "target": "hidden", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "js_private_export", + "source": "good", + "target": "publicFn", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_qualified_return", + "source": "entry", + "target": "Worker::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_try_result", + "source": "entry", + "target": "Runner::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_nested_macro", + "source": "main", + "target": "Worker::create", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_nested_macro", + "source": "main", + "target": "Worker::run", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "py_django_manager", + "source": "entry", + "target": "Model::save", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "js_foreign_annotation", + "source": "entry", + "target": "Local::execute", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "rs_module_value_namespaces", + "source": "entry", + "target": "once", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_opaque_macro", + "source": "main", + "target": "Worker::create", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "rs_opaque_macro", + "source": "main", + "target": "Worker::run", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "js_static_subscript", + "source": "entry", + "target": "internal", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "js_dynamic_subscript", + "source": "entry", + "target": "internal", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "js_cjs_default_property", + "source": "bad", + "target": "make", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "js_cjs_default_property", + "source": "good", + "target": "make", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "js_cjs_default_import", + "source": "entry", + "target": "make", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "js_cjs_object_import", + "source": "bad", + "target": "make", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "js_cjs_object_import", + "source": "good", + "target": "make", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_external_initializer", + "source": "wrong", + "target": "Local::execute", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "go_external_initializer", + "source": "wrong", + "target": "Local::Type", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "rs_duplicate_type_members", + "source": "wrong", + "target": "Worker::stop", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "rs_duplicate_type_members", + "source": "right", + "target": "Worker::stop", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_lifetime_return", + "source": "entry", + "target": "Worker::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_lifetime_return", + "source": "entry", + "target": "Noise::execute", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "rs_result_direct_chain", + "source": "wrong", + "target": "Worker::execute", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "rs_result_direct_chain", + "source": "right", + "target": "Worker::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "py_factory_return", + "source": "entry", + "target": "Worker::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "py_factory_return", + "source": "entry", + "target": "Noise::execute", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "py_nested_factory_scope", + "source": "first", + "target": "Worker::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "py_nested_factory_scope", + "source": "second", + "target": "Noise::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "py_nested_factory_scope", + "source": "second", + "target": "Worker::execute", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "py_mixed_factory_return", + "source": "wrong", + "target": "Worker::execute", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "py_mixed_factory_return", + "source": "wrong", + "target": "Noise::execute", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "py_factory_field", + "source": "Owner::run", + "target": "Worker::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "py_factory_field", + "source": "Owner::run", + "target": "Noise::execute", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "py_return_annotation", + "source": "entry", + "target": "Worker::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_pointer_receivers", + "source": "annotation", + "target": "Worker::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_pointer_receivers", + "source": "boxed", + "target": "Worker::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_pointer_receivers", + "source": "allocated", + "target": "Worker::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_pointer_receivers", + "source": "copied", + "target": "Worker::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_pointer_receivers", + "source": "direct", + "target": "Worker::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_pointer_receivers", + "source": "wrong", + "target": "Worker::clone", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "rs_pointer_alias", + "source": "entry", + "target": "Worker::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_custom_pointer", + "source": "entry", + "target": "Noise::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_custom_pointer", + "source": "entry", + "target": "Worker::execute", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "rs_try_direct_chain", + "source": "entry", + "target": "Worker::execute", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "js_nested_helpers", + "source": "first", + "target": "first::helper", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "js_nested_helpers", + "source": "second", + "target": "second::helper", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "js_nested_helpers", + "source": "second", + "target": "first::helper", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "rs_nested_helpers", + "source": "first", + "target": "first::helper", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_nested_helpers", + "source": "second", + "target": "second::helper", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_nested_helpers", + "source": "second", + "target": "first::helper", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "py_union_annotation", + "source": "wrong", + "target": "Worker::execute", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "py_union_annotation", + "source": "wrong", + "target": "Noise::execute", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "py_generator_factory", + "source": "wrong", + "target": "Worker::execute", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "rs_pointer_field_not_erased", + "source": "Owner::wrong", + "target": "Worker::clone", + "expected": false, + "actual": false, + "pass": true + }, + { + "case": "rs_imported_impl_owner", + "source": "entry", + "target": "Worker::new", + "expected": true, + "actual": true, + "pass": true + }, + { + "case": "rs_imported_impl_owner", + "source": "entry", + "target": "Worker::execute", + "expected": true, + "actual": true, + "pass": true + } + ], + "workspacePassed": 137, + "workspaceIgnored": 1, + "randomEditSequences": 6, + "randomEditsPerSequence": 100, + "independentSql": [ + { + "repo": "express", + "strictSharedSql": 2062, + "supportedCallEdgesSql": 1105, + "sharedCallEdgesSql": 1097, + "sourceDigest": "c39abc479d71163b943ac64b92be04fe71520805fc8e0ffe6948d61d11e61603", + "sourceBytesRestored": true, + "timedOutFiles": 0, + "nonRouteNodeIdentity": { + "cgr": 866, + "oracle": 866, + "intersection": 866, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + } + }, + { + "repo": "gin", + "strictSharedSql": 7678, + "supportedCallEdgesSql": 3487, + "sharedCallEdgesSql": 3482, + "sourceDigest": "62fea02b516804db33f5a7ed817a55b306d40d485847dcaeef87987ad8566b09", + "sourceBytesRestored": true, + "timedOutFiles": 0, + "nonRouteNodeIdentity": { + "cgr": 2436, + "oracle": 2436, + "intersection": 2436, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + } + }, + { + "repo": "tokio", + "strictSharedSql": 34176, + "supportedCallEdgesSql": 11083, + "sharedCallEdgesSql": 10596, + "sourceDigest": "714f5d8b2c0dc196ff30e98fbeba0bc5efc48caf695cfeb3f4d1360296f2f30b", + "sourceBytesRestored": true, + "timedOutFiles": 0, + "nonRouteNodeIdentity": { + "cgr": 14460, + "oracle": 14460, + "intersection": 14460, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + } + }, + { + "repo": "django", + "strictSharedSql": 174356, + "supportedCallEdgesSql": 44998, + "sharedCallEdgesSql": 44006, + "sourceDigest": "3d77c24c790cfce7a0ebd2b6b8adc0ac91fb6f7df15daf98bba248334ad915ff", + "sourceBytesRestored": true, + "timedOutFiles": 0, + "nonRouteNodeIdentity": { + "cgr": 61915, + "oracle": 61915, + "intersection": 61915, + "cgrOnly": 0, + "oracleOnly": 0, + "precision": 1.0, + "recall": 1.0, + "f1": 1.0, + "jaccard": 1.0 + } + } + ], + "realRepositoryChecks": 24, + "changedReturnConsumerChecks": 12, + "changedReturnReResolvedFiles": 2, + "changedReturnProjectFiles": 63, + "engine3UpgradeMatchesFull": true, + "repeatedTokioWorkerCounts": [ + 1, + 2, + 4 + ], + "supplementaryDeadlineChecks": 2, + "clippy": "Rust 1.99, all targets except vendored kernel, -D warnings, passed", + "format": "CI package list passed", + "cliMcpSmoke": "passed", + "newPerformanceClaim": false, + "proofScriptsAndFixturesCommitted": false + }, + "strictDesignGate": { + "minimumPrecision": 0.97, + "minimumRecall": 0.95, + "passed": false, + "failingRepositories": [ + "express", + "gin", + "tokio", + "django" + ] + } +}