From 31f355f2196e6ad356b7be36ff35bc5963b21f92 Mon Sep 17 00:00:00 2001 From: sunerpy Date: Thu, 20 Aug 2026 13:05:28 +0800 Subject: [PATCH] feat(extract): model unions, unit structs and COM interfaces as containers MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three declarations that a reader treats as types were invisible or mis-shaped, so the graph disagreed with the source. A union was not a kind at all. A bare `union U { ... }` produced no node, while `typedef union { ... } A;` was recorded as a type alias — and a C++ union's member method, having no container to belong to, degraded into a free function whose callers were then absorbed by a same-named struct method. That last part is a false edge, not a gap: a call on the union bound to the wrong type entirely. `union` is now a first-class kind for C, C++, ObjC and Rust, appended to NodeKind so every other variant's discriminant — and therefore every existing node id — stays put. TypeScript's `A | B` remains a type alias, as upstream has it. A Rust unit struct was dropped before its node was minted, taking its `impl Trait for Unit` edge with it, which concentrated the loss in exactly the marker and test-double layers. Bodiless structs are now definitions where the language says they are, opt-in per language rather than globally. Function-local structs stay unindexed, unchanged and deliberate. The MSVC COM `interface` keyword parsed as a function, losing the container, its members' method kind, and its base-class reference. It is now rewritten to `struct` before parsing, behind a lexical mask: comments, character, string and raw-string literals, and whole preprocessor logical lines are excluded, as is `interface class`. A naive keyword match corrupts real code — it rewrites inside a block comment, where a complete declaration becomes the next node's docstring, and it turns C++/CLI `interface class` into invalid syntax. EXTRACTION_VERSION 6 -> 7. The cpp golden is regenerated for seven new fixtures and a rust corpus is added; the other fourteen are byte-identical, with every pre-existing row compared across nodes, edges, refs and files. On this repo the change adds 53 struct nodes and their 53 implements edges and removes nothing. --- AGENTS.md | 20 +- .../fixtures/cpp/com_interface.hpp | 20 + .../fixtures/cpp/instantiate_agg.cpp | 4 + .../fixtures/cpp/instantiate_rank.cpp | 5 + .../fixtures/cpp/neg_interface.hpp | 11 + .../codegraph-bench/fixtures/cpp/union_agg.c | 9 + .../fixtures/cpp/union_agg.cpp | 10 + .../codegraph-bench/fixtures/cpp/union_agg.mm | 2 + .../codegraph-bench/fixtures/rust/consumer.rs | 9 + crates/codegraph-bench/fixtures/rust/lib.rs | 54 ++ crates/codegraph-bench/tests/equivalence.rs | 26 + crates/codegraph-core/src/types.rs | 11 +- crates/codegraph-extract/src/lang/c.rs | 6 + crates/codegraph-extract/src/lang/cpp.rs | 350 ++++++- crates/codegraph-extract/src/lang/objc.rs | 7 + crates/codegraph-extract/src/lang/rust.rs | 6 + crates/codegraph-extract/src/spec.rs | 19 + crates/codegraph-extract/src/walker.rs | 398 +++++++- crates/codegraph-graph/src/graph/mod.rs | 3 +- crates/codegraph-graph/src/query/scoring.rs | 1 + crates/codegraph-mcp/src/engine.rs | 5 +- crates/codegraph-resolve/src/context.rs | 3 +- .../codegraph-resolve/src/import_resolver.rs | 2 + crates/codegraph-resolve/src/name_matcher.rs | 11 +- crates/codegraph-resolve/src/resolver.rs | 7 +- .../codegraph-resolve/src/snapshot_context.rs | 3 +- crates/codegraph-resolve/src/types.rs | 16 +- .../tier3/instantiate_agg/instantiate_agg.cpp | 4 + .../instantiate_rank/instantiate_rank.cpp | 5 + .../fixtures/tier3/union_method/union_agg.cpp | 10 + .../tests/tier3_union_edges.rs | 277 ++++++ crates/codegraph-store/src/index_state.rs | 2 +- crates/codegraph-store/src/queries.rs | 19 + crates/codegraph-store/tests/index_state.rs | 2 +- docs/equivalence.md | 118 ++- reference/golden/cpp/colby.db | Bin 176128 -> 217088 bytes reference/golden/cpp/edges.json | 360 +++++++ reference/golden/cpp/files.json | 56 ++ reference/golden/cpp/nodes.json | 878 +++++++++++++++++- reference/golden/cpp/refs.json | 20 + reference/golden/rust/colby.db | Bin 0 -> 151552 bytes reference/golden/rust/edges.json | 275 ++++++ reference/golden/rust/files.json | 18 + reference/golden/rust/nodes.json | 398 ++++++++ reference/golden/rust/refs.json | 32 + reference/golden/rust/schema.sql | 117 +++ 46 files changed, 3561 insertions(+), 48 deletions(-) create mode 100644 crates/codegraph-bench/fixtures/cpp/com_interface.hpp create mode 100644 crates/codegraph-bench/fixtures/cpp/instantiate_agg.cpp create mode 100644 crates/codegraph-bench/fixtures/cpp/instantiate_rank.cpp create mode 100644 crates/codegraph-bench/fixtures/cpp/neg_interface.hpp create mode 100644 crates/codegraph-bench/fixtures/cpp/union_agg.c create mode 100644 crates/codegraph-bench/fixtures/cpp/union_agg.cpp create mode 100644 crates/codegraph-bench/fixtures/cpp/union_agg.mm create mode 100644 crates/codegraph-bench/fixtures/rust/consumer.rs create mode 100644 crates/codegraph-bench/fixtures/rust/lib.rs create mode 100644 crates/codegraph-resolve/tests/fixtures/tier3/instantiate_agg/instantiate_agg.cpp create mode 100644 crates/codegraph-resolve/tests/fixtures/tier3/instantiate_rank/instantiate_rank.cpp create mode 100644 crates/codegraph-resolve/tests/fixtures/tier3/union_method/union_agg.cpp create mode 100644 crates/codegraph-resolve/tests/tier3_union_edges.rs create mode 100644 reference/golden/rust/colby.db create mode 100644 reference/golden/rust/edges.json create mode 100644 reference/golden/rust/files.json create mode 100644 reference/golden/rust/nodes.json create mode 100644 reference/golden/rust/refs.json create mode 100644 reference/golden/rust/schema.sql diff --git a/AGENTS.md b/AGENTS.md index 06824a3b..dc4e6adc 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -29,12 +29,22 @@ Protocol) stdio server. No AI / vector / LLM anywhere in the binary — output i `reference/golden/cpp/` (corpus `crates/codegraph-bench/fixtures/cpp/`; guards #1043 C++ class/struct inheritance incl. templated-base stripping byte-for-byte, and retroactively - the earlier C++ extraction work). + the earlier C++ extraction work; grown to 17 files by Tier 3 with the MSVC COM + `interface` positives + five guard negatives (#1519) and the C / C++ / ObjC + `union` fixtures incl. both `typedef union` re-kinds and both instantiation + paths (PR #1516) — it is the C-FAMILY corpus, not a strictly-C++ one, since it + holds `.c` and `.mm` files too), and `reference/golden/rust/` + (corpus `crates/codegraph-bench/fixtures/rust/`; the repo's only Rust corpus, + guards #1513/PR #1514 unit structs — 3 `struct` nodes and 4 `implements` edges, + where the unit struct produced NO node before — plus the Rust half of PR #1516's + first-class `union` kind, byte-for-byte; it deliberately claims NO `instantiates` + edge, because that edge fires only for the call-expression construction form and + a Rust union is constructible only as `U { … }`). The Python cross-file edge is resolved by Gate 3a's unique-name fallback; import Gate 3b is deliberately unreachable for real Python nodes because the extractor does not mark them exported. Regen recipe: `docs/equivalence.md` "Godot fixture" / "Ruby fixture" / "Python fixture" / "Kotlin fixture" / - "TypeScript resolution fixture" / "C++ fixture" sections. + "TypeScript resolution fixture" / "C++ fixture" / "Rust fixture" sections. - **node-id formula**: `{kind}:{sha256("{filePath}:{kind}:{name}:{line}").hex[:32]}`; file nodes are the literal `file:{relpath}`; lines are 1-based; paths relative with `/`. - **No AI / vector / LLM crates** — enforced by `scripts/guardrail.sh` (CI gate): @@ -45,7 +55,11 @@ Protocol) stdio server. No AI / vector / LLM anywhere in the binary — output i `codegraph-core` (types/config/logger) · `codegraph-store` (SQLite+FTS5) · `codegraph-extract` (tree-sitter walker + embedded + custom extractors; incl. C++ `base_class_clause` → `Extends` -inheritance extraction with templated-base stripping, #1043) · `codegraph-graph` (traversal + FTS search) · +inheritance extraction with templated-base stripping, #1043; a shared `extract_aggregate` behind +`extract_struct`/`extract_union` so the `union` kind — C/C++/ObjC `union_specifier`, Rust +`union_item`, PR #1516 — inherits struct behaviour by construction, plus the opt-in +`allow_bodiless_struct()` that makes a Rust `struct Unit;` a definition rather than a forward +declaration, #1513) · `codegraph-graph` (traversal + FTS search) · `codegraph-resolve` (import + name matcher + FrameworkResolver; concrete `GodotResolver` impl — autoload-call + signal-handler resolution) · `codegraph-mcp` (stdio JSON-RPC; `codegraph_explore` runs a change-surface rescue, #1064, that surfaces a callable's buried parameter/return-type files into the explored subgraph; every source-emitting diff --git a/crates/codegraph-bench/fixtures/cpp/com_interface.hpp b/crates/codegraph-bench/fixtures/cpp/com_interface.hpp new file mode 100644 index 00000000..fde44ddb --- /dev/null +++ b/crates/codegraph-bench/fixtures/cpp/com_interface.hpp @@ -0,0 +1,20 @@ +struct SControl : IBase { + virtual void Ping() = 0; + void Run() { } +}; + +interface IWidget : IBase { + virtual void Ping() = 0; + void Run() { } +}; + +interface IPlain { + virtual void Ping() = 0; +}; + +interface INewlineBrace +{ + virtual void Ping() = 0; +}; + +int interface_count = 0; diff --git a/crates/codegraph-bench/fixtures/cpp/instantiate_agg.cpp b/crates/codegraph-bench/fixtures/cpp/instantiate_agg.cpp new file mode 100644 index 00000000..78ad77d7 --- /dev/null +++ b/crates/codegraph-bench/fixtures/cpp/instantiate_agg.cpp @@ -0,0 +1,4 @@ +union Reg { int raw; float val; }; +struct Ctl { int id; }; +void mk_union() { Reg r = Reg(); (void)r; } +void mk_struct() { Ctl c = Ctl(); (void)c; } diff --git a/crates/codegraph-bench/fixtures/cpp/instantiate_rank.cpp b/crates/codegraph-bench/fixtures/cpp/instantiate_rank.cpp new file mode 100644 index 00000000..bc8fdc46 --- /dev/null +++ b/crates/codegraph-bench/fixtures/cpp/instantiate_rank.cpp @@ -0,0 +1,5 @@ +union Value { int i; float f; }; +struct Packet { int id; }; +void Value() { } +void ctor_union() { Value v{1}; (void)v; } +void ctor_struct() { Packet p{2}; (void)p; } diff --git a/crates/codegraph-bench/fixtures/cpp/neg_interface.hpp b/crates/codegraph-bench/fixtures/cpp/neg_interface.hpp new file mode 100644 index 00000000..e417cb8d --- /dev/null +++ b/crates/codegraph-bench/fixtures/cpp/neg_interface.hpp @@ -0,0 +1,11 @@ +/* + interface INegComment; +*/ +interface class INegCli { public: virtual void B()=0; }; +interface struct INegStructKw { int x; }; +const char* idl = R"( +interface INegGhost { virtual void B() = 0; }; +)"; +#define NEG_DECL \ + interface INegMacro +struct NegReal { int x; }; diff --git a/crates/codegraph-bench/fixtures/cpp/union_agg.c b/crates/codegraph-bench/fixtures/cpp/union_agg.c new file mode 100644 index 00000000..8f5e405f --- /dev/null +++ b/crates/codegraph-bench/fixtures/cpp/union_agg.c @@ -0,0 +1,9 @@ +union Named { int i; float f; }; +struct Ctl { int x; }; +typedef union { int a; float b; } AnonU; +typedef struct { int a; int b; } AnonS; +typedef union NamedTag { int c; } NamedU; +union Fwd; +struct FwdS; +union { int q; } anon_var; +int read_named(union Named *p) { return p->i; } diff --git a/crates/codegraph-bench/fixtures/cpp/union_agg.cpp b/crates/codegraph-bench/fixtures/cpp/union_agg.cpp new file mode 100644 index 00000000..1f6b690e --- /dev/null +++ b/crates/codegraph-bench/fixtures/cpp/union_agg.cpp @@ -0,0 +1,10 @@ +union WithMethod { + int i; float f; + int read_field() { return i; } +}; +struct SWithMethod { + int i; + int read_field() { return i; } +}; +void drive_union() { WithMethod w; w.read_field(); } +void drive_struct() { SWithMethod s; s.read_field(); } diff --git a/crates/codegraph-bench/fixtures/cpp/union_agg.mm b/crates/codegraph-bench/fixtures/cpp/union_agg.mm new file mode 100644 index 00000000..89c5949a --- /dev/null +++ b/crates/codegraph-bench/fixtures/cpp/union_agg.mm @@ -0,0 +1,2 @@ +union ObjcU { int i; float f; }; +struct ObjcS { int i; }; diff --git a/crates/codegraph-bench/fixtures/rust/consumer.rs b/crates/codegraph-bench/fixtures/rust/consumer.rs new file mode 100644 index 00000000..010c3e5a --- /dev/null +++ b/crates/codegraph-bench/fixtures/rust/consumer.rs @@ -0,0 +1,9 @@ +use crate::{Bits, Greet, UnitStruct}; + +pub fn describe_unit(u: &UnitStruct) -> String { + u.greet() +} + +pub fn describe_bits(b: &Bits) -> String { + b.greet() +} diff --git a/crates/codegraph-bench/fixtures/rust/lib.rs b/crates/codegraph-bench/fixtures/rust/lib.rs new file mode 100644 index 00000000..f38cdb38 --- /dev/null +++ b/crates/codegraph-bench/fixtures/rust/lib.rs @@ -0,0 +1,54 @@ +pub trait Greet { + fn greet(&self) -> String; +} + +pub struct UnitStruct; + +pub struct BraceStruct { + pub x: u32, +} + +pub struct TupleStruct(pub u8); + +impl Greet for UnitStruct { + fn greet(&self) -> String { + "unit".to_string() + } +} + +impl Greet for BraceStruct { + fn greet(&self) -> String { + "brace".to_string() + } +} + +impl Greet for TupleStruct { + fn greet(&self) -> String { + "tuple".to_string() + } +} + +pub union Bits { + pub i: u32, + pub f: f32, +} + +impl Bits { + pub fn raw(&self) -> u32 { + unsafe { self.i } + } +} + +impl Greet for Bits { + fn greet(&self) -> String { + "bits".to_string() + } +} + +pub fn make_unit() -> UnitStruct { + UnitStruct +} + +pub fn make_bits() -> Bits { + Bits { i: 0 } +} diff --git a/crates/codegraph-bench/tests/equivalence.rs b/crates/codegraph-bench/tests/equivalence.rs index e42afef0..76296097 100644 --- a/crates/codegraph-bench/tests/equivalence.rs +++ b/crates/codegraph-bench/tests/equivalence.rs @@ -110,6 +110,24 @@ fn cpp_db_is_self_equivalent_to_cpp_golden() { assert_equivalent(&cpp_db(), &cpp_golden_dir()).unwrap(); } +#[test] +fn generated_golden_matches_committed_rust_fixture() { + // Guards item 7 (Rust unit structs are indexed, so `impl Trait for Unit` + // forms) and item 9-Rust (`union` is a first-class kind) against byte-drift. + let tempdir = TestDir::new("generated-golden-rust"); + write_golden(&rust_db(), tempdir.path()).unwrap(); + + let expected = load_golden(&rust_golden_dir()).unwrap(); + let actual = load_golden(tempdir.path()).unwrap(); + + diff_canonical(&expected, &actual, None).unwrap(); +} + +#[test] +fn rust_db_is_self_equivalent_to_rust_golden() { + assert_equivalent(&rust_db(), &rust_golden_dir()).unwrap(); +} + #[test] fn generated_golden_matches_committed_python_fixture() { let tempdir = TestDir::new("generated-golden-python"); @@ -412,6 +430,14 @@ fn cpp_golden_dir() -> PathBuf { workspace_root().join("reference/golden/cpp") } +fn rust_db() -> PathBuf { + workspace_root().join("reference/golden/rust/colby.db") +} + +fn rust_golden_dir() -> PathBuf { + workspace_root().join("reference/golden/rust") +} + fn python_db() -> PathBuf { workspace_root().join("reference/golden/python/colby.db") } diff --git a/crates/codegraph-core/src/types.rs b/crates/codegraph-core/src/types.rs index a03b2546..7d5f6056 100644 --- a/crates/codegraph-core/src/types.rs +++ b/crates/codegraph-core/src/types.rs @@ -6,10 +6,12 @@ use std::fmt; // protocol, function, method, property, field, variable, constant, enum, // enum_member, type_alias, namespace, parameter, import, export, route, // component. +// `union` is APPENDED (upstream PR #1516): appending keeps every other +// variant's discriminant, and therefore every existing node id, stable. // EdgeKind lines 48-60: contains, calls, imports, exports, extends, // implements, references, type_of, returns, instantiates, overrides, // decorates. -pub const NODE_KIND_STRINGS: [&str; 22] = [ +pub const NODE_KIND_STRINGS: [&str; 23] = [ "file", "module", "class", @@ -32,6 +34,7 @@ pub const NODE_KIND_STRINGS: [&str; 22] = [ "export", "route", "component", + "union", ]; pub const EDGE_KIND_STRINGS: [&str; 12] = [ @@ -140,10 +143,12 @@ pub enum NodeKind { Route, #[serde(rename = "component")] Component, + #[serde(rename = "union")] + Union, } impl NodeKind { - pub const ALL: [Self; 22] = [ + pub const ALL: [Self; 23] = [ Self::File, Self::Module, Self::Class, @@ -166,6 +171,7 @@ impl NodeKind { Self::Export, Self::Route, Self::Component, + Self::Union, ]; pub const fn as_str(self) -> &'static str { @@ -192,6 +198,7 @@ impl NodeKind { Self::Export => "export", Self::Route => "route", Self::Component => "component", + Self::Union => "union", } } } diff --git a/crates/codegraph-extract/src/lang/c.rs b/crates/codegraph-extract/src/lang/c.rs index fe40c524..b2852df8 100644 --- a/crates/codegraph-extract/src/lang/c.rs +++ b/crates/codegraph-extract/src/lang/c.rs @@ -36,6 +36,9 @@ impl LanguageSpec for CSpec { fn struct_types(&self) -> &'static [&'static str] { &["struct_specifier"] } + fn union_types(&self) -> &'static [&'static str] { + &["union_specifier"] + } fn enum_types(&self) -> &'static [&'static str] { &["enum_specifier"] } @@ -77,6 +80,9 @@ impl LanguageSpec for CSpec { if child.kind() == "struct_specifier" && child_by_field(child, "body").is_some() { return Some(NodeKind::Struct); } + if child.kind() == "union_specifier" && child_by_field(child, "body").is_some() { + return Some(NodeKind::Union); + } } None } diff --git a/crates/codegraph-extract/src/lang/cpp.rs b/crates/codegraph-extract/src/lang/cpp.rs index 8c8162d5..9815a40d 100644 --- a/crates/codegraph-extract/src/lang/cpp.rs +++ b/crates/codegraph-extract/src/lang/cpp.rs @@ -36,6 +36,9 @@ impl LanguageSpec for CppSpec { fn struct_types(&self) -> &'static [&'static str] { &["struct_specifier"] } + fn union_types(&self) -> &'static [&'static str] { + &["union_specifier"] + } fn enum_types(&self) -> &'static [&'static str] { &["enum_specifier"] } @@ -117,6 +120,9 @@ impl LanguageSpec for CppSpec { if child.kind() == "struct_specifier" && child_by_field(child, "body").is_some() { return Some(NodeKind::Struct); } + if child.kind() == "union_specifier" && child_by_field(child, "body").is_some() { + return Some(NodeKind::Union); + } } None } @@ -143,8 +149,8 @@ impl LanguageSpec for CppSpec { /// on char boundaries, so byte length (and thus line/column) is preserved. Each /// pass is `contains`-gated, so macro-free C++ is returned byte-identical. fn pre_parse_cpp_source(source: &str, file_path: &str) -> String { - let bytes = blank_cpp_annotation_macro_calls(blank_cpp_inline_annotation_macros( - blank_cpp_api_prefix_macros(source.as_bytes().to_vec()), + let bytes = blank_msvc_com_interface_keyword(blank_cpp_annotation_macro_calls( + blank_cpp_inline_annotation_macros(blank_cpp_api_prefix_macros(source.as_bytes().to_vec())), )); let lower = file_path.to_ascii_lowercase(); let bytes = if lower.ends_with(".metal") { @@ -438,6 +444,239 @@ fn blank_cpp_annotation_macro_calls(bytes: Vec) -> Vec { bytes } +/// Rewrite a line-leading MSVC COM `interface` keyword to `struct` + 3 spaces +/// (#1519). `interface` is 9 bytes and `struct` is 6, so the 3 trailing spaces +/// keep the byte length — and therefore every node's line and column — exactly +/// as it was, the same contract every other pass in this file honours. +/// +/// `interface` is not a C++ keyword, so tree-sitter-cpp reads +/// `interface IFoo : IBase { … };` as a `function_definition`: the container +/// becomes a `function`, its members become free `function`s instead of +/// `method`s, and the base clause is lost entirely. A COM `interface` IS +/// `#define`d to `struct`, so rewriting the token recovers all three at once. +/// +/// Declined unless EVERY byte of the token is ordinary code per +/// [`cpp_code_mask`], and declined when the next token is `class`, `struct`, +/// `union` or `enum` — C++/CLI `interface class IFoo` is valid input today and +/// the naive rewrite would emit the INVALID `struct class IFoo`. +/// `contains`-gated, so C++ without the token is returned byte-identical. +fn blank_msvc_com_interface_keyword(bytes: Vec) -> Vec { + const KEYWORD: &[u8] = b"interface"; + let source = match std::str::from_utf8(&bytes) { + Ok(source) => source, + Err(_) => return bytes, + }; + if !source.contains("interface") { + return bytes; + } + let mask = cpp_code_mask(source); + let src = source.as_bytes(); + let mut starts: Vec = Vec::new(); + let mut pos = 0usize; + loop { + let line_end = src[pos..] + .iter() + .position(|&b| b == b'\n') + .map_or(src.len(), |offset| pos + offset); + let mut i = pos; + while i < line_end && matches!(src[i], b' ' | b'\t') { + i += 1; + } + if i + KEYWORD.len() <= line_end && &src[i..i + KEYWORD.len()] == KEYWORD { + let all_code = (i..i + KEYWORD.len()).all(|k| mask[k]); + let mut j = i + KEYWORD.len(); + let mut saw_space = false; + while j < line_end && matches!(src[j], b' ' | b'\t') { + saw_space = true; + j += 1; + } + let ident_start = src + .get(j) + .is_some_and(|b| b.is_ascii_alphabetic() || *b == b'_'); + let mut k = j; + while k < line_end && (src[k].is_ascii_alphanumeric() || src[k] == b'_') { + k += 1; + } + let excluded = matches!(&src[j..k], b"class" | b"struct" | b"union" | b"enum"); + if all_code && saw_space && ident_start && !excluded { + starts.push(i); + } + } + if line_end >= src.len() { + break; + } + pos = line_end + 1; + } + let mut bytes = bytes; + for start in starts { + bytes[start..start + 6].copy_from_slice(b"struct"); + for b in bytes[start + 6..start + KEYWORD.len()].iter_mut() { + *b = b' '; + } + } + bytes +} + +/// Byte mask over `src`: `true` where the byte is ordinary code. One forward +/// scan tracking the five lexical states a textual match could hide in — line +/// comments, block comments, char and string literals, C++ raw strings +/// (`R"delim( … )delim"`, delimiter captured so a custom delimiter still closes +/// correctly), and whole LOGICAL preprocessor lines including backslash +/// continuations. Lexical state is not optional for #1519: a comment can hold a +/// COMPLETE declaration (`/* interface IFoo; */`) that becomes the FOLLOWING +/// node's docstring, so a purely textual match corrupts extraction output even +/// though it never mints a node. +fn cpp_code_mask(src: &str) -> Vec { + let bytes = src.as_bytes(); + let mut mask = vec![true; bytes.len()]; + let mut i = 0usize; + let mut at_line_start = true; + while i < bytes.len() { + let b = bytes[i]; + if b == b'\n' { + at_line_start = true; + i += 1; + continue; + } + if at_line_start { + if matches!(b, b' ' | b'\t' | b'\r') { + i += 1; + continue; + } + at_line_start = false; + if b == b'#' { + i = mask_preprocessor_line(bytes, &mut mask, i); + at_line_start = true; + continue; + } + } + if b == b'/' && bytes.get(i + 1) == Some(&b'/') { + while i < bytes.len() && bytes[i] != b'\n' { + mask[i] = false; + i += 1; + } + continue; + } + if b == b'/' && bytes.get(i + 1) == Some(&b'*') { + mask[i] = false; + mask[i + 1] = false; + i += 2; + while i < bytes.len() { + let closing = bytes[i] == b'*' && bytes.get(i + 1) == Some(&b'/'); + mask[i] = false; + i += 1; + if closing { + mask[i] = false; + i += 1; + break; + } + } + continue; + } + // A raw string is recognised by the `R` immediately before the quote, + // which also covers every encoding prefix (`LR"`, `u8R"`, `uR"`, `UR"`). + if b == b'"' && i > 0 && bytes[i - 1] == b'R' { + i = mask_raw_string(bytes, &mut mask, i); + continue; + } + if b == b'"' || b == b'\'' { + i = mask_quoted_literal(bytes, &mut mask, i, b); + continue; + } + i += 1; + } + mask +} + +/// Mask a whole LOGICAL preprocessor line starting at `start` (the `#`), +/// following every backslash-newline continuation. Returns the index just past +/// the logical line. The continuation matters: `#define D \` + a following +/// ` interface IFoo` line is one directive, and its second physical line is +/// not code. +fn mask_preprocessor_line(bytes: &[u8], mask: &mut [bool], start: usize) -> usize { + let mut i = start; + loop { + while i < bytes.len() && bytes[i] != b'\n' { + mask[i] = false; + i += 1; + } + let mut back = i; + if back > start && bytes[back - 1] == b'\r' { + back -= 1; + } + let continued = back > start && bytes[back - 1] == b'\\'; + if i < bytes.len() { + mask[i] = false; + i += 1; + } + if !continued || i >= bytes.len() { + return i; + } + } +} + +/// Mask `R"delim( … )delim"` from its opening quote. The delimiter is captured +/// so a custom one (`R"xy( … )xy"`) closes on its own terminator instead of the +/// first `)"`. A malformed opener falls back to ordinary string rules. +fn mask_raw_string(bytes: &[u8], mask: &mut [bool], quote: usize) -> usize { + let mut delim_end = quote + 1; + while delim_end < bytes.len() + && bytes[delim_end] != b'(' + && delim_end - (quote + 1) < 16 + && !bytes[delim_end].is_ascii_whitespace() + { + delim_end += 1; + } + if delim_end >= bytes.len() || bytes[delim_end] != b'(' { + return mask_quoted_literal(bytes, mask, quote, b'"'); + } + let mut closer = Vec::with_capacity(delim_end - quote + 1); + closer.push(b')'); + closer.extend_from_slice(&bytes[quote + 1..delim_end]); + closer.push(b'"'); + let mut k = delim_end + 1; + let end = loop { + if k + closer.len() > bytes.len() { + break bytes.len(); + } + if bytes[k..k + closer.len()] == closer[..] { + break k + closer.len(); + } + k += 1; + }; + for m in mask.iter_mut().take(end).skip(quote) { + *m = false; + } + end +} + +/// Mask a `"…"` or `'…'` literal from its opening quote, honouring backslash +/// escapes. An unterminated literal stops at the newline rather than swallowing +/// the rest of the file. +fn mask_quoted_literal(bytes: &[u8], mask: &mut [bool], start: usize, quote: u8) -> usize { + mask[start] = false; + let mut i = start + 1; + while i < bytes.len() { + let c = bytes[i]; + if c == b'\n' { + break; + } + mask[i] = false; + i += 1; + if c == b'\\' { + if i < bytes.len() && bytes[i] != b'\n' { + mask[i] = false; + i += 1; + } + continue; + } + if c == quote { + break; + } + } + i +} + /// Recover the real function name from the macro-definition idiom /// `MACRO_NAME(real_name, typed args…) { body }` (flash-attention's /// `DEFINE_FLASH_FORWARD_KERNEL(flash_fwd_kernel, bool Is_dropout, …) { … }`): @@ -823,6 +1062,113 @@ mod tests { assert_eq!(out, src); } + #[test] + fn msvc_com_interface_rewrite_preserves_byte_offsets() { + // `interface` (9 bytes) -> `struct` (6) + 3 spaces, so every subsequent + // byte offset — and therefore every node's line and column — is exactly + // where it was. A shorter or longer replacement would silently shift the + // whole file's positions. + let src = "interface IWidget : IBase {\n void Run() { }\n};\n"; + let out = pre_parse_cpp_source(src, "com.hpp"); + assert_eq!( + out.len(), + src.len(), + "the rewrite must preserve byte length" + ); + assert_eq!(out, "struct IWidget : IBase {\n void Run() { }\n};\n"); + // The rewritten declaration must land on the same line and column as the + // equivalent struct written by hand. + let control = "struct SControl : IBase {\n void Run() { }\n};\n"; + let control_out = pre_parse_cpp_source(control, "ctl.hpp"); + assert_eq!( + control_out, control, + "the control must be returned unchanged" + ); + assert_eq!( + out.find("IWidget").expect("name present"), + control.find("SControl").expect("control name present"), + "the rewritten name must start at the control's column" + ); + } + + /// Every §3.3.3 shape, as a direct unit test of the pass: 11 that must NOT + /// fire and 4 that must, each also asserting byte length is preserved. This + /// is the ONLY isolated proof of the `class`/`struct`/`union`/`enum` + /// exclusion — the end-to-end `neg_interface.hpp` invariance test cannot see + /// it, because dropping the exclusion emits `struct class INegCli`, which + /// tree-sitter's error recovery happens to extract identically for that + /// file's text (measured). The exclusion is still required: it stops the pass + /// emitting invalid C++ from input that parses correctly today. + #[test] + fn cpp_code_mask_covers_comments_strings_and_preproc() { + let must_not_fire: &[(&str, &str)] = &[ + ( + "block comment", + "/*\ninterface IFoo;\n*/\nstruct R { int x; };\n", + ), + ( + "block cmt full decl", + "/*\ninterface IGhost { virtual void B() = 0; };\n*/\nstruct R { int x; };\n", + ), + ("line comment", "// interface IFoo;\nstruct R { int x; };\n"), + ( + "cpp/cli class", + "interface class IFoo { public: virtual void B()=0; };\n", + ), + ("interface struct", "interface struct IBar { int x; };\n"), + ("__interface", "__interface IFoo { virtual void B()=0; };\n"), + ("raw string", "const char* s = R\"(\ninterface IFoo\n)\";\n"), + ( + "raw string full decl", + "const char* s = R\"(\ninterface IGhost { virtual void B() = 0; };\n)\";\n", + ), + ( + "raw delim", + "const char* s = R\"xy(\ninterface IFoo )\" still inside\n)xy\";\n", + ), + ( + "macro continuation", + "#define DECL \\\n interface IMacro\nstruct R { int x; };\n", + ), + ("interface_ptr", "int interface_ptr = 0;\n"), + ]; + for (label, src) in must_not_fire { + let out = pre_parse_cpp_source(src, "n.hpp"); + assert_eq!(out.len(), src.len(), "{label}: byte length moved"); + assert_eq!(out, *src, "{label}: the substitution must NOT fire"); + } + + let must_fire: &[(&str, &str, &str)] = &[ + ( + "plain", + "interface IWidget : IBase {\n};\n", + "struct IWidget : IBase {\n};\n", + ), + ( + "newline brace", + "interface INewline\n{\n};\n", + "struct INewline\n{\n};\n", + ), + ( + "indented", + " interface IIndent {\n};\n", + " struct IIndent {\n};\n", + ), + ( + // The discriminating case: the masked `#define` directive is left + // alone while the real declaration beneath it IS rewritten. + "define interface", + "#define interface struct\ninterface IDefined {\n};\n", + "#define interface struct\nstruct IDefined {\n};\n", + ), + ]; + for (label, src, want) in must_fire { + let out = pre_parse_cpp_source(src, "p.hpp"); + assert_eq!(out.len(), src.len(), "{label}: byte length moved"); + assert_eq!(out, *want, "{label}: the substitution must fire"); + } + } + #[test] fn blank_cpp_annotation_in_expression_untouched() { let src = "if (CHECK(x)) {}"; diff --git a/crates/codegraph-extract/src/lang/objc.rs b/crates/codegraph-extract/src/lang/objc.rs index dbdef3f7..95f194c9 100644 --- a/crates/codegraph-extract/src/lang/objc.rs +++ b/crates/codegraph-extract/src/lang/objc.rs @@ -45,6 +45,10 @@ impl LanguageSpec for ObjCSpec { &["struct_specifier"] } + fn union_types(&self) -> &'static [&'static str] { + &["union_specifier"] + } + fn enum_types(&self) -> &'static [&'static str] { &["enum_specifier"] } @@ -112,6 +116,9 @@ impl LanguageSpec for ObjCSpec { if child.kind() == "struct_specifier" && child_by_field(child, "body").is_some() { return Some(NodeKind::Struct); } + if child.kind() == "union_specifier" && child_by_field(child, "body").is_some() { + return Some(NodeKind::Union); + } } None } diff --git a/crates/codegraph-extract/src/lang/rust.rs b/crates/codegraph-extract/src/lang/rust.rs index 6d80b11c..461fb237 100644 --- a/crates/codegraph-extract/src/lang/rust.rs +++ b/crates/codegraph-extract/src/lang/rust.rs @@ -30,6 +30,9 @@ impl LanguageSpec for RustSpec { fn struct_types(&self) -> &'static [&'static str] { &["struct_item"] } + fn union_types(&self) -> &'static [&'static str] { + &["union_item"] + } fn enum_types(&self) -> &'static [&'static str] { &["enum_item"] } @@ -51,6 +54,9 @@ impl LanguageSpec for RustSpec { fn interface_kind(&self) -> NodeKind { NodeKind::Trait } + fn allow_bodiless_struct(&self) -> bool { + true + } fn name_field(&self) -> &'static str { "name" } diff --git a/crates/codegraph-extract/src/spec.rs b/crates/codegraph-extract/src/spec.rs index 7a4b6aac..033a62c2 100644 --- a/crates/codegraph-extract/src/spec.rs +++ b/crates/codegraph-extract/src/spec.rs @@ -35,6 +35,15 @@ pub trait LanguageSpec: Sync { fn interface_types(&self) -> &'static [&'static str]; fn struct_types(&self) -> &'static [&'static str]; fn enum_types(&self) -> &'static [&'static str]; + + /// Node types extracted as [`NodeKind::Union`] through the shared aggregate + /// path. Empty by default: only C, C++, ObjC (`union_specifier`) and Rust + /// (`union_item`) have a union declaration. TypeScript's `A | B` is + /// deliberately NOT here — it stays a `type_alias`, as upstream PR #1516 + /// decided. + fn union_types(&self) -> &'static [&'static str] { + &[] + } fn enum_member_types(&self) -> &'static [&'static str]; fn type_alias_types(&self) -> &'static [&'static str]; fn import_types(&self) -> &'static [&'static str]; @@ -91,6 +100,16 @@ pub trait LanguageSpec: Sync { false } + /// A bodiless `struct NAME;` is a COMPLETE definition, not a forward + /// declaration. Opt-in, because the default is the C-shaped rule: in + /// C/C++/ObjC `struct Foo;` really is a forward declaration and must stay + /// unindexed (`c_bodiless_forward_struct_is_skipped`). Rust has no forward + /// declarations, so the unit form is always a definition + /// (upstream #1513/PR #1514). + fn allow_bodiless_struct(&self) -> bool { + false + } + fn get_signature(&self, _node: Node<'_>, _source: &str) -> Option { None } diff --git a/crates/codegraph-extract/src/walker.rs b/crates/codegraph-extract/src/walker.rs index 0c4459bc..7d21d553 100644 --- a/crates/codegraph-extract/src/walker.rs +++ b/crates/codegraph-extract/src/walker.rs @@ -268,6 +268,9 @@ impl<'a, 'tree> TreeSitterWalker<'a, 'tree> { } else if has_type(self.spec.struct_types(), node_type) { self.extract_struct(node); skip_children = true; + } else if has_type(self.spec.union_types(), node_type) { + self.extract_union(node); + skip_children = true; } else if has_type(self.spec.enum_types(), node_type) { self.extract_enum(node); skip_children = true; @@ -2159,12 +2162,31 @@ impl<'a, 'tree> TreeSitterWalker<'a, 'tree> { } fn extract_struct(&mut self, node: SyntaxNode<'tree>) { - let Some(body) = self.resolve_body(node) else { + self.extract_aggregate(node, NodeKind::Struct); + } + + fn extract_union(&mut self, node: SyntaxNode<'tree>) { + self.extract_aggregate(node, NodeKind::Union); + } + + /// Shared struct/union extractor (upstream `6978acc`'s `extractAggregate`). + /// One body, so a union's members, methods, containment and inheritance + /// behave like a struct's BY CONSTRUCTION rather than by parallel + /// maintenance — which is what every downstream `Union`-in-a-kind-set port + /// assumes. + fn extract_aggregate(&mut self, node: SyntaxNode<'tree>, kind: NodeKind) { + // #1093 / #1513 — a bodiless aggregate is a C/C++/ObjC forward + // declaration and stays unindexed, but a Rust `struct Unit;` is a + // complete definition, so the spec decides. The node is minted BEFORE + // the body walk (PR #1514) and the walk is conditional, which is the + // shape `extract_interface` already has. + let body = self.resolve_body(node); + if body.is_none() && !self.spec.allow_bodiless_struct() { return; - }; + } let name = self.extract_name(node); - let struct_node = self.create_node( - NodeKind::Struct, + let aggregate_node = self.create_node( + kind, &name, node, NodeExtra { @@ -2174,13 +2196,15 @@ impl<'a, 'tree> TreeSitterWalker<'a, 'tree> { ..NodeExtra::default() }, ); - let Some(struct_node) = struct_node else { + let Some(aggregate_node) = aggregate_node else { return; }; - self.extract_inheritance(node, &struct_node.id); - self.node_stack.push(struct_node.id); - self.visit_named_children(body); - self.node_stack.pop(); + self.extract_inheritance(node, &aggregate_node.id); + if let Some(body) = body { + self.node_stack.push(aggregate_node.id); + self.visit_named_children(body); + self.node_stack.pop(); + } } fn extract_method(&mut self, node: SyntaxNode<'tree>) { @@ -2239,6 +2263,7 @@ impl<'a, 'tree> TreeSitterWalker<'a, 'tree> { && matches!( n.kind, NodeKind::Struct + | NodeKind::Union | NodeKind::Class | NodeKind::Enum | NodeKind::Trait @@ -2404,6 +2429,7 @@ impl<'a, 'tree> TreeSitterWalker<'a, 'tree> { alias_kind, NodeKind::Class | NodeKind::Struct + | NodeKind::Union | NodeKind::Interface | NodeKind::Trait | NodeKind::Enum @@ -3732,6 +3758,7 @@ impl<'a, 'tree> TreeSitterWalker<'a, 'tree> { node.kind, NodeKind::Class | NodeKind::Struct + | NodeKind::Union | NodeKind::Interface | NodeKind::Trait | NodeKind::Enum @@ -7504,4 +7531,357 @@ g() ->\n\ "an identifier receiver must still emit `s.trim`, got: {java:?}" ); } + + // ---- Tier 3 / item 7 — Rust unit structs (upstream #1513, PR #1514) ---- + + #[test] + fn rust_unit_struct_is_indexed_with_its_impl_edge() { + // A bodiless `struct NAME;` is a COMPLETE definition in Rust, not a + // forward declaration, so it must mint a node and its `impl Trait for` + // must produce an Implements ref exactly as the bodied controls do. + let src = r#" +pub trait Greet { fn greet(&self) -> String; } + +pub struct UnitStruct; +pub struct BraceStruct { pub x: u32 } +pub struct TupleStruct(pub u8); + +impl Greet for UnitStruct { fn greet(&self) -> String { "unit".to_string() } } +impl Greet for BraceStruct { fn greet(&self) -> String { "brace".to_string() } } +impl Greet for TupleStruct { fn greet(&self) -> String { "tuple".to_string() } } +"#; + let (nodes, refs) = run("lib.rs", src, Language::Rust); + assert!( + has_node(&nodes, NodeKind::Struct, "UnitStruct"), + "the unit struct must be indexed" + ); + // Controls: both bodied forms are indexed today and must stay indexed. + assert!(has_node(&nodes, NodeKind::Struct, "BraceStruct")); + assert!(has_node(&nodes, NodeKind::Struct, "TupleStruct")); + let implements = refs + .iter() + .filter(|r| r.reference_kind == EdgeKind::Implements) + .count(); + assert_eq!( + implements, 3, + "each of the three structs must carry an Implements ref, got {implements}" + ); + } + + // ---- Tier 3 / item 8 — MSVC COM `interface` (upstream #1519) ---- + + /// The §7.2 `com_interface.hpp` fixture text, shared by the extraction test + /// and the byte-offset test so both speak about the same bytes. + const COM_INTERFACE_SRC: &str = "\ +struct SControl : IBase { + virtual void Ping() = 0; + void Run() { } +}; + +interface IWidget : IBase { + virtual void Ping() = 0; + void Run() { } +}; + +interface IPlain { + virtual void Ping() = 0; +}; + +interface INewlineBrace +{ + virtual void Ping() = 0; +}; + +int interface_count = 0; +"; + + /// The §7.2 `neg_interface.hpp` fixture text: the five shapes the guard must + /// decline. Written as an escaped literal because a raw string cannot nest + /// the `R"( … )"` it needs to contain. + const NEG_INTERFACE_SRC: &str = concat!( + "/*\n interface INegComment;\n*/\n", + "interface class INegCli { public: virtual void B()=0; };\n", + "interface struct INegStructKw { int x; };\n", + "const char* idl = R\"(\ninterface INegGhost { virtual void B() = 0; };\n)\";\n", + "#define NEG_DECL \\\n interface INegMacro\n", + "struct NegReal { int x; };\n", + ); + + #[test] + fn cpp_msvc_com_interface_extracts_as_struct() { + let (nodes, refs) = run("com_interface.hpp", COM_INTERFACE_SRC, Language::Cpp); + // Loss 1 — the COM interface must be a container, not a function. + for name in ["IWidget", "IPlain", "INewlineBrace"] { + assert!( + has_node(&nodes, NodeKind::Struct, name), + "`interface {name}` must extract as a struct" + ); + } + assert!(has_node(&nodes, NodeKind::Struct, "SControl")); + assert!( + !nodes + .iter() + .any(|n| n.kind == NodeKind::Function && n.file_path == "com_interface.hpp"), + "no node in this file may stay a function: {:?}", + nodes + .iter() + .filter(|n| n.kind == NodeKind::Function) + .map(|n| (n.name.as_str(), n.start_line)) + .collect::>() + ); + // Loss 2 — the member is a method of the interface, not a free function. + let mut runs = nodes + .iter() + .filter(|n| n.kind == NodeKind::Method && n.name == "Run") + .map(|n| n.qualified_name.as_str()) + .collect::>(); + runs.sort_unstable(); + assert_eq!( + runs, + ["IWidget::Run", "SControl::Run"], + "both members must be methods of their own container" + ); + // Loss 3 — the base type is visible. The control emits one today; the + // rewritten interface must emit the second. + let extends_ibase = refs + .iter() + .filter(|r| r.reference_kind == EdgeKind::Extends && r.reference_name == "IBase") + .count(); + assert_eq!( + extends_ibase, 2, + "SControl and IWidget must each emit `extends IBase`, got {extends_ibase}" + ); + } + + // ---- Tier 3 / item 9 — first-class `union` nodes (upstream PR #1516) ---- + + #[test] + fn rust_union_is_indexed_with_its_impl_edge() { + let src = r#" +pub trait Greet { fn greet(&self) -> String; } +pub union Bits { pub i: u32, pub f: f32 } +impl Bits { pub fn raw(&self) -> u32 { unsafe { self.i } } } +impl Greet for Bits { fn greet(&self) -> String { "bits".to_string() } } +"#; + let (nodes, refs) = run("lib.rs", src, Language::Rust); + assert!( + has_node(&nodes, NodeKind::Union, "Bits"), + "a Rust union must be a first-class union node" + ); + assert!( + !has_node(&nodes, NodeKind::Struct, "Bits"), + "a union must not be re-kinded to a struct" + ); + assert!( + has_ref(&refs, EdgeKind::Implements, "Greet"), + "the union's `impl Greet for` must produce an Implements ref" + ); + } + + #[test] + fn c_cpp_objc_union_is_indexed_not_a_struct() { + for (file, src, lang) in [ + ( + "m.c", + "union Named { int i; float f; };\nstruct Ctl { int x; };\n", + Language::C, + ), + ( + "m.cpp", + "union Named { int i; float f; };\nstruct Ctl { int x; };\n", + Language::Cpp, + ), + ( + "m.mm", + "union Named { int i; float f; };\nstruct Ctl { int x; };\n", + Language::ObjC, + ), + ] { + let (nodes, _) = run(file, src, lang); + assert!( + has_node(&nodes, NodeKind::Union, "Named"), + "{file}: `union Named` must be a union node" + ); + assert!( + !has_node(&nodes, NodeKind::Struct, "Named"), + "{file}: the union must not be kinded as a struct" + ); + // Control: the struct beside it is unchanged. + assert!( + has_node(&nodes, NodeKind::Struct, "Ctl"), + "{file}: the struct control must stay a struct" + ); + } + } + + #[test] + fn cpp_union_member_method_belongs_to_the_union() { + // Pre-fix this member leaked to FILE scope as `function:read_field` with + // no container, which is what let a call on the union bind the SAME-NAMED + // struct method instead (the false edge in upstream #1515). + let src = concat!( + "union WithMethod {\n", + " int i; float f;\n", + " int read_field() { return i; }\n", + "};\n", + "struct SWithMethod {\n", + " int i;\n", + " int read_field() { return i; }\n", + "};\n", + ); + let (nodes, _) = run("union_agg.cpp", src, Language::Cpp); + let union_node = node(&nodes, NodeKind::Union, "WithMethod"); + let mut members = nodes + .iter() + .filter(|n| n.kind == NodeKind::Method && n.name == "read_field") + .map(|n| n.qualified_name.as_str()) + .collect::>(); + members.sort_unstable(); + assert_eq!( + members, + ["SWithMethod::read_field", "WithMethod::read_field"], + "the union's member must be a method qualified by the union" + ); + assert!( + !nodes + .iter() + .any(|n| n.kind == NodeKind::Function && n.name == "read_field"), + "no `read_field` may remain a free function at file scope" + ); + assert!( + union_node.start_line == 1 && union_node.end_line >= 4, + "the union must span its whole body: {union_node:?}" + ); + } + + #[test] + fn cpp_out_of_line_union_method_gets_its_contains_edge() { + // The receiver-owner lookup is the widening that fails SILENTLY: an + // out-of-line `Union::method` still becomes a method with the right + // qualified name, so only the missing `contains union -> method` edge + // reveals the omission. + let src = concat!( + "union WithMethod {\n", + " int i;\n", + " int read_field();\n", + "};\n", + "int WithMethod::read_field() { return i; }\n", + ); + let result = extract_source("u.cpp", src, Some(Language::Cpp)); + assert!(result.errors.is_empty(), "errors: {:?}", result.errors); + let union_id = &node(&result.nodes, NodeKind::Union, "WithMethod").id; + let method_id = &node(&result.nodes, NodeKind::Method, "read_field").id; + assert!( + result.edges.iter().any(|e| e.kind == EdgeKind::Contains + && &e.source == union_id + && &e.target == method_id), + "the out-of-line method must be contained by its union" + ); + } + + #[test] + fn c_typedef_union_is_one_union_node_named_by_the_typedef() { + let src = concat!( + "typedef union { int a; float b; } AnonU;\n", + "typedef struct { int a; int b; } AnonS;\n", + "typedef union NamedTag { int c; } NamedU;\n", + ); + let (nodes, _) = run("m.c", src, Language::C); + let named = nodes + .iter() + .filter(|n| n.name == "NamedU") + .collect::>(); + assert_eq!( + named.len(), + 1, + "`typedef union NamedTag {{…}} NamedU;` must mint exactly ONE node, got {named:?}" + ); + assert_eq!(named[0].kind, NodeKind::Union); + // The inner tag is not a separate node: extract_type_alias consumes the + // union_specifier, so it is never re-dispatched. + assert!( + !nodes.iter().any(|n| n.name == "NamedTag"), + "the union's tag must not become its own node" + ); + assert!(has_node(&nodes, NodeKind::Union, "AnonU")); + // Control: the struct typedef beside it keeps its kind. + assert!(has_node(&nodes, NodeKind::Struct, "AnonS")); + } + + #[test] + fn bodiless_and_anonymous_unions_are_not_indexed() { + let src = concat!( + "union Fwd;\n", + "struct FwdS;\n", + "union { int q; } anon_var;\n", + "struct { int r; } anon_struct_var;\n", + "union Named { int i; };\n", + ); + let (nodes, _) = run("m.c", src, Language::C); + // A bodiless C union is a forward declaration: the shared aggregate guard + // drops it, the same rule that keeps `struct Foo;` out. + assert!(!nodes.iter().any(|n| n.name == "Fwd")); + assert!(!nodes.iter().any(|n| n.name == "FwdS")); + // An anonymous union mints nothing, because the anonymous struct beside it + // mints nothing — both are consumed by the `declaration` arm. + assert!( + !nodes.iter().any(|n| n.name == ""), + "an anonymous aggregate must mint no node: {:?}", + nodes.iter().map(|n| &n.name).collect::>() + ); + // Positive control, so the negatives cannot pass by the file failing to parse. + assert!(has_node(&nodes, NodeKind::Union, "Named")); + } + + #[test] + fn cpp_interface_guard_negatives_are_extraction_invariant() { + // GREEN BEFORE THE FIX: this encodes today's measured output, so it is an + // invariance guard rather than a regression test written afterwards. Each + // row is a value a leaking mask would change — `INegCli`'s docstring is + // the sharpest, because a comment-blind substitution rewrites the comment + // text itself. + let (nodes, _) = run("neg_interface.hpp", NEG_INTERFACE_SRC, Language::Cpp); + let mut got = nodes + .iter() + .filter(|n| n.kind != NodeKind::File) + .map(|n| { + ( + n.kind, + n.name.as_str(), + n.start_line, + n.docstring.as_deref(), + ) + }) + .collect::>(); + got.sort_by_key(|row| row.2); + assert_eq!( + got, + vec![ + ( + NodeKind::Function, + "INegCli", + 4, + Some("interface INegComment;") + ), + (NodeKind::Function, "INegStructKw", 5, None), + (NodeKind::Struct, "NegReal", 11, None), + ], + "the guard leaked: extraction output moved" + ); + // A count catches a PHANTOM node that a name list would miss. + assert_eq!(got.len(), 3, "expected exactly 3 nodes, got {got:?}"); + // Survives tree-sitter error-recovery differences in the garbage names. + assert!( + !nodes + .iter() + .any(|n| n.kind == NodeKind::Struct && n.name.starts_with("INeg")), + "an INeg* name became a struct: the interface class/struct exclusion failed" + ); + for phantom in ["INegGhost", "INegMacro"] { + assert!( + !nodes.iter().any(|n| n.name == phantom), + "{phantom} must mint no node of any kind" + ); + } + } } diff --git a/crates/codegraph-graph/src/graph/mod.rs b/crates/codegraph-graph/src/graph/mod.rs index b49cb0cb..bf40377c 100644 --- a/crates/codegraph-graph/src/graph/mod.rs +++ b/crates/codegraph-graph/src/graph/mod.rs @@ -15,10 +15,11 @@ use serde::Serialize; // upstream graph/traversal.ts:506 — container kinds whose `contains` // children are pulled into the impact set at the same depth as the container. -const CONTAINER_KINDS: [NodeKind; 7] = [ +const CONTAINER_KINDS: [NodeKind; 8] = [ NodeKind::Class, NodeKind::Interface, NodeKind::Struct, + NodeKind::Union, NodeKind::Trait, NodeKind::Protocol, NodeKind::Module, diff --git a/crates/codegraph-graph/src/query/scoring.rs b/crates/codegraph-graph/src/query/scoring.rs index 2c13d1fa..59c3dd18 100644 --- a/crates/codegraph-graph/src/query/scoring.rs +++ b/crates/codegraph-graph/src/query/scoring.rs @@ -652,6 +652,7 @@ pub fn kind_bonus(kind: NodeKind) -> f64 { NodeKind::Interface => 9.0, NodeKind::TypeAlias => 6.0, NodeKind::Struct => 6.0, + NodeKind::Union => 6.0, NodeKind::Trait => 9.0, NodeKind::Enum => 5.0, NodeKind::Component => 8.0, diff --git a/crates/codegraph-mcp/src/engine.rs b/crates/codegraph-mcp/src/engine.rs index 9a14efed..b418bdd5 100644 --- a/crates/codegraph-mcp/src/engine.rs +++ b/crates/codegraph-mcp/src/engine.rs @@ -49,9 +49,10 @@ const CALLABLE_KINDS: [NodeKind; 4] = [ /// Type node kinds a signature edge may point at — the rescue only surfaces /// these. Mirrors upstream `TYPE_KINDS` (`tools.ts:2621`). -const TYPE_KINDS: [NodeKind; 7] = [ +const TYPE_KINDS: [NodeKind; 8] = [ NodeKind::Class, NodeKind::Struct, + NodeKind::Union, NodeKind::Interface, NodeKind::Trait, NodeKind::Protocol, @@ -2853,6 +2854,7 @@ fn is_container(kind: NodeKind) -> bool { NodeKind::Class | NodeKind::Interface | NodeKind::Struct + | NodeKind::Union | NodeKind::Trait | NodeKind::Protocol | NodeKind::Enum @@ -2867,6 +2869,7 @@ fn is_meaningful_kind(kind: NodeKind) -> bool { | NodeKind::Class | NodeKind::Interface | NodeKind::Struct + | NodeKind::Union | NodeKind::Trait | NodeKind::Protocol | NodeKind::Enum diff --git a/crates/codegraph-resolve/src/context.rs b/crates/codegraph-resolve/src/context.rs index 54a2cc0b..acc9f218 100644 --- a/crates/codegraph-resolve/src/context.rs +++ b/crates/codegraph-resolve/src/context.rs @@ -198,9 +198,10 @@ impl ResolutionContext for StoreResolutionContext<'_> { fn get_supertypes(&self, type_name: &str, language: Language) -> Vec { // Union implements/extends targets of every same-named type node // (index.ts:425-442). - const SUPERTYPE_BEARING: [NodeKind; 6] = [ + const SUPERTYPE_BEARING: [NodeKind; 7] = [ NodeKind::Class, NodeKind::Struct, + NodeKind::Union, NodeKind::Interface, NodeKind::Trait, NodeKind::Protocol, diff --git a/crates/codegraph-resolve/src/import_resolver.rs b/crates/codegraph-resolve/src/import_resolver.rs index 05627117..6b4c21c6 100644 --- a/crates/codegraph-resolve/src/import_resolver.rs +++ b/crates/codegraph-resolve/src/import_resolver.rs @@ -1947,6 +1947,7 @@ fn is_static_member_container(kind: NodeKind) -> bool { kind, NodeKind::Class | NodeKind::Struct + | NodeKind::Union | NodeKind::Interface | NodeKind::Enum | NodeKind::Trait @@ -2213,6 +2214,7 @@ fn resolve_rust_path_reference( n.kind, NodeKind::Function | NodeKind::Struct + | NodeKind::Union | NodeKind::Enum | NodeKind::Trait | NodeKind::TypeAlias diff --git a/crates/codegraph-resolve/src/name_matcher.rs b/crates/codegraph-resolve/src/name_matcher.rs index 99130b50..b22d85c9 100644 --- a/crates/codegraph-resolve/src/name_matcher.rs +++ b/crates/codegraph-resolve/src/name_matcher.rs @@ -495,12 +495,13 @@ fn cpp_last_segment(name: &str) -> &str { .unwrap_or(name) } -/// Does the graph hold a class/struct named `name`'s last segment? +/// Does the graph hold a class/struct/union named `name`'s last segment? /// (`cppClassExists`, `name-matcher.ts:621-626`). fn cpp_class_exists(name: &str, reference: &RefView, context: &dyn ResolutionContext) -> bool { let last = cpp_last_segment(name); context.get_nodes_by_name(last).iter().any(|n| { - matches!(n.kind, NodeKind::Class | NodeKind::Struct) && n.language == reference.language + matches!(n.kind, NodeKind::Class | NodeKind::Struct | NodeKind::Union) + && n.language == reference.language }) } @@ -1436,7 +1437,7 @@ pub fn match_method_call( ) { if matches!( class_node.kind, - NodeKind::Class | NodeKind::Struct | NodeKind::Interface + NodeKind::Class | NodeKind::Struct | NodeKind::Union | NodeKind::Interface ) { if class_node.language != reference.language { continue; @@ -1462,7 +1463,7 @@ pub fn match_method_call( ) { if matches!( class_node.kind, - NodeKind::Class | NodeKind::Struct | NodeKind::Interface + NodeKind::Class | NodeKind::Struct | NodeKind::Union | NodeKind::Interface ) { if class_node.language != reference.language { continue; @@ -1867,7 +1868,7 @@ fn find_best_match<'a>(reference: &RefView, candidates: &'a [Node]) -> Option<&' EdgeKind::Instantiates => { if matches!( candidate.kind, - NodeKind::Class | NodeKind::Struct | NodeKind::Interface + NodeKind::Class | NodeKind::Struct | NodeKind::Union | NodeKind::Interface ) { score += 25.0; } diff --git a/crates/codegraph-resolve/src/resolver.rs b/crates/codegraph-resolve/src/resolver.rs index 44c8e3e3..f825dd13 100644 --- a/crates/codegraph-resolve/src/resolver.rs +++ b/crates/codegraph-resolve/src/resolver.rs @@ -1186,6 +1186,7 @@ impl ReferenceResolver { from_node.kind, NodeKind::Class | NodeKind::Struct + | NodeKind::Union | NodeKind::Interface | NodeKind::Trait | NodeKind::Protocol @@ -1371,7 +1372,10 @@ impl ReferenceResolver { // Promote calls → instantiates (index.ts:771-776). if kind == EdgeKind::Calls { if let Ok(Some(target_node)) = store.node_by_id(&reference.target_node_id) { - if matches!(target_node.kind, NodeKind::Class | NodeKind::Struct) { + if matches!( + target_node.kind, + NodeKind::Class | NodeKind::Struct | NodeKind::Union + ) { kind = EdgeKind::Instantiates; } } @@ -2055,6 +2059,7 @@ fn is_supertype_bearing_or_module(kind: NodeKind) -> bool { kind, NodeKind::Class | NodeKind::Struct + | NodeKind::Union | NodeKind::Interface | NodeKind::Trait | NodeKind::Protocol diff --git a/crates/codegraph-resolve/src/snapshot_context.rs b/crates/codegraph-resolve/src/snapshot_context.rs index a65143df..6a407612 100644 --- a/crates/codegraph-resolve/src/snapshot_context.rs +++ b/crates/codegraph-resolve/src/snapshot_context.rs @@ -268,9 +268,10 @@ impl ResolutionContext for SnapshotResolutionContext { // Union implements/extends targets of every same-named type node, // reading the per-chunk edge adjacency instead of the live store // (matches `StoreResolutionContext::get_supertypes`). - const SUPERTYPE_BEARING: [NodeKind; 6] = [ + const SUPERTYPE_BEARING: [NodeKind; 7] = [ NodeKind::Class, NodeKind::Struct, + NodeKind::Union, NodeKind::Interface, NodeKind::Trait, NodeKind::Protocol, diff --git a/crates/codegraph-resolve/src/types.rs b/crates/codegraph-resolve/src/types.rs index d0ee6b73..d6826c5f 100644 --- a/crates/codegraph-resolve/src/types.rs +++ b/crates/codegraph-resolve/src/types.rs @@ -43,12 +43,13 @@ pub fn is_esm_language(language: Language) -> bool { /// `namespace Foo {}` binds `Foo` as much as a `class Foo` does, which is why /// `Module`/`Namespace` belong here too. /// -/// Upstream's set carries 11 kinds including `union`; we have no -/// `NodeKind::Union` yet, so this is the other 10 and `Union` must join it when -/// the kind exists. -pub const TYPE_DECLARING_KINDS: [NodeKind; 10] = [ +/// Matches upstream's 11-kind set: `Union` joined it when `NodeKind::Union` was +/// added (PR #1516), because a C/C++/ObjC/Rust `union` declares a type name +/// exactly as a `struct` does. +pub const TYPE_DECLARING_KINDS: [NodeKind; 11] = [ NodeKind::Class, NodeKind::Struct, + NodeKind::Union, NodeKind::Interface, NodeKind::Trait, NodeKind::Protocol, @@ -389,7 +390,7 @@ mod tests { #[test] fn all_node_kinds_classified_against_supertype_and_import_sets() { - // Every one of the 22 kinds is classified explicitly, so a kind added + // Every one of the 23 kinds is classified explicitly, so a kind added // later cannot be silently omitted from either gate: the two expected // lists below are exhaustive and the assertion compares whole sets. let type_declaring: Vec = NodeKind::ALL @@ -409,8 +410,9 @@ mod tests { NodeKind::TypeAlias, NodeKind::Namespace, NodeKind::Component, + NodeKind::Union, ], - "10 supertype-eligible kinds — no `Union` yet, which Tier 3 must add" + "11 supertype-eligible kinds, `Union` among them since Tier 3" ); let non_importable: Vec = NodeKind::ALL @@ -430,7 +432,7 @@ mod tests { assert_eq!( NodeKind::ALL.len(), - 22, + 23, "kind count changed — revisit both sets" ); } diff --git a/crates/codegraph-resolve/tests/fixtures/tier3/instantiate_agg/instantiate_agg.cpp b/crates/codegraph-resolve/tests/fixtures/tier3/instantiate_agg/instantiate_agg.cpp new file mode 100644 index 00000000..78ad77d7 --- /dev/null +++ b/crates/codegraph-resolve/tests/fixtures/tier3/instantiate_agg/instantiate_agg.cpp @@ -0,0 +1,4 @@ +union Reg { int raw; float val; }; +struct Ctl { int id; }; +void mk_union() { Reg r = Reg(); (void)r; } +void mk_struct() { Ctl c = Ctl(); (void)c; } diff --git a/crates/codegraph-resolve/tests/fixtures/tier3/instantiate_rank/instantiate_rank.cpp b/crates/codegraph-resolve/tests/fixtures/tier3/instantiate_rank/instantiate_rank.cpp new file mode 100644 index 00000000..bc8fdc46 --- /dev/null +++ b/crates/codegraph-resolve/tests/fixtures/tier3/instantiate_rank/instantiate_rank.cpp @@ -0,0 +1,5 @@ +union Value { int i; float f; }; +struct Packet { int id; }; +void Value() { } +void ctor_union() { Value v{1}; (void)v; } +void ctor_struct() { Packet p{2}; (void)p; } diff --git a/crates/codegraph-resolve/tests/fixtures/tier3/union_method/union_agg.cpp b/crates/codegraph-resolve/tests/fixtures/tier3/union_method/union_agg.cpp new file mode 100644 index 00000000..1f6b690e --- /dev/null +++ b/crates/codegraph-resolve/tests/fixtures/tier3/union_method/union_agg.cpp @@ -0,0 +1,10 @@ +union WithMethod { + int i; float f; + int read_field() { return i; } +}; +struct SWithMethod { + int i; + int read_field() { return i; } +}; +void drive_union() { WithMethod w; w.read_field(); } +void drive_struct() { SWithMethod s; s.read_field(); } diff --git a/crates/codegraph-resolve/tests/tier3_union_edges.rs b/crates/codegraph-resolve/tests/tier3_union_edges.rs new file mode 100644 index 00000000..22b2d848 --- /dev/null +++ b/crates/codegraph-resolve/tests/tier3_union_edges.rs @@ -0,0 +1,277 @@ +//! Tier 3 union-reachability regression tests (upstream PR #1516, `e922563`). +//! +//! A `union` node nothing points at would be worse than no union node at all, so +//! each test here drives the FULL extract → resolve pipeline over a committed +//! fixture under `tests/fixtures/tier3/` and asserts an edge REACHES the union — +//! and, where a wrong edge existed before, that the wrong edge is GONE. Both +//! directions, because "the right edge appeared" alone cannot notice that the +//! false one survived beside it. +//! +//! The three cases exercise three INDEPENDENT code paths, each with its own +//! same-shaped struct control: +//! * `instantiate_agg` — `resolver.rs`'s `Calls` → `Instantiates` promotion +//! * `instantiate_rank` — `name_matcher.rs`'s `Instantiates` candidate bonus +//! * `union_method` — `name_matcher.rs`'s `matchMethodCall` candidate kinds +//! +//! They are separate fixtures on purpose: one file mixing the mechanisms would +//! make every isolated revert-proof ambiguous. +//! +//! Fixtures are read in place and never written to; the store lives in a temp +//! file, so the worktree stays clean. + +use std::path::{Path, PathBuf}; + +use codegraph_core::types::{Edge, EdgeKind, FileRecord, Node, NodeKind}; +use codegraph_extract::{detect_language, extract_file}; +use codegraph_resolve::ReferenceResolver; +use codegraph_store::Store; + +fn fixture_root(name: &str) -> PathBuf { + Path::new(env!("CARGO_MANIFEST_DIR")) + .join("tests") + .join("fixtures") + .join("tier3") + .join(name) +} + +fn temp_db_path(test_name: &str) -> PathBuf { + let mut path = std::env::temp_dir(); + let nanos = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .expect("clock after epoch") + .as_nanos(); + path.push(format!( + "codegraph-tier3-{test_name}-{}-{nanos}.db", + std::process::id() + )); + path +} + +fn fixture_files(root: &Path) -> Vec { + let mut out = Vec::new(); + for entry in std::fs::read_dir(root).expect("read fixture dir") { + let path = entry.expect("dir entry").path(); + if let Ok(relative) = path.strip_prefix(root) { + out.push(relative.to_string_lossy().replace('\\', "/")); + } + } + out.sort(); + out +} + +struct Resolved { + store: Store, + edges: Vec, + refs: Vec, +} + +impl Resolved { + fn node(&self, id: &str) -> Node { + self.store + .node_by_id(id) + .expect("node lookup") + .expect("node exists") + } + + /// The single node of `kind` named `name`. Panics on 0 or >1, so a fixture + /// that stops producing the node fails loudly instead of silently skipping. + fn only(&self, kind: NodeKind, name: &str) -> Node { + let mut found: Vec = self + .store + .nodes_by_name(name) + .expect("nodes by name") + .into_iter() + .filter(|n| n.kind == kind) + .collect(); + assert_eq!( + found.len(), + 1, + "want exactly one {kind:?} named {name}, got {found:?}" + ); + found.pop().expect("checked len") + } + + /// `(edge kind, "targetkind:targetname")` for every non-`Contains` edge out + /// of `source_id`. + fn out_of(&self, source_id: &str) -> Vec<(EdgeKind, String)> { + let mut rows: Vec<(EdgeKind, String)> = self + .edges + .iter() + .filter(|e| e.source == source_id) + .map(|e| { + let t = self.node(&e.target); + (e.kind, format!("{:?}:{}", t.kind, t.name)) + }) + .collect(); + rows.sort_by(|a, b| format!("{a:?}").cmp(&format!("{b:?}"))); + rows + } +} + +fn resolve_fixture(name: &str) -> Resolved { + let root = fixture_root(name); + assert!(root.is_dir(), "missing committed fixture {name}"); + let relative = fixture_files(&root); + assert!(!relative.is_empty(), "fixture {name} has no files"); + + let mut store = Store::open(&temp_db_path(name)).expect("open store"); + for path in &relative { + let language = detect_language(path); + let result = extract_file(&root, path).expect("extract file"); + store + .upsert_file(&FileRecord { + path: path.clone(), + content_hash: "fixture".to_string(), + language, + size: 0, + modified_at: 0, + indexed_at: 0, + node_count: result.nodes.len() as i64, + errors: Vec::new(), + }) + .expect("upsert file"); + store.upsert_nodes(&result.nodes).expect("upsert nodes"); + store + .insert_edges(&result.edges) + .expect("insert contains edges"); + store + .insert_unresolved_refs(&result.unresolved_references) + .expect("insert unresolved refs"); + } + + let root_str = root.to_string_lossy().to_string(); + let mut resolver = ReferenceResolver::new(root_str.clone()); + { + let context = codegraph_resolve::StoreResolutionContext::new(&store, &root_str); + resolver.initialize(&context); + } + resolver + .resolve_and_persist(&mut store) + .expect("resolve and persist"); + + let mut edges = Vec::new(); + for kind in NodeKind::ALL { + for node in store.nodes_by_kind(kind).expect("nodes by kind") { + for edge in store + .edges_by_source_kind(&node.id, None) + .expect("edges by source") + { + if edge.kind != EdgeKind::Contains { + edges.push(edge); + } + } + } + } + let refs = store + .all_unresolved_refs() + .expect("all unresolved refs") + .into_iter() + .map(|r| format!("{:?}|{}", r.reference_kind, r.reference_name)) + .collect(); + Resolved { store, edges, refs } +} + +#[test] +fn cpp_union_call_construction_is_promoted_to_instantiates() { + // Given `Reg r = Reg();` where `Reg` is a union and the ONLY node of that + // name, and `Ctl c = Ctl();` as the struct control, + // When the pipeline resolves, + // Then the union's ref — extracted as `Calls`, measured PRE-FIX as a DANGLING + // unresolved ref because no union node existed to bind — both resolves and is + // promoted to `Instantiates`, leaving NO `Calls` edge behind. + let g = resolve_fixture("instantiate_agg"); + let mk_union = g.only(NodeKind::Function, "mk_union"); + let out = g.out_of(&mk_union.id); + + assert!( + out.contains(&(EdgeKind::Instantiates, "Union:Reg".to_string())), + "the union construction must be promoted to instantiates: {out:?}" + ); + assert!( + !out.iter().any(|(kind, _)| *kind == EdgeKind::Calls), + "a Calls edge must NOT survive the promotion: {out:?}" + ); + assert!( + !g.refs.iter().any(|r| r == "Calls|Reg"), + "the `Reg` ref must no longer be dangling: {:?}", + g.refs + ); + + let mk_struct = g.only(NodeKind::Function, "mk_struct"); + assert!( + g.out_of(&mk_struct.id) + .contains(&(EdgeKind::Instantiates, "Struct:Ctl".to_string())), + "the struct control regressed: {:?}", + g.out_of(&mk_struct.id) + ); +} + +#[test] +fn cpp_union_wins_instantiates_ranking_over_a_same_named_function() { + // Given `Value v{1};` — a brace construction, so the ref is extracted as + // `Instantiates` — competing against a SAME-NAMED `void Value()`, + // When the pipeline ranks the candidates, + // Then the `+25` aggregate bonus makes the union win. Measured PRE-FIX this + // bound `function:Value`, the WRONG target, so the assertion is stated in both + // directions: the union is hit and the function is not touched at all. + let g = resolve_fixture("instantiate_rank"); + let ctor_union = g.only(NodeKind::Function, "ctor_union"); + let out = g.out_of(&ctor_union.id); + + assert!( + out.contains(&(EdgeKind::Instantiates, "Union:Value".to_string())), + "the union must win the Instantiates ranking: {out:?}" + ); + assert!( + !out.iter().any(|(_, target)| target == "Function:Value"), + "no edge may reach the same-named function: {out:?}" + ); + + let ctor_struct = g.only(NodeKind::Function, "ctor_struct"); + assert!( + g.out_of(&ctor_struct.id) + .contains(&(EdgeKind::Instantiates, "Struct:Packet".to_string())), + "the struct control regressed: {:?}", + g.out_of(&ctor_struct.id) + ); +} + +#[test] +fn cpp_union_method_call_binds_the_union_not_the_struct() { + // Given a union and a struct in one file that each define `read_field`, and + // one INSTANCE call on each receiver, + // When the pipeline resolves the method calls, + // Then each binds its OWN receiver's member. Measured PRE-FIX: the union had + // no node, so its member was a free function and `w.read_field()` bound + // `SWithMethod::read_field` — a false edge to the wrong type, not merely a + // missing one. Receiver type has to decide, since the names are identical. + // + // The load-bearing fix here is the EXTRACTION-side `is_inside_class_like_node` + // widening, which makes the member a `method` owned by the union; reverting it + // alone reproduces the false edge. Reverting either `match_method_call` + // candidate filter does NOT: receiver-type inference resolves this shape + // before that strategy runs. Three other shapes were tried and each is + // claimed by an earlier path too — a Rust `Bits::raw(b)` by exact + // qualified-name matching, and a C++ `Cfg::probe()` never even reaches the + // resolver as a qualified ref because the extractor emits the bare `probe`. + // So `match_method_call`'s union widening is a symmetric port hunk with no + // reachable fixture in this tree; it is compile-verified, not behaviour-proven. + let g = resolve_fixture("union_method"); + for (caller, want_owner) in [ + ("drive_union", "WithMethod::read_field"), + ("drive_struct", "SWithMethod::read_field"), + ] { + let from = g.only(NodeKind::Function, caller); + let bound: Vec = g + .edges + .iter() + .filter(|e| e.source == from.id && e.kind == EdgeKind::Calls) + .map(|e| g.node(&e.target).qualified_name) + .collect(); + assert_eq!( + bound, + vec![want_owner.to_string()], + "{caller} must bind exactly {want_owner}" + ); + } +} diff --git a/crates/codegraph-store/src/index_state.rs b/crates/codegraph-store/src/index_state.rs index 09f0568d..0bfb9f3f 100644 --- a/crates/codegraph-store/src/index_state.rs +++ b/crates/codegraph-store/src/index_state.rs @@ -115,7 +115,7 @@ pub const CURRENT_STORAGE_PROTOCOL: u64 = 2; /// The extraction-pipeline version this binary produces. This is the single /// source of truth: no other crate may define its own copy. -pub const CURRENT_EXTRACTION_VERSION: u64 = 6; +pub const CURRENT_EXTRACTION_VERSION: u64 = 7; /// The `project_metadata` key under which a built index records the extraction /// version it was produced with. Single source of truth for the key spelling. diff --git a/crates/codegraph-store/src/queries.rs b/crates/codegraph-store/src/queries.rs index fec11174..bc972211 100644 --- a/crates/codegraph-store/src/queries.rs +++ b/crates/codegraph-store/src/queries.rs @@ -1706,6 +1706,7 @@ fn parse_node_kind(value: String) -> rusqlite::Result { "export" => NodeKind::Export, "route" => NodeKind::Route, "component" => NodeKind::Component, + "union" => NodeKind::Union, _ => return Err(enum_error(value, "node kind")), }; Ok(kind) @@ -1982,6 +1983,24 @@ mod tests { ); } + #[test] + fn union_node_round_trips_kind_through_sqlite() { + // `parse_node_kind` is a string match with a rejecting `_` arm, so a new + // NodeKind that extraction can WRITE but this cannot READ fails only at + // runtime, with `unknown node kind: union`. The extractor never round-trips + // through SQLite, so no extraction test can catch that. + let mut store = store("union-round-trip"); + store.upsert_file(&file("src/bits.rs")).unwrap(); + let mut inserted = node("union:bits", "Bits", "src/bits.rs"); + inserted.kind = NodeKind::Union; + + store.upsert_nodes(std::slice::from_ref(&inserted)).unwrap(); + + let read_back = store.node_by_id("union:bits").unwrap(); + assert_eq!(read_back, Some(inserted.clone())); + assert_eq!(read_back.unwrap().kind, NodeKind::Union); + } + #[test] fn gdscript_node_round_trips_language_through_sqlite() { let mut store = store("gdscript-round-trip"); diff --git a/crates/codegraph-store/tests/index_state.rs b/crates/codegraph-store/tests/index_state.rs index 0da480ae..6493cb72 100644 --- a/crates/codegraph-store/tests/index_state.rs +++ b/crates/codegraph-store/tests/index_state.rs @@ -119,7 +119,7 @@ fn assert_corrupt( fn index_state_constants_and_canonical_payload_are_exact() { /// The extraction version the immediately preceding release wrote. Read from /// `index_state.rs` at implementation time; see plan decision C1 step 0. - const PREVIOUS_EXTRACTION_VERSION: u64 = 5; + const PREVIOUS_EXTRACTION_VERSION: u64 = 6; assert_eq!(CURRENT_STORAGE_PROTOCOL, 2); assert_eq!(CURRENT_EXTRACTION_VERSION, PREVIOUS_EXTRACTION_VERSION + 1); diff --git a/docs/equivalence.md b/docs/equivalence.md index 2850e097..172f0503 100644 --- a/docs/equivalence.md +++ b/docs/equivalence.md @@ -422,10 +422,74 @@ A further file exercises the Batch B explicit-operator gain (upstream #1268): `instance-method` at confidence 0.9 (`Vec2::operator+` twice, `Vec2::operator[]`, `Vec2::get`). +Seven further files exercise the Tier 3 aggregate work — MSVC COM `interface` +(upstream #1519) and first-class `union` nodes (upstream PR #1516). **This corpus +is the C-FAMILY corpus, not a strictly-C++ one**: it already held a `.c` file, and +Tier 3 adds a `.mm` file whose extension maps to the ObjC spec, so `cpp/` names the +family rather than the dialect. + +- **MSVC COM `interface` positives** — `com_interface.hpp` carries `struct SControl` + as the control plus three `interface` shapes (`IWidget : IBase` with a base clause, + `IPlain` without one, and `INewlineBrace` with the brace on the next line). The + keyword is not C++, so tree-sitter reads each as a `function_definition`: the + container became a `function`, its member `Run` a free `function` instead of a + `method`, and the base clause vanished. The offset-preserving pre-parse rewrites + the line-leading keyword to `struct` + 3 spaces (9 bytes → 9 bytes, so every line + and column is unchanged), and the golden now pins all three as `struct` with + `IWidget::Run` a `method` and TWO `extends IBase` refs. `int interface_count = 0;` + is the mid-line negative in the same file. +- **MSVC COM `interface` negatives** — `neg_interface.hpp` holds the five shapes the + guard must DECLINE, and pins them by extraction-INVARIANCE rather than by "the + substitution did not fire": a block comment containing `interface INegComment;`, a + C++/CLI `interface class`, an `interface struct`, a raw string containing a full + `interface INegGhost {…};` declaration, and a `#define` continuation line carrying + `interface INegMacro`. The golden pins exactly THREE nodes, the sharpest value + being `INegCli`'s `docstring` — the verbatim `interface INegComment;`. A + comment-blind substitution rewrites that string to `struct INegComment;`, which + is how a leaking guard is caught. `INegCli`/`INegStructKw` staying `function` is + pre-existing garbage from the C++/CLI misparse and is deliberately preserved. +- **C union** — `union_agg.c` (the second `.c` file, so the C walker is under test) + covers `union Named` plus both `typedef union` RE-KINDS (`AnonU` and `NamedU` were + `type_alias` before and are `union` now — node ids change), with `struct Ctl` / + `AnonS` as controls and three negatives: `union Fwd;` (bodiless forward + declaration, stays unindexed, `struct FwdS;` as its control) and + `union { int q; } anon_var;` (anonymous, mints nothing, as the anonymous struct + already did). `typedef union NamedTag { … } NamedU;` mints exactly ONE node named + `NamedU`; the tag never becomes a node. +- **C++ union member method** — `union_agg.cpp` gives `union WithMethod` and + `struct SWithMethod` a SAME-NAMED `read_field`, plus one call on each receiver. + Before the fix the union's member leaked to file scope as a free `function`, so + `w.read_field()` bound `SWithMethod::read_field` — a FALSE edge to the wrong type, + not merely a missing one. The golden pins each call on its own receiver's member, + so receiver type has to decide. +- **ObjC union** — `union_agg.mm` is the repo's ONLY Objective-C fixture (`.mm` maps + to the ObjC spec). It pins `union ObjcU` beside `struct ObjcS`. +- **`Calls` → `Instantiates` promotion** — `instantiate_agg.cpp` has `Reg r = Reg();` + where the union is the only node of that name (measured pre-fix: a DANGLING `calls +Reg` ref, because no union node existed to bind), with `Ctl c = Ctl();` as the + control. The golden pins `instantiates mk_union -> union:Reg` and NO surviving + `calls` edge. +- **`Instantiates` candidate ranking** — `instantiate_rank.cpp` has `Value v{1};` + competing against a same-named `void Value()`. Measured pre-fix it bound + `function:Value`, the WRONG target; the golden pins the union winning, with + `Packet p{2};` as the control. Kept in a SEPARATE file from the promotion case on + purpose: one file mixing both mechanisms would make either revert-proof ambiguous. + +**Why the union/struct members are named `read_field` and not `get`.** `get` is the +only duplicated symbol name in this corpus already (`operators.cpp:5` `Vec2::get` +and `template_method.cpp:12` `Box::get`), and one of those carries a live +2-candidate `calls` edge. Naming the new members `get` would take that candidate set +to four and put an existing, unrelated golden edge at risk of re-pointing — drift in +files this change has no business touching. `read_field` keeps the property that +matters (two same-named members inside the new file, so receiver type must +disambiguate) and drops the one that only adds risk. + The minimal source corpus lives at `crates/codegraph-bench/fixtures/cpp/` -(`attr_macro.c`, `base.hpp`, `derived.cpp`, `namespaced.cpp`, -`namespaced_member.cpp`, `namespaced_member.hpp`, `operators.cpp`, -`template_method.cpp`, `templated_call.cpp`, `ue_actor.h`). The inheritance base +(`attr_macro.c`, `base.hpp`, `com_interface.hpp`, `derived.cpp`, +`instantiate_agg.cpp`, `instantiate_rank.cpp`, `namespaced.cpp`, +`namespaced_member.cpp`, `namespaced_member.hpp`, `neg_interface.hpp`, +`operators.cpp`, `template_method.cpp`, `templated_call.cpp`, `ue_actor.h`, +`union_agg.c`, `union_agg.cpp`, `union_agg.mm` — 17 files). The inheritance base classes live in a `.hpp` file (not `.h`, which maps to `Language::C` by extension); `ue_actor.h` deliberately uses `.h` to guard the content-based C++ reclassification, and `attr_macro.c` uses `.c` so the @@ -456,6 +520,54 @@ Like the Ruby fixture, both the index and the dump are byte-stable, and the `cpp_db_is_self_equivalent_to_cpp_golden` tests in `crates/codegraph-bench/tests/equivalence.rs` enforce it. +### Rust fixture + +`reference/golden/rust/` guards the two Tier 3 items that need Rust source, which +no other corpus could reach — before it there was no `.rs` file anywhere under +`crates/codegraph-bench/fixtures/`: + +- **unit structs are indexed** (upstream #1513 / PR #1514) — `lib.rs` declares + `struct UnitStruct;` beside `BraceStruct { … }` and `TupleStruct(u8)`, and gives + all three an `impl Greet for`. A bodiless `struct NAME;` is a COMPLETE definition + in Rust, not a forward declaration, so before the fix the unit struct produced no + node at all — and its `implements` edge went with it, leaving `UnitStruct::greet` + an orphan naming a type the graph did not contain. The golden pins exactly three + `struct` nodes and **four** `implements` edges (three structs + the union). +- **`union` is a first-class kind** (upstream PR #1516) — `union Bits` carries an + inherent `impl` (`raw`) and a trait `impl` (`greet`). The golden pins `union:Bits` + with `contains union:Bits -> method:raw`, `contains union:Bits -> method:greet` and + `implements union:Bits -> trait:Greet`. +- **cross-file resolution** — `consumer.rs` calls `u.greet()` / `b.greet()` on a + `&UnitStruct` and a `&Bits`, so `implements` and method resolution have to work + across files rather than only within one. + +**The Rust corpus deliberately makes NO instantiation claim.** An `instantiates` edge +fires only for the CALL-EXPRESSION construction form: `TupleStruct(2)` yes, a bare +path `UnitStruct` no, a struct literal `Bits { i: 0 }` no. A Rust union is +constructible only as `Bits { … }`, so no Rust union can ever emit that edge — +`make_unit` / `make_bits` are return-type references, not instantiation assertions, +and the golden carries zero `instantiates` edges. Instantiation is pinned in C++ +instead (`instantiate_agg.cpp` / `instantiate_rank.cpp`), which is upstream's own +shape. The corpus carries **no `Cargo.toml`**: it is indexed, not compiled, and a +manifest inside the workspace tree could confuse `cargo`. + +Regenerate reproducibly (identical recipe to the C++ fixture, substituting `rust`): + +```bash +mkdir -p reference/golden/rust +rm -rf /tmp/cg-fixture-rust +cp -r crates/codegraph-bench/fixtures/rust /tmp/cg-fixture-rust +cargo build --release -p codegraph-rs +CODEGRAPH_NO_DAEMON=1 CODEGRAPH_NO_WATCH=1 \ + ./target/release/codegraph init /tmp/cg-fixture-rust +cp /tmp/cg-fixture-rust/.codegraph/codegraph.db reference/golden/rust/colby.db +cargo run -p codegraph-bench --bin bench -- \ + --gen-golden reference/golden/rust/colby.db reference/golden/rust +``` + +`generated_golden_matches_committed_rust_fixture` and +`rust_db_is_self_equivalent_to_rust_golden` enforce byte-stability. + ### Metal fixture A fifth golden fixture, `reference/golden/metal/`, guards Metal Shading Language diff --git a/reference/golden/cpp/colby.db b/reference/golden/cpp/colby.db index 45edc05b9461561888aa2b70f725a6a25919c463..6e558a3ac4768d8ba1f896ce09ff0f5fff1056f1 100644 GIT binary patch literal 217088 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 tiu@-BnDsOX!SBR=t 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%0AeKNZfmi~u1Y!xq66it#Xo^_>wtC~n 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 N>w3^wzIn{o{~z`vEr$RA delta 14494 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 literal 0 HcmV?d00001 diff --git a/reference/golden/rust/edges.json b/reference/golden/rust/edges.json new file mode 100644 index 00000000..f52b6a93 --- /dev/null +++ b/reference/golden/rust/edges.json @@ -0,0 +1,275 @@ +[ + { + "col": 0, + "kind": "imports", + "line": 1, + "metadata": { + "confidence": 0.9, + "resolvedBy": "exact-match" + }, + "provenance": null, + "source": "file:consumer.rs", + "target": "import:b45211470cf011dde09b7990d7e238e4" + }, + { + "col": 4, + "kind": "calls", + "line": 4, + "metadata": { + "confidence": 0.9, + "resolvedBy": "instance-method" + }, + "provenance": null, + "source": "function:c8e1506aa2c158eff8b9790ef4ebfa5c", + "target": "method:7fc738eac7790ac49dfa4b6a7cd6b9a9" + }, + { + "col": 4, + "kind": "calls", + "line": 8, + "metadata": { + "confidence": 0.9, + "resolvedBy": "instance-method" + }, + "provenance": null, + "source": "function:88c7f6ab9fc2123a08f9ecf37298bd40", + "target": "method:332692d36b049f0071041145d30d687c" + }, + { + "col": 5, + "kind": "implements", + "line": 13, + "metadata": { + "confidence": 0.9, + "resolvedBy": "exact-match" + }, + "provenance": null, + "source": "struct:280f7daaeca096946aa3484658c88063", + "target": "trait:822b89fd17ee8e49a50fbe03e4fe72de" + }, + { + "col": 5, + "kind": "implements", + "line": 19, + "metadata": { + "confidence": 0.9, + "resolvedBy": "exact-match" + }, + "provenance": null, + "source": "struct:ba608806a3b56b3964d9f8172341f9d2", + "target": "trait:822b89fd17ee8e49a50fbe03e4fe72de" + }, + { + "col": 5, + "kind": "implements", + "line": 25, + "metadata": { + "confidence": 0.9, + "resolvedBy": "exact-match" + }, + "provenance": null, + "source": "struct:1ef30d9d3f298b426fbbbd5910139ecc", + "target": "trait:822b89fd17ee8e49a50fbe03e4fe72de" + }, + { + "col": 5, + "kind": "implements", + "line": 42, + "metadata": { + "confidence": 0.9, + "resolvedBy": "exact-match" + }, + "provenance": null, + "source": "union:466d8ec81e4f465f813cbcac35562ca9", + "target": "trait:822b89fd17ee8e49a50fbe03e4fe72de" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "file:consumer.rs", + "target": "function:88c7f6ab9fc2123a08f9ecf37298bd40" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "file:consumer.rs", + "target": "function:c8e1506aa2c158eff8b9790ef4ebfa5c" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "file:consumer.rs", + "target": "import:b45211470cf011dde09b7990d7e238e4" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "file:lib.rs", + "target": "function:190b8fbf32e627648ed53f2ce8cc285c" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "file:lib.rs", + "target": "function:e7de8b9d2d442c9a564bee08c82b145a" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "file:lib.rs", + "target": "method:15074a95e078da927a780dccd5ed2448" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "file:lib.rs", + "target": "method:332692d36b049f0071041145d30d687c" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "file:lib.rs", + "target": "method:7fc738eac7790ac49dfa4b6a7cd6b9a9" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "file:lib.rs", + "target": "method:8cb04e8ca5d9379a7bdf1b71236238cf" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "file:lib.rs", + "target": "method:f1fe944ca0591095cb695294229acbb1" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "file:lib.rs", + "target": "struct:1ef30d9d3f298b426fbbbd5910139ecc" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "file:lib.rs", + "target": "struct:280f7daaeca096946aa3484658c88063" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "file:lib.rs", + "target": "struct:ba608806a3b56b3964d9f8172341f9d2" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "file:lib.rs", + "target": "trait:822b89fd17ee8e49a50fbe03e4fe72de" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "file:lib.rs", + "target": "union:466d8ec81e4f465f813cbcac35562ca9" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "struct:1ef30d9d3f298b426fbbbd5910139ecc", + "target": "method:15074a95e078da927a780dccd5ed2448" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "struct:280f7daaeca096946aa3484658c88063", + "target": "method:7fc738eac7790ac49dfa4b6a7cd6b9a9" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "struct:ba608806a3b56b3964d9f8172341f9d2", + "target": "method:8cb04e8ca5d9379a7bdf1b71236238cf" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "trait:822b89fd17ee8e49a50fbe03e4fe72de", + "target": "method:28764bbfc23c2fe8ec24a7d1b72b1330" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "union:466d8ec81e4f465f813cbcac35562ca9", + "target": "method:332692d36b049f0071041145d30d687c" + }, + { + "col": null, + "kind": "contains", + "line": null, + "metadata": null, + "provenance": null, + "source": "union:466d8ec81e4f465f813cbcac35562ca9", + "target": "method:f1fe944ca0591095cb695294229acbb1" + } +] diff --git a/reference/golden/rust/files.json b/reference/golden/rust/files.json new file mode 100644 index 00000000..4ac637ce --- /dev/null +++ b/reference/golden/rust/files.json @@ -0,0 +1,18 @@ +[ + { + "content_hash": "8121cdd4bac4cf4e031fa69ca8b2ceea14f7f61e2357a339025afdcb51ea6585", + "errors": null, + "language": "rust", + "node_count": 4, + "path": "consumer.rs", + "size": 164 + }, + { + "content_hash": "32fd3f5a2c8b2054c3197394a04d39f75f8ad52de6afe38e76ec0e4ee7358960", + "errors": null, + "language": "rust", + "node_count": 14, + "path": "lib.rs", + "size": 767 + } +] diff --git a/reference/golden/rust/nodes.json b/reference/golden/rust/nodes.json new file mode 100644 index 00000000..02874e21 --- /dev/null +++ b/reference/golden/rust/nodes.json @@ -0,0 +1,398 @@ +[ + { + "decorators": null, + "docstring": null, + "end_column": 0, + "end_line": 10, + "file_path": "consumer.rs", + "id": "file:consumer.rs", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "file", + "language": "rust", + "name": "consumer.rs", + "qualified_name": "consumer.rs", + "return_type": null, + "signature": null, + "start_column": 0, + "start_line": 1, + "type_parameters": null, + "visibility": null + }, + { + "decorators": null, + "docstring": null, + "end_column": 0, + "end_line": 55, + "file_path": "lib.rs", + "id": "file:lib.rs", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "file", + "language": "rust", + "name": "lib.rs", + "qualified_name": "lib.rs", + "return_type": null, + "signature": null, + "start_column": 0, + "start_line": 1, + "type_parameters": null, + "visibility": null + }, + { + "decorators": null, + "docstring": null, + "end_column": 1, + "end_line": 54, + "file_path": "lib.rs", + "id": "function:190b8fbf32e627648ed53f2ce8cc285c", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "function", + "language": "rust", + "name": "make_bits", + "qualified_name": "make_bits", + "return_type": "Bits", + "signature": "() -> Bits", + "start_column": 0, + "start_line": 52, + "type_parameters": null, + "visibility": "public" + }, + { + "decorators": null, + "docstring": null, + "end_column": 1, + "end_line": 9, + "file_path": "consumer.rs", + "id": "function:88c7f6ab9fc2123a08f9ecf37298bd40", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "function", + "language": "rust", + "name": "describe_bits", + "qualified_name": "describe_bits", + "return_type": "String", + "signature": "(b: &Bits) -> String", + "start_column": 0, + "start_line": 7, + "type_parameters": null, + "visibility": "public" + }, + { + "decorators": null, + "docstring": null, + "end_column": 1, + "end_line": 5, + "file_path": "consumer.rs", + "id": "function:c8e1506aa2c158eff8b9790ef4ebfa5c", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "function", + "language": "rust", + "name": "describe_unit", + "qualified_name": "describe_unit", + "return_type": "String", + "signature": "(u: &UnitStruct) -> String", + "start_column": 0, + "start_line": 3, + "type_parameters": null, + "visibility": "public" + }, + { + "decorators": null, + "docstring": null, + "end_column": 1, + "end_line": 50, + "file_path": "lib.rs", + "id": "function:e7de8b9d2d442c9a564bee08c82b145a", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "function", + "language": "rust", + "name": "make_unit", + "qualified_name": "make_unit", + "return_type": "UnitStruct", + "signature": "() -> UnitStruct", + "start_column": 0, + "start_line": 48, + "type_parameters": null, + "visibility": "public" + }, + { + "decorators": null, + "docstring": null, + "end_column": 37, + "end_line": 1, + "file_path": "consumer.rs", + "id": "import:b45211470cf011dde09b7990d7e238e4", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "import", + "language": "rust", + "name": "crate", + "qualified_name": "crate", + "return_type": null, + "signature": "use crate::{Bits, Greet, UnitStruct};", + "start_column": 0, + "start_line": 1, + "type_parameters": null, + "visibility": null + }, + { + "decorators": null, + "docstring": null, + "end_column": 5, + "end_line": 28, + "file_path": "lib.rs", + "id": "method:15074a95e078da927a780dccd5ed2448", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "method", + "language": "rust", + "name": "greet", + "qualified_name": "TupleStruct::greet", + "return_type": "String", + "signature": "(&self) -> String", + "start_column": 4, + "start_line": 26, + "type_parameters": null, + "visibility": "private" + }, + { + "decorators": null, + "docstring": null, + "end_column": 30, + "end_line": 2, + "file_path": "lib.rs", + "id": "method:28764bbfc23c2fe8ec24a7d1b72b1330", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "method", + "language": "rust", + "name": "greet", + "qualified_name": "Greet::greet", + "return_type": "String", + "signature": "(&self) -> String", + "start_column": 4, + "start_line": 2, + "type_parameters": null, + "visibility": "private" + }, + { + "decorators": null, + "docstring": null, + "end_column": 5, + "end_line": 45, + "file_path": "lib.rs", + "id": "method:332692d36b049f0071041145d30d687c", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "method", + "language": "rust", + "name": "greet", + "qualified_name": "Bits::greet", + "return_type": "String", + "signature": "(&self) -> String", + "start_column": 4, + "start_line": 43, + "type_parameters": null, + "visibility": "private" + }, + { + "decorators": null, + "docstring": null, + "end_column": 5, + "end_line": 16, + "file_path": "lib.rs", + "id": "method:7fc738eac7790ac49dfa4b6a7cd6b9a9", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "method", + "language": "rust", + "name": "greet", + "qualified_name": "UnitStruct::greet", + "return_type": "String", + "signature": "(&self) -> String", + "start_column": 4, + "start_line": 14, + "type_parameters": null, + "visibility": "private" + }, + { + "decorators": null, + "docstring": null, + "end_column": 5, + "end_line": 22, + "file_path": "lib.rs", + "id": "method:8cb04e8ca5d9379a7bdf1b71236238cf", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "method", + "language": "rust", + "name": "greet", + "qualified_name": "BraceStruct::greet", + "return_type": "String", + "signature": "(&self) -> String", + "start_column": 4, + "start_line": 20, + "type_parameters": null, + "visibility": "private" + }, + { + "decorators": null, + "docstring": null, + "end_column": 5, + "end_line": 39, + "file_path": "lib.rs", + "id": "method:f1fe944ca0591095cb695294229acbb1", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "method", + "language": "rust", + "name": "raw", + "qualified_name": "Bits::raw", + "return_type": null, + "signature": "(&self) -> u32", + "start_column": 4, + "start_line": 37, + "type_parameters": null, + "visibility": "public" + }, + { + "decorators": null, + "docstring": null, + "end_column": 31, + "end_line": 11, + "file_path": "lib.rs", + "id": "struct:1ef30d9d3f298b426fbbbd5910139ecc", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "struct", + "language": "rust", + "name": "TupleStruct", + "qualified_name": "TupleStruct", + "return_type": null, + "signature": null, + "start_column": 0, + "start_line": 11, + "type_parameters": null, + "visibility": "public" + }, + { + "decorators": null, + "docstring": null, + "end_column": 22, + "end_line": 5, + "file_path": "lib.rs", + "id": "struct:280f7daaeca096946aa3484658c88063", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "struct", + "language": "rust", + "name": "UnitStruct", + "qualified_name": "UnitStruct", + "return_type": null, + "signature": null, + "start_column": 0, + "start_line": 5, + "type_parameters": null, + "visibility": "public" + }, + { + "decorators": null, + "docstring": null, + "end_column": 1, + "end_line": 9, + "file_path": "lib.rs", + "id": "struct:ba608806a3b56b3964d9f8172341f9d2", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "struct", + "language": "rust", + "name": "BraceStruct", + "qualified_name": "BraceStruct", + "return_type": null, + "signature": null, + "start_column": 0, + "start_line": 7, + "type_parameters": null, + "visibility": "public" + }, + { + "decorators": null, + "docstring": null, + "end_column": 1, + "end_line": 3, + "file_path": "lib.rs", + "id": "trait:822b89fd17ee8e49a50fbe03e4fe72de", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "trait", + "language": "rust", + "name": "Greet", + "qualified_name": "Greet", + "return_type": null, + "signature": null, + "start_column": 0, + "start_line": 1, + "type_parameters": null, + "visibility": null + }, + { + "decorators": null, + "docstring": null, + "end_column": 1, + "end_line": 34, + "file_path": "lib.rs", + "id": "union:466d8ec81e4f465f813cbcac35562ca9", + "is_abstract": 0, + "is_async": 0, + "is_exported": 0, + "is_static": 0, + "kind": "union", + "language": "rust", + "name": "Bits", + "qualified_name": "Bits", + "return_type": null, + "signature": null, + "start_column": 0, + "start_line": 31, + "type_parameters": null, + "visibility": "public" + } +] diff --git a/reference/golden/rust/refs.json b/reference/golden/rust/refs.json new file mode 100644 index 00000000..1cb3eab3 --- /dev/null +++ b/reference/golden/rust/refs.json @@ -0,0 +1,32 @@ +[ + { + "candidates": null, + "col": 12, + "file_path": "consumer.rs", + "from_node_id": "file:consumer.rs", + "language": "rust", + "line": 1, + "reference_kind": "imports", + "reference_name": "crate::Bits" + }, + { + "candidates": null, + "col": 18, + "file_path": "consumer.rs", + "from_node_id": "file:consumer.rs", + "language": "rust", + "line": 1, + "reference_kind": "imports", + "reference_name": "crate::Greet" + }, + { + "candidates": null, + "col": 25, + "file_path": "consumer.rs", + "from_node_id": "file:consumer.rs", + "language": "rust", + "line": 1, + "reference_kind": "imports", + "reference_name": "crate::UnitStruct" + } +] diff --git a/reference/golden/rust/schema.sql b/reference/golden/rust/schema.sql new file mode 100644 index 00000000..d36218fe --- /dev/null +++ b/reference/golden/rust/schema.sql @@ -0,0 +1,117 @@ +CREATE TABLE schema_versions ( +version INTEGER PRIMARY KEY, +applied_at INTEGER NOT NULL, +description TEXT +); +CREATE TABLE nodes ( +id TEXT PRIMARY KEY, +kind TEXT NOT NULL, +name TEXT NOT NULL, +qualified_name TEXT NOT NULL, +file_path TEXT NOT NULL, +language TEXT NOT NULL, +start_line INTEGER NOT NULL, +end_line INTEGER NOT NULL, +start_column INTEGER NOT NULL, +end_column INTEGER NOT NULL, +docstring TEXT, +signature TEXT, +visibility TEXT, +is_exported INTEGER DEFAULT 0, +is_async INTEGER DEFAULT 0, +is_static INTEGER DEFAULT 0, +is_abstract INTEGER DEFAULT 0, +decorators TEXT, -- JSON array +type_parameters TEXT, -- JSON array +return_type TEXT, -- normalized return/result type name (e.g. C++ method return, for receiver-type inference) +updated_at INTEGER NOT NULL +); +CREATE TABLE edges ( +id INTEGER PRIMARY KEY AUTOINCREMENT, +source TEXT NOT NULL, +target TEXT NOT NULL, +kind TEXT NOT NULL, +metadata TEXT, -- JSON object +line INTEGER, +col INTEGER, +provenance TEXT DEFAULT NULL, +FOREIGN KEY (source) REFERENCES nodes(id) ON DELETE CASCADE, +FOREIGN KEY (target) REFERENCES nodes(id) ON DELETE CASCADE +); +CREATE TABLE sqlite_sequence(name,seq); +CREATE TABLE files ( +path TEXT PRIMARY KEY, +content_hash TEXT NOT NULL, +language TEXT NOT NULL, +size INTEGER NOT NULL, +modified_at INTEGER NOT NULL, +indexed_at INTEGER NOT NULL, +node_count INTEGER DEFAULT 0, +errors TEXT -- JSON array +); +CREATE TABLE unresolved_refs ( +id INTEGER PRIMARY KEY AUTOINCREMENT, +from_node_id TEXT NOT NULL, +reference_name TEXT NOT NULL, +reference_kind TEXT NOT NULL, +line INTEGER NOT NULL, +col INTEGER NOT NULL, +candidates TEXT, -- JSON array +file_path TEXT NOT NULL DEFAULT '', +language TEXT NOT NULL DEFAULT 'unknown', +reference_subkind TEXT, +FOREIGN KEY (from_node_id) REFERENCES nodes(id) ON DELETE CASCADE +); +CREATE INDEX idx_nodes_kind ON nodes(kind); +CREATE INDEX idx_nodes_name ON nodes(name); +CREATE INDEX idx_nodes_qualified_name ON nodes(qualified_name); +CREATE INDEX idx_nodes_file_path ON nodes(file_path); +CREATE INDEX idx_nodes_language ON nodes(language); +CREATE INDEX idx_nodes_file_line ON nodes(file_path, start_line); +CREATE INDEX idx_nodes_lower_name ON nodes(lower(name)); +CREATE VIRTUAL TABLE nodes_fts USING fts5( +id, +name, +qualified_name, +docstring, +signature, +content='nodes', +content_rowid='rowid' +) +/* nodes_fts(id,name,qualified_name,docstring,signature) */; +CREATE TABLE 'nodes_fts_data'(id INTEGER PRIMARY KEY, block BLOB); +CREATE TABLE 'nodes_fts_idx'(segid, term, pgno, PRIMARY KEY(segid, term)) WITHOUT ROWID; +CREATE TABLE 'nodes_fts_docsize'(id INTEGER PRIMARY KEY, sz BLOB); +CREATE TABLE 'nodes_fts_config'(k PRIMARY KEY, v) WITHOUT ROWID; +CREATE TRIGGER nodes_ai AFTER INSERT ON nodes BEGIN +INSERT INTO nodes_fts(rowid, id, name, qualified_name, docstring, signature) +VALUES (NEW.rowid, NEW.id, NEW.name, NEW.qualified_name, NEW.docstring, NEW.signature); +END; +CREATE TRIGGER nodes_ad AFTER DELETE ON nodes BEGIN +INSERT INTO nodes_fts(nodes_fts, rowid, id, name, qualified_name, docstring, signature) +VALUES ('delete', OLD.rowid, OLD.id, OLD.name, OLD.qualified_name, OLD.docstring, OLD.signature); +END; +CREATE TRIGGER nodes_au AFTER UPDATE ON nodes BEGIN +INSERT INTO nodes_fts(nodes_fts, rowid, id, name, qualified_name, docstring, signature) +VALUES ('delete', OLD.rowid, OLD.id, OLD.name, OLD.qualified_name, OLD.docstring, OLD.signature); +INSERT INTO nodes_fts(rowid, id, name, qualified_name, docstring, signature) +VALUES (NEW.rowid, NEW.id, NEW.name, NEW.qualified_name, NEW.docstring, NEW.signature); +END; +CREATE INDEX idx_edges_kind ON edges(kind); +CREATE INDEX idx_edges_source_kind ON edges(source, kind); +CREATE INDEX idx_edges_target_kind ON edges(target, kind); +CREATE UNIQUE INDEX idx_edges_identity +ON edges(source, target, kind, IFNULL(line, -1), IFNULL(col, -1)); +CREATE INDEX idx_files_language ON files(language); +CREATE INDEX idx_files_modified_at ON files(modified_at); +CREATE INDEX idx_unresolved_from_node ON unresolved_refs(from_node_id); +CREATE INDEX idx_unresolved_name ON unresolved_refs(reference_name); +CREATE INDEX idx_unresolved_file_path ON unresolved_refs(file_path); +CREATE INDEX idx_unresolved_from_name ON unresolved_refs(from_node_id, reference_name); +CREATE INDEX idx_edges_provenance ON edges(provenance); +CREATE TABLE project_metadata ( +key TEXT PRIMARY KEY, +value TEXT NOT NULL, +updated_at INTEGER NOT NULL +); +CREATE TABLE sqlite_stat1(tbl,idx,stat);