From 91f61aa4b545f04bfba99631d4c6f5cc162086b3 Mon Sep 17 00:00:00 2001 From: KennySimpson <70093673+KennyMcSimpson@users.noreply.github.com> Date: Sun, 1 Nov 2026 22:32:14 +0800 Subject: [PATCH] fix: preserve TypeScript initializer types through satisfies --- crates/cg-core/src/brand.rs | 2 +- crates/cg-extract/src/facts/js.rs | 7 +++- crates/cg-extract/tests/facts_js.rs | 30 +++++++++++++++ crates/cg-resolve/tests/resolve_e2e.rs | 51 ++++++++++++++++++++++++++ crates/cg-sync/tests/incremental.rs | 40 ++++++++++++++++++++ 5 files changed, 127 insertions(+), 3 deletions(-) diff --git a/crates/cg-core/src/brand.rs b/crates/cg-core/src/brand.rs index 8d42f0e..8740215 100644 --- a/crates/cg-core/src/brand.rs +++ b/crates/cg-core/src/brand.rs @@ -17,7 +17,7 @@ pub const UPSTREAM_CONFIG_FILE: &str = "codegraph.json"; pub const CONFIG_FILE: &str = "cgr.json"; /// Version of the resolution rules: changing resolver behaviour bumps this, which /// marks older indexes as "built by an older engine" (design doc 5.8). -pub const ENGINE_VERSION: u32 = 4; +pub const ENGINE_VERSION: u32 = 5; /// Version of the on-disk segment format; a mismatch forces a full rebuild. pub const FORMAT_VERSION: u32 = 2; /// The upstream commit whose kernel is vendored (see crates/cg-kernel/UPSTREAM_COMMIT). diff --git a/crates/cg-extract/src/facts/js.rs b/crates/cg-extract/src/facts/js.rs index 86d259e..df84f5f 100644 --- a/crates/cg-extract/src/facts/js.rs +++ b/crates/cg-extract/src/facts/js.rs @@ -126,8 +126,11 @@ fn value_info(cx: &Cx, v: Node) -> (String, String) { let c = v.child_by_field_name("constructor").map(|c| cx.text(c).to_owned()).unwrap_or_default(); (String::new(), c) } - "await_expression" | "parenthesized_expression" | "non_null_expression" => v.named_child(0).map(|c| value_info(cx, c)).unwrap_or_default(), - "as_expression" | "satisfies_expression" => { + // `satisfies` checks a constraint without replacing the operand's type. + "await_expression" | "parenthesized_expression" | "non_null_expression" | "satisfies_expression" => { + v.named_child(0).map(|c| value_info(cx, c)).unwrap_or_default() + } + "as_expression" => { let t = v.named_child(1).map(|c| ts_type_name(cx, c)).unwrap_or_default(); (t, String::new()) } diff --git a/crates/cg-extract/tests/facts_js.rs b/crates/cg-extract/tests/facts_js.rs index 950637c..6b808ac 100644 --- a/crates/cg-extract/tests/facts_js.rs +++ b/crates/cg-extract/tests/facts_js.rs @@ -62,3 +62,33 @@ export class Widget extends Base { assert!(f.scopes.iter().any(|s| s.kind == ScopeKind::Class)); assert!(f.scopes.iter().filter(|s| s.kind == ScopeKind::Function).count() >= 3); } + +#[test] +fn typescript_satisfies_preserves_initializer_evidence() { + let src = r#"const direct = new Service() satisfies Runner; +const factory = makeService() satisfies Runner; +const grouped = (new Service() satisfies Runner) satisfies object; +const asserted = (new Service() as Runner) satisfies object; +const cast = new Service() as Runner; +const unknown = externalValue satisfies Runner; +const annotated: Runner = new Service() satisfies object; +class Holder { service = new Service() satisfies Runner; } +"#; + for lang in [Lang::TypeScript, Lang::Tsx] { + let b = run("satisfies.ts", src, lang); + assert_eq!(b.flags & (fileflags::PARSE_ERROR | fileflags::PANICKED), 0, "{:?}", b.errors); + for (name, decl_type, init_ctor) in [ + ("direct", "", "Service"), + ("factory", "", "makeService()"), + ("grouped", "", "Service"), + ("asserted", "Runner", ""), + ("cast", "Runner", ""), + ("unknown", "", ""), + ("annotated", "Runner", "Service"), + ("service", "", "Service"), + ] { + let binding = b.facts.bindings.iter().find(|binding| binding.name == name).unwrap(); + assert_eq!((binding.decl_type.as_str(), binding.init_ctor.as_str()), (decl_type, init_ctor), "{lang:?} {name}"); + } + } +} diff --git a/crates/cg-resolve/tests/resolve_e2e.rs b/crates/cg-resolve/tests/resolve_e2e.rs index d33b3ab..03e9819 100644 --- a/crates/cg-resolve/tests/resolve_e2e.rs +++ b/crates/cg-resolve/tests/resolve_e2e.rs @@ -77,6 +77,57 @@ export class Widget extends Base { assert!(has(&edges, "src/index.ts -imports-> src/service.ts")); } +#[test] +fn typescript_satisfies_keeps_concrete_call_targets() { + let (_d, view) = project(&[ + ("service.ts", "export interface Runner { run(): void }\nexport class Service { run() {} extra() {} }\nexport function makeService(): Service { return new Service(); }\n"), + ( + "app.ts", + r#"import { Runner, Service, makeService } from './service'; +export function direct() { + const service = new Service() satisfies Runner; + service.run(); + service.extra(); +} +export function factory() { + const service = makeService() satisfies Runner; + service.run(); + service.extra(); +} +export function plainFactory() { + const service = makeService(); + service.run(); + service.extra(); +} +export class Holder { + service = new Service() satisfies Runner; + use() { this.service.run(); this.service.extra(); } +} +export function asserted() { + const service = (new Service() as Runner) satisfies object; + service.run(); +} +"#, + ), + ]); + let edges = dump::dump_edges(&view); + for caller in ["app.ts::direct", "app.ts::Holder::use"] { + for method in ["run", "extra"] { + assert!( + has(&edges, &format!("{caller} -calls-> service.ts::Service::{method}")), + "{caller} must retain the initializer's concrete receiver: {edges:#?}" + ); + } + assert!(!has(&edges, &format!("{caller} -calls-> service.ts::Runner::run")), "satisfies must not replace the receiver with its constraint"); + } + let call_targets = |caller: &str| { + let prefix = format!("app.ts::{caller} -calls-> "); + edges.iter().filter_map(|edge| edge.strip_prefix(&prefix)).collect::>() + }; + assert_eq!(call_targets("factory"), call_targets("plainFactory"), "satisfies must preserve the existing factory inference behavior"); + assert!(has(&edges, "app.ts::asserted -calls-> service.ts::Runner::run"), "an inner as assertion still supplies its explicit type"); +} + #[test] fn python_modules_and_self() { let (_d, view) = project(&[ diff --git a/crates/cg-sync/tests/incremental.rs b/crates/cg-sync/tests/incremental.rs index abe7593..78570f8 100644 --- a/crates/cg-sync/tests/incremental.rs +++ b/crates/cg-sync/tests/incremental.rs @@ -532,6 +532,46 @@ fn up_to_date_tree_writes_nothing() { assert_eq!(Store::at(root).read_manifest().unwrap().unwrap().generation, m2.generation); } +#[test] +fn typescript_satisfies_receiver_edits_match_full_rebuild() { + let dir = tempfile::tempdir().unwrap(); + let root = dir.path(); + write(root, "service.ts", "export interface Runner { run(): void }\nexport class First { run() {} }\nexport class Second { run() {} }\n", 0); + // Enough independent files and references to exercise a delta rather than + // the small-project or affected-reference full-rebuild fallback. + for i in 0..40 { + write(root, &format!("filler{i}.ts"), &format!("export function filler{i}() {{ helper{i}(); }}\nfunction helper{i}() {{}}\n"), 0); + } + for (step, (expression, target)) in [ + ("new First() satisfies Runner", "First"), + ("new Second() satisfies Runner", "Second"), + ("(new First() as Runner) satisfies object", "Runner"), + ("new First() satisfies Runner", "First"), + ] + .iter() + .enumerate() + { + write( + root, + "app.ts", + &format!( + "import {{ Runner, First, Second }} from './service';\nexport function main() {{\n const service = {expression};\n service.run();\n}}\n" + ), + step as u64 + 1, + ); + if step == 0 { + index_project(root, &opts()).unwrap(); + } else { + let report = sync(root, &SyncOptions { index: opts(), ..Default::default() }).unwrap(); + assert!(report.full_rebuild.is_none(), "must exercise incremental resolution: {report:?}"); + } + let snap = Store::at(root).open_snapshot().unwrap(); + let calls: Vec<_> = dump::dump_edges(&snap.view).into_iter().filter(|edge| edge.starts_with("app.ts::main -calls-> ")).collect(); + assert_eq!(calls, vec![format!("app.ts::main -calls-> service.ts::{target}::run")]); + assert_eq!(canonical_of(root), full_canonical(root), "{expression}"); + } +} + #[test] fn compaction_preserves_live_graph_and_future_sync_without_source_access() { let dir = tempfile::tempdir().unwrap();