From 1f4db493f20d5b200dcfc6089ea2d211f35fcd3a Mon Sep 17 00:00:00 2001 From: Sascha <18143567+SaschaOnTour@users.noreply.github.com> Date: Mon, 1 Jun 2026 14:51:49 +0200 Subject: [PATCH 1/7] fix(test-detection): recognise #[quickcheck] as a test entry point (v1.3.1) has_test_attr matched only path segments test/rstest/test_case, so a #[quickcheck] property fn (segment `quickcheck`, not ending in `test`) was treated as production code and could be flagged DEAD_CODE / uncovered. Add `quickcheck` to the last-segment match. Failing-first regression test added to framework_test_attributes_recognized. Slice 0a of the test-quality-execution plan. Co-Authored-By: Claude Opus 4.8 (1M context) --- .gitignore | 1 + CHANGELOG.md | 18 ++++++++++++++++++ Cargo.lock | 2 +- Cargo.toml | 2 +- src/adapters/shared/cfg_test.rs | 11 +++++++---- src/adapters/shared/tests/cfg_test.rs | 4 ++++ 6 files changed, 32 insertions(+), 6 deletions(-) diff --git a/.gitignore b/.gitignore index 2b9349c8..3264d6d9 100644 --- a/.gitignore +++ b/.gitignore @@ -6,6 +6,7 @@ .claude/ *.baseline.json coverage.lcov +*.profraw CLAUDE.md bugs/ bugs.txt diff --git a/CHANGELOG.md b/CHANGELOG.md index 9fd07110..5c84b760 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,24 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [1.3.1] - 2026-06-01 + +Patch release: **test-recognition bug fix** — `#[quickcheck]` property +functions are now recognised as test entry points. This continues the +v1.3.0 work of routing all test forms through the shared `cfg_test` +predicates; `quickcheck`'s attribute (path segment `quickcheck`, not +ending in `test`) was the one common framework attribute still missed, +so a `#[quickcheck]` property fn could be flagged `DEAD_CODE` / uncovered +when treated as production code. + +### Fixed (test detection) + +- **`has_test_attr` (`adapters/shared/cfg_test.rs`) now recognises + `#[quickcheck]`** alongside `#[test]`, `#[rstest]`, `#[test_case]`, and + any attribute whose path ends in `test`. Failing-first regression test + added to `framework_test_attributes_recognized` in + `src/adapters/shared/tests/cfg_test.rs`. + ## [1.3.0] - 2026-05-29 Minor release (one breaking removal — see below): **test-entry-point diff --git a/Cargo.lock b/Cargo.lock index f04e281c..8fdd4e12 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -578,7 +578,7 @@ dependencies = [ [[package]] name = "rustqual" -version = "1.3.0" +version = "1.3.1" dependencies = [ "clap", "clap_complete", diff --git a/Cargo.toml b/Cargo.toml index 82d58071..9ddf6a4d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "rustqual" -version = "1.3.0" +version = "1.3.1" edition = "2021" description = "Comprehensive Rust code quality analyzer — seven dimensions: IOSP, Complexity, DRY, SRP, Coupling, Test Quality, Architecture" license = "MIT" diff --git a/src/adapters/shared/cfg_test.rs b/src/adapters/shared/cfg_test.rs index ba20060e..8dfe63cc 100644 --- a/src/adapters/shared/cfg_test.rs +++ b/src/adapters/shared/cfg_test.rs @@ -21,14 +21,17 @@ pub fn has_cfg_test(attrs: &[syn::Attribute]) -> bool { /// Recognises the bare `#[test]` plus the common framework variants: /// any attribute whose path ends in `test` (`#[tokio::test]`, /// `#[async_std::test]`, `#[googletest::test]`, …) and the renamed -/// macros `#[rstest]` and `#[test_case]`. Matching on the last path -/// segment keeps both bare and fully-qualified forms (`#[rstest::rstest]`) -/// in scope without an exhaustive crate list. +/// macros `#[rstest]`, `#[test_case]` and `#[quickcheck]`. Matching on +/// the last path segment keeps both bare and fully-qualified forms +/// (`#[rstest::rstest]`) in scope without an exhaustive crate list. /// Operation: attribute inspection logic, no own calls. pub fn has_test_attr(attrs: &[syn::Attribute]) -> bool { attrs.iter().any(|attr| { attr.path().segments.last().is_some_and(|seg| { - seg.ident == "test" || seg.ident == "rstest" || seg.ident == "test_case" + seg.ident == "test" + || seg.ident == "rstest" + || seg.ident == "test_case" + || seg.ident == "quickcheck" }) }) } diff --git a/src/adapters/shared/tests/cfg_test.rs b/src/adapters/shared/tests/cfg_test.rs index f10181b7..d094d63d 100644 --- a/src/adapters/shared/tests/cfg_test.rs +++ b/src/adapters/shared/tests/cfg_test.rs @@ -41,6 +41,10 @@ fn framework_test_attributes_recognized() { has_test_attr(&fn_attrs("#[test_case(1)] fn t() {}")), "#[test_case] must be recognised" ); + assert!( + has_test_attr(&fn_attrs("#[quickcheck] fn prop(x: u8) -> bool { true }")), + "#[quickcheck] must be recognised" + ); } #[test] From 0b68f0527bee31fa2e5601e7fd0ec20174d5e4eb Mon Sep 17 00:00:00 2001 From: Sascha <18143567+SaschaOnTour@users.noreply.github.com> Date: Mon, 1 Jun 2026 15:19:58 +0200 Subject: [PATCH 2/7] fix(test-detection): walk proptest!/quickcheck! macro bodies (v1.3.2) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit syn does not expand function-like macros, so #[test] fns declared inside proptest!{} / quickcheck!{} were opaque Item::Macro nodes — invisible to test classification and every analyzer dimension. Add a macro-expansion pre-pass (adapters/shared/macro_expansion.rs) run once at the top of run_analysis: it replaces a recognised test-macro invocation with the fn items it declares, each marked #[test] so they route through the shared cfg_test::has_test_attr recognition. Lenient by design — proptest's non-Rust `x in ` params are dropped (body preserved), a leading #![proptest_config(..)] is tolerated, and any parse failure keeps the original opaque macro (blind spot, never a regression). Recognition lives next to cfg_test in adapters/shared (one place for all test-recognition policy). run_analysis now takes parsed by value so the pre-pass can rewrite in place; the single hook covers both production entry points and all tests. Failing-first regression tests in src/adapters/shared/tests/macro_expansion.rs. Slice 0b of the test-quality-execution plan. Co-Authored-By: Claude Opus 4.8 (1M context) --- CHANGELOG.md | 30 ++++ Cargo.lock | 2 +- Cargo.toml | 2 +- src/adapters/shared/macro_expansion.rs | 152 ++++++++++++++++++ src/adapters/shared/mod.rs | 1 + src/adapters/shared/tests/macro_expansion.rs | 158 +++++++++++++++++++ src/adapters/shared/tests/mod.rs | 1 + src/app/pipeline.rs | 9 +- src/app/tests/pipeline.rs | 12 +- src/lib.rs | 2 +- 10 files changed, 358 insertions(+), 11 deletions(-) create mode 100644 src/adapters/shared/macro_expansion.rs create mode 100644 src/adapters/shared/tests/macro_expansion.rs diff --git a/CHANGELOG.md b/CHANGELOG.md index 5c84b760..dc397120 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,36 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [1.3.2] - 2026-06-01 + +Patch release: **test-recognition bug fix** — test functions declared +inside `proptest! { … }` and `quickcheck! { … }` macro bodies are now +visible to every analyzer dimension. `syn` does not expand function-like +macros, so a `#[test] fn` inside `proptest! { … }` was an opaque +`Item::Macro` — its body was invisible to test classification, IOSP, DRY, +complexity, SRP and test-quality alike. A new pre-pass surfaces them. + +### Fixed (test detection) + +- **`proptest!` / `quickcheck!` bodies are walked.** A new pre-pass + (`adapters/shared/macro_expansion.rs`, run once at the top of + `run_analysis`) replaces a recognised test-macro invocation with the + `fn` items it declares, each marked `#[test]` so it routes through the + shared `cfg_test::has_test_attr` recognition. The reconstruction is + lenient: `proptest`'s non-Rust `x in ` parameter grammar is + dropped (the body — what length/complexity/DRY measure — is preserved + verbatim); a leading `#![proptest_config(…)]` inner attribute is + tolerated; anything that fails to parse is kept as the original opaque + macro (a blind spot, never a regression). Recognition lives next to + `cfg_test` in `adapters/shared` to keep all test-recognition policy in + one place. Failing-first regression tests in + `src/adapters/shared/tests/macro_expansion.rs`. + +### Changed (internal) + +- `app::run_analysis` now takes its `parsed` files by value so the + expansion pre-pass can rewrite them in place before any dimension runs. + ## [1.3.1] - 2026-06-01 Patch release: **test-recognition bug fix** — `#[quickcheck]` property diff --git a/Cargo.lock b/Cargo.lock index 8fdd4e12..bdc994a1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -578,7 +578,7 @@ dependencies = [ [[package]] name = "rustqual" -version = "1.3.1" +version = "1.3.2" dependencies = [ "clap", "clap_complete", diff --git a/Cargo.toml b/Cargo.toml index 9ddf6a4d..4ff1bd58 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "rustqual" -version = "1.3.1" +version = "1.3.2" edition = "2021" description = "Comprehensive Rust code quality analyzer — seven dimensions: IOSP, Complexity, DRY, SRP, Coupling, Test Quality, Architecture" license = "MIT" diff --git a/src/adapters/shared/macro_expansion.rs b/src/adapters/shared/macro_expansion.rs new file mode 100644 index 00000000..a85c0299 --- /dev/null +++ b/src/adapters/shared/macro_expansion.rs @@ -0,0 +1,152 @@ +//! Pre-pass that surfaces test functions hidden inside test-defining +//! macro bodies (`proptest! { … }`, `quickcheck! { … }`). +//! +//! `syn` does not expand function-like macros, so a `#[test] fn` declared +//! inside `proptest! { … }` is an opaque `Item::Macro` — invisible to every +//! analyzer dimension. This module walks the parsed trees once, before any +//! dimension runs, and replaces a recognised test-macro invocation with the +//! `fn` items it declares, each marked `#[test]` (so it routes through the +//! same `cfg_test::has_test_attr` recognition as every other test). +//! +//! It is deliberately lenient: `proptest!`'s `x in ` parameter +//! grammar is not valid Rust, so the inner functions are reconstructed with +//! an empty parameter list (the body — what length/complexity/DRY measure — +//! is preserved verbatim). Anything that fails to parse is left as the +//! original opaque macro: a blind spot, never a regression. + +use syn::parse::{Parse, ParseStream}; + +use crate::adapters::shared::cfg_test::has_test_attr; + +/// Expand recognised test-macro bodies in every parsed file, in place. +/// Integration: delegates the per-file item rewrite. +pub fn expand_test_macros(parsed: &mut [(String, String, syn::File)]) { + parsed.iter_mut().for_each(|(_, _, file)| { + let items = std::mem::take(&mut file.items); + file.items = expand_items(items); + }); +} + +/// Rewrite a list of items, expanding test macros and recursing into modules. +/// Integration: flat-maps each item through `expand_item`. +fn expand_items(items: Vec) -> Vec { + items.into_iter().flat_map(expand_item).collect() +} + +/// Expand one item: a test macro becomes its `fn`s, a module is recursed +/// into, everything else passes through unchanged. +/// Integration: dispatches on the item kind to a handler. +fn expand_item(item: syn::Item) -> Vec { + match item { + syn::Item::Macro(m) => expand_macro_item(m), + syn::Item::Mod(m) => vec![syn::Item::Mod(expand_mod(m))], + other => vec![other], + } +} + +/// Recurse a module's inline body through `expand_items`. +/// Operation: rebinds the module content when present. +fn expand_mod(mut m: syn::ItemMod) -> syn::ItemMod { + if let Some((brace, items)) = m.content { + m.content = Some((brace, expand_items(items))); + } + m +} + +/// Replace a recognised test macro with the `fn`s it declares; otherwise +/// (unrecognised macro or unparseable body) keep the macro item verbatim. +/// Operation: guards on recognition + extraction success. +fn expand_macro_item(m: syn::ItemMacro) -> Vec { + if !is_test_macro(&m.mac) { + return vec![syn::Item::Macro(m)]; + } + let fns = extract_test_fns(&m.mac); + if fns.is_empty() { + vec![syn::Item::Macro(m)] + } else { + fns + } +} + +/// True if the macro is a known test-defining macro (`proptest!`, +/// `quickcheck!`), matched on the last path segment so both bare and +/// fully-qualified forms (`proptest::proptest!`) are in scope. +/// Operation: attribute-style path inspection. +fn is_test_macro(mac: &syn::Macro) -> bool { + mac.path + .segments + .last() + .is_some_and(|seg| seg.ident == "proptest" || seg.ident == "quickcheck") +} + +/// Parse the macro body into the `fn` items it declares. Returns an empty +/// vec on any parse failure (the caller then keeps the macro opaque). +/// Operation: delegates to the lenient `MacroTestFns` parser. +fn extract_test_fns(mac: &syn::Macro) -> Vec { + syn::parse2::(mac.tokens.clone()) + .map(|parsed| parsed.fns) + .unwrap_or_default() +} + +/// Lenient parser for the body of a test-defining macro: a leading run of +/// inner attributes (e.g. `#![proptest_config(…)]`) followed by one or more +/// `[#attrs] [vis] fn name[]() [-> ret] [where …] +/// { block }` shapes. +struct MacroTestFns { + fns: Vec, +} + +impl Parse for MacroTestFns { + fn parse(input: ParseStream) -> syn::Result { + // Drain a leading inner-attribute block such as proptest's + // `#![proptest_config(Config { .. })]` — it is config, not a fn. + let _config = input.call(syn::Attribute::parse_inner)?; + let mut fns = Vec::new(); + while !input.is_empty() { + fns.push(parse_one_test_fn(input)?); + } + Ok(Self { fns }) + } +} + +/// Parse a single inner function shape and rebuild it as a `#[test] fn` +/// with an empty parameter list. The original parameters (which may use +/// `proptest`'s non-Rust `x in ` grammar) are intentionally +/// dropped; the body, attributes, generics and return type are preserved. +/// Operation: sequential token parsing + struct construction. +fn parse_one_test_fn(input: ParseStream) -> syn::Result { + let mut attrs = input.call(syn::Attribute::parse_outer)?; + let _vis: syn::Visibility = input.parse()?; + let fn_token: syn::Token![fn] = input.parse()?; + let ident: syn::Ident = input.parse()?; + let mut generics: syn::Generics = input.parse()?; + let params; + syn::parenthesized!(params in input); + let _ignored: proc_macro2::TokenStream = params.parse()?; + let output: syn::ReturnType = input.parse()?; + generics.where_clause = input.parse()?; + let block: syn::Block = input.parse()?; + + if !has_test_attr(&attrs) { + attrs.push(syn::parse_quote!(#[test])); + } + let sig = syn::Signature { + constness: None, + asyncness: None, + unsafety: None, + abi: None, + fn_token, + ident, + generics, + paren_token: syn::token::Paren::default(), + inputs: syn::punctuated::Punctuated::new(), + variadic: None, + output, + }; + Ok(syn::Item::Fn(syn::ItemFn { + attrs, + vis: syn::Visibility::Inherited, + sig, + block: Box::new(block), + })) +} diff --git a/src/adapters/shared/mod.rs b/src/adapters/shared/mod.rs index 1eaf5d9c..41e5e713 100644 --- a/src/adapters/shared/mod.rs +++ b/src/adapters/shared/mod.rs @@ -7,6 +7,7 @@ pub mod cfg_test; pub mod cfg_test_files; pub mod file_to_module; +pub mod macro_expansion; pub mod normalize; pub mod use_tree; diff --git a/src/adapters/shared/tests/macro_expansion.rs b/src/adapters/shared/tests/macro_expansion.rs new file mode 100644 index 00000000..845bb0c2 --- /dev/null +++ b/src/adapters/shared/tests/macro_expansion.rs @@ -0,0 +1,158 @@ +use crate::adapters::shared::cfg_test::has_test_attr; +use crate::adapters::shared::macro_expansion::expand_test_macros; + +/// Run the expansion pre-pass over a single source file and return the +/// rewritten syntax tree. +fn expand(src: &str) -> syn::File { + let file = syn::parse_file(src).expect("parse failed"); + let mut parsed = vec![("t.rs".to_string(), src.to_string(), file)]; + expand_test_macros(&mut parsed); + parsed.into_iter().next().unwrap().2 +} + +/// Collect every `fn` reachable in the file as `(name, is_test_attr)`, +/// descending into inline modules. +fn collect_fns(items: &[syn::Item]) -> Vec<(String, bool)> { + let mut out = Vec::new(); + for item in items { + match item { + syn::Item::Fn(f) => out.push((f.sig.ident.to_string(), has_test_attr(&f.attrs))), + syn::Item::Mod(m) => { + if let Some((_, inner)) = &m.content { + out.extend(collect_fns(inner)); + } + } + _ => {} + } + } + out +} + +fn has_macro_item(items: &[syn::Item]) -> bool { + items.iter().any(|i| matches!(i, syn::Item::Macro(_))) +} + +#[test] +fn proptest_block_surfaces_inner_test_fn() { + let file = expand( + r#" +#[cfg(test)] +mod tests { + proptest! { + #[test] + fn prop_under_100(x in 0..100u32) { + assert!(x < 100); + } + } +} +"#, + ); + let fns = collect_fns(&file.items); + assert!( + fns.iter().any(|(n, t)| n == "prop_under_100" && *t), + "proptest! inner fn must surface as a test fn, got {fns:?}" + ); +} + +#[test] +fn proptest_block_surfaces_multiple_fns() { + let file = expand( + r#" +proptest! { + #[test] + fn first(x in 0..1u8) { let _ = x; } + #[test] + fn second(y in 0..1u8) { let _ = y; } +} +"#, + ); + let names: Vec = collect_fns(&file.items) + .into_iter() + .filter(|(_, t)| *t) + .map(|(n, _)| n) + .collect(); + assert!( + names.contains(&"first".to_string()) && names.contains(&"second".to_string()), + "both proptest fns must surface, got {names:?}" + ); +} + +#[test] +fn proptest_config_attribute_does_not_block_expansion() { + let file = expand( + r#" +proptest! { + #![proptest_config(ProptestConfig { cases: 10, ..ProptestConfig::default() })] + #[test] + fn with_config(x in 0..10u32) { + assert!(x < 10); + } +} +"#, + ); + let fns = collect_fns(&file.items); + assert!( + fns.iter().any(|(n, t)| n == "with_config" && *t), + "leading #![proptest_config(..)] must not block expansion, got {fns:?}" + ); +} + +#[test] +fn quickcheck_block_marks_fn_as_test() { + // quickcheck! does not write `#[test]` in the source — the macro adds + // it. The expansion must synthesise it so the fn is recognised. + let file = expand( + r#" +mod tests { + quickcheck! { + fn commutes(x: u32, y: u32) -> bool { + x.wrapping_add(y) == y.wrapping_add(x) + } + } +} +"#, + ); + let fns = collect_fns(&file.items); + assert!( + fns.iter().any(|(n, t)| n == "commutes" && *t), + "quickcheck! fn must surface and be marked as a test, got {fns:?}" + ); +} + +#[test] +fn non_test_macro_left_untouched() { + let file = expand( + r#" +lazy_static! { + static ref VALUE: u32 = 5; +} +"#, + ); + assert!( + collect_fns(&file.items).is_empty(), + "a non-test macro must not produce any fn" + ); + assert!( + has_macro_item(&file.items), + "the original non-test macro item must be preserved" + ); +} + +#[test] +fn unparseable_test_macro_falls_back_to_opaque() { + let file = expand( + r#" +proptest! { + this is @@ not a valid fn body +} +"#, + ); + assert!( + collect_fns(&file.items).is_empty(), + "unparseable body must yield no fns" + ); + assert!( + has_macro_item(&file.items), + "unparseable test macro must be kept verbatim (no regression)" + ); +} diff --git a/src/adapters/shared/tests/mod.rs b/src/adapters/shared/tests/mod.rs index bc1a3e8d..88acc2e4 100644 --- a/src/adapters/shared/tests/mod.rs +++ b/src/adapters/shared/tests/mod.rs @@ -1,5 +1,6 @@ mod cfg_test; mod cfg_test_files; mod file_to_module; +mod macro_expansion; mod normalize; mod use_tree; diff --git a/src/app/pipeline.rs b/src/app/pipeline.rs index a62bf224..0e7fdc53 100644 --- a/src/app/pipeline.rs +++ b/src/app/pipeline.rs @@ -74,9 +74,14 @@ fn run_primary_analysis( /// Run analysis and apply suppressions, returning all analysis results. /// Integration: orchestrates primary + secondary + architecture passes. pub(crate) fn run_analysis( - parsed: &[(String, String, syn::File)], + mut parsed: Vec<(String, String, syn::File)>, config: &Config, ) -> AnalysisResult { + // Surface test fns hidden in test-macro bodies (`proptest!`, + // `quickcheck!`) before any dimension runs, so every pass — including + // cfg-test classification below — sees them as ordinary `#[test]` fns. + crate::adapters::shared::macro_expansion::expand_test_macros(&mut parsed); + let parsed = parsed.as_slice(); // Compute once and thread through both passes — IOSP uses it to mark // in-cfg-test functions as test code; DRY dead-code uses it to split // prod vs test calls. Previously built twice. @@ -178,7 +183,7 @@ pub(crate) fn analyze_and_output( ) { let files = collect_filtered_files(path, config); let parsed = read_and_parse_files(&files, path); - let analysis = run_analysis(&parsed, config); + let analysis = run_analysis(parsed, config); output_results(&analysis, output_format, verbose, suggestions, config); } diff --git a/src/app/tests/pipeline.rs b/src/app/tests/pipeline.rs index fae2468b..16c1ba46 100644 --- a/src/app/tests/pipeline.rs +++ b/src/app/tests/pipeline.rs @@ -183,7 +183,7 @@ fn test_collect_suppression_multiple() { fn test_run_analysis_empty_input() { let parsed: Vec<(String, String, syn::File)> = vec![]; let config = Config::default(); - let analysis = run_analysis(&parsed, &config); + let analysis = run_analysis(parsed, &config); assert!(analysis.results.is_empty()); assert_eq!(analysis.summary.total, 0); } @@ -194,7 +194,7 @@ fn test_run_analysis_trivial_function() { let syntax = syn::parse_file(source).unwrap(); let parsed = vec![("test.rs".to_string(), source.to_string(), syntax)]; let config = Config::default(); - let analysis = run_analysis(&parsed, &config); + let analysis = run_analysis(parsed, &config); assert_eq!(analysis.results.len(), 1); assert!(matches!( analysis.results[0].classification, @@ -576,7 +576,7 @@ fn violator(x: i32) { let syntax = syn::parse_file(code).unwrap(); let parsed = vec![("test.rs".to_string(), code.to_string(), syntax)]; let config = Config::default(); - let analysis = run_analysis(&parsed, &config); + let analysis = run_analysis(parsed, &config); assert!( analysis .results @@ -631,7 +631,7 @@ fn beta(x: i32, y: i32) -> i32 { let syntax = syn::parse_file(source).unwrap(); let parsed = vec![("test.rs".to_string(), source.to_string(), syntax)]; let config = Config::default(); - let analysis = run_analysis(&parsed, &config); + let analysis = run_analysis(parsed, &config); assert!( !analysis.findings.dry.is_empty(), "findings.dry empty — duplicate not detected" @@ -669,7 +669,7 @@ fn measured(x: i32) -> i32 { let syntax = syn::parse_file(source).unwrap(); let parsed = vec![("test.rs".to_string(), source.to_string(), syntax)]; let config = Config::default(); - let analysis = run_analysis(&parsed, &config); + let analysis = run_analysis(parsed, &config); let measured = analysis .results .iter() @@ -692,7 +692,7 @@ fn test_run_analysis_findings_architecture_field_present() { // `findings.architecture` field must exist and be empty. let parsed: Vec<(String, String, syn::File)> = vec![]; let config = Config::default(); - let analysis = run_analysis(&parsed, &config); + let analysis = run_analysis(parsed, &config); assert!(analysis.findings.architecture.is_empty()); let _len: usize = analysis.findings.architecture.len(); } diff --git a/src/lib.rs b/src/lib.rs index 0bb1fa92..04398d26 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -85,7 +85,7 @@ pub fn run() -> Result<(), i32> { } let parsed = adapters::source::filesystem::read_and_parse_files(&files, &cli.path); - let mut analysis = app::run_analysis(&parsed, &config); + let mut analysis = app::run_analysis(parsed, &config); if cli.sort_by_effort { sort_by_effort(&mut analysis.results); } From 0ee1d28b53fcd44bf00fc7291967c09456011a47 Mon Sep 17 00:00:00 2001 From: Sascha <18143567+SaschaOnTour@users.noreply.github.com> Date: Mon, 1 Jun 2026 15:27:17 +0200 Subject: [PATCH 3/7] feat(config): add [tests] section for per-test-code threshold overrides MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Introduces the configuration surface for applying a curated subset of checks to test code (Phase #1, Slice 1a — scaffolding only, no behaviour change yet). TestsConfig holds Option overrides — max_function_lines (LONG_FN), file_length_baseline, file_length_ceiling, max_methods — each defaulting to None, meaning the matching production threshold is inherited. So out of the box test code is judged by the same limits as production; a project can relax them per field. The curated APPLY/KEEP split itself is fixed (not configurable). Field names mirror [complexity] / [srp]. Resolver methods that read these are added in the consuming slices (1c LONG_FN, 1d SRP) to avoid dead code. Documented in rustqual.toml and book/reference-configuration.md; tests in config/tests/sections.rs. Co-Authored-By: Claude Opus 4.8 (1M context) --- book/reference-configuration.md | 29 ++++++++++++++++++++ rustqual.toml | 19 ++++++++++++++ src/adapters/config/mod.rs | 7 ++++- src/adapters/config/sections.rs | 26 ++++++++++++++++++ src/adapters/config/tests/sections.rs | 38 +++++++++++++++++++++++++++ 5 files changed, 118 insertions(+), 1 deletion(-) diff --git a/book/reference-configuration.md b/book/reference-configuration.md index 91ce3997..d5b8c484 100644 --- a/book/reference-configuration.md +++ b/book/reference-configuration.md @@ -112,6 +112,35 @@ extra_assertion_macros = ["verify", "check_invariant", "expect_that"] `TQ-004` and `TQ-005` activate when `--coverage ` is supplied. +## `[tests]` + +Per-test-code threshold overrides. rustqual applies a **fixed, curated** +subset of checks to test code — `DRY-001`/`DRY-004`/`DRY-005`, `LONG_FN` +(function length), and SRP size (file/module length, method count). The rest +stay test-exempt (`ERROR_HANDLING`, `MAGIC_NUMBER`, IOSP, `DRY-002` dead +code, `DRY-003` wildcard imports, Coupling, all Structural detectors). Which +checks apply is **not** configurable; only the thresholds below are. + +Each key overrides the matching production threshold *for test code only*. +An unset key inherits the production value, so by default test code is judged +by the same limits as production. Field names mirror `[complexity]` and +`[srp]`. + +| Key | Inherits | Meaning | +|---|---|---| +| `max_function_lines` | `[complexity].max_function_lines` | `LONG_FN` limit for test fns | +| `file_length_baseline` | `[srp].file_length_baseline` | File-length score baseline for test files | +| `file_length_ceiling` | `[srp].file_length_ceiling` | File-length score ceiling for test files | +| `max_methods` | `[srp].max_methods` | Method-count limit for test impls | + +```toml +[tests] +max_function_lines = 120 +file_length_baseline = 500 +file_length_ceiling = 1200 +max_methods = 40 +``` + ## `[weights]` Quality-score weights. Must sum to `1.0`. diff --git a/rustqual.toml b/rustqual.toml index cfa7f014..349262d2 100644 --- a/rustqual.toml +++ b/rustqual.toml @@ -87,6 +87,25 @@ enabled = true # Example: extra_assertion_macros = ["verify", "check", "expect_that"] # extra_assertion_macros = [] +# ── Test-Code Thresholds ─────────────────────────────────────────────── +# +# rustqual applies a curated subset of checks to test code: DRY-001/004/005, +# LONG_FN (function length), and SRP size (file/module length, method count). +# Everything else stays test-exempt (ERROR_HANDLING, MAGIC_NUMBER, IOSP, +# DRY-002 dead code, DRY-003 wildcards, Coupling, all Structural detectors). +# This split is fixed; only the thresholds are configurable. +# +# Each key overrides the matching production threshold FOR TEST CODE ONLY. +# An unset key inherits the production value, so by default test code is +# judged by the same limits as production. Field names mirror [complexity] +# and [srp]. + +[tests] +# max_function_lines = 60 # overrides [complexity].max_function_lines (LONG_FN) +# file_length_baseline = 300 # overrides [srp].file_length_baseline +# file_length_ceiling = 600 # overrides [srp].file_length_ceiling +# max_methods = 20 # overrides [srp].max_methods + # ── Quality Score Weights ────────────────────────────────────────────── [weights] diff --git a/src/adapters/config/mod.rs b/src/adapters/config/mod.rs index d4ae82b6..eddb098e 100644 --- a/src/adapters/config/mod.rs +++ b/src/adapters/config/mod.rs @@ -11,7 +11,7 @@ pub use init::{generate_default_config, generate_tailored_config}; use sections::DEFAULT_MAX_SUPPRESSION_RATIO; pub use sections::{ BoilerplateConfig, ComplexityConfig, CouplingConfig, DuplicatesConfig, ReportConfig, SrpConfig, - StructuralConfig, TestConfig, WeightsConfig, + StructuralConfig, TestConfig, TestsConfig, WeightsConfig, }; /// Configuration for the rustqual analyzer. @@ -65,6 +65,10 @@ pub struct Config { /// Test quality analysis configuration. pub test_quality: TestConfig, + /// Per-test-code threshold overrides (curated checks applied to test + /// code; unset fields inherit the production thresholds). + pub tests: TestsConfig, + /// Architecture-Dimension configuration (v1.0). pub architecture: ArchitectureConfig, @@ -101,6 +105,7 @@ impl Default for Config { coupling: CouplingConfig::default(), structural: StructuralConfig::default(), test_quality: TestConfig::default(), + tests: TestsConfig::default(), architecture: ArchitectureConfig::default(), weights: WeightsConfig::default(), report: ReportConfig::default(), diff --git a/src/adapters/config/sections.rs b/src/adapters/config/sections.rs index 38c3b7cd..6061c1a8 100644 --- a/src/adapters/config/sections.rs +++ b/src/adapters/config/sections.rs @@ -198,6 +198,32 @@ impl Default for SrpConfig { } } +/// Per-test-code threshold overrides. +/// +/// rustqual applies a curated subset of checks to test code — DRY-001/004/005 +/// (duplicate fns / fragments / repeated matches), LONG_FN (function length), +/// and SRP size (file/module length, method count). The remaining checks stay +/// test-exempt: ERROR_HANDLING, MAGIC_NUMBER, IOSP, DRY-002 dead code, DRY-003 +/// wildcard imports, Coupling, and all Structural detectors. **This split is +/// fixed — only the thresholds below are configurable.** +/// +/// Each field overrides the matching production threshold *for test code +/// only*. The default is `None`, meaning the production value is inherited — +/// so out of the box test code is judged by the same limits as production. +/// Field names mirror the production sections (`[complexity]`, `[srp]`). +#[derive(Debug, Deserialize, Clone, Default)] +#[serde(default, deny_unknown_fields)] +pub struct TestsConfig { + /// Overrides `[complexity].max_function_lines` for test fns (LONG_FN). + pub max_function_lines: Option, + /// Overrides `[srp].file_length_baseline` for test files. + pub file_length_baseline: Option, + /// Overrides `[srp].file_length_ceiling` for test files. + pub file_length_ceiling: Option, + /// Overrides `[srp].max_methods` for test impls / inherent blocks. + pub max_methods: Option, +} + /// Configuration for coupling analysis. #[derive(Debug, Deserialize, Clone)] #[serde(default, deny_unknown_fields)] diff --git a/src/adapters/config/tests/sections.rs b/src/adapters/config/tests/sections.rs index 8ad72ed6..48426f9c 100644 --- a/src/adapters/config/tests/sections.rs +++ b/src/adapters/config/tests/sections.rs @@ -91,6 +91,44 @@ fn test_srp_config_deserialize_with_weights() { assert!((c.weights[0] - 0.5).abs() < f64::EPSILON); } +#[test] +fn test_tests_config_defaults_inherit_production() { + // Every override is None by default → the production threshold is used. + let c = TestsConfig::default(); + assert_eq!(c.max_function_lines, None); + assert_eq!(c.file_length_baseline, None); + assert_eq!(c.file_length_ceiling, None); + assert_eq!(c.max_methods, None); +} + +#[test] +fn test_tests_config_deserialize_overrides() { + let toml_str = r#" + max_function_lines = 120 + file_length_baseline = 500 + file_length_ceiling = 1200 + max_methods = 40 + "#; + let c: TestsConfig = toml::from_str(toml_str).unwrap(); + assert_eq!(c.max_function_lines, Some(120)); + assert_eq!(c.file_length_baseline, Some(500)); + assert_eq!(c.file_length_ceiling, Some(1200)); + assert_eq!(c.max_methods, Some(40)); +} + +#[test] +fn test_tests_config_partial_override_leaves_rest_none() { + let c: TestsConfig = toml::from_str("max_function_lines = 90").unwrap(); + assert_eq!(c.max_function_lines, Some(90)); + assert_eq!(c.file_length_ceiling, None); +} + +#[test] +fn test_tests_config_rejects_unknown_field() { + let result: Result = toml::from_str("max_fn_lines = 90"); + assert!(result.is_err(), "deny_unknown_fields must reject typos"); +} + // qual:allow(test) reason: "verifies production constant, no function/type call needed" #[test] fn test_quality_weights_sum_to_one() { From a7ce84a8e25bc2dd7b25ee0f53003c01d65859e6 Mon Sep 17 00:00:00 2001 From: Sascha <18143567+SaschaOnTour@users.noreply.github.com> Date: Mon, 1 Jun 2026 15:52:41 +0200 Subject: [PATCH 4/7] test(call-parity): extract pub_fns_by_layer helper to dedupe pub_fns tests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Slice 1b cleanup (gate still off — pure test refactor). The pub_fns tests each repeated the same ~13-line PubFnInputs construction (empty wrapper / promoted-attr / workspace sets) verbatim across ~39 tests. Extract a pub_fns_by_layer(&files) helper; the 3 tests that need a non-empty set still call collect_pub_fns_by_layer directly. Cuts the DRY fallout on pub_fns.rs from 988 fragment entries → 2 and 56 duplicate-fn entries → 14 (measured with DRY applied to tests). Co-Authored-By: Claude Opus 4.8 (1M context) --- .../call_parity_rule/tests/pub_fns.rs | 629 ++---------------- 1 file changed, 60 insertions(+), 569 deletions(-) diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns.rs index 8084c00f..f54ba5e2 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns.rs @@ -31,6 +31,27 @@ fn names_for_layer<'ast>( .unwrap_or_default() } +/// Collect pub fns by layer for the common test case — empty wrapper, +/// promoted-attribute, and workspace-lookup sets. Tests that need a +/// non-empty set call `collect_pub_fns_by_layer` directly. +fn pub_fns_by_layer<'ast>( + files: &[(&'ast str, &'ast syn::File)], +) -> HashMap>> { + let aliases = aliases_from_files(files); + collect_pub_fns_by_layer(PubFnInputs { + files, + aliases_per_file: &aliases, + layers: &three_layer(), + transparent_wrappers: &HashSet::new(), + promoted_attributes: &HashSet::new(), + workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { + cfg_test_files: &HashSet::new(), + crate_root_modules: &HashSet::new(), + workspace_module_paths: &HashSet::new(), + }, + }) +} + #[test] fn test_collect_pub_fns_in_layer_free_fn() { let file = parse( @@ -39,21 +60,7 @@ fn test_collect_pub_fns_in_layer_free_fn() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!(cli.contains("cmd_stats"), "cli = {cli:?}"); } @@ -67,21 +74,7 @@ fn test_collect_pub_fns_skips_private_fns() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!(cli.contains("cmd_stats")); assert!(!cli.contains("helper"), "private fn must be skipped"); @@ -98,21 +91,7 @@ fn test_pub_crate_is_treated_as_public_for_intra_crate_layers() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!(cli.contains("cmd_stats"), "pub(crate) must be collected"); } @@ -126,21 +105,7 @@ fn test_pub_super_and_pub_in_path_treated_as_public() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!(cli.contains("cmd_a")); assert!(cli.contains("cmd_b")); @@ -158,21 +123,7 @@ fn test_collect_pub_fns_collects_pub_impl_methods_for_pub_type() { "#, ); let files = vec![("src/application/session.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let app = names_for_layer(&by_layer, "application"); assert!(app.contains("search"), "pub impl method must be collected"); assert!( @@ -201,21 +152,7 @@ fn test_collect_pub_fns_recognises_impl_across_files() { ("src/application/session.rs", &decl_file), ("src/application/session_impls.rs", &impl_file), ]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let app = names_for_layer(&by_layer, "application"); assert!( app.contains("search"), @@ -237,21 +174,7 @@ fn test_collect_pub_fns_skips_impl_methods_on_private_type() { "#, ); let files = vec![("src/application/session.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let app = names_for_layer(&by_layer, "application"); assert!( !app.contains("search"), @@ -269,21 +192,7 @@ fn test_collect_pub_fns_groups_by_layer() { ("src/mcp/handlers.rs", &mcp_file), ("src/application/stats.rs", &app_file), ]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); assert_eq!( names_for_layer(&by_layer, "cli"), ["cmd_stats".to_string()].into() @@ -333,21 +242,7 @@ fn test_collect_pub_fns_skips_test_attr_fns() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!(cli.contains("cmd_stats")); assert!(!cli.contains("not_a_handler"), "#[test] fn must be skipped"); @@ -359,21 +254,7 @@ fn test_collect_pub_fns_skips_unmatched_files() { // call-parity scope (neither as adapter member nor as target). let file = parse("pub fn free_floating() {}"); let files = vec![("src/utils/misc.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); for layer in ["application", "cli", "mcp"] { assert!( names_for_layer(&by_layer, layer).is_empty(), @@ -397,21 +278,7 @@ fn test_collect_pub_fns_skips_pub_fn_inside_private_inline_mod() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!( cli.contains("visible_top"), @@ -434,21 +301,7 @@ fn test_collect_pub_fns_treats_pub_self_as_private() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!( cli.contains("visible"), @@ -477,21 +330,7 @@ fn test_collect_pub_fns_skips_impl_method_on_type_in_private_inline_mod() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!( !cli.contains("op"), @@ -518,21 +357,7 @@ fn test_collect_pub_fns_records_impl_in_private_mod_for_public_type() { "#, ); let files = vec![("src/application/session.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let app = names_for_layer(&by_layer, "application"); assert!( app.contains("diff"), @@ -561,21 +386,7 @@ fn test_collect_pub_fns_records_impl_via_nested_pub_use_export_path() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!( cli.contains("op"), @@ -602,21 +413,7 @@ fn test_collect_pub_fns_records_impl_via_chained_type_alias() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!( cli.contains("op"), @@ -643,21 +440,7 @@ fn test_collect_pub_fns_does_not_promote_bare_local_arc() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!( !cli.contains("op"), @@ -726,21 +509,7 @@ fn test_collect_pub_fns_does_not_promote_qualified_local_arc() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!( !cli.contains("op"), @@ -769,21 +538,7 @@ fn test_collect_pub_fns_does_not_promote_local_wrapper_alias() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!( !cli.contains("op"), @@ -810,21 +565,7 @@ fn test_collect_pub_fns_records_impl_via_renamed_stdlib_wrapper() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!( cli.contains("op"), @@ -893,21 +634,7 @@ fn test_collect_pub_fns_records_impl_via_pub_type_alias_through_wrapper() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!( cli.contains("op"), @@ -934,21 +661,7 @@ fn test_collect_pub_fns_records_impl_via_pub_type_alias() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!( cli.contains("op"), @@ -976,21 +689,7 @@ fn test_collect_pub_fns_records_renamed_reexport_impl_methods() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!( cli.contains("op"), @@ -1019,21 +718,7 @@ fn test_collect_pub_fns_chases_reexported_type_alias_to_target() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!( cli.contains("op"), @@ -1063,21 +748,7 @@ fn test_collect_pub_fns_records_pub_use_reexport_with_qualified_impl() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!( cli.contains("op"), @@ -1107,19 +778,7 @@ fn test_collect_pub_fns_skips_trait_impl_method_on_private_self_type() { "#, ); let files = vec![("src/application/mod.rs", &file)]; - let aliases = aliases_from_files(&files); - let by_layer = collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }); + let by_layer = pub_fns_by_layer(&files); let app = names_for_layer(&by_layer, "application"); assert!( !app.contains("handle"), @@ -1147,19 +806,7 @@ fn test_collect_pub_fns_records_inherited_trait_impl_methods() { "#, ); let files = vec![("src/application/mod.rs", &file)]; - let aliases = aliases_from_files(&files); - let by_layer = collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }); + let by_layer = pub_fns_by_layer(&files); let app = names_for_layer(&by_layer, "application"); assert!( app.contains("handle"), @@ -1181,19 +828,7 @@ fn test_collect_pub_fns_excludes_orphan_file_not_declared_in_crate_root() { ("src/cli/mod.rs", &cli), ("src/application/mod.rs", &app), ]; - let aliases = aliases_from_files(&files); - let by_layer = collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }); + let by_layer = pub_fns_by_layer(&files); let app_fns = names_for_layer(&by_layer, "application"); assert!( !app_fns.contains("helper"), @@ -1218,19 +853,7 @@ fn test_collect_pub_fns_unions_lib_and_main_root_trees() { ("src/application/mod.rs", &app), ("src/cli/mod.rs", &cli), ]; - let aliases = aliases_from_files(&files); - let by_layer = collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }); + let by_layer = pub_fns_by_layer(&files); let app_fns = names_for_layer(&by_layer, "application"); let cli_fns = names_for_layer(&by_layer, "cli"); assert!( @@ -1259,19 +882,7 @@ fn test_collect_pub_fns_includes_crate_root_mod_decl_without_pub() { ("src/cli/mod.rs", &cli_mod), ("src/application/mod.rs", &app_mod), ]; - let aliases = aliases_from_files(&files); - let by_layer = collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }); + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); let app = names_for_layer(&by_layer, "application"); assert!( @@ -1297,19 +908,7 @@ fn test_collect_pub_fns_excludes_pub_fn_under_private_ancestor_chain() { ("src/application/internal/mod.rs", &internal), ("src/application/internal/deep.rs", &deep), ]; - let aliases = aliases_from_files(&files); - let by_layer = collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }); + let by_layer = pub_fns_by_layer(&files); let app_fns = names_for_layer(&by_layer, "application"); assert!( !app_fns.contains("helper"), @@ -1329,19 +928,7 @@ fn test_collect_pub_fns_excludes_pub_fn_in_file_backed_private_module() { ("src/application/mod.rs", &parent), ("src/application/internal.rs", &child), ]; - let aliases = aliases_from_files(&files); - let by_layer = collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }); + let by_layer = pub_fns_by_layer(&files); let app = names_for_layer(&by_layer, "application"); assert!( !app.contains("helper"), @@ -1359,19 +946,7 @@ fn test_collect_pub_fns_includes_pub_fn_in_file_backed_public_module() { ("src/application/mod.rs", &parent), ("src/application/internal.rs", &child), ]; - let aliases = aliases_from_files(&files); - let by_layer = collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }); + let by_layer = pub_fns_by_layer(&files); let app = names_for_layer(&by_layer, "application"); assert!( app.contains("helper"), @@ -1405,21 +980,7 @@ fn test_collect_pub_fns_skips_impl_methods_under_short_name_collision() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let cli = names_for_layer(&by_layer, "cli"); assert!( cli.contains("run"), @@ -1456,21 +1017,7 @@ fn pub_fn_records_deprecated_attribute_bare() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); let dep = deprecated_for_layer(&by_layer, "cli"); assert_eq!(dep.get("cmd_old"), Some(&true)); } @@ -1484,21 +1031,7 @@ fn pub_fn_records_deprecated_with_message() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); assert_eq!( deprecated_for_layer(&by_layer, "cli").get("cmd_old"), Some(&true) @@ -1514,21 +1047,7 @@ fn pub_fn_records_deprecated_with_args() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); assert_eq!( deprecated_for_layer(&by_layer, "cli").get("cmd_old"), Some(&true) @@ -1543,21 +1062,7 @@ fn pub_fn_no_attribute_not_deprecated() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); assert_eq!( deprecated_for_layer(&by_layer, "cli").get("cmd_active"), Some(&false) @@ -1574,21 +1079,7 @@ fn pub_fn_other_attribute_not_deprecated() { "#, ); let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; + let by_layer = pub_fns_by_layer(&files); assert_eq!( deprecated_for_layer(&by_layer, "cli").get("cmd_active"), Some(&false) From 73b696cc93acc54e601d90d3f7d6a2f2bf6849b4 Mon Sep 17 00:00:00 2001 From: Sascha <18143567+SaschaOnTour@users.noreply.github.com> Date: Tue, 2 Jun 2026 16:47:01 +0200 Subject: [PATCH 5/7] feat(test-quality): apply DRY, LONG_FN & SRP-size to test code (v1.4.0) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Phase 1 of the test-quality-execution plan: a curated subset of quality checks now runs on test code, at `[tests]`-section thresholds that default to the production values. - DRY (DRY-001/004/005) run on tests; `[duplicates] ignore_tests` removed (BREAKING config: a stale `ignore_tests` line now fails to parse). - LONG_FN runs on test fns at `[tests].max_function_lines`. - SRP file-length (SRP_MODULE) runs on test files at `[tests].file_length_baseline`/`ceiling`. The SRP cohesion (independent-cluster) check stays PRODUCTION-ONLY — a test file's many independent `#[test]` fns are its purpose, not a low-cohesion smell. `analyze_module_srp` takes a `test_length_thresholds: (usize, usize)` tuple (one param to stay within SRP_PARAMS). Remediation done as real fixes, not suppressions: - ~25 oversized test files split along behavioral seams into focused directory sub-modules (mod.rs + thematic parts). - All 20 transient LONG_FN test suppressions added during 1c were then eliminated via arrange/act separation (const-hoisted fixtures/tables, fixture builders, dead-fixture removal, imports/docs lifted out of fn bodies). The total `qual:allow(complexity)` count is back to the pre-work baseline (9, all in production code) — net zero new suppressions across the whole effort. Docs: CLAUDE.md Test-aware bullet, README, CHANGELOG [1.4.0], rustqual.toml + book/reference-configuration.md `[tests]` section. Self-analysis (`cargo run -- . --fail-on-warnings`) = 0 findings across all seven dimensions; nextest green; clippy -Dwarnings clean. Co-Authored-By: Claude Opus 4.8 (1M context) --- CHANGELOG.md | 33 + Cargo.lock | 2 +- Cargo.toml | 2 +- book/reference-configuration.md | 11 +- .../call_parity_rule/tests/calls.rs | 1158 ------- .../call_parity_rule/tests/calls/basic.rs | 120 + .../tests/calls/inference_fallback.rs | 126 + .../call_parity_rule/tests/calls/mod.rs | 214 ++ .../tests/calls/receiver_tracking.rs | 156 + .../tests/calls/resolution_misc.rs | 264 ++ .../call_parity_rule/tests/calls/turbofish.rs | 192 ++ .../call_parity_rule/tests/cfg_test_impl.rs | 140 +- .../call_parity_rule/tests/check_a.rs | 408 --- .../call_parity_rule/tests/check_a/misc.rs | 64 + .../call_parity_rule/tests/check_a/mod.rs | 52 + .../call_parity_rule/tests/check_a/table.rs | 275 ++ .../call_parity_rule/tests/check_b.rs | 1799 ---------- .../tests/check_b/anchor_coverage.rs | 255 ++ .../tests/check_b/anchor_edge_cases.rs | 184 ++ .../tests/check_b/coverage.rs | 234 ++ .../call_parity_rule/tests/check_b/hints.rs | 279 ++ .../tests/check_b/missing_adapter.rs | 174 + .../call_parity_rule/tests/check_b/mod.rs | 201 ++ .../tests/check_b/promotion.rs | 199 ++ .../tests/check_b/visibility.rs | 113 + .../call_parity_rule/tests/check_c.rs | 114 +- .../call_parity_rule/tests/check_d.rs | 353 -- .../tests/check_d/anchor_multiplicity.rs | 98 + .../call_parity_rule/tests/check_d/mod.rs | 91 + .../tests/check_d/multiplicity.rs | 167 + .../tests/end_to_end_snapshot.rs | 69 +- .../tests/module_resolution.rs | 514 --- .../tests/module_resolution/mod.rs | 38 + .../tests/module_resolution/part_a.rs | 186 ++ .../tests/module_resolution/part_b.rs | 191 ++ .../call_parity_rule/tests/pub_fns.rs | 1087 ------ .../tests/pub_fns/classification.rs | 202 ++ .../tests/pub_fns/deprecated.rs | 95 + .../tests/pub_fns/free_and_groups.rs | 117 + .../call_parity_rule/tests/pub_fns/mod.rs | 106 + .../tests/pub_fns/private_mods.rs | 192 ++ .../tests/pub_fns/reexport_aliases.rs | 286 ++ .../tests/receiver_tracing.rs | 417 --- .../tests/receiver_tracing/mod.rs | 45 + .../tests/receiver_tracing/part_a.rs | 195 ++ .../tests/receiver_tracing/part_b.rs | 120 + .../tests/reexport_resolution.rs | 515 --- .../basic_and_trait_dispatch.rs | 235 ++ .../impl_and_value_reexport.rs | 254 ++ .../tests/reexport_resolution/mod.rs | 16 + .../call_parity_rule/tests/regressions.rs | 1305 -------- .../regressions/fast_path_and_negative.rs | 146 + .../tests/regressions/method_chains.rs | 154 + .../call_parity_rule/tests/regressions/mod.rs | 209 ++ .../tests/regressions/self_resolution.rs | 188 ++ .../tests/regressions/trait_dispatch.rs | 169 + .../tests/regressions/wrapper_peeling.rs | 237 ++ .../tests/regressions/wrappers_and_aliases.rs | 182 + .../call_parity_rule/tests/support.rs | 17 + .../call_parity_rule/tests/target_anchors.rs | 765 ----- .../target_anchors/across_bound_spellings.rs | 108 + .../tests/target_anchors/capability.rs | 240 ++ .../tests/target_anchors/mod.rs | 49 + .../target_anchors/trait_anchor_edges.rs | 248 ++ .../call_parity_rule/tests/touchpoints.rs | 639 ---- .../tests/touchpoints/anchor_membership.rs | 196 ++ .../call_parity_rule/tests/touchpoints/mod.rs | 59 + .../tests/touchpoints/sets.rs | 290 ++ .../type_infer/tests/infer_call.rs | 48 +- .../type_infer/tests/patterns_destructure.rs | 96 +- .../type_infer/tests/resolve.rs | 844 ----- .../type_infer/tests/resolve/mod.rs | 134 + .../type_infer/tests/resolve/part_a.rs | 175 + .../type_infer/tests/resolve/part_b.rs | 229 ++ .../type_infer/tests/workspace_index.rs | 2919 ----------------- .../empty_and_struct_fields.rs | 85 + .../workspace_index/inline_mod_and_traits.rs | 233 ++ .../leading_colon_and_disambiguation.rs | 299 ++ .../workspace_index/method_and_fn_returns.rs | 237 ++ .../type_infer/tests/workspace_index/mod.rs | 243 ++ .../workspace_index/turbofish_and_generics.rs | 227 ++ .../architecture/matcher/tests/macro_call.rs | 7 +- .../architecture/matcher/tests/method_call.rs | 39 +- .../architecture/matcher/tests/mod.rs | 14 + .../analyzers/architecture/tests/compiled.rs | 31 +- .../analyzers/architecture/tests/explain.rs | 38 +- .../architecture/tests/forbidden_rule.rs | 12 +- .../architecture/tests/golden_examples.rs | 21 +- .../analyzers/architecture/tests/mod.rs | 27 + src/adapters/analyzers/coupling/tests/root.rs | 91 +- src/adapters/analyzers/coupling/tests/sdp.rs | 115 +- .../analyzers/dry/boilerplate/tests/root.rs | 633 ---- .../boilerplate/tests/root/bp001_to_005.rs | 210 ++ .../boilerplate/tests/root/bp006_to_008.rs | 231 ++ .../boilerplate/tests/root/bp009_onward.rs | 188 ++ .../dry/boilerplate/tests/root/mod.rs | 15 + src/adapters/analyzers/dry/fragments.rs | 32 +- src/adapters/analyzers/dry/functions.rs | 45 +- src/adapters/analyzers/dry/match_patterns.rs | 41 +- src/adapters/analyzers/dry/mod.rs | 4 +- src/adapters/analyzers/dry/tests/dead_code.rs | 443 ++- src/adapters/analyzers/dry/tests/fragments.rs | 102 +- src/adapters/analyzers/dry/tests/functions.rs | 69 +- .../analyzers/dry/tests/match_patterns.rs | 50 +- src/adapters/analyzers/dry/tests/mod.rs | 15 + src/adapters/analyzers/dry/tests/root.rs | 345 +- src/adapters/analyzers/iosp/tests/classify.rs | 72 +- src/adapters/analyzers/iosp/tests/root.rs | 1330 -------- .../iosp/tests/root/classification_exact.rs | 133 + .../tests/root/classification_predicate.rs | 160 + .../iosp/tests/root/classify_basics.rs | 213 ++ .../tests/root/complexity_and_metadata.rs | 122 + .../iosp/tests/root/dispatch_and_getters.rs | 228 ++ .../analyzers/iosp/tests/root/is_test.rs | 93 + src/adapters/analyzers/iosp/tests/root/mod.rs | 77 + .../analyzers/iosp/tests/root/own_calls_a.rs | 166 + .../analyzers/iosp/tests/root/own_calls_b.rs | 150 + .../tests/scope/collection_and_ownership.rs | 108 + .../analyzers/iosp/tests/scope/mod.rs | 17 + .../trivial_and_edge_cases.rs} | 118 +- .../analyzers/iosp/visitor/tests/root.rs | 547 --- .../iosp/visitor/tests/root/complexity.rs | 141 + .../iosp/visitor/tests/root/construction.rs | 189 ++ .../tests/root/magic_and_delegation.rs | 194 ++ .../analyzers/iosp/visitor/tests/root/mod.rs | 34 + src/adapters/analyzers/srp/mod.rs | 10 +- src/adapters/analyzers/srp/module.rs | 42 +- src/adapters/analyzers/srp/tests/cohesion.rs | 545 --- .../srp/tests/cohesion/lcom4_and_collector.rs | 224 ++ .../analyzers/srp/tests/cohesion/mod.rs | 109 + .../analyzers/srp/tests/cohesion/scoring.rs | 102 + .../analyzers/srp/tests/cohesion/warnings.rs | 115 + src/adapters/analyzers/srp/tests/module.rs | 564 ---- .../analyzers/srp/tests/module/clusters.rs | 271 ++ .../analyzers/srp/tests/module/mod.rs | 13 + .../srp/tests/module/production_lines.rs | 137 + .../srp/tests/module/scoring_and_analysis.rs | 155 + src/adapters/analyzers/srp/tests/root.rs | 8 +- .../analyzers/structural/tests/btc.rs | 8 +- .../analyzers/structural/tests/deh.rs | 8 +- .../analyzers/structural/tests/iet.rs | 8 +- .../analyzers/structural/tests/mod.rs | 41 + .../analyzers/structural/tests/nms.rs | 9 +- src/adapters/analyzers/structural/tests/oi.rs | 9 +- .../analyzers/structural/tests/sit.rs | 9 +- .../analyzers/structural/tests/slm.rs | 9 +- src/adapters/analyzers/tq/tests/coverage.rs | 45 +- src/adapters/analyzers/tq/tests/sut.rs | 30 +- src/adapters/analyzers/tq/tests/untested.rs | 83 +- src/adapters/config/init.rs | 2 - src/adapters/config/sections.rs | 2 - src/adapters/config/tests/init.rs | 112 +- src/adapters/report/html/tests/root.rs | 32 +- src/adapters/report/mod.rs | 2 + src/adapters/report/sarif/tests/root.rs | 373 --- src/adapters/report/sarif/tests/root/core.rs | 151 + src/adapters/report/sarif/tests/root/mod.rs | 25 + .../tests/root/orphan_and_architecture.rs | 163 + src/adapters/report/sarif/tests/rules.rs | 55 +- src/adapters/report/test_support.rs | 77 + src/adapters/report/tests/ai.rs | 610 ---- .../report/tests/ai/build_ai_value_shape.rs | 83 + .../report/tests/ai/dimension_entries_a.rs | 188 ++ .../report/tests/ai/dimension_entries_b.rs | 121 + src/adapters/report/tests/ai/mod.rs | 81 + .../report/tests/ai/smoke_and_orphan.rs | 108 + src/adapters/report/tests/baseline.rs | 216 +- src/adapters/report/tests/github.rs | 430 --- .../report/tests/github/annotations.rs | 203 ++ src/adapters/report/tests/github/mod.rs | 59 + src/adapters/report/tests/github/rendering.rs | 125 + src/adapters/report/tests/json.rs | 586 ---- src/adapters/report/tests/json/mod.rs | 28 + .../tests/json/srp_complexity_severity.rs | 206 ++ .../tests/json/summary_fields_and_orphan.rs | 119 + .../report/tests/json/violations_and_dups.rs | 186 ++ src/adapters/report/tests/root/mod.rs | 12 + .../report/tests/root/quality_score.rs | 183 ++ .../{root.rs => root/summary_and_json.rs} | 276 +- src/adapters/report/tests/suggestions.rs | 30 +- src/adapters/report/text/tests/root.rs | 31 +- src/adapters/shared/tests/cfg_test_files.rs | 140 +- src/adapters/shared/tests/normalize.rs | 91 +- src/adapters/source/tests/filesystem.rs | 129 +- src/app/metrics.rs | 11 + .../complexity_predicates.rs | 23 +- src/app/orphan_suppressions/mod.rs | 6 +- src/app/secondary.rs | 2 +- src/app/tests/metrics.rs | 385 --- src/app/tests/metrics/mod.rs | 128 + src/app/tests/metrics/param_warnings.rs | 73 + src/app/tests/metrics/suppression.rs | 162 + src/app/tests/pipeline.rs | 95 +- src/app/tests/warnings.rs | 1392 -------- .../warnings/exclude_and_error_handling.rs | 110 + src/app/tests/warnings/extended_warnings.rs | 203 ++ src/app/tests/warnings/mod.rs | 136 + .../warnings/orphan_basics_and_suppression.rs | 218 ++ .../tests/warnings/orphan_dry_and_disabled.rs | 176 + .../tests/warnings/orphan_module_tq_arch.rs | 142 + src/app/tests/warnings/orphan_support.rs | 233 ++ src/app/warnings.rs | 25 +- 202 files changed, 19149 insertions(+), 22398 deletions(-) delete mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/calls.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/calls/basic.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/calls/inference_fallback.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/calls/mod.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/calls/receiver_tracking.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/calls/resolution_misc.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/calls/turbofish.rs delete mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/check_a.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/check_a/misc.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/check_a/mod.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/check_a/table.rs delete mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/check_b.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/anchor_coverage.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/anchor_edge_cases.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/coverage.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/hints.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/missing_adapter.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/mod.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/promotion.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/visibility.rs delete mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/check_d.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/check_d/anchor_multiplicity.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/check_d/mod.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/check_d/multiplicity.rs delete mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/module_resolution.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/module_resolution/mod.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/module_resolution/part_a.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/module_resolution/part_b.rs delete mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/classification.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/deprecated.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/free_and_groups.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/mod.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/private_mods.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/reexport_aliases.rs delete mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/receiver_tracing.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/receiver_tracing/mod.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/receiver_tracing/part_a.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/receiver_tracing/part_b.rs delete mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/reexport_resolution.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/reexport_resolution/basic_and_trait_dispatch.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/reexport_resolution/impl_and_value_reexport.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/reexport_resolution/mod.rs delete mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/regressions.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/fast_path_and_negative.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/method_chains.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/mod.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/self_resolution.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/trait_dispatch.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/wrapper_peeling.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/wrappers_and_aliases.rs delete mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors/across_bound_spellings.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors/capability.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors/mod.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors/trait_anchor_edges.rs delete mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/touchpoints.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/touchpoints/anchor_membership.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/touchpoints/mod.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/touchpoints/sets.rs delete mode 100644 src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve/mod.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve/part_a.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve/part_b.rs delete mode 100644 src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/empty_and_struct_fields.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/inline_mod_and_traits.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/leading_colon_and_disambiguation.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/method_and_fn_returns.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/mod.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/turbofish_and_generics.rs delete mode 100644 src/adapters/analyzers/dry/boilerplate/tests/root.rs create mode 100644 src/adapters/analyzers/dry/boilerplate/tests/root/bp001_to_005.rs create mode 100644 src/adapters/analyzers/dry/boilerplate/tests/root/bp006_to_008.rs create mode 100644 src/adapters/analyzers/dry/boilerplate/tests/root/bp009_onward.rs create mode 100644 src/adapters/analyzers/dry/boilerplate/tests/root/mod.rs delete mode 100644 src/adapters/analyzers/iosp/tests/root.rs create mode 100644 src/adapters/analyzers/iosp/tests/root/classification_exact.rs create mode 100644 src/adapters/analyzers/iosp/tests/root/classification_predicate.rs create mode 100644 src/adapters/analyzers/iosp/tests/root/classify_basics.rs create mode 100644 src/adapters/analyzers/iosp/tests/root/complexity_and_metadata.rs create mode 100644 src/adapters/analyzers/iosp/tests/root/dispatch_and_getters.rs create mode 100644 src/adapters/analyzers/iosp/tests/root/is_test.rs create mode 100644 src/adapters/analyzers/iosp/tests/root/mod.rs create mode 100644 src/adapters/analyzers/iosp/tests/root/own_calls_a.rs create mode 100644 src/adapters/analyzers/iosp/tests/root/own_calls_b.rs create mode 100644 src/adapters/analyzers/iosp/tests/scope/collection_and_ownership.rs create mode 100644 src/adapters/analyzers/iosp/tests/scope/mod.rs rename src/adapters/analyzers/iosp/tests/{scope.rs => scope/trivial_and_edge_cases.rs} (72%) delete mode 100644 src/adapters/analyzers/iosp/visitor/tests/root.rs create mode 100644 src/adapters/analyzers/iosp/visitor/tests/root/complexity.rs create mode 100644 src/adapters/analyzers/iosp/visitor/tests/root/construction.rs create mode 100644 src/adapters/analyzers/iosp/visitor/tests/root/magic_and_delegation.rs create mode 100644 src/adapters/analyzers/iosp/visitor/tests/root/mod.rs delete mode 100644 src/adapters/analyzers/srp/tests/cohesion.rs create mode 100644 src/adapters/analyzers/srp/tests/cohesion/lcom4_and_collector.rs create mode 100644 src/adapters/analyzers/srp/tests/cohesion/mod.rs create mode 100644 src/adapters/analyzers/srp/tests/cohesion/scoring.rs create mode 100644 src/adapters/analyzers/srp/tests/cohesion/warnings.rs delete mode 100644 src/adapters/analyzers/srp/tests/module.rs create mode 100644 src/adapters/analyzers/srp/tests/module/clusters.rs create mode 100644 src/adapters/analyzers/srp/tests/module/mod.rs create mode 100644 src/adapters/analyzers/srp/tests/module/production_lines.rs create mode 100644 src/adapters/analyzers/srp/tests/module/scoring_and_analysis.rs delete mode 100644 src/adapters/report/sarif/tests/root.rs create mode 100644 src/adapters/report/sarif/tests/root/core.rs create mode 100644 src/adapters/report/sarif/tests/root/mod.rs create mode 100644 src/adapters/report/sarif/tests/root/orphan_and_architecture.rs create mode 100644 src/adapters/report/test_support.rs delete mode 100644 src/adapters/report/tests/ai.rs create mode 100644 src/adapters/report/tests/ai/build_ai_value_shape.rs create mode 100644 src/adapters/report/tests/ai/dimension_entries_a.rs create mode 100644 src/adapters/report/tests/ai/dimension_entries_b.rs create mode 100644 src/adapters/report/tests/ai/mod.rs create mode 100644 src/adapters/report/tests/ai/smoke_and_orphan.rs delete mode 100644 src/adapters/report/tests/github.rs create mode 100644 src/adapters/report/tests/github/annotations.rs create mode 100644 src/adapters/report/tests/github/mod.rs create mode 100644 src/adapters/report/tests/github/rendering.rs delete mode 100644 src/adapters/report/tests/json.rs create mode 100644 src/adapters/report/tests/json/mod.rs create mode 100644 src/adapters/report/tests/json/srp_complexity_severity.rs create mode 100644 src/adapters/report/tests/json/summary_fields_and_orphan.rs create mode 100644 src/adapters/report/tests/json/violations_and_dups.rs create mode 100644 src/adapters/report/tests/root/mod.rs create mode 100644 src/adapters/report/tests/root/quality_score.rs rename src/adapters/report/tests/{root.rs => root/summary_and_json.rs} (54%) delete mode 100644 src/app/tests/metrics.rs create mode 100644 src/app/tests/metrics/mod.rs create mode 100644 src/app/tests/metrics/param_warnings.rs create mode 100644 src/app/tests/metrics/suppression.rs delete mode 100644 src/app/tests/warnings.rs create mode 100644 src/app/tests/warnings/exclude_and_error_handling.rs create mode 100644 src/app/tests/warnings/extended_warnings.rs create mode 100644 src/app/tests/warnings/mod.rs create mode 100644 src/app/tests/warnings/orphan_basics_and_suppression.rs create mode 100644 src/app/tests/warnings/orphan_dry_and_disabled.rs create mode 100644 src/app/tests/warnings/orphan_module_tq_arch.rs create mode 100644 src/app/tests/warnings/orphan_support.rs diff --git a/CHANGELOG.md b/CHANGELOG.md index dc397120..65df4aba 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,39 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [1.4.0] - 2026-06-02 + +Minor release: **quality checks now run on test code.** DRY (duplicate-function +DRY-001, code-fragment DRY-004, repeated-match DRY-005), function-length +(LONG_FN), and SRP file-length (SRP_MODULE) previously skipped +`#[cfg(test)]`/test files. They now analyze test code too, so duplicated test +helpers, copy-pasted arrange/assert blocks, overlong test fns, and oversized +test files are all flagged — at test-specific thresholds that default to the +production values. + +### Changed +- **BREAKING (config):** the `[duplicates] ignore_tests` field is **removed**. + Because `[duplicates]` uses `deny_unknown_fields`, a `rustqual.toml` that + still sets `ignore_tests` will now fail to parse — delete the line. There is + no replacement: DRY-001/004/005 always run on tests. `detect_repeated_matches` + no longer takes a config argument. +- DRY-003 (wildcard imports) remains test-exempt by its own logic, unchanged. +- **LONG_FN now applies to test functions** at the new + `[tests].max_function_lines` threshold (an `Option` defaulting to + `[complexity].max_function_lines` = production, 60). Large table-driven tests + were refactored — case tables hoisted to module-level `const`s so the test + body stays small; genuinely-long single-scenario tests carry a + `// qual:allow(complexity)` with rationale. +- **SRP file-length (SRP_MODULE) now applies to test files** at the new + `[tests].file_length_baseline` / `[tests].file_length_ceiling` thresholds + (`Option`s defaulting to `[srp]` = 300 / 800). Oversized test files were + **split along behavioral seams** into focused sub-modules — no suppressions. + The SRP **cohesion** (independent-cluster) check stays **production-only**: a + test file's many independent `#[test]` fns are its purpose, not a low-cohesion + smell. +- Cognitive/cyclomatic/nesting complexity already ran on tests; magic-number + and error-handling checks remain test-exempt; no change there. + ## [1.3.2] - 2026-06-01 Patch release: **test-recognition bug fix** — test functions declared diff --git a/Cargo.lock b/Cargo.lock index bdc994a1..e87e8cf4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -578,7 +578,7 @@ dependencies = [ [[package]] name = "rustqual" -version = "1.3.2" +version = "1.4.0" dependencies = [ "clap", "clap_complete", diff --git a/Cargo.toml b/Cargo.toml index 4ff1bd58..40fa36e4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "rustqual" -version = "1.3.2" +version = "1.4.0" edition = "2021" description = "Comprehensive Rust code quality analyzer — seven dimensions: IOSP, Complexity, DRY, SRP, Coupling, Test Quality, Architecture" license = "MIT" diff --git a/book/reference-configuration.md b/book/reference-configuration.md index d5b8c484..379db7eb 100644 --- a/book/reference-configuration.md +++ b/book/reference-configuration.md @@ -116,10 +116,13 @@ extra_assertion_macros = ["verify", "check_invariant", "expect_that"] Per-test-code threshold overrides. rustqual applies a **fixed, curated** subset of checks to test code — `DRY-001`/`DRY-004`/`DRY-005`, `LONG_FN` -(function length), and SRP size (file/module length, method count). The rest -stay test-exempt (`ERROR_HANDLING`, `MAGIC_NUMBER`, IOSP, `DRY-002` dead -code, `DRY-003` wildcard imports, Coupling, all Structural detectors). Which -checks apply is **not** configurable; only the thresholds below are. +(function length), and SRP **file-length** (`SRP_MODULE`). The rest stay +test-exempt (`ERROR_HANDLING`, `MAGIC_NUMBER`, IOSP, `DRY-002` dead code, +`DRY-003` wildcard imports, Coupling, all Structural detectors). The SRP +**cohesion** check (independent function clusters) is also **production-only**: +a test file's many independent `#[test]` fns are its purpose, not a low-cohesion +smell — so only file-length is judged on test files. Which checks apply is +**not** configurable; only the thresholds below are. Each key overrides the matching production threshold *for test code only*. An unset key inherits the production value, so by default test code is judged diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/calls.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/calls.rs deleted file mode 100644 index 29f5beb1..00000000 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/calls.rs +++ /dev/null @@ -1,1158 +0,0 @@ -//! Tests for the canonical call-target collector — the pre-pass that -//! turns a `syn::Block` into a `HashSet` of canonical targets, -//! including receiver-type-tracked method calls. - -use crate::adapters::analyzers::architecture::call_parity_rule::calls::{ - collect_canonical_calls, FnContext, -}; -use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; -use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::{ - collect_crate_root_modules, collect_local_symbols, -}; -use crate::adapters::shared::use_tree::{gather_alias_map, AliasMap, ScopedAliasMap}; -use std::collections::{HashMap, HashSet}; - -fn parse_file(src: &str) -> syn::File { - syn::parse_str(src).expect("parse file") -} - -fn parse_type(src: &str) -> syn::Type { - syn::parse_str(src).expect("parse type") -} - -/// Build a context from a full file source plus the name of the fn whose -/// body we want to analyse. Picks up the fn's signature + alias map -/// automatically. -struct FileCtx { - file: syn::File, - alias_map: AliasMap, - aliases_per_scope: ScopedAliasMap, - local_symbols: HashSet, - local_decl_scopes: HashMap>>, - crate_root_modules: HashSet, -} - -impl FileCtx { - fn file_scope<'a>(&'a self, importing_file: &'a str) -> FileScope<'a> { - FileScope { - path: importing_file, - alias_map: &self.alias_map, - aliases_per_scope: &self.aliases_per_scope, - local_symbols: &self.local_symbols, - local_decl_scopes: &self.local_decl_scopes, - crate_root_modules: &self.crate_root_modules, - workspace_module_paths: None, - } - } -} - -fn load(src: &str) -> FileCtx { - let file = parse_file(src); - let alias_map = gather_alias_map(&file); - let local_symbols = collect_local_symbols(&file); - // Single-file unit tests don't populate the scoped overlays — - // they're left empty so the resolver falls back to flat behaviour. - FileCtx { - file, - alias_map, - aliases_per_scope: ScopedAliasMap::new(), - local_symbols, - local_decl_scopes: HashMap::new(), - crate_root_modules: HashSet::new(), - } -} - -fn load_with_roots(src: &str, roots: &[&str]) -> FileCtx { - let mut fctx = load(src); - fctx.crate_root_modules = roots.iter().map(|s| s.to_string()).collect(); - fctx -} - -/// Convenience — rebuild crate_root_modules from a slice of pseudo-file -/// paths (same shape `build_call_graph` sees) so tests match the real -/// pipeline's derivation. -fn roots_from_paths(paths: &[&str]) -> HashSet { - let fake: Vec<(&str, &syn::File)> = Vec::new(); - let _ = fake; - let dummy = parse_file(""); - let refs: Vec<(&str, &syn::File)> = paths.iter().map(|p| (*p, &dummy)).collect(); - collect_crate_root_modules(&refs) -} - -fn find_fn<'a>(file: &'a syn::File, name: &str) -> &'a syn::ItemFn { - file.items - .iter() - .find_map(|i| match i { - syn::Item::Fn(f) if f.sig.ident == name => Some(f), - _ => None, - }) - .unwrap_or_else(|| panic!("fn {name} not found")) -} - -fn impl_self_ty_name(item_impl: &syn::ItemImpl) -> Option { - match item_impl.self_ty.as_ref() { - syn::Type::Path(p) => p.path.segments.last().map(|s| s.ident.to_string()), - _ => None, - } -} - -fn find_impl_fn<'a>( - file: &'a syn::File, - type_name: &str, - fn_name: &str, -) -> (&'a syn::ItemImpl, &'a syn::ImplItemFn) { - file.items - .iter() - .filter_map(|item| match item { - syn::Item::Impl(i) if impl_self_ty_name(i).as_deref() == Some(type_name) => Some(i), - _ => None, - }) - .find_map(|item_impl| { - item_impl.items.iter().find_map(|it| match it { - syn::ImplItem::Fn(f) if f.sig.ident == fn_name => Some((item_impl, f)), - _ => None, - }) - }) - .unwrap_or_else(|| panic!("impl {type_name}::{fn_name} not found")) -} - -fn sig_params(sig: &syn::Signature) -> Vec<(String, &syn::Type)> { - sig.inputs - .iter() - .filter_map(|arg| match arg { - syn::FnArg::Typed(pt) => { - let name = match pt.pat.as_ref() { - syn::Pat::Ident(pi) => pi.ident.to_string(), - _ => return None, - }; - Some((name, pt.ty.as_ref())) - } - _ => None, - }) - .collect() -} - -fn ctx_for_fn<'a>( - fctx: &'a FileCtx, - file_scope: &'a FileScope<'a>, - fn_name: &str, -) -> FnContext<'a> { - let f = find_fn(&fctx.file, fn_name); - FnContext { - file: file_scope, - mod_stack: &[], - body: &f.block, - signature_params: sig_params(&f.sig), - generic_params: std::collections::HashMap::new(), - self_type: None, - workspace_index: None, - workspace_files: None, - reexports: None, - } -} - -fn canonical_of_impl_self(item: &syn::ItemImpl) -> Option> { - if let syn::Type::Path(p) = item.self_ty.as_ref() { - Some( - p.path - .segments - .iter() - .map(|s| s.ident.to_string()) - .collect(), - ) - } else { - None - } -} - -// ── Basic call resolution ───────────────────────────────────── - -#[test] -fn test_collect_direct_qualified_call() { - let fctx = load( - r#" - pub fn cmd_search() { - crate::application::stats::get_stats(1); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains("crate::application::stats::get_stats")); -} - -#[test] -fn test_collect_unqualified_via_use_alias() { - let fctx = load( - r#" - use crate::application::stats::get_stats; - pub fn cmd_search() { - get_stats(1); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains("crate::application::stats::get_stats")); -} - -#[test] -fn test_collect_unqualified_no_alias_is_bare() { - let fctx = load( - r#" - pub fn cmd_search() { - foo(1); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains(":foo")); -} - -#[test] -fn test_collect_in_semicolon_separated_macro_descends() { - // Regression: `vec![expr; n]`-style macros have tokens `expr ; n` - // which fails the comma-list parser. The block fallback wraps them - // in braces and extracts stmt-level expressions. - let fctx = load( - r#" - pub fn cmd_search() { - let _v = vec![compute(x); 3]; - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains(":compute"), - "`;`-separated macro body must still descend, got {calls:?}" - ); -} - -#[test] -fn test_collect_in_macro_descends() { - let fctx = load( - r#" - pub fn cmd_search() { - debug_assert!(validate(1)); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains(":validate")); - // The macro itself must not be recorded as a call target. - assert!(!calls.contains(":debug_assert")); -} - -#[test] -fn test_collect_self_super_prefix() { - // `self::` inside `src/cli/mod.rs` resolves against module `crate::cli`, - // so `self::helpers::format` → `crate::cli::helpers::format`. A non-mod - // file (e.g. `src/cli/handlers.rs`) would resolve to - // `crate::cli::handlers::helpers::format`, which is the Rust-semantic - // outcome; the collector defers to `resolve_to_crate_absolute` for - // this so both cases stay consistent with the file's module path. - let fctx = load( - r#" - pub fn cmd_search() { - self::helpers::format(1); - } - "#, - ); - let fs = fctx.file_scope("src/cli/mod.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::cli::helpers::format"), - "calls = {:?}", - calls - ); -} - -#[test] -fn test_collect_turbofish_stripped() { - let fctx = load( - r#" - pub fn cmd_search() { - Box::::new(42); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains(":Box::new")); -} - -// ── Turbofish + inferred-T resolution (v1.2.1) ──────────────────── - -#[test] -fn test_collect_turbofish_call_resolves_via_use() { - // `record_symbol_query::(args)` with a `use` import in - // scope → the call must canonicalise to the absolute path of the - // imported function, not `:`. Pre-fix, turbofish call sites - // were dropped from the call graph. - let fctx = load( - r#" - use crate::middleware::record_symbol_query; - pub fn cmd_search() { - record_symbol_query::(0); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::middleware::record_symbol_query"), - "turbofish call must resolve through use-alias, got {calls:?}" - ); -} - -#[test] -fn test_collect_inferred_generic_call_resolves_via_use() { - // `record_operation(args)` (T inferred) with use in scope. Same - // resolution path as a non-generic call — confirms there's no - // generic-args-keying mismatch on the definition side. - let fctx = load( - r#" - use crate::middleware::record_operation; - pub fn cmd_search() { - record_operation(0, "x", true); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::middleware::record_operation"), - "inferred-generic call must resolve through use-alias, got {calls:?}" - ); -} - -#[test] -fn test_turbofish_in_impl_method_body_resolves() { - // Turbofish call lives inside an impl method, not a free fn. The - // impl block's self_ty has its own scope; the `use` must still be - // visible in the body. - let fctx = load( - r#" - use crate::middleware::record_symbol_query; - pub struct Session; - impl Session { - pub fn refs(&self, sym: &str) { - record_symbol_query::(&self, sym); - } - } - "#, - ); - let fs = fctx.file_scope("src/application/session.rs"); - let f = find_impl_fn(&fctx.file, "Session", "refs"); - let ctx = FnContext { - file: &fs, - mod_stack: &[], - body: &f.1.block, - signature_params: sig_params(&f.1.sig), - generic_params: std::collections::HashMap::new(), - self_type: canonical_of_impl_self(f.0), - workspace_index: None, - workspace_files: None, - reexports: None, - }; - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::middleware::record_symbol_query"), - "turbofish in impl-method body must resolve via use, got {calls:?}" - ); -} - -#[test] -fn test_turbofish_via_child_module_qualified_path_resolves() { - // Pattern that may bite when use is in a sibling/child module: - // qualified-path call with turbofish, no `use` at the call site. - let fctx = load_with_roots( - r#" - pub fn cmd_search() { - crate::middleware::record_symbol_query::(0); - } - "#, - &["middleware"], - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::middleware::record_symbol_query"), - "qualified-path turbofish must resolve, got {calls:?}" - ); -} - -#[test] -fn test_multiple_turbofish_calls_to_same_fn_resolve_to_one_canonical() { - // Three turbofish call sites, three different generic args. - // The collector must dedupe to a single canonical entry (the call - // set is a HashSet). - let fctx = load( - r#" - use crate::middleware::record_symbol_query; - pub struct Session; - impl Session { - pub fn refs(&self, sym: &str) { - record_symbol_query::(&self, sym); - record_symbol_query::(&self, sym); - record_symbol_query::(&self, sym); - } - } - "#, - ); - let fs = fctx.file_scope("src/application/session.rs"); - let f = find_impl_fn(&fctx.file, "Session", "refs"); - let ctx = FnContext { - file: &fs, - mod_stack: &[], - body: &f.1.block, - signature_params: sig_params(&f.1.sig), - generic_params: std::collections::HashMap::new(), - self_type: canonical_of_impl_self(f.0), - workspace_index: None, - workspace_files: None, - reexports: None, - }; - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::middleware::record_symbol_query"), - "all three turbofish call sites must dedupe to one canonical, got {calls:?}" - ); -} - -#[test] -fn test_turbofish_unresolved_path_still_bare() { - // No `use` for `Box` → still `:Box::new`. Behavior unchanged - // for genuinely unresolvable paths; only the resolved case needed - // fixing. - let fctx = load( - r#" - pub fn cmd_search() { - Box::::new(42); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains(":Box::new"), - "unresolved turbofish should still bare-key, got {calls:?}" - ); -} - -#[test] -fn test_collect_closure_body_collected() { - let fctx = load( - r#" - pub fn cmd_search() { - let f = |x: u32| inner_call(x); - f(1); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains(":inner_call")); -} - -#[test] -fn test_collect_await_is_not_extra_call() { - let fctx = load( - r#" - pub async fn cmd_search() { - f(1).await; - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains(":f")); - // .await is not a call target - assert!(!calls.iter().any(|c| c.contains("await"))); -} - -#[test] -fn test_collect_self_dispatch_in_impl() { - let fctx = load( - r#" - pub struct RlmSession; - impl RlmSession { - pub fn search(&self) { - Self::internal_helper(); - } - } - "#, - ); - let (item, f) = find_impl_fn(&fctx.file, "RlmSession", "search"); - let self_ty = canonical_of_impl_self(item); - let ctx = FnContext { - file: &FileScope { - path: "src/application/session.rs", - alias_map: &fctx.alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &fctx.local_symbols, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &fctx.crate_root_modules, - workspace_module_paths: None, - }, - mod_stack: &[], - body: &f.block, - signature_params: sig_params(&f.sig), - generic_params: std::collections::HashMap::new(), - self_type: self_ty, - workspace_index: None, - workspace_files: None, - reexports: None, - }; - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::application::session::RlmSession::internal_helper"), - "calls = {:?}", - calls - ); -} - -// ── Receiver-Type-Tracking ──────────────────────────────────── - -#[test] -fn test_tracker_let_constructor_binding() { - let fctx = load( - r#" - use crate::app::session::RlmSession; - pub fn cmd_search(q: u32) { - let s = RlmSession::open_cwd(); - s.search(q); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::app::session::RlmSession::search"), - "calls = {:?}", - calls - ); -} - -#[test] -fn test_tracker_let_type_annotation() { - let fctx = load( - r#" - use crate::app::session::RlmSession; - pub fn cmd_search(q: u32) { - let s: RlmSession = make_session(); - s.search(q); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains("crate::app::session::RlmSession::search")); -} - -#[test] -fn test_tracker_fn_param_type() { - let fctx = load( - r#" - use crate::app::session::RlmSession; - pub fn handle(session: RlmSession) { - session.search(1); - } - "#, - ); - let fs = fctx.file_scope("src/mcp/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "handle"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains("crate::app::session::RlmSession::search")); -} - -#[test] -fn test_tracker_fn_param_ref_type() { - let fctx = load( - r#" - use crate::app::session::RlmSession; - pub fn handle(session: &RlmSession) { - session.search(1); - } - "#, - ); - let fs = fctx.file_scope("src/mcp/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "handle"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains("crate::app::session::RlmSession::search")); -} - -#[test] -fn test_tracker_fn_param_arc_type() { - let fctx = load( - r#" - use crate::app::session::RlmSession; - use std::sync::Arc; - pub fn handle(session: Arc) { - session.search(1); - } - "#, - ); - let fs = fctx.file_scope("src/mcp/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "handle"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains("crate::app::session::RlmSession::search")); -} - -#[test] -fn test_tracker_fn_param_box_ref_mut_type() { - let fctx = load( - r#" - use crate::app::session::RlmSession; - pub fn a(session: Box) { session.search(1); } - pub fn b(session: &mut RlmSession) { session.search(1); } - "#, - ); - let fs = fctx.file_scope("src/mcp/handlers.rs"); - for name in &["a", "b"] { - let ctx = ctx_for_fn(&fctx, &fs, name); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::app::session::RlmSession::search"), - "fn {name} calls = {:?}", - calls - ); - } -} - -#[test] -fn test_tracker_alias_resolved_constructor() { - let fctx = load( - r#" - use crate::app::session::RlmSession; - pub fn cmd_search() { - let s = RlmSession::open(); - s.search(1); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains("crate::app::session::RlmSession::search")); -} - -#[test] -fn test_tracker_shadowing_uses_latest() { - let fctx = load( - r#" - use crate::app::session::RlmSession; - use crate::cli::CliSession; - pub fn cmd_search() { - let s = CliSession::new(); - let s = RlmSession::open(); - s.search(1); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains("crate::app::session::RlmSession::search")); - assert!(!calls.contains("crate::cli::CliSession::search")); -} - -#[test] -fn test_tracker_unknown_receiver_falls_back_to_method_shape() { - let fctx = load( - r#" - pub fn cmd_search(x: UnknownType) { - x.search(1); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains(":search")); - assert!(!calls.iter().any(|c| c.contains("UnknownType::search"))); -} - -#[test] -fn test_tracker_closure_inherits_parent_bindings() { - let fctx = load( - r#" - use crate::app::session::RlmSession; - pub fn cmd_search() { - let s = RlmSession::open(); - let f = || s.search(1); - f(); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains("crate::app::session::RlmSession::search")); -} - -#[test] -fn test_tracker_factory_helper_unresolved_falls_back_to_method_shape() { - // Documented limitation: no 1-hop return-type inference. - let fctx = load( - r#" - pub fn cmd_search() { - let s = helpers::open_session(); - s.search(1); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains(":search")); -} - -#[test] -fn test_tracker_in_async_fn() { - let fctx = load( - r#" - use crate::app::session::RlmSession; - pub async fn handle(s: RlmSession) { - s.search(1).await; - } - "#, - ); - let fs = fctx.file_scope("src/mcp/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "handle"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains("crate::app::session::RlmSession::search")); -} - -#[test] -fn test_collect_async_block() { - let fctx = load( - r#" - use crate::app::session::RlmSession; - pub fn cmd_search() { - let s = RlmSession::open(); - let _fut = async { s.search(1) }; - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::app::session::RlmSession::search"), - "calls = {:?}", - calls - ); -} - -#[test] -fn test_empty_body_yields_no_calls() { - let fctx = load("pub fn f() {}"); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "f"); - let calls = collect_canonical_calls(&ctx); - assert_eq!(calls, HashSet::::new()); -} - -#[test] -fn test_local_helper_call_resolves_to_crate_module() { - // Regression: `helper()` without a `use` statement is a valid Rust - // same-module call. Must resolve to `crate::::helper` - // so the graph sees the edge — not `:helper` dead-end. - let fctx = load( - r#" - fn helper() {} - pub fn cmd_foo() { - helper(); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_foo"); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::cli::handlers::helper"), - "local helper must resolve via file module, got {calls:?}" - ); - assert!( - !calls.contains(":helper"), - "local helper must not fall back to bare, got {calls:?}" - ); -} - -#[test] -fn test_external_call_without_use_still_falls_to_bare() { - // Conservative: if the first segment isn't in local_symbols (and no - // `use` aliased it), stay `:…`. Otherwise external crate or - // stdlib calls would be wrongly attributed to the local module. - let fctx = load( - r#" - pub fn cmd_foo() { - not_a_local_symbol(); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_foo"); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains(":not_a_local_symbol"), - "unknown fn must stay bare, got {calls:?}" - ); -} - -#[test] -fn test_super_aliased_call_normalises_to_crate_rooted() { - // `use super::stats::get_stats;` expands to `["super","stats","get_stats"]` - // in the alias map. Without normalisation the canonical would be - // `super::stats::get_stats`, which never matches graph nodes. - // Post-alias re-normalisation turns it into `crate::…::get_stats`. - let fctx = load( - r#" - use super::stats::get_stats; - pub fn cmd_foo() { - get_stats(); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_foo"); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::cli::stats::get_stats"), - "super-aliased call must normalise to crate::, got {calls:?}" - ); - assert!( - !calls.iter().any(|c| c.starts_with("super::")), - "super-rooted canonical must not leak, got {calls:?}" - ); -} - -#[test] -fn test_unqualified_local_type_in_signature_resolves() { - // `struct Session;` declared in this file + `fn f(s: Session)` — Rust - // doesn't require a `use` for same-file types. Receiver tracking must - // still resolve `s.search()` via the local-type fallback. - let fctx = load( - r#" - pub struct Session; - impl Session { - pub fn search(&self) {} - } - pub fn cmd_foo(s: Session) { - s.search(); - } - "#, - ); - let fs = fctx.file_scope("src/application/session.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_foo"); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::application::session::Session::search"), - "unqualified local-type receiver must resolve, got {calls:?}" - ); - assert!( - !calls.contains(":search"), - "must not fall back to :, got {calls:?}" - ); -} - -#[test] -fn test_rust2018_absolute_call_without_use_resolves_to_crate_rooted() { - // Regression: `app::foo()` called directly (no `use app::foo;`) is - // also a crate-root module call in Rust 2018+. Must resolve to - // `crate::app::foo`, mirroring the alias-backed case. - let fctx = load_with_roots( - r#" - pub fn cmd_x() { - app::foo(); - } - "#, - &["app"], - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_x"); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::app::foo"), - "unaliased Rust 2018+ call must crate-prefix, got {calls:?}" - ); - assert!( - !calls.iter().any(|c| c == ":app::foo"), - "must not fall back to bare, got {calls:?}" - ); -} - -#[test] -fn test_rust2018_absolute_import_resolves_to_crate_rooted() { - // Rust 2018+: `use app::foo;` at the top of a non-root file is the - // crate-root module `app`, equivalent to `use crate::app::foo;`. - // When `app` is a known workspace root module, the alias expansion - // must prepend `crate::` so the call graph matches. - let fctx = load_with_roots( - r#" - use app::foo; - pub fn cmd_x() { - foo(); - } - "#, - &["app"], - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_x"); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::app::foo"), - "Rust 2018+ absolute import must normalise to crate::, got {calls:?}" - ); - assert!( - !calls.iter().any(|c| c == "app::foo"), - "must not leave unprefixed app::foo, got {calls:?}" - ); -} - -#[test] -fn test_collect_crate_root_modules_from_paths() { - // `src/app/mod.rs`, `src/app/session.rs`, `src/cli/handlers.rs` → - // {"app", "cli"}. `src/lib.rs` and `src/main.rs` are excluded. - let roots = roots_from_paths(&[ - "src/app/mod.rs", - "src/app/session.rs", - "src/cli/handlers.rs", - "src/lib.rs", - "src/main.rs", - ]); - assert!(roots.contains("app")); - assert!(roots.contains("cli")); - assert!(!roots.contains("lib")); - assert!(!roots.contains("main")); -} - -#[test] -fn test_top_level_self_as_alias_maps_to_current_file() { - // `use self as fs;` at the top of `src/util/fs_helpers.rs` — `self` - // at crate-root-adjacent position means the current file's module. - // Downstream normalisation must resolve `fs::something` to - // `crate::util::fs_helpers::something`, not leak as a dead-end. - let fctx = load( - r#" - use self as fs; - pub fn cmd_x() { - fs::something(); - } - "#, - ); - let fs = fctx.file_scope("src/util/fs_helpers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_x"); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::util::fs_helpers::something"), - "top-level self-alias must resolve to the current file's module, got {calls:?}" - ); -} - -#[test] -fn test_qualified_impl_path_does_not_double_crate() { - // `impl crate::app::Session { fn search() }` — the impl header - // already gives a crate-rooted path. The canonical Self-target must - // be `crate::app::Session::search`, NOT - // `crate::::crate::app::Session::search`. - let fctx = load( - r#" - impl crate::app::Session { - pub fn search(&self) { - Self::internal_helper(); - } - } - "#, - ); - let (item, f) = find_impl_fn(&fctx.file, "Session", "search"); - let self_ty = canonical_of_impl_self(item); - let ctx = FnContext { - file: &FileScope { - path: "src/other_file.rs", - alias_map: &fctx.alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &fctx.local_symbols, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &fctx.crate_root_modules, - workspace_module_paths: None, - }, - mod_stack: &[], - body: &f.block, - signature_params: sig_params(&f.sig), - generic_params: std::collections::HashMap::new(), - self_type: self_ty, - workspace_index: None, - workspace_files: None, - reexports: None, - }; - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::app::Session::internal_helper"), - "qualified impl path must canonicalise as-is, got {calls:?}" - ); - assert!( - !calls.iter().any(|c| c.contains("crate::crate::")), - "must not double-crate, got {calls:?}" - ); -} - -// ── Shallow-inference fallback (Task 1.6) ──────────────────────── - -/// Helper: build a `FnContext` with a pre-populated workspace index. -fn ctx_with_index<'a>( - fctx: &'a FileCtx, - file_scope: &'a FileScope<'a>, - fn_name: &str, - index: &'a crate::adapters::analyzers::architecture::call_parity_rule::type_infer::WorkspaceTypeIndex, -) -> FnContext<'a> { - let f = find_fn(&fctx.file, fn_name); - FnContext { - file: file_scope, - mod_stack: &[], - body: &f.block, - signature_params: sig_params(&f.sig), - generic_params: std::collections::HashMap::new(), - self_type: None, - workspace_index: Some(index), - workspace_files: None, - reexports: None, - } -} - -#[test] -fn test_inference_fallback_resolves_method_chain_ctor_pattern() { - // The pattern that motivated this inference work: method chain - // on a constructor + `?` unwrap. Legacy extract_let_binding can't - // see through the MethodCall; inference walks the chain and ends at T. - use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::{ - CanonicalType, WorkspaceTypeIndex, - }; - let fctx = load( - r#" - use crate::app::session::Session; - pub fn cmd_diff() { - let session = Session::open().map_err(handle_err).unwrap(); - session.diff(); - } - "#, - ); - let mut index = WorkspaceTypeIndex::new(); - // `Session::open()` returns Result. - index.insert_method_return( - "crate::app::session::Session", - "open", - CanonicalType::Result(Box::new(CanonicalType::path([ - "crate", "app", "session", "Session", - ]))), - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_with_index(&fctx, &fs, "cmd_diff", &index); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::app::session::Session::diff"), - "inference fallback should resolve session.diff(), got {calls:?}" - ); -} - -#[test] -fn test_inference_fallback_resolves_field_access() { - // `ctx.session.diff()` — receiver is Expr::Field, resolved via the - // inference layer + workspace struct-field index. Fixture uses - // `use crate::app::Ctx` so the signature-param `&Ctx` canonicalises - // to `crate::app::Ctx` directly. - use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::{ - CanonicalType, WorkspaceTypeIndex, - }; - let fctx = load( - r#" - use crate::app::Ctx; - pub fn handle_diff(ctx: &Ctx) { - ctx.session.diff(); - } - "#, - ); - let mut index = WorkspaceTypeIndex::new(); - index.insert_struct_field( - "crate::app::Ctx", - "session", - CanonicalType::path(["crate", "app", "Session"]), - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_with_index(&fctx, &fs, "handle_diff", &index); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::app::Session::diff"), - "field-access inference should resolve ctx.session.diff(), got {calls:?}" - ); -} - -#[test] -fn test_inference_fallback_on_result_unwrap_chain() { - // End-to-end: `session.open().unwrap().diff()` — combinator table - // unwraps Result, then method resolution on Session proceeds. - use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::{ - CanonicalType, WorkspaceTypeIndex, - }; - let fctx = load( - r#" - use crate::app::session::Session; - pub fn cmd_direct() { - Session::open().unwrap().diff(); - } - "#, - ); - let mut index = WorkspaceTypeIndex::new(); - index.insert_method_return( - "crate::app::session::Session", - "open", - CanonicalType::Result(Box::new(CanonicalType::path([ - "crate", "app", "session", "Session", - ]))), - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_with_index(&fctx, &fs, "cmd_direct", &index); - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::app::session::Session::diff"), - "combinator chain should resolve Session::open().unwrap().diff(), got {calls:?}" - ); -} - -#[test] -fn test_existing_fast_path_still_works_without_index() { - // Regression guard: legacy extract_let_binding keeps working when - // workspace_index is None (unit-test fixture shape). - let fctx = load( - r#" - use crate::app::session::RlmSession; - pub fn cmd_search(q: u32) { - let s = RlmSession::open_cwd(); - s.search(q); - } - "#, - ); - let fs = fctx.file_scope("src/cli/handlers.rs"); - let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); - let calls = collect_canonical_calls(&ctx); - assert!(calls.contains("crate::app::session::RlmSession::search")); -} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/basic.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/basic.rs new file mode 100644 index 00000000..8d3a4959 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/basic.rs @@ -0,0 +1,120 @@ +use super::*; + +// ── Basic call resolution ───────────────────────────────────── + +#[test] +fn test_collect_direct_qualified_call() { + let calls = calls_in( + r#" + pub fn cmd_search() { + crate::application::stats::get_stats(1); + } + "#, + "src/cli/handlers.rs", + "cmd_search", + ); + assert!(calls.contains("crate::application::stats::get_stats")); +} + +#[test] +fn test_collect_unqualified_via_use_alias() { + let calls = calls_in( + r#" + use crate::application::stats::get_stats; + pub fn cmd_search() { + get_stats(1); + } + "#, + "src/cli/handlers.rs", + "cmd_search", + ); + assert!(calls.contains("crate::application::stats::get_stats")); +} + +#[test] +fn test_collect_unqualified_no_alias_is_bare() { + let calls = calls_in( + r#" + pub fn cmd_search() { + foo(1); + } + "#, + "src/cli/handlers.rs", + "cmd_search", + ); + assert!(calls.contains(":foo")); +} + +#[test] +fn test_collect_in_semicolon_separated_macro_descends() { + // Regression: `vec![expr; n]`-style macros have tokens `expr ; n` + // which fails the comma-list parser. The block fallback wraps them + // in braces and extracts stmt-level expressions. + let calls = calls_in( + r#" + pub fn cmd_search() { + let _v = vec![compute(x); 3]; + } + "#, + "src/cli/handlers.rs", + "cmd_search", + ); + assert!( + calls.contains(":compute"), + "`;`-separated macro body must still descend, got {calls:?}" + ); +} + +#[test] +fn test_collect_in_macro_descends() { + let calls = calls_in( + r#" + pub fn cmd_search() { + debug_assert!(validate(1)); + } + "#, + "src/cli/handlers.rs", + "cmd_search", + ); + assert!(calls.contains(":validate")); + // The macro itself must not be recorded as a call target. + assert!(!calls.contains(":debug_assert")); +} + +#[test] +fn test_collect_self_super_prefix() { + // `self::` inside `src/cli/mod.rs` resolves against module `crate::cli`, + // so `self::helpers::format` → `crate::cli::helpers::format`. A non-mod + // file (e.g. `src/cli/handlers.rs`) would resolve to + // `crate::cli::handlers::helpers::format`, which is the Rust-semantic + // outcome; the collector defers to `resolve_to_crate_absolute` for + // this so both cases stay consistent with the file's module path. + let calls = calls_in( + r#" + pub fn cmd_search() { + self::helpers::format(1); + } + "#, + "src/cli/mod.rs", + "cmd_search", + ); + assert!( + calls.contains("crate::cli::helpers::format"), + "calls = {:?}", + calls + ); +} + +#[test] +fn test_collect_turbofish_stripped() { + let calls = calls_in( + r#" + pub fn cmd_search() { + Box::::new(42); + } + "#, + "src/cli/handlers.rs", + "cmd_search", + ); + assert!(calls.contains(":Box::new")); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/inference_fallback.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/inference_fallback.rs new file mode 100644 index 00000000..0297bb67 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/inference_fallback.rs @@ -0,0 +1,126 @@ +use super::*; + +// ── Shallow-inference fallback (Task 1.6) ──────────────────────── + +/// Helper: build a `FnContext` with a pre-populated workspace index. +fn ctx_with_index<'a>( + fctx: &'a FileCtx, + file_scope: &'a FileScope<'a>, + fn_name: &str, + index: &'a crate::adapters::analyzers::architecture::call_parity_rule::type_infer::WorkspaceTypeIndex, +) -> FnContext<'a> { + let f = find_fn(&fctx.file, fn_name); + FnContext { + file: file_scope, + mod_stack: &[], + body: &f.block, + signature_params: sig_params(&f.sig), + generic_params: std::collections::HashMap::new(), + self_type: None, + workspace_index: Some(index), + workspace_files: None, + reexports: None, + } +} + +#[test] +fn test_inference_fallback_resolves_session_diff_through_open_result() { + // `Session::open()` returns Result; inference unwraps the + // combinator chain (legacy extract_let_binding can't see through the + // MethodCall) and resolves the trailing `.diff()` to Session::diff, + // however the chain is spelled. (label, source, fn) + use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::{ + CanonicalType, WorkspaceTypeIndex, + }; + let cases: &[(&str, &str, &str)] = &[ + ( + "method chain ctor + map_err + unwrap via let binding", + r#" + use crate::app::session::Session; + pub fn cmd_diff() { + let session = Session::open().map_err(handle_err).unwrap(); + session.diff(); + } + "#, + "cmd_diff", + ), + ( + "direct open().unwrap().diff() combinator chain", + r#" + use crate::app::session::Session; + pub fn cmd_direct() { + Session::open().unwrap().diff(); + } + "#, + "cmd_direct", + ), + ]; + for (label, src, fn_name) in cases { + let fctx = load(src); + let mut index = WorkspaceTypeIndex::new(); + index.insert_method_return( + "crate::app::session::Session", + "open", + CanonicalType::Result(Box::new(CanonicalType::path([ + "crate", "app", "session", "Session", + ]))), + ); + let fs = fctx.file_scope("src/cli/handlers.rs"); + let ctx = ctx_with_index(&fctx, &fs, fn_name, &index); + let calls = collect_canonical_calls(&ctx); + assert!( + calls.contains("crate::app::session::Session::diff"), + "case {label}: {calls:?}" + ); + } +} + +#[test] +fn test_inference_fallback_resolves_field_access() { + // `ctx.session.diff()` — receiver is Expr::Field, resolved via the + // inference layer + workspace struct-field index. Fixture uses + // `use crate::app::Ctx` so the signature-param `&Ctx` canonicalises + // to `crate::app::Ctx` directly. + use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::{ + CanonicalType, WorkspaceTypeIndex, + }; + let fctx = load( + r#" + use crate::app::Ctx; + pub fn handle_diff(ctx: &Ctx) { + ctx.session.diff(); + } + "#, + ); + let mut index = WorkspaceTypeIndex::new(); + index.insert_struct_field( + "crate::app::Ctx", + "session", + CanonicalType::path(["crate", "app", "Session"]), + ); + let fs = fctx.file_scope("src/cli/handlers.rs"); + let ctx = ctx_with_index(&fctx, &fs, "handle_diff", &index); + let calls = collect_canonical_calls(&ctx); + assert!( + calls.contains("crate::app::Session::diff"), + "field-access inference should resolve ctx.session.diff(), got {calls:?}" + ); +} + +#[test] +fn test_existing_fast_path_still_works_without_index() { + // Regression guard: legacy extract_let_binding keeps working when + // workspace_index is None (unit-test fixture shape). + let calls = calls_in( + r#" + use crate::app::session::RlmSession; + pub fn cmd_search(q: u32) { + let s = RlmSession::open_cwd(); + s.search(q); + } + "#, + "src/cli/handlers.rs", + "cmd_search", + ); + assert!(calls.contains("crate::app::session::RlmSession::search")); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/mod.rs new file mode 100644 index 00000000..8cbe1e68 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/mod.rs @@ -0,0 +1,214 @@ +//! Tests for call-site collection + canonical resolution. Split into focused +//! sub-files (each ≤ the SRP file-length cap); shared imports, the `FileCtx` +//! fixture, and the parse/load/calls_in helpers live here and reach the +//! sub-modules via `use super::*`. + +pub(super) use crate::adapters::analyzers::architecture::call_parity_rule::calls::*; +pub(super) use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; +pub(super) use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::*; +pub(super) use crate::adapters::shared::use_tree::{gather_alias_map, AliasMap, ScopedAliasMap}; +pub(super) use std::collections::{HashMap, HashSet}; + +mod basic; +mod inference_fallback; +mod receiver_tracking; +mod resolution_misc; +mod turbofish; + +pub(super) fn parse_file(src: &str) -> syn::File { + syn::parse_str(src).expect("parse file") +} + +pub(super) fn parse_type(src: &str) -> syn::Type { + syn::parse_str(src).expect("parse type") +} + +/// Build a context from a full file source plus the name of the fn whose +/// body we want to analyse. Picks up the fn's signature + alias map +/// automatically. +pub(super) struct FileCtx { + pub(super) file: syn::File, + pub(super) alias_map: AliasMap, + pub(super) aliases_per_scope: ScopedAliasMap, + pub(super) local_symbols: HashSet, + pub(super) local_decl_scopes: HashMap>>, + pub(super) crate_root_modules: HashSet, +} + +impl FileCtx { + pub(super) fn file_scope<'a>(&'a self, importing_file: &'a str) -> FileScope<'a> { + FileScope { + path: importing_file, + alias_map: &self.alias_map, + aliases_per_scope: &self.aliases_per_scope, + local_symbols: &self.local_symbols, + local_decl_scopes: &self.local_decl_scopes, + crate_root_modules: &self.crate_root_modules, + workspace_module_paths: None, + } + } +} + +pub(super) fn load(src: &str) -> FileCtx { + let file = parse_file(src); + let alias_map = gather_alias_map(&file); + let local_symbols = collect_local_symbols(&file); + // Single-file unit tests don't populate the scoped overlays — + // they're left empty so the resolver falls back to flat behaviour. + FileCtx { + file, + alias_map, + aliases_per_scope: ScopedAliasMap::new(), + local_symbols, + local_decl_scopes: HashMap::new(), + crate_root_modules: HashSet::new(), + } +} + +pub(super) fn load_with_roots(src: &str, roots: &[&str]) -> FileCtx { + let mut fctx = load(src); + fctx.crate_root_modules = roots.iter().map(|s| s.to_string()).collect(); + fctx +} + +/// Convenience — rebuild crate_root_modules from a slice of pseudo-file +/// paths (same shape `build_call_graph` sees) so tests match the real +/// pipeline's derivation. +pub(super) fn roots_from_paths(paths: &[&str]) -> HashSet { + let fake: Vec<(&str, &syn::File)> = Vec::new(); + let _ = fake; + let dummy = parse_file(""); + let refs: Vec<(&str, &syn::File)> = paths.iter().map(|p| (*p, &dummy)).collect(); + collect_crate_root_modules(&refs) +} + +pub(super) fn find_fn<'a>(file: &'a syn::File, name: &str) -> &'a syn::ItemFn { + file.items + .iter() + .find_map(|i| match i { + syn::Item::Fn(f) if f.sig.ident == name => Some(f), + _ => None, + }) + .unwrap_or_else(|| panic!("fn {name} not found")) +} + +pub(super) fn impl_self_ty_name(item_impl: &syn::ItemImpl) -> Option { + match item_impl.self_ty.as_ref() { + syn::Type::Path(p) => p.path.segments.last().map(|s| s.ident.to_string()), + _ => None, + } +} + +pub(super) fn find_impl_fn<'a>( + file: &'a syn::File, + type_name: &str, + fn_name: &str, +) -> (&'a syn::ItemImpl, &'a syn::ImplItemFn) { + file.items + .iter() + .filter_map(|item| match item { + syn::Item::Impl(i) if impl_self_ty_name(i).as_deref() == Some(type_name) => Some(i), + _ => None, + }) + .find_map(|item_impl| { + item_impl.items.iter().find_map(|it| match it { + syn::ImplItem::Fn(f) if f.sig.ident == fn_name => Some((item_impl, f)), + _ => None, + }) + }) + .unwrap_or_else(|| panic!("impl {type_name}::{fn_name} not found")) +} + +pub(super) fn sig_params(sig: &syn::Signature) -> Vec<(String, &syn::Type)> { + sig.inputs + .iter() + .filter_map(|arg| match arg { + syn::FnArg::Typed(pt) => { + let name = match pt.pat.as_ref() { + syn::Pat::Ident(pi) => pi.ident.to_string(), + _ => return None, + }; + Some((name, pt.ty.as_ref())) + } + _ => None, + }) + .collect() +} + +pub(super) fn ctx_for_fn<'a>( + fctx: &'a FileCtx, + file_scope: &'a FileScope<'a>, + fn_name: &str, +) -> FnContext<'a> { + let f = find_fn(&fctx.file, fn_name); + FnContext { + file: file_scope, + mod_stack: &[], + body: &f.block, + signature_params: sig_params(&f.sig), + generic_params: std::collections::HashMap::new(), + self_type: None, + workspace_index: None, + workspace_files: None, + reexports: None, + } +} + +/// Load `src`, resolve `fn_name`'s body as if imported into `importing_file`, +/// and return its canonical call set — the shared arrange across most tests +/// (load → file_scope → ctx_for_fn → collect_canonical_calls). +pub(super) fn calls_in(src: &str, importing_file: &str, fn_name: &str) -> HashSet { + let fctx = load(src); + let fs = fctx.file_scope(importing_file); + let ctx = ctx_for_fn(&fctx, &fs, fn_name); + collect_canonical_calls(&ctx) +} + +pub(super) fn calls_in_roots( + src: &str, + roots: &[&str], + importing_file: &str, + fn_name: &str, +) -> HashSet { + let fctx = load_with_roots(src, roots); + let fs = fctx.file_scope(importing_file); + let ctx = ctx_for_fn(&fctx, &fs, fn_name); + collect_canonical_calls(&ctx) +} + +pub(super) fn calls_in_impl_method( + src: &str, + importing_file: &str, + type_name: &str, + fn_name: &str, +) -> HashSet { + let fctx = load(src); + let fs = fctx.file_scope(importing_file); + let (item, f) = find_impl_fn(&fctx.file, type_name, fn_name); + let ctx = FnContext { + file: &fs, + mod_stack: &[], + body: &f.block, + signature_params: sig_params(&f.sig), + generic_params: std::collections::HashMap::new(), + self_type: canonical_of_impl_self(item), + workspace_index: None, + workspace_files: None, + reexports: None, + }; + collect_canonical_calls(&ctx) +} + +pub(super) fn canonical_of_impl_self(item: &syn::ItemImpl) -> Option> { + if let syn::Type::Path(p) = item.self_ty.as_ref() { + Some( + p.path + .segments + .iter() + .map(|s| s.ident.to_string()) + .collect(), + ) + } else { + None + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/receiver_tracking.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/receiver_tracking.rs new file mode 100644 index 00000000..b491c800 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/receiver_tracking.rs @@ -0,0 +1,156 @@ +use super::*; + +// ── Receiver-Type-Tracking ──────────────────────────────────── + +const RLM_USE: &str = "use crate::app::session::RlmSession;"; +/// Receiver-tracking case: `(label, source, importing_file, fn)`. `String` +/// source (built with `format!`) so the shared `use` prefix can be reused. +type ReceiverCase = (&'static str, String, &'static str, &'static str); + +/// Cases where the `RlmSession` receiver type is carried by a function +/// parameter (by value, by ref, `Arc`-wrapped, and async). +fn receiver_param_cases() -> Vec { + vec![ + ( + "fn param by value", + format!("{RLM_USE}\npub fn handle(session: RlmSession) {{ session.search(1); }}"), + "src/mcp/handlers.rs", + "handle", + ), + ( + "fn param by ref", + format!("{RLM_USE}\npub fn handle(session: &RlmSession) {{ session.search(1); }}"), + "src/mcp/handlers.rs", + "handle", + ), + ( + "fn param Arc-wrapped", + format!("{RLM_USE}\nuse std::sync::Arc;\npub fn handle(session: Arc) {{ session.search(1); }}"), + "src/mcp/handlers.rs", + "handle", + ), + ( + "async fn", + format!("{RLM_USE}\npub async fn handle(s: RlmSession) {{ s.search(1).await; }}"), + "src/mcp/handlers.rs", + "handle", + ), + ] +} + +/// Cases where the receiver type comes from a local binding (constructor, +/// type annotation, alias-resolved constructor, closure capture). +fn receiver_binding_cases() -> Vec { + vec![ + ( + "let-binding constructor", + format!("{RLM_USE}\npub fn cmd_search(q: u32) {{ let s = RlmSession::open_cwd(); s.search(q); }}"), + "src/cli/handlers.rs", + "cmd_search", + ), + ( + "let type annotation", + format!("{RLM_USE}\npub fn cmd_search(q: u32) {{ let s: RlmSession = make_session(); s.search(q); }}"), + "src/cli/handlers.rs", + "cmd_search", + ), + ( + "alias-resolved constructor", + format!("{RLM_USE}\npub fn cmd_search() {{ let s = RlmSession::open(); s.search(1); }}"), + "src/cli/handlers.rs", + "cmd_search", + ), + ( + "closure inherits parent binding", + format!("{RLM_USE}\npub fn cmd_search() {{ let s = RlmSession::open(); let f = || s.search(1); f(); }}"), + "src/cli/handlers.rs", + "cmd_search", + ), + ] +} + +#[test] +fn tracker_resolves_receiver_type() { + // However a binding/param of `RlmSession` is introduced, `s.search()` + // must resolve to `RlmSession::search`. + let mut cases = receiver_param_cases(); + cases.extend(receiver_binding_cases()); + for (label, src, path, fn_name) in &cases { + let calls = calls_in(src, path, fn_name); + assert!( + calls.contains("crate::app::session::RlmSession::search"), + "case {label}: {calls:?}" + ); + } +} + +#[test] +fn test_tracker_fn_param_box_ref_mut_type() { + let fctx = load( + r#" + use crate::app::session::RlmSession; + pub fn a(session: Box) { session.search(1); } + pub fn b(session: &mut RlmSession) { session.search(1); } + "#, + ); + let fs = fctx.file_scope("src/mcp/handlers.rs"); + for name in &["a", "b"] { + let ctx = ctx_for_fn(&fctx, &fs, name); + let calls = collect_canonical_calls(&ctx); + assert!( + calls.contains("crate::app::session::RlmSession::search"), + "fn {name} calls = {:?}", + calls + ); + } +} + +#[test] +fn test_tracker_shadowing_uses_latest() { + let calls = calls_in( + r#" + use crate::app::session::RlmSession; + use crate::cli::CliSession; + pub fn cmd_search() { + let s = CliSession::new(); + let s = RlmSession::open(); + s.search(1); + } + "#, + "src/cli/handlers.rs", + "cmd_search", + ); + assert!(calls.contains("crate::app::session::RlmSession::search")); + assert!(!calls.contains("crate::cli::CliSession::search")); +} + +#[test] +fn test_tracker_unknown_receiver_falls_back_to_method_shape() { + let calls = calls_in( + r#" + pub fn cmd_search(x: UnknownType) { + x.search(1); + } + "#, + "src/cli/handlers.rs", + "cmd_search", + ); + assert!(calls.contains(":search")); + assert!(!calls.iter().any(|c| c.contains("UnknownType::search"))); +} + +#[test] +fn test_tracker_factory_helper_unresolved_falls_back_to_method_shape() { + // Documented limitation: no 1-hop return-type inference. + let calls = calls_in( + r#" + pub fn cmd_search() { + let s = helpers::open_session(); + s.search(1); + } + "#, + "src/cli/handlers.rs", + "cmd_search", + ); + assert!(calls.contains(":search")); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/resolution_misc.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/resolution_misc.rs new file mode 100644 index 00000000..c6d64aae --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/resolution_misc.rs @@ -0,0 +1,264 @@ +use super::*; + +#[test] +fn test_collect_async_block() { + let calls = calls_in( + r#" + use crate::app::session::RlmSession; + pub fn cmd_search() { + let s = RlmSession::open(); + let _fut = async { s.search(1) }; + } + "#, + "src/cli/handlers.rs", + "cmd_search", + ); + assert!( + calls.contains("crate::app::session::RlmSession::search"), + "calls = {:?}", + calls + ); +} + +#[test] +fn test_empty_body_yields_no_calls() { + let calls = calls_in("pub fn f() {}", "src/cli/handlers.rs", "f"); + assert_eq!(calls, HashSet::::new()); +} + +#[test] +fn test_local_helper_call_resolves_to_crate_module() { + // Regression: `helper()` without a `use` statement is a valid Rust + // same-module call. Must resolve to `crate::::helper` + // so the graph sees the edge — not `:helper` dead-end. + let calls = calls_in( + r#" + fn helper() {} + pub fn cmd_foo() { + helper(); + } + "#, + "src/cli/handlers.rs", + "cmd_foo", + ); + assert!( + calls.contains("crate::cli::handlers::helper"), + "local helper must resolve via file module, got {calls:?}" + ); + assert!( + !calls.contains(":helper"), + "local helper must not fall back to bare, got {calls:?}" + ); +} + +#[test] +fn test_external_call_without_use_still_falls_to_bare() { + // Conservative: if the first segment isn't in local_symbols (and no + // `use` aliased it), stay `:…`. Otherwise external crate or + // stdlib calls would be wrongly attributed to the local module. + let calls = calls_in( + r#" + pub fn cmd_foo() { + not_a_local_symbol(); + } + "#, + "src/cli/handlers.rs", + "cmd_foo", + ); + assert!( + calls.contains(":not_a_local_symbol"), + "unknown fn must stay bare, got {calls:?}" + ); +} + +#[test] +fn test_super_aliased_call_normalises_to_crate_rooted() { + // `use super::stats::get_stats;` expands to `["super","stats","get_stats"]` + // in the alias map. Without normalisation the canonical would be + // `super::stats::get_stats`, which never matches graph nodes. + // Post-alias re-normalisation turns it into `crate::…::get_stats`. + let calls = calls_in( + r#" + use super::stats::get_stats; + pub fn cmd_foo() { + get_stats(); + } + "#, + "src/cli/handlers.rs", + "cmd_foo", + ); + assert!( + calls.contains("crate::cli::stats::get_stats"), + "super-aliased call must normalise to crate::, got {calls:?}" + ); + assert!( + !calls.iter().any(|c| c.starts_with("super::")), + "super-rooted canonical must not leak, got {calls:?}" + ); +} + +#[test] +fn test_unqualified_local_type_in_signature_resolves() { + // `struct Session;` declared in this file + `fn f(s: Session)` — Rust + // doesn't require a `use` for same-file types. Receiver tracking must + // still resolve `s.search()` via the local-type fallback. + let calls = calls_in( + r#" + pub struct Session; + impl Session { + pub fn search(&self) {} + } + pub fn cmd_foo(s: Session) { + s.search(); + } + "#, + "src/application/session.rs", + "cmd_foo", + ); + assert!( + calls.contains("crate::application::session::Session::search"), + "unqualified local-type receiver must resolve, got {calls:?}" + ); + assert!( + !calls.contains(":search"), + "must not fall back to :, got {calls:?}" + ); +} + +#[test] +fn test_rust2018_absolute_call_without_use_resolves_to_crate_rooted() { + // Regression: `app::foo()` called directly (no `use app::foo;`) is + // also a crate-root module call in Rust 2018+. Must resolve to + // `crate::app::foo`, mirroring the alias-backed case. + let calls = calls_in_roots( + r#" + pub fn cmd_x() { + app::foo(); + } + "#, + &["app"], + "src/cli/handlers.rs", + "cmd_x", + ); + assert!( + calls.contains("crate::app::foo"), + "unaliased Rust 2018+ call must crate-prefix, got {calls:?}" + ); + assert!( + !calls.iter().any(|c| c == ":app::foo"), + "must not fall back to bare, got {calls:?}" + ); +} + +#[test] +fn test_rust2018_absolute_import_resolves_to_crate_rooted() { + // Rust 2018+: `use app::foo;` at the top of a non-root file is the + // crate-root module `app`, equivalent to `use crate::app::foo;`. + // When `app` is a known workspace root module, the alias expansion + // must prepend `crate::` so the call graph matches. + let calls = calls_in_roots( + r#" + use app::foo; + pub fn cmd_x() { + foo(); + } + "#, + &["app"], + "src/cli/handlers.rs", + "cmd_x", + ); + assert!( + calls.contains("crate::app::foo"), + "Rust 2018+ absolute import must normalise to crate::, got {calls:?}" + ); + assert!( + !calls.iter().any(|c| c == "app::foo"), + "must not leave unprefixed app::foo, got {calls:?}" + ); +} + +#[test] +fn test_collect_crate_root_modules_from_paths() { + // `src/app/mod.rs`, `src/app/session.rs`, `src/cli/handlers.rs` → + // {"app", "cli"}. `src/lib.rs` and `src/main.rs` are excluded. + let roots = roots_from_paths(&[ + "src/app/mod.rs", + "src/app/session.rs", + "src/cli/handlers.rs", + "src/lib.rs", + "src/main.rs", + ]); + assert!(roots.contains("app")); + assert!(roots.contains("cli")); + assert!(!roots.contains("lib")); + assert!(!roots.contains("main")); +} + +#[test] +fn test_top_level_self_as_alias_maps_to_current_file() { + // `use self as fs;` at the top of `src/util/fs_helpers.rs` — `self` + // at crate-root-adjacent position means the current file's module. + // Downstream normalisation must resolve `fs::something` to + // `crate::util::fs_helpers::something`, not leak as a dead-end. + let calls = calls_in( + r#" + use self as fs; + pub fn cmd_x() { + fs::something(); + } + "#, + "src/util/fs_helpers.rs", + "cmd_x", + ); + assert!( + calls.contains("crate::util::fs_helpers::something"), + "top-level self-alias must resolve to the current file's module, got {calls:?}" + ); +} + +#[test] +fn test_qualified_impl_path_does_not_double_crate() { + // `impl crate::app::Session { fn search() }` — the impl header + // already gives a crate-rooted path. The canonical Self-target must + // be `crate::app::Session::search`, NOT + // `crate::::crate::app::Session::search`. + let fctx = load( + r#" + impl crate::app::Session { + pub fn search(&self) { + Self::internal_helper(); + } + } + "#, + ); + let (item, f) = find_impl_fn(&fctx.file, "Session", "search"); + let self_ty = canonical_of_impl_self(item); + let ctx = FnContext { + file: &FileScope { + path: "src/other_file.rs", + alias_map: &fctx.alias_map, + aliases_per_scope: &ScopedAliasMap::new(), + local_symbols: &fctx.local_symbols, + local_decl_scopes: &HashMap::new(), + crate_root_modules: &fctx.crate_root_modules, + workspace_module_paths: None, + }, + mod_stack: &[], + body: &f.block, + signature_params: sig_params(&f.sig), + generic_params: std::collections::HashMap::new(), + self_type: self_ty, + workspace_index: None, + workspace_files: None, + reexports: None, + }; + let calls = collect_canonical_calls(&ctx); + assert!( + calls.contains("crate::app::Session::internal_helper"), + "qualified impl path must canonicalise as-is, got {calls:?}" + ); + assert!( + !calls.iter().any(|c| c.contains("crate::crate::")), + "must not double-crate, got {calls:?}" + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/turbofish.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/turbofish.rs new file mode 100644 index 00000000..0ef6837a --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/turbofish.rs @@ -0,0 +1,192 @@ +use super::*; + +// ── Turbofish + inferred-T resolution (v1.2.1) ──────────────────── + +#[test] +fn test_collect_turbofish_call_resolves_via_use() { + // `record_symbol_query::(args)` with a `use` import in + // scope → the call must canonicalise to the absolute path of the + // imported function, not `:`. Pre-fix, turbofish call sites + // were dropped from the call graph. + let calls = calls_in( + r#" + use crate::middleware::record_symbol_query; + pub fn cmd_search() { + record_symbol_query::(0); + } + "#, + "src/cli/handlers.rs", + "cmd_search", + ); + assert!( + calls.contains("crate::middleware::record_symbol_query"), + "turbofish call must resolve through use-alias, got {calls:?}" + ); +} + +#[test] +fn test_collect_inferred_generic_call_resolves_via_use() { + // `record_operation(args)` (T inferred) with use in scope. Same + // resolution path as a non-generic call — confirms there's no + // generic-args-keying mismatch on the definition side. + let calls = calls_in( + r#" + use crate::middleware::record_operation; + pub fn cmd_search() { + record_operation(0, "x", true); + } + "#, + "src/cli/handlers.rs", + "cmd_search", + ); + assert!( + calls.contains("crate::middleware::record_operation"), + "inferred-generic call must resolve through use-alias, got {calls:?}" + ); +} + +#[test] +fn test_turbofish_in_impl_method_body_resolves() { + // Turbofish call lives inside an impl method, not a free fn. The + // impl block's self_ty has its own scope; the `use` must still be + // visible in the body. + let calls = calls_in_impl_method( + r#" + use crate::middleware::record_symbol_query; + pub struct Session; + impl Session { + pub fn refs(&self, sym: &str) { + record_symbol_query::(&self, sym); + } + } + "#, + "src/application/session.rs", + "Session", + "refs", + ); + assert!( + calls.contains("crate::middleware::record_symbol_query"), + "turbofish in impl-method body must resolve via use, got {calls:?}" + ); +} + +#[test] +fn test_turbofish_via_child_module_qualified_path_resolves() { + // Pattern that may bite when use is in a sibling/child module: + // qualified-path call with turbofish, no `use` at the call site. + let fctx = load_with_roots( + r#" + pub fn cmd_search() { + crate::middleware::record_symbol_query::(0); + } + "#, + &["middleware"], + ); + let fs = fctx.file_scope("src/cli/handlers.rs"); + let ctx = ctx_for_fn(&fctx, &fs, "cmd_search"); + let calls = collect_canonical_calls(&ctx); + assert!( + calls.contains("crate::middleware::record_symbol_query"), + "qualified-path turbofish must resolve, got {calls:?}" + ); +} + +#[test] +fn test_multiple_turbofish_calls_to_same_fn_resolve_to_one_canonical() { + // Three turbofish call sites, three different generic args. + // The collector must dedupe to a single canonical entry (the call + // set is a HashSet). + let calls = calls_in_impl_method( + r#" + use crate::middleware::record_symbol_query; + pub struct Session; + impl Session { + pub fn refs(&self, sym: &str) { + record_symbol_query::(&self, sym); + record_symbol_query::(&self, sym); + record_symbol_query::(&self, sym); + } + } + "#, + "src/application/session.rs", + "Session", + "refs", + ); + assert!( + calls.contains("crate::middleware::record_symbol_query"), + "all three turbofish call sites must dedupe to one canonical, got {calls:?}" + ); +} + +#[test] +fn test_turbofish_unresolved_path_still_bare() { + // No `use` for `Box` → still `:Box::new`. Behavior unchanged + // for genuinely unresolvable paths; only the resolved case needed + // fixing. + let calls = calls_in( + r#" + pub fn cmd_search() { + Box::::new(42); + } + "#, + "src/cli/handlers.rs", + "cmd_search", + ); + assert!( + calls.contains(":Box::new"), + "unresolved turbofish should still bare-key, got {calls:?}" + ); +} + +#[test] +fn test_collect_closure_body_collected() { + let calls = calls_in( + r#" + pub fn cmd_search() { + let f = |x: u32| inner_call(x); + f(1); + } + "#, + "src/cli/handlers.rs", + "cmd_search", + ); + assert!(calls.contains(":inner_call")); +} + +#[test] +fn test_collect_await_is_not_extra_call() { + let calls = calls_in( + r#" + pub async fn cmd_search() { + f(1).await; + } + "#, + "src/cli/handlers.rs", + "cmd_search", + ); + assert!(calls.contains(":f")); + // .await is not a call target + assert!(!calls.iter().any(|c| c.contains("await"))); +} + +#[test] +fn test_collect_self_dispatch_in_impl() { + let calls = calls_in_impl_method( + r#" + pub struct RlmSession; + impl RlmSession { + pub fn search(&self) { + Self::internal_helper(); + } + } + "#, + "src/application/session.rs", + "RlmSession", + "search", + ); + assert!( + calls.contains("crate::application::session::RlmSession::internal_helper"), + "calls = {:?}", + calls + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/cfg_test_impl.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/cfg_test_impl.rs index 70818d6d..32ad2fbc 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/cfg_test_impl.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/cfg_test_impl.rs @@ -12,6 +12,14 @@ use crate::adapters::analyzers::architecture::call_parity_rule::pub_fns::{ }; use std::collections::HashSet; +/// `(label, files, present_anchor, absent_anchor)` for the cfg-test anchor cases. +type AnchorCase = ( + &'static str, + &'static [(&'static str, &'static str)], + &'static str, + &'static str, +); + #[test] fn file_fn_collector_skips_cfg_test_impl_block() { // `#[cfg(test)] impl X { pub fn helper(&self) {} }` — the attribute @@ -41,84 +49,70 @@ fn file_fn_collector_skips_cfg_test_impl_block() { ); } -#[test] -fn record_trait_impl_excludes_cfg_test_overrides_from_overridden_set() { - // Mixed impl block: one production method + one `#[cfg(test)]` - // method on the same `impl Handler for X { … }`. The trait-impl - // index must record the production method as overriding, but the - // test-only method must NOT enter the override set — otherwise - // production dispatch on `dyn Handler.helper()` would route to - // a phantom `X::helper` (whose body is cfg-test-gated and never - // present in production builds). - // - // We assert via the anchor capability set: an anchor for `helper` - // has NO production impl in the workspace, so `target_anchor_capabilities` - // for the target layer must NOT include it (the overridden set - // for `helper` is empty after filtering, so no impl-layer is - // recorded for the helper anchor). - let ws = build_workspace(&[( - "src/application/h.rs", - r#" - pub trait Handler { - fn handle(&self); - fn helper(&self); - } - pub struct X; - impl Handler for X { - fn handle(&self) {} - #[cfg(test)] - fn helper(&self) {} - } - "#, - )]); +/// Target-layer (`application`) anchor capability names for a workspace. +fn target_anchor_caps(files: &[(&str, &str)]) -> HashSet { + let ws = build_workspace(files); let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - let caps: std::collections::HashSet<&str> = graph + graph .target_anchor_capabilities("application", &[]) - .map(|(name, _)| name) - .collect(); - assert!( - caps.contains("crate::application::h::Handler::handle"), - "production method must be present as anchor capability, got {caps:?}" - ); - assert!( - !caps.contains("crate::application::h::Handler::helper"), - "cfg-test method must NOT be in target anchor capabilities — its only override is test-only and `record_trait_impl` filters it out, leaving the override set empty for helper, so no impl-layer is recorded; got {caps:?}" - ); + .map(|(name, _)| name.to_string()) + .collect() } #[test] -fn record_trait_methods_excludes_cfg_test_method_default_body() { - // Production trait that declares a `#[cfg(test)]` method WITH a - // default body. Without filtering at the per-method level, the - // default body lands in `trait_methods_with_default_body`, the - // method ends up in `trait_methods`, and the unified capability - // rule promotes it to a target anchor — even though the method - // is invisible in production builds. Filter test-only entries - // when walking trait items so anchor capabilities + dispatch - // gating only see production methods. - let ws = build_workspace(&[( - "src/application/h.rs", - r#" - pub trait Handler { - fn handle(&self) {} - #[cfg(test)] - fn test_helper(&self) {} - } - "#, - )]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - let caps: std::collections::HashSet<&str> = graph - .target_anchor_capabilities("application", &[]) - .map(|(name, _)| name) - .collect(); - assert!( - caps.contains("crate::application::h::Handler::handle"), - "production default-body method must remain a target anchor capability, got {caps:?}" - ); - assert!( - !caps.contains("crate::application::h::Handler::test_helper"), - "cfg-test trait method (even with default body) must NOT be a target anchor capability; got {caps:?}" - ); +fn cfg_test_trait_methods_excluded_from_anchor_capabilities() { + // A `#[cfg(test)]` trait method — whether it's a test-only impl override + // (its production override set ends up empty) or a test-only default body + // on the trait — must NOT become a target anchor capability, while the + // sibling production method still does. (label, files, present, absent) + let cases: &[AnchorCase] = &[ + ( + "cfg-test impl override is filtered from the override set", + &[( + "src/application/h.rs", + r#" + pub trait Handler { + fn handle(&self); + fn helper(&self); + } + pub struct X; + impl Handler for X { + fn handle(&self) {} + #[cfg(test)] + fn helper(&self) {} + } + "#, + )], + "crate::application::h::Handler::handle", + "crate::application::h::Handler::helper", + ), + ( + "cfg-test trait default-body method is filtered from trait_methods", + &[( + "src/application/h.rs", + r#" + pub trait Handler { + fn handle(&self) {} + #[cfg(test)] + fn test_helper(&self) {} + } + "#, + )], + "crate::application::h::Handler::handle", + "crate::application::h::Handler::test_helper", + ), + ]; + for (label, files, present, absent) in cases { + let caps = target_anchor_caps(files); + assert!( + caps.contains(*present), + "case {label}: production method `{present}` must be a capability; got {caps:?}" + ); + assert!( + !caps.contains(*absent), + "case {label}: cfg-test method `{absent}` must NOT be a capability; got {caps:?}" + ); + } } #[test] diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_a.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_a.rs deleted file mode 100644 index 4f244243..00000000 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_a.rs +++ /dev/null @@ -1,408 +0,0 @@ -//! Tests for Check A (adapter-must-delegate). -//! -//! Each test sets up a small multi-file workspace via `build_workspace`, -//! compiles layers + call-parity config, and asserts findings emitted -//! by `check_no_delegation`. -//! -//! Suppression via `// qual:allow(architecture)` is covered by the -//! golden-example integration test in Task 5 — it piggy-backs on the -//! existing `mark_architecture_suppressions` pipeline and doesn't need -//! a separate unit test here. - -use super::support::{ - build_workspace, cli_mcp_config, empty_cfg_test, run_check_a, three_layer, Workspace, -}; -use crate::adapters::analyzers::architecture::{MatchLocation, ViolationKind}; - -fn assert_no_delegation_fn_names(findings: &[MatchLocation]) -> Vec { - findings - .iter() - .filter_map(|f| match &f.kind { - ViolationKind::CallParityNoDelegation { fn_name, .. } => Some(fn_name.clone()), - _ => None, - }) - .collect() -} - -// ── Basic direct / inline cases ─────────────────────────────── - -#[test] -fn test_adapter_fn_direct_delegation_passes() { - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::stats::get_stats; - pub fn cmd_stats() { - get_stats(); - } - "#, - ), - ]); - let layers = three_layer(); - let cp = cli_mcp_config(3); - let findings = run_check_a(&ws, &layers, &cp, &empty_cfg_test()); - assert!( - assert_no_delegation_fn_names(&findings).is_empty(), - "direct delegation should pass, got {findings:?}" - ); -} - -#[test] -fn test_adapter_fn_inline_impl_fails() { - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/cli/handlers.rs", - r#" - pub fn cmd_stats() { - let _ = 42; - } - "#, - ), - ]); - let findings = run_check_a(&ws, &three_layer(), &cli_mcp_config(3), &empty_cfg_test()); - let names = assert_no_delegation_fn_names(&findings); - assert!( - names.contains(&"cmd_stats".to_string()), - "inline fn should be flagged, got {names:?}" - ); -} - -#[test] -fn test_adapter_fn_transitive_delegation_via_helper_passes() { - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/cli/helpers.rs", - r#" - use crate::application::stats::get_stats; - pub fn prepare() { - get_stats(); - } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::cli::helpers::prepare; - pub fn cmd_stats() { - prepare(); - } - "#, - ), - ]); - let findings = run_check_a(&ws, &three_layer(), &cli_mcp_config(3), &empty_cfg_test()); - let names = assert_no_delegation_fn_names(&findings); - assert!( - !names.contains(&"cmd_stats".to_string()), - "transitive delegation at depth 2 should pass, got {names:?}" - ); -} - -#[test] -fn test_adapter_fn_transitive_depth_exceeds_limit_fails() { - // Chain: cmd_stats → h1 → h2 → h3 → h4 → get_stats (5 hops). - // With call_depth=3 we only explore 3 edges deep → target not reached. - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/cli/helpers.rs", - r#" - use crate::application::stats::get_stats; - pub fn h4() { get_stats(); } - pub fn h3() { h4(); } - pub fn h2() { h3(); } - pub fn h1() { h2(); } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::cli::helpers::h1; - pub fn cmd_stats() { h1(); } - "#, - ), - ]); - let findings = run_check_a(&ws, &three_layer(), &cli_mcp_config(3), &empty_cfg_test()); - let names = assert_no_delegation_fn_names(&findings); - assert!( - names.contains(&"cmd_stats".to_string()), - "depth-exceeding chain should flag cmd_stats, got {names:?}" - ); -} - -#[test] -fn test_call_depth_1_only_direct_calls() { - // cmd_stats calls helper() which calls get_stats. - // call_depth=1: only direct calls count → helper is not in target → fail. - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/cli/helpers.rs", - r#" - use crate::application::stats::get_stats; - pub fn helper() { get_stats(); } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::cli::helpers::helper; - pub fn cmd_stats() { helper(); } - "#, - ), - ]); - let findings = run_check_a(&ws, &three_layer(), &cli_mcp_config(1), &empty_cfg_test()); - let names = assert_no_delegation_fn_names(&findings); - assert!( - names.contains(&"cmd_stats".to_string()), - "call_depth=1 should flag cmd_stats (helper is not target), got {names:?}" - ); -} - -#[test] -fn test_adapter_fn_method_call_does_not_count() { - // Adapter calls `disp.run(x)` — method call on unknown type, stays - // `:run` = layer-unknown = no delegation. - let ws = build_workspace(&[ - ("src/application/dispatch.rs", "pub fn run_it() {}"), - ( - "src/cli/handlers.rs", - r#" - pub fn cmd_stats(disp: UnknownType) { - disp.run(); - } - "#, - ), - ]); - let findings = run_check_a(&ws, &three_layer(), &cli_mcp_config(3), &empty_cfg_test()); - let names = assert_no_delegation_fn_names(&findings); - assert!( - names.contains(&"cmd_stats".to_string()), - "method call on unknown type must not count as delegation" - ); -} - -#[test] -fn test_adapter_fn_cross_adapter_call_does_not_count() { - // CLI calls an MCP fn (peer, not target) → no delegation credit. - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::stats::get_stats; - pub fn handle_stats() { get_stats(); } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::mcp::handlers::handle_stats; - pub fn cmd_stats() { handle_stats(); } - "#, - ), - ]); - let findings = run_check_a(&ws, &three_layer(), &cli_mcp_config(1), &empty_cfg_test()); - // At depth 1, cmd_stats only reaches handle_stats (in mcp, not app). → fail. - let names = assert_no_delegation_fn_names(&findings); - assert!( - names.contains(&"cmd_stats".to_string()), - "cross-adapter call at depth 1 must not count, got {names:?}" - ); -} - -#[test] -fn test_adapter_fn_cross_adapter_call_blocked_even_at_deeper_depth() { - // Even at greater call_depth the CLI walk must not inherit MCP's - // application touchpoints. CLI never crosses into the target - // layer itself — cmd_stats must therefore still flag NoDelegation. - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::stats::get_stats; - pub fn handle_stats() { get_stats(); } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::mcp::handlers::handle_stats; - pub fn cmd_stats() { handle_stats(); } - "#, - ), - ]); - let findings = run_check_a(&ws, &three_layer(), &cli_mcp_config(2), &empty_cfg_test()); - let names = assert_no_delegation_fn_names(&findings); - assert!( - names.contains(&"cmd_stats".to_string()), - "peer-adapter walks must not inherit touchpoints; expected cmd_stats in {names:?}" - ); -} - -#[test] -fn test_adapter_fn_cfg_test_file_skipped() { - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/cli/handlers.rs", - r#" - pub fn cmd_stats() { - let _ = 42; - } - "#, - ), - ]); - let mut cfg_test = std::collections::HashSet::new(); - cfg_test.insert("src/cli/handlers.rs".to_string()); - let findings = run_check_a(&ws, &three_layer(), &cli_mcp_config(3), &cfg_test); - assert!( - findings.is_empty(), - "cfg-test adapter file must not produce findings, got {findings:?}" - ); -} - -#[test] -fn test_adapter_fn_not_in_any_adapter_layer_ignored() { - // Fn in a layer NOT listed as an adapter → not checked. - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/application/api.rs", - r#" - pub fn internal_api() { - let _ = 42; - } - "#, - ), - ]); - let findings = run_check_a(&ws, &three_layer(), &cli_mcp_config(3), &empty_cfg_test()); - assert!( - findings.is_empty(), - "non-adapter-layer fn must not be checked" - ); -} - -#[test] -fn test_finding_line_is_fn_sig_line() { - let src = "\n\n\npub fn cmd_stats() { let _ = 42; }\n"; - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ("src/cli/handlers.rs", src), - ]); - let findings = run_check_a(&ws, &three_layer(), &cli_mcp_config(3), &empty_cfg_test()); - let finding = findings - .iter() - .find(|f| matches!(f.kind, ViolationKind::CallParityNoDelegation { .. })) - .expect("expected a CallParityNoDelegation finding"); - // `pub fn cmd_stats` is on line 4 (1-indexed) given 3 leading newlines. - assert_eq!( - finding.line, 4, - "line must anchor on fn sig, got {finding:?}" - ); - assert_eq!(finding.file, "src/cli/handlers.rs"); -} - -#[test] -fn test_unparseable_impl_self_type_does_not_collapse_with_free_fns() { - // Regression: `impl Trait for &dyn Something { fn search() }`'s - // self-type can't be canonicalised. Previously it was pushed as - // `Vec::new()`, which made `search` canonicalise to - // `crate::::search` — colliding with a same-named free fn - // in the same file and silently polluting the graph. The skip - // must leave the free fn's node intact. - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::stats::get_stats; - pub fn search() { get_stats(); } - impl dyn std::fmt::Debug { - // Not a real impl this analyser understands — self-type - // isn't a plain path, so every method inside must be - // skipped, not recorded as `crate::cli::handlers::*`. - pub fn search(&self) {} - } - pub fn cmd_x() { search(); } - "#, - ), - ]); - let findings = run_check_a(&ws, &three_layer(), &cli_mcp_config(3), &empty_cfg_test()); - let names = assert_no_delegation_fn_names(&findings); - assert!( - !names.contains(&"cmd_x".to_string()), - "free-fn `search` must remain the node `cmd_x` reaches via delegation, got {names:?}" - ); -} - -#[test] -fn test_convergent_graph_does_not_double_enqueue() { - // Regression guard: if `WalkState::enqueue_unvisited` only checks - // visited at dequeue (not enqueue), a convergent graph can queue - // the same node many times. Here 3 helpers all fan out to both - // `app::a` and `app::b`, and the same callees reach `app::common`. - // The walk must still terminate (and delegation must resolve) - // without blowing up the queue. - let ws = build_workspace(&[ - ( - "src/application/common.rs", - r#" - pub fn common() {} - pub fn a() { common(); } - pub fn b() { common(); } - "#, - ), - ( - "src/cli/helpers.rs", - r#" - use crate::application::common::{a, b}; - pub fn h1() { a(); b(); } - pub fn h2() { a(); b(); } - pub fn h3() { a(); b(); } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::cli::helpers::{h1, h2, h3}; - pub fn cmd_x() { h1(); h2(); h3(); } - "#, - ), - ]); - let findings = run_check_a(&ws, &three_layer(), &cli_mcp_config(3), &empty_cfg_test()); - let names = assert_no_delegation_fn_names(&findings); - assert!( - !names.contains(&"cmd_x".to_string()), - "convergent delegation must still resolve, got {names:?}" - ); -} - -// ── Deprecated-handler exclusion (v1.2.1) ───────────────────── - -#[test] -fn check_a_skips_deprecated_handler() { - // A deprecated adapter pub-fn that doesn't delegate would normally - // fire Check A. Marked `#[deprecated]`, it must be skipped — alias - // being phased out shouldn't drag the parity report. - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/cli/handlers.rs", - r#" - #[deprecated] - pub fn cmd_old() { let _ = 42; } - "#, - ), - ]); - let findings = run_check_a(&ws, &three_layer(), &cli_mcp_config(3), &empty_cfg_test()); - let names = assert_no_delegation_fn_names(&findings); - assert!( - !names.contains(&"cmd_old".to_string()), - "deprecated handler should be excluded from Check A, got {names:?}" - ); -} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_a/misc.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_a/misc.rs new file mode 100644 index 00000000..80f45fde --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_a/misc.rs @@ -0,0 +1,64 @@ +use super::*; + +#[test] +fn test_adapter_fn_cfg_test_file_skipped() { + let ws = build_workspace(&[ + ("src/application/stats.rs", "pub fn get_stats() {}"), + ( + "src/cli/handlers.rs", + r#" + pub fn cmd_stats() { + let _ = 42; + } + "#, + ), + ]); + let mut cfg_test = std::collections::HashSet::new(); + cfg_test.insert("src/cli/handlers.rs".to_string()); + let findings = run_check_a(&ws, &three_layer(), &cli_mcp_config(3), &cfg_test); + assert!( + findings.is_empty(), + "cfg-test adapter file must not produce findings, got {findings:?}" + ); +} + +#[test] +fn test_adapter_fn_not_in_any_adapter_layer_ignored() { + // Fn in a layer NOT listed as an adapter → not checked. + let ws = build_workspace(&[ + ("src/application/stats.rs", "pub fn get_stats() {}"), + ( + "src/application/api.rs", + r#" + pub fn internal_api() { + let _ = 42; + } + "#, + ), + ]); + let findings = run_a(&ws, 3); + assert!( + findings.is_empty(), + "non-adapter-layer fn must not be checked" + ); +} + +#[test] +fn test_finding_line_is_fn_sig_line() { + let src = "\n\n\npub fn cmd_stats() { let _ = 42; }\n"; + let ws = build_workspace(&[ + ("src/application/stats.rs", "pub fn get_stats() {}"), + ("src/cli/handlers.rs", src), + ]); + let findings = run_a(&ws, 3); + let finding = findings + .iter() + .find(|f| matches!(f.kind, ViolationKind::CallParityNoDelegation { .. })) + .expect("expected a CallParityNoDelegation finding"); + // `pub fn cmd_stats` is on line 4 (1-indexed) given 3 leading newlines. + assert_eq!( + finding.line, 4, + "line must anchor on fn sig, got {finding:?}" + ); + assert_eq!(finding.file, "src/cli/handlers.rs"); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_a/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_a/mod.rs new file mode 100644 index 00000000..5960b6c2 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_a/mod.rs @@ -0,0 +1,52 @@ +//! Tests for Check A (adapter-must-delegate). +//! +//! Each test sets up a small multi-file workspace via `build_workspace`, +//! compiles layers + call-parity config, and asserts findings emitted +//! by `check_no_delegation`. Split into focused sub-files (each ≤ the SRP +//! file-length cap); shared imports + helpers live here and reach the +//! sub-modules via `use super::*`. +//! +//! Suppression via `// qual:allow(architecture)` is covered by the +//! golden-example integration test in Task 5 — it piggy-backs on the +//! existing `mark_architecture_suppressions` pipeline and doesn't need +//! a separate unit test here. + +pub(super) use super::support::{ + build_workspace, cli_mcp_config, empty_cfg_test, run_check_a, three_layer, Workspace, +}; +pub(super) use crate::adapters::analyzers::architecture::{MatchLocation, ViolationKind}; + +/// `(path, source)` file entries for a small workspace fixture. +pub(super) type WsFiles = &'static [(&'static str, &'static str)]; +/// Delegation case: `(label, files, depth, fn_name, flagged)`. +pub(super) type DelegationCase = (&'static str, WsFiles, usize, &'static str, bool); + +mod misc; +mod table; + +/// Run Check A with the three-layer layout, a `cli_mcp_config(depth)` config, +/// and no cfg-test files — the shared call across most Check-A tests. +pub(super) fn run_a(ws: &Workspace, depth: usize) -> Vec { + run_check_a( + ws, + &three_layer(), + &cli_mcp_config(depth), + &empty_cfg_test(), + ) +} + +pub(super) fn assert_no_delegation_fn_names(findings: &[MatchLocation]) -> Vec { + findings + .iter() + .filter_map(|f| match &f.kind { + ViolationKind::CallParityNoDelegation { fn_name, .. } => Some(fn_name.clone()), + _ => None, + }) + .collect() +} + +/// Build a workspace, run Check A at `depth`, and return the names of +/// adapter fns flagged for no-delegation. +pub(super) fn delegation_names(files: WsFiles, depth: usize) -> Vec { + assert_no_delegation_fn_names(&run_a(&build_workspace(files), depth)) +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_a/table.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_a/table.rs new file mode 100644 index 00000000..89c14e7c --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_a/table.rs @@ -0,0 +1,275 @@ +use super::*; + +// ── Basic direct / inline cases ─────────────────────────────── + +// Check A flags an adapter pub-fn when it does NOT reach a target-layer fn +// within `call_depth` hops (own-layer/peer-adapter hops don't count; method +// calls on unknown types and cross-adapter calls don't delegate). +// (label, files, depth, fn_name, flagged) +const DELEGATION_CASES: &[DelegationCase] = &[ + ( + "direct delegation to target passes", + &[ + ("src/application/stats.rs", "pub fn get_stats() {}"), + ( + "src/cli/handlers.rs", + r#" + use crate::application::stats::get_stats; + pub fn cmd_stats() { + get_stats(); + } + "#, + ), + ], + 3, + "cmd_stats", + false, + ), + ( + "inline-only adapter fn is flagged", + &[ + ("src/application/stats.rs", "pub fn get_stats() {}"), + ( + "src/cli/handlers.rs", + r#" + pub fn cmd_stats() { + let _ = 42; + } + "#, + ), + ], + 3, + "cmd_stats", + true, + ), + ( + "transitive delegation via a same-layer helper passes", + &[ + ("src/application/stats.rs", "pub fn get_stats() {}"), + ( + "src/cli/helpers.rs", + r#" + use crate::application::stats::get_stats; + pub fn prepare() { + get_stats(); + } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::cli::helpers::prepare; + pub fn cmd_stats() { + prepare(); + } + "#, + ), + ], + 3, + "cmd_stats", + false, + ), + ( + // cmd_stats → h1 → h2 → h3 → h4 → get_stats (5 hops); depth 3 + // explores only 3 edges deep → target never reached. + "delegation chain exceeding call_depth is flagged", + &[ + ("src/application/stats.rs", "pub fn get_stats() {}"), + ( + "src/cli/helpers.rs", + r#" + use crate::application::stats::get_stats; + pub fn h4() { get_stats(); } + pub fn h3() { h4(); } + pub fn h2() { h3(); } + pub fn h1() { h2(); } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::cli::helpers::h1; + pub fn cmd_stats() { h1(); } + "#, + ), + ], + 3, + "cmd_stats", + true, + ), + ( + // call_depth=1: only direct calls count, helper isn't target → fail + "call_depth=1 counts only direct calls", + &[ + ("src/application/stats.rs", "pub fn get_stats() {}"), + ( + "src/cli/helpers.rs", + r#" + use crate::application::stats::get_stats; + pub fn helper() { get_stats(); } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::cli::helpers::helper; + pub fn cmd_stats() { helper(); } + "#, + ), + ], + 1, + "cmd_stats", + true, + ), + ( + // `disp.run()` on an unknown type stays `:run` = no delegation + "method call on unknown type does not count", + &[ + ("src/application/dispatch.rs", "pub fn run_it() {}"), + ( + "src/cli/handlers.rs", + r#" + pub fn cmd_stats(disp: UnknownType) { + disp.run(); + } + "#, + ), + ], + 3, + "cmd_stats", + true, + ), + ( + // CLI → MCP (peer adapter, not target) earns no delegation credit + "cross-adapter call at depth 1 does not count", + &[ + ("src/application/stats.rs", "pub fn get_stats() {}"), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::stats::get_stats; + pub fn handle_stats() { get_stats(); } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::mcp::handlers::handle_stats; + pub fn cmd_stats() { handle_stats(); } + "#, + ), + ], + 1, + "cmd_stats", + true, + ), + ( + // even at deeper depth, a peer-adapter walk must not inherit + // MCP's application touchpoints + "cross-adapter call blocked even at deeper depth", + &[ + ("src/application/stats.rs", "pub fn get_stats() {}"), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::stats::get_stats; + pub fn handle_stats() { get_stats(); } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::mcp::handlers::handle_stats; + pub fn cmd_stats() { handle_stats(); } + "#, + ), + ], + 2, + "cmd_stats", + true, + ), + ( + // unparseable `impl dyn Debug` self-type must be skipped, leaving + // the free fn `search` intact as cmd_x's delegation target + "unparseable impl self-type does not collapse with free fns", + &[ + ("src/application/stats.rs", "pub fn get_stats() {}"), + ( + "src/cli/handlers.rs", + r#" + use crate::application::stats::get_stats; + pub fn search() { get_stats(); } + impl dyn std::fmt::Debug { + pub fn search(&self) {} + } + pub fn cmd_x() { search(); } + "#, + ), + ], + 3, + "cmd_x", + false, + ), + ( + // convergent fan-out must still terminate and resolve delegation + "convergent graph does not double-enqueue", + &[ + ( + "src/application/common.rs", + r#" + pub fn common() {} + pub fn a() { common(); } + pub fn b() { common(); } + "#, + ), + ( + "src/cli/helpers.rs", + r#" + use crate::application::common::{a, b}; + pub fn h1() { a(); b(); } + pub fn h2() { a(); b(); } + pub fn h3() { a(); b(); } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::cli::helpers::{h1, h2, h3}; + pub fn cmd_x() { h1(); h2(); h3(); } + "#, + ), + ], + 3, + "cmd_x", + false, + ), + ( + // a `#[deprecated]` non-delegating adapter fn is excluded + "deprecated handler is skipped", + &[ + ("src/application/stats.rs", "pub fn get_stats() {}"), + ( + "src/cli/handlers.rs", + r#" + #[deprecated] + pub fn cmd_old() { let _ = 42; } + "#, + ), + ], + 3, + "cmd_old", + false, + ), +]; + +#[test] +fn adapter_delegation_flagging() { + for (label, files, depth, fn_name, flagged) in DELEGATION_CASES { + let names = delegation_names(files, *depth); + assert_eq!( + names.contains(&fn_name.to_string()), + *flagged, + "case {label}: flagged fns = {names:?}" + ); + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b.rs deleted file mode 100644 index 98f2f1a7..00000000 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b.rs +++ /dev/null @@ -1,1799 +0,0 @@ -//! Tests for Check B (parity-coverage). -//! -//! Each test sets up a small multi-file workspace and asserts the -//! `missing_adapters` set produced by `check_missing_adapter` for each -//! target-layer pub-fn. Suppression is covered end-to-end in Task 5. - -use super::support::{ - build_workspace, cli_mcp_config, empty_cfg_test, four_layer, globset, ports_app_cli_mcp, - run_check_b, three_layer, -}; -use crate::adapters::analyzers::architecture::compiled::CompiledCallParity; -use crate::adapters::analyzers::architecture::{MatchLocation, ViolationKind}; -use std::collections::HashSet; - -fn make_config( - call_depth: usize, - adapters: &[&str], - exclude_targets: &[&str], -) -> CompiledCallParity { - CompiledCallParity { - adapters: adapters.iter().map(|s| s.to_string()).collect(), - target: "application".to_string(), - call_depth, - exclude_targets: globset(exclude_targets), - transparent_wrappers: HashSet::new(), - transparent_macros: HashSet::new(), - promoted_attributes: HashSet::new(), - single_touchpoint: crate::config::architecture::SingleTouchpointMode::default(), - } -} - -/// `missing_adapters` list for a specific `target_fn` — `None` when -/// no CallParityMissingAdapter finding exists for that target. -fn missing_adapters_for(findings: &[MatchLocation], target_fn: &str) -> Option> { - findings.iter().find_map(|f| match &f.kind { - ViolationKind::CallParityMissingAdapter { - target_fn: tf, - missing_adapters, - .. - } if tf == target_fn => Some(missing_adapters.clone()), - _ => None, - }) -} - -/// Hint text for the missing-adapter finding on `target_fn`, if any. -/// Returns `None` if there's no finding or the finding has hint=None. -fn hint_for(findings: &[MatchLocation], target_fn: &str) -> Option { - findings.iter().find_map(|f| match &f.kind { - ViolationKind::CallParityMissingAdapter { - target_fn: tf, - hint, - .. - } if tf == target_fn => hint.clone(), - _ => None, - }) -} - -/// Three-layer `cli + mcp + application` config with `application` as -/// target and an empty exclude_targets — the shared shape for the -/// hint/cascade/promoted-attribute tests further down. -fn cli_mcp_config_full() -> CompiledCallParity { - let mut cp = cli_mcp_config(3); - cp.exclude_targets = globset(&[]); - cp -} - -/// Extract the `(target_fn, missing_adapters)` pair from a -/// CallParityMissingAdapter finding, as `String` for easy assertions. -fn missing_pairs(findings: &[MatchLocation]) -> Vec<(String, Vec)> { - findings - .iter() - .filter_map(|f| match &f.kind { - ViolationKind::CallParityMissingAdapter { - target_fn, - missing_adapters, - .. - } => Some((target_fn.clone(), missing_adapters.clone())), - _ => None, - }) - .collect() -} - -// ── Direct / transitive coverage ────────────────────────────── - -#[test] -fn test_target_fn_called_from_all_adapters_passes() { - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::stats::get_stats; - pub fn cmd_stats() { get_stats(); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::stats::get_stats; - pub fn handle_stats() { get_stats(); } - "#, - ), - ( - "src/rest/handlers.rs", - r#" - use crate::application::stats::get_stats; - pub fn post_stats() { get_stats(); } - "#, - ), - ]); - let cp = make_config(3, &["cli", "mcp", "rest"], &[]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - assert!( - missing_pairs(&findings).is_empty(), - "covered-by-all should pass, got {findings:?}" - ); -} - -#[test] -fn test_target_fn_missing_one_adapter_fails() { - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::stats::get_stats; - pub fn cmd_stats() { get_stats(); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::stats::get_stats; - pub fn handle_stats() { get_stats(); } - "#, - ), - // rest is missing - ]); - let cp = make_config(3, &["cli", "mcp", "rest"], &[]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - let pairs = missing_pairs(&findings); - assert_eq!(pairs.len(), 1); - assert!(pairs[0].0.ends_with("get_stats")); - assert_eq!(pairs[0].1, vec!["rest".to_string()]); -} - -#[test] -fn test_target_fn_missing_two_adapters_fails() { - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::stats::get_stats; - pub fn cmd_stats() { get_stats(); } - "#, - ), - ]); - let cp = make_config(3, &["cli", "mcp", "rest"], &[]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - let pairs = missing_pairs(&findings); - assert_eq!(pairs.len(), 1); - let mut missing = pairs[0].1.clone(); - missing.sort(); - assert_eq!(missing, vec!["mcp".to_string(), "rest".to_string()]); -} - -#[test] -fn test_target_fn_not_called_from_any_adapter_lists_all_missing() { - let ws = build_workspace(&[("src/application/stats.rs", "pub fn get_stats() {}")]); - let cp = make_config(3, &["cli", "mcp", "rest"], &[]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - let pairs = missing_pairs(&findings); - assert_eq!(pairs.len(), 1); - let mut missing = pairs[0].1.clone(); - missing.sort(); - assert_eq!( - missing, - vec!["cli".to_string(), "mcp".to_string(), "rest".to_string()] - ); -} - -#[test] -fn test_target_fn_reached_transitively_passes() { - // rest reaches via a service wrapper (depth 2). - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::stats::get_stats; - pub fn cmd_stats() { get_stats(); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::stats::get_stats; - pub fn handle_stats() { get_stats(); } - "#, - ), - ( - "src/rest/service.rs", - r#" - use crate::application::stats::get_stats; - pub fn wrap() { get_stats(); } - "#, - ), - ( - "src/rest/handlers.rs", - r#" - use crate::rest::service::wrap; - pub fn post_stats() { wrap(); } - "#, - ), - ]); - let cp = make_config(3, &["cli", "mcp", "rest"], &[]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - assert!( - missing_pairs(&findings).is_empty(), - "transitive coverage should pass, got {findings:?}" - ); -} - -#[test] -fn test_target_fn_transitive_depth_exceeds_fails() { - // REST only reaches the target through a layer-less intermediate - // (`src/shared/` is not a mapped layer), so a shallow call_depth - // misses it while cli + mcp hit the target directly at depth 1. - // - // Backward walk from get_stats: - // depth 1: cli::cmd_stats, mcp::handle_stats, shared::deep_call - // depth 2: rest::post_stats (through deep_call) - // With call_depth = 1 the BFS stops at depth 1 → rest missing. - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::stats::get_stats; - pub fn cmd_stats() { get_stats(); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::stats::get_stats; - pub fn handle_stats() { get_stats(); } - "#, - ), - ( - "src/shared/helpers.rs", - r#" - use crate::application::stats::get_stats; - pub fn deep_call() { get_stats(); } - "#, - ), - ( - "src/rest/handlers.rs", - r#" - use crate::shared::helpers::deep_call; - pub fn post_stats() { deep_call(); } - "#, - ), - ]); - let cp = make_config(1, &["cli", "mcp", "rest"], &[]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - let pairs = missing_pairs(&findings); - assert_eq!(pairs.len(), 1, "got {findings:?}"); - assert_eq!(pairs[0].1, vec!["rest".to_string()]); -} - -#[test] -fn test_target_fn_only_called_from_tests_fails() { - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::stats::get_stats; - pub fn cmd_stats() { get_stats(); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::stats::get_stats; - pub fn handle_stats() { get_stats(); } - "#, - ), - ( - "src/rest/tests.rs", - r#" - use crate::application::stats::get_stats; - #[cfg(test)] - mod tests { - use super::*; - #[test] - fn test_stats() { get_stats(); } - } - "#, - ), - ]); - let cp = make_config(3, &["cli", "mcp", "rest"], &[]); - let mut cfg_test = HashSet::new(); - cfg_test.insert("src/rest/tests.rs".to_string()); - let findings = run_check_b(&ws, &four_layer(), &cp, &cfg_test); - let pairs = missing_pairs(&findings); - assert_eq!(pairs.len(), 1, "got {findings:?}"); - assert_eq!(pairs[0].1, vec!["rest".to_string()]); -} - -#[test] -fn test_non_pub_target_fn_ignored() { - // Private target fn is not part of the parity surface → no finding - // even when no adapter calls it. - let ws = build_workspace(&[("src/application/stats.rs", "fn get_stats() {}")]); - let cp = make_config(3, &["cli", "mcp", "rest"], &[]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - assert!(missing_pairs(&findings).is_empty()); -} - -#[test] -fn test_method_caller_with_receiver_binding_counts() { - // `let s = Session::open(); s.search()` → receiver tracking resolves - // the method call to application::session::Session::search, so the - // mcp adapter counts as reaching `search`. - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - pub struct Session; - impl Session { - pub fn open() -> Self { Session } - pub fn search(&self) {} - } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::Session; - pub fn cmd_search() { - let s = Session::open(); - s.search(); - } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::session::Session; - pub fn handle_search() { - let s = Session::open(); - s.search(); - } - "#, - ), - ]); - // Only test cli + mcp coverage so rest doesn't appear as missing. - let cp = make_config(3, &["cli", "mcp"], &[]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - // `search` is reached from both adapters; `open` is reached from both. - assert!( - missing_pairs(&findings).is_empty(), - "method-call via binding should count, got {findings:?}" - ); -} - -#[test] -fn test_method_caller_without_binding_ignored() { - // Caller invokes `x.get_stats()` on an unknown-type receiver → - // `:get_stats`, layer-unknown, so the call doesn't count - // as reaching `crate::application::stats::get_stats`. - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/cli/handlers.rs", - r#" - pub fn cmd_stats(x: UnknownType) { x.get_stats(); } - "#, - ), - ]); - let cp = make_config(3, &["cli"], &[]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - let pairs = missing_pairs(&findings); - assert_eq!(pairs.len(), 1); - assert_eq!(pairs[0].1, vec!["cli".to_string()]); -} - -// ── exclude_targets glob ────────────────────────────────────── - -#[test] -fn test_target_in_exclude_targets_glob_ignored() { - let ws = build_workspace(&[ - ("src/application/setup.rs", "pub fn run() {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::setup::run; - pub fn cmd_setup() { run(); } - "#, - ), - // mcp + rest missing, but `setup::run` is excluded. - ]); - let cp = make_config(3, &["cli", "mcp", "rest"], &["application::setup::*"]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - assert!( - missing_pairs(&findings).is_empty(), - "glob-excluded target should not produce a finding, got {findings:?}" - ); -} - -#[test] -fn test_target_not_matching_exclude_glob_still_checked() { - let ws = build_workspace(&[ - ( - "src/application/setup.rs", - r#" - pub fn run() {} - "#, - ), - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::setup::run; - use crate::application::stats::get_stats; - pub fn cmd_setup() { run(); } - pub fn cmd_stats() { get_stats(); } - "#, - ), - ]); - // Exclude only setup::*; stats::get_stats remains in scope. - let cp = make_config(3, &["cli", "mcp"], &["application::setup::*"]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - let pairs = missing_pairs(&findings); - assert_eq!(pairs.len(), 1, "got {findings:?}"); - assert!(pairs[0].0.ends_with("get_stats")); - assert_eq!(pairs[0].1, vec!["mcp".to_string()]); -} - -#[test] -fn test_exclude_targets_uses_canonical_without_crate_prefix() { - // Glob patterns in config don't carry the `crate::` prefix — the - // matcher needs to strip it before comparing. - let ws = build_workspace(&[("src/application/setup.rs", "pub fn run() {}")]); - let cp = make_config(3, &["cli", "mcp"], &["application::setup::run"]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - assert!(missing_pairs(&findings).is_empty()); -} - -// ── Orphan target-layer islands (v1.2.1) ─────────────────────── - -#[test] -fn test_orphan_target_with_only_dead_target_caller_fires() { - // `admin_purge` is a target pub fn that no adapter touches at the - // boundary. Its only caller in the target layer is another target - // fn (`_legacy_wrapper`) that is ITSELF unreachable from any - // adapter — a dead island within the target layer. - // - // Before the fix: `has_target_layer_caller` returned true (because - // `_legacy_wrapper` is a target-layer caller) and the orphan - // branch was suppressed → no finding. False negative. - // - // After: the orphan branch only suppresses when the target is - // transitively reachable from at least one adapter touchpoint. - // Since neither admin_purge nor _legacy_wrapper is reachable - // from any adapter, the orphan finding fires. - let ws = build_workspace(&[ - ( - "src/application/admin.rs", - r#" - pub fn admin_purge() {} - pub fn _legacy_wrapper() { admin_purge(); } - "#, - ), - // No adapter touches admin_purge or _legacy_wrapper. - ( - "src/cli/handlers.rs", - r#" - pub fn cmd_other() {} - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - pub fn handle_other() {} - "#, - ), - ]); - let cp = make_config(3, &["cli", "mcp"], &[]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - let names: Vec = missing_pairs(&findings) - .into_iter() - .map(|(t, _)| t) - .collect(); - assert!( - names.iter().any(|n| n.ends_with("admin_purge")), - "orphan target with only dead target-internal callers must fire, got {names:?}" - ); -} - -#[test] -fn test_target_reached_transitively_via_target_chain_no_finding() { - // Wired chain: cli → session.search (boundary touchpoint) → - // record_operation (target-internal). record_operation has zero - // adapter coverage but is reachable through session.search from - // cli. Must NOT fire (it's not orphan; it's wired). - let ws = build_workspace(&[ - ( - "src/application/middleware.rs", - r#" - pub fn record_operation() {} - "#, - ), - ( - "src/application/session.rs", - r#" - use crate::application::middleware::record_operation; - pub fn search() { record_operation(); } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::search; - pub fn cmd_search() { search(); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::session::search; - pub fn handle_search() { search(); } - "#, - ), - ]); - let cp = make_config(3, &["cli", "mcp"], &[]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - let names: Vec = missing_pairs(&findings) - .into_iter() - .map(|(t, _)| t) - .collect(); - assert!( - !names.iter().any(|n| n.ends_with("record_operation")), - "transitively-reached target must not fire, got {names:?}" - ); -} - -#[test] -fn test_target_self_caller_only_still_fires_orphan() { - // Self-call: `admin_purge` calls itself recursively. Before the - // fix, has_target_layer_caller saw `admin_purge` as its own caller - // (target layer), suppressed the orphan branch. Should fire. - let ws = build_workspace(&[( - "src/application/admin.rs", - r#" - pub fn admin_purge() { admin_purge(); } - "#, - )]); - let cp = make_config(3, &["cli", "mcp"], &[]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - let names: Vec = missing_pairs(&findings) - .into_iter() - .map(|(t, _)| t) - .collect(); - assert!( - names.iter().any(|n| n.ends_with("admin_purge")), - "self-only-caller orphan must still fire, got {names:?}" - ); -} - -// ── Boundary semantic (v1.2.1) ───────────────────────────────── - -#[test] -fn test_post_boundary_helper_not_flagged_when_transitive_reach_asymmetric() { - // The asymmetric setup: cli reaches `record_operation` transitively - // (via search), mcp doesn't reach it at all (handle_admin → admin, - // which doesn't touch record_operation). Under the OLD leaf- - // reachability semantic, this would fire a Check B finding for - // `record_operation` ("missing from mcp"). Under the new boundary - // semantic, `record_operation` is application-internal plumbing - // that no adapter touches at the boundary — not a parity concern. - let ws = build_workspace(&[ - ( - "src/application/middleware.rs", - r#" - pub fn record_operation() {} - "#, - ), - ( - "src/application/session.rs", - r#" - use crate::application::middleware::record_operation; - pub fn search() { record_operation(); } - pub fn admin() {} - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::search; - pub fn cmd_search() { search(); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::session::admin; - pub fn handle_admin() { admin(); } - "#, - ), - ]); - let cp = make_config(3, &["cli", "mcp"], &[]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - let pairs = missing_pairs(&findings); - // `search` is reached only by cli → mismatch finding. - // `admin` is reached only by mcp → mismatch finding. - // `record_operation` is post-boundary plumbing → MUST NOT appear. - let names: Vec = pairs.iter().map(|(t, _)| t.clone()).collect(); - assert!( - !names.iter().any(|n| n.ends_with("record_operation")), - "post-boundary helper should not appear in findings, got {pairs:?}" - ); -} - -#[test] -fn test_internal_application_chain_no_findings() { - // session.search → record_operation → impact_count: a chain of - // internal application fns. Adapters touch only `search`. None of - // `record_operation` / `impact_count` should produce findings. - let ws = build_workspace(&[ - ( - "src/application/middleware.rs", - r#" - pub fn impact_count() -> u32 { 0 } - pub fn record_operation() { impact_count(); } - "#, - ), - ( - "src/application/session.rs", - r#" - use crate::application::middleware::record_operation; - pub fn search() { record_operation(); } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::search; - pub fn cmd_search() { search(); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::session::search; - pub fn handle_search() { search(); } - "#, - ), - ]); - let cp = make_config(3, &["cli", "mcp"], &[]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - assert!( - missing_pairs(&findings).is_empty(), - "deeper application chain should not fire findings, got {findings:?}" - ); -} - -#[test] -fn test_capability_in_one_adapter_only_fires_for_that_target() { - // cli reaches `admin_purge`; mcp doesn't. mcp reaches `search` too, - // both adapters cover that one. Only `admin_purge` produces a - // finding (mismatch case: present in cli, missing from mcp). - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - pub fn search() {} - pub fn admin_purge() {} - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::{search, admin_purge}; - pub fn cmd_search() { search(); } - pub fn cmd_admin() { admin_purge(); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::session::search; - pub fn handle_search() { search(); } - "#, - ), - ]); - let cp = make_config(3, &["cli", "mcp"], &[]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - let pairs = missing_pairs(&findings); - assert_eq!(pairs.len(), 1, "got {findings:?}"); - assert!( - pairs[0].0.ends_with("admin_purge"), - "expected admin_purge finding, got {pairs:?}" - ); - assert_eq!(pairs[0].1, vec!["mcp".to_string()]); -} - -#[test] -fn test_impl_in_separate_file_matches_receiver_tracked_calls() { - // Regression: `use crate::application::session::Session; impl Session - // { pub fn search() }` in a different file from the type declaration. - // Without alias-map-based canonicalisation of the impl self-type, - // Check B's node for `search` would be - // `crate::application::session_impls::Session::search` while the - // caller's receiver-tracked canonical is - // `crate::application::session::Session::search` — the two never - // match and every adapter looks like it's missing. - let ws = build_workspace(&[ - ("src/application/session.rs", "pub struct Session;"), - ( - "src/application/session_impls.rs", - r#" - use crate::application::session::Session; - impl Session { - pub fn open() -> Self { Session } - pub fn search(&self) {} - } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::Session; - pub fn cmd_search() { - let s = Session::open(); - s.search(); - } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::session::Session; - pub fn handle_search() { - let s = Session::open(); - s.search(); - } - "#, - ), - ]); - let cp = make_config(3, &["cli", "mcp"], &[]); - let findings = run_check_b(&ws, &four_layer(), &cp, &empty_cfg_test()); - assert!( - missing_pairs(&findings).is_empty(), - "cross-file impl via use should match receiver-tracked calls, got {findings:?}" - ); -} - -// ── Trait-method anchor coverage ────────────────────────────── - -fn ports_cp() -> CompiledCallParity { - CompiledCallParity { - adapters: vec!["cli".to_string(), "mcp".to_string()], - target: "application".to_string(), - call_depth: 3, - exclude_targets: globset(&[]), - transparent_wrappers: HashSet::new(), - transparent_macros: HashSet::new(), - promoted_attributes: HashSet::new(), - single_touchpoint: crate::config::architecture::SingleTouchpointMode::default(), - } -} - -#[test] -fn check_b_silent_when_anchor_covered_by_all_adapters() { - // Trait in `ports`, impl in `application` (target). Both CLI and - // MCP dispatch via `dyn Handler.handle()` — anchor - // `crate::ports::handler::Handler::handle` is in both adapters' - // touchpoint sets. The anchor IS a target capability (its impl - // lives in application), and BOTH adapters reach it → Check B - // must be silent. - let ws = build_workspace(&[ - ( - "src/ports/handler.rs", - "pub trait Handler { fn handle(&self); }", - ), - ( - "src/application/logging.rs", - r#" - use crate::ports::handler::Handler; - pub struct LoggingHandler; - impl Handler for LoggingHandler { fn handle(&self) {} } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::ports::handler::Handler; - pub fn cmd_dispatch(h: &dyn Handler) { h.handle(); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::ports::handler::Handler; - pub fn mcp_dispatch(h: &dyn Handler) { h.handle(); } - "#, - ), - ]); - let findings = run_check_b(&ws, &ports_app_cli_mcp(), &ports_cp(), &empty_cfg_test()); - let pairs = missing_pairs(&findings); - let anchor = "crate::ports::handler::Handler::handle"; - assert!( - !pairs.iter().any(|(target, _)| target == anchor), - "anchor covered by all adapters must not produce a finding, got {pairs:?}" - ); -} - -#[test] -fn check_b_silent_for_concrete_impl_when_only_anchor_reached() { - // Both adapters dispatch via `dyn Handler.handle()`. The walker - // registers ONLY the anchor `Handler::handle` as touchpoint — - // concrete impl methods like `LoggingHandler::handle` never enter - // the touchpoint set via dispatch. Without F5's anchor-backed- - // concrete skip, Check B would flag `LoggingHandler::handle` as - // an orphan even though the trait-method anchor IS covered by - // both adapters. - let ws = build_workspace(&[ - ( - "src/ports/handler.rs", - "pub trait Handler { fn handle(&self); }", - ), - ( - "src/application/logging.rs", - r#" - use crate::ports::handler::Handler; - pub struct LoggingHandler; - impl Handler for LoggingHandler { fn handle(&self) {} } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::ports::handler::Handler; - pub fn cmd_dispatch(h: &dyn Handler) { h.handle(); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::ports::handler::Handler; - pub fn mcp_dispatch(h: &dyn Handler) { h.handle(); } - "#, - ), - ]); - let findings = run_check_b(&ws, &ports_app_cli_mcp(), &ports_cp(), &empty_cfg_test()); - let pairs = missing_pairs(&findings); - let concrete = "crate::application::logging::LoggingHandler::handle"; - assert!( - !pairs.iter().any(|(target, _)| target == concrete), - "concrete impl-method must NOT be flagged as orphan when its anchor is covered; got {pairs:?}" - ); -} - -#[test] -fn check_b_flags_inherent_method_even_when_same_name_inherited_default_exists() { - // Canonical collision: the inherent method `impl AppHandler { fn - // handle… }` and the inherited-default `impl Handler for - // AppHandler {}` share the canonical `AppHandler::handle`. The - // inherent method has a real body and is a normal target pub-fn - // — Check B must surface a missing-adapter finding when no - // adapter reaches it. It must NOT be silently treated as - // "anchor-backed" via the empty trait impl. - let ws = build_workspace(&[ - ( - "src/ports/handler.rs", - "pub trait Handler { fn handle(&self) {} }", - ), - ( - "src/application/logging.rs", - r#" - use crate::ports::handler::Handler; - pub struct AppHandler; - impl Handler for AppHandler {} - impl AppHandler { pub fn handle(&self) {} } - "#, - ), - ("src/cli/handlers.rs", "pub fn cmd_other() {}"), - ("src/mcp/handlers.rs", "pub fn mcp_other() {}"), - ]); - let findings = run_check_b(&ws, &ports_app_cli_mcp(), &ports_cp(), &empty_cfg_test()); - let pairs = missing_pairs(&findings); - let inherent = "crate::application::logging::AppHandler::handle"; - assert!( - pairs.iter().any(|(target, _)| target == inherent), - "inherent method `AppHandler::handle` must produce a missing-adapter finding; it must not be silently absorbed into the trait anchor; got {pairs:?}" - ); -} - -#[test] -fn check_b_silent_anchor_when_adapters_call_inherited_default_concretely() { - // Inherited-default impl: every adapter covers the capability via - // the concrete form (UFCS or struct-method call). The edge-rewrite - // post-pass folds those phantom edges onto the trait anchor, so - // coverage hits the anchor for both adapters and the anchor pass - // stays silent. - let ws = build_workspace(&[ - ( - "src/ports/handler.rs", - "pub trait Handler { fn handle(&self) {} }", - ), - ( - "src/application/logging.rs", - // Empty impl — inherits the trait default body. - r#" - use crate::ports::handler::Handler; - pub struct AppHandler; - impl Handler for AppHandler {} - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::logging::AppHandler; - pub fn cmd_log() { AppHandler::handle(&AppHandler); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::logging::AppHandler; - pub fn mcp_log() { AppHandler::handle(&AppHandler); } - "#, - ), - ]); - let findings = run_check_b(&ws, &ports_app_cli_mcp(), &ports_cp(), &empty_cfg_test()); - let pairs = missing_pairs(&findings); - let anchor = "crate::ports::handler::Handler::handle"; - assert!( - !pairs.iter().any(|(target, _)| target == anchor), - "anchor must be silent when every adapter covers the capability via the inherited-default concrete form; got {pairs:?}" - ); -} - -#[test] -fn check_b_anchor_finding_excluded_via_impl_path_glob() { - // `exclude_targets = ["application::admin::*"]` matches the impl - // path; the anchor finding for `ports::Handler::handle` must be - // silenced via the anchor's backed impl_method_canonicals. - let ws = build_workspace(&[ - ( - "src/ports/handler.rs", - "pub trait Handler { fn handle(&self); }", - ), - ( - "src/application/admin.rs", - r#" - use crate::ports::handler::Handler; - pub struct AdminHandler; - impl Handler for AdminHandler { fn handle(&self) {} } - "#, - ), - ("src/cli/handlers.rs", "pub fn cmd_other() {}"), - ("src/mcp/handlers.rs", "pub fn mcp_other() {}"), - ]); - let mut cp = ports_cp(); - cp.exclude_targets = globset(&["application::admin::*"]); - let findings = run_check_b(&ws, &ports_app_cli_mcp(), &cp, &empty_cfg_test()); - let pairs = missing_pairs(&findings); - let anchor = "crate::ports::handler::Handler::handle"; - assert!( - !pairs.iter().any(|(target, _)| target == anchor), - "anchor finding must be silenced when exclude_targets matches an impl_method_canonical (`application::admin::*` matches `application::admin::AdminHandler::handle`); got {pairs:?}" - ); -} - -#[test] -fn check_b_silent_anchor_when_all_adapters_cover_via_direct_concrete() { - // Every adapter calls the concrete impl directly; no dispatch - // anywhere. The anchor pass must suppress the orphan finding via - // the impl-method-canonical coverage check. - let ws = build_workspace(&[ - ( - "src/ports/handler.rs", - "pub trait Handler { fn handle(&self); }", - ), - ( - "src/application/logging.rs", - r#" - use crate::ports::handler::Handler; - pub struct LoggingHandler; - impl Handler for LoggingHandler { fn handle(&self) {} } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::logging::LoggingHandler; - pub fn cmd_log() { LoggingHandler::handle(&LoggingHandler); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::logging::LoggingHandler; - pub fn mcp_log() { LoggingHandler::handle(&LoggingHandler); } - "#, - ), - ]); - let findings = run_check_b(&ws, &ports_app_cli_mcp(), &ports_cp(), &empty_cfg_test()); - let pairs = missing_pairs(&findings); - let anchor = "crate::ports::handler::Handler::handle"; - assert!( - !pairs.iter().any(|(target, _)| target == anchor), - "anchor must be silent when the capability is covered via direct concrete by every adapter; got {pairs:?}" - ); -} - -#[test] -fn check_b_does_not_skip_concrete_when_an_adapter_calls_it_directly() { - // Mixed-form drift: cli direct concrete, mcp dispatch. The - // concrete pass must still run so the form-mismatch surfaces. - let ws = build_workspace(&[ - ( - "src/ports/handler.rs", - "pub trait Handler { fn handle(&self); }", - ), - ( - "src/application/logging.rs", - r#" - use crate::ports::handler::Handler; - pub struct LoggingHandler; - impl Handler for LoggingHandler { fn handle(&self) {} } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::logging::LoggingHandler; - pub fn cmd_log() { - LoggingHandler::handle(&LoggingHandler); - } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::ports::handler::Handler; - pub fn mcp_dispatch(h: &dyn Handler) { h.handle(); } - "#, - ), - ]); - let findings = run_check_b(&ws, &ports_app_cli_mcp(), &ports_cp(), &empty_cfg_test()); - let pairs = missing_pairs(&findings); - let concrete = "crate::application::logging::LoggingHandler::handle"; - let concrete_finding = pairs.iter().find(|(t, _)| t == concrete); - assert!( - concrete_finding.is_some(), - "concrete impl-method must NOT be silently skipped when at least one adapter (cli) calls it directly — drift between cli (direct) and mcp (dispatch) must surface; got {pairs:?}" - ); - if let Some((_, missing)) = concrete_finding { - assert!( - missing.iter().any(|a| a == "mcp"), - "concrete pass must report mcp as missing (it reaches via dispatch, not direct concrete); got {missing:?}" - ); - } -} - -#[test] -fn check_b_flags_anchor_orphan_when_no_adapter_reaches_it() { - // Trait `Orphan` in ports with overriding impl in application. - // No adapter dispatches through it. The anchor is a target - // capability that no adapter wires up → Check B must flag it - // as orphan/missing-from-all-adapters. - let ws = build_workspace(&[ - ( - "src/ports/orphan.rs", - "pub trait Orphan { fn handle(&self); }", - ), - ( - "src/application/orphan_impl.rs", - r#" - use crate::ports::orphan::Orphan; - pub struct OrphanImpl; - impl Orphan for OrphanImpl { fn handle(&self) {} } - "#, - ), - // CLI and MCP exist but never dispatch via `dyn Orphan`. - ("src/cli/handlers.rs", "pub fn cmd_other() {}"), - ("src/mcp/handlers.rs", "pub fn mcp_other() {}"), - ]); - let findings = run_check_b(&ws, &ports_app_cli_mcp(), &ports_cp(), &empty_cfg_test()); - let pairs = missing_pairs(&findings); - let anchor = "crate::ports::orphan::Orphan::handle"; - assert!( - pairs.iter().any(|(target, _)| target == anchor), - "anchor reached by NO adapter must be flagged as orphan, got {pairs:?}" - ); -} - -#[test] -fn anchor_finding_carries_trait_method_source_line() { - // Anchor findings must carry the trait method's real file + line - // (1-based) — line=0 placeholders break suppression-window matching, - // the orphan detector's window scan, and SARIF startLine validity. - let ws = build_workspace(&[ - ( - // Lines: 1=blank, 2=trait header, 3=method decl - "src/ports/orphan.rs", - "\npub trait Orphan {\n fn handle(&self);\n}\n", - ), - ( - "src/application/orphan_impl.rs", - r#" - use crate::ports::orphan::Orphan; - pub struct OrphanImpl; - impl Orphan for OrphanImpl { fn handle(&self) {} } - "#, - ), - ("src/cli/handlers.rs", "pub fn cmd_other() {}"), - ("src/mcp/handlers.rs", "pub fn mcp_other() {}"), - ]); - let findings = run_check_b(&ws, &ports_app_cli_mcp(), &ports_cp(), &empty_cfg_test()); - let anchor = "crate::ports::orphan::Orphan::handle"; - let hit = findings - .iter() - .find(|f| match &f.kind { - ViolationKind::CallParityMissingAdapter { target_fn, .. } => target_fn == anchor, - _ => false, - }) - .unwrap_or_else(|| panic!("anchor orphan finding missing, got {findings:?}")); - assert_eq!( - hit.file, "src/ports/orphan.rs", - "anchor finding must carry the trait method's source file, got {hit:?}" - ); - assert_eq!( - hit.line, 3, - "anchor finding must carry the trait method's 1-based line number, got {hit:?}" - ); - // F6.3 cross-check: anchor finding line is non-zero AND a - // valid 1-based line number, matching SARIF startLine - // requirements and what suppression-window matchers expect. - assert!( - hit.line >= 1, - "anchor finding line must be 1-based (>=1), got {}", - hit.line - ); -} - -#[test] -fn check_b_anchor_only_target_surface_still_inspected() { - // Target layer has NO concrete pub fns — only a default-body trait - // declared there. The trait method is a target capability via the - // unified rule. Even though in practice `pub_fns_by_layer["application"]` - // is created (empty vec) by the collector's `or_default()`, the - // target-anchor branch must still fire a missing-adapter finding. - // Sister test below directly exercises the `None` branch via a - // hand-stripped pub_fns_by_layer. - let ws = build_workspace(&[ - ( - "src/application/cap.rs", - "pub trait Cap { fn run(&self) {} }", - ), - ("src/cli/handlers.rs", "pub fn cmd_other() {}"), - ("src/mcp/handlers.rs", "pub fn mcp_other() {}"), - ]); - let findings = run_check_b(&ws, &ports_app_cli_mcp(), &ports_cp(), &empty_cfg_test()); - let pairs = missing_pairs(&findings); - let anchor = "crate::application::cap::Cap::run"; - assert!( - pairs.iter().any(|(target, _)| target == anchor), - "anchor in anchor-only target layer must still fire missing-adapter, got {pairs:?}" - ); -} - -#[test] -fn check_b_anchor_reached_transitively_via_target_chain_no_finding() { - // cli reaches a target fn that dispatches via `dyn Handler`; mcp - // doesn't reach the anchor at all. The anchor must stay silent - // (post-boundary plumbing wired via at least one adapter). - let ws = build_workspace(&[ - ( - "src/ports/handler.rs", - "pub trait Handler { fn handle(&self); }", - ), - ( - "src/application/wires.rs", - r#" - use crate::ports::handler::Handler; - pub struct LoggingHandler; - impl Handler for LoggingHandler { fn handle(&self) {} } - pub fn dispatch(h: &dyn Handler) { h.handle(); } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::wires::{dispatch, LoggingHandler}; - pub fn cmd_run() { dispatch(&LoggingHandler); } - "#, - ), - ("src/mcp/handlers.rs", "pub fn cmd_other() {}"), - ]); - let findings = run_check_b(&ws, &ports_app_cli_mcp(), &ports_cp(), &empty_cfg_test()); - let pairs = missing_pairs(&findings); - let anchor = "crate::ports::handler::Handler::handle"; - assert!( - !pairs.iter().any(|(target, _)| target == anchor), - "anchor reachable transitively via an adapter-touched target fn must be silent (post-boundary plumbing rule), got {pairs:?}" - ); -} - -#[test] -fn check_b_anchor_inspected_even_when_target_layer_absent_from_pub_fns_map() { - // Strips the target entry from pub_fns_by_layer to exercise the - // `None` branch of `get(target)`. Anchor enumeration must still - // run. - use super::support::borrowed_files; - use crate::adapters::analyzers::architecture::call_parity_rule::build_handler_touchpoints; - use crate::adapters::analyzers::architecture::call_parity_rule::check_b::check_missing_adapter; - use crate::adapters::analyzers::architecture::call_parity_rule::pub_fns::{ - collect_pub_fns_by_layer, PubFnInputs, - }; - use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::build_call_graph; - - let ws = build_workspace(&[ - ( - "src/application/cap.rs", - "pub trait Cap { fn run(&self) {} }", - ), - ("src/cli/handlers.rs", "pub fn cmd_other() {}"), - ("src/mcp/handlers.rs", "pub fn mcp_other() {}"), - ]); - let layers = ports_app_cli_mcp(); - let cp = ports_cp(); - let cfg_test = empty_cfg_test(); - let borrowed = borrowed_files(&ws); - let crate_root_modules = HashSet::new(); - let workspace_module_paths = HashSet::new(); - let workspace = crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &cfg_test, - crate_root_modules: &crate_root_modules, - workspace_module_paths: &workspace_module_paths, - }; - let mut pub_fns = collect_pub_fns_by_layer(PubFnInputs { - files: &borrowed, - aliases_per_file: &ws.aliases_per_file, - layers: &layers, - transparent_wrappers: &cp.transparent_wrappers, - promoted_attributes: &cp.promoted_attributes, - workspace: &workspace, - }); - let graph = build_call_graph( - &borrowed, - &ws.aliases_per_file, - &layers, - &cp.transparent_wrappers, - &workspace, - ); - let touchpoints = build_handler_touchpoints(&pub_fns, &graph, &cp); - pub_fns.remove("application"); - assert!( - !pub_fns.contains_key("application"), - "test precondition: target layer key must be absent before invoking check_missing_adapter" - ); - let findings = check_missing_adapter(&pub_fns, &graph, &touchpoints, &cp); - let pairs = missing_pairs(&findings); - let anchor = "crate::application::cap::Cap::run"; - assert!( - pairs.iter().any(|(target, _)| target == anchor), - "with target layer absent from pub_fns_by_layer, anchor enumeration must still run; got {pairs:?}" - ); -} - -// ───────────────────────────────────────────────────────────────────── -// Cascade clearance — when an adapter reaches a generic dispatcher -// that resolves to a trait-anchor edge, downstream callees of the -// impl method must be cleared from missing-adapter findings via the -// forward BFS through target-internal edges. -// ───────────────────────────────────────────────────────────────────── - -#[test] -fn check_b_cascade_clears_when_target_reached_via_generic_trait_dispatch() { - // An adapter reaches a generic runner that dispatches via - // `Q::execute(...)` to a trait impl. The impl body calls another - // application helper. With the trait-anchor edge in place, the - // helper must NOT show up as missing — the BFS from the boundary - // touchpoints follows the anchor to the impl, then onwards. - let ws = build_workspace(&[ - ( - "src/application/symbol.rs", - r#" - pub trait SymbolQuery { - fn execute(&self); - } - pub struct DepsQuery; - impl SymbolQuery for DepsQuery { - fn execute(&self) { - collect_callees(); - } - } - pub fn collect_callees() {} - "#, - ), - ( - "src/application/runner.rs", - r#" - use crate::application::symbol::SymbolQuery; - - pub fn run(q: Q) { - Q::execute(&q); - } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::runner::run; - use crate::application::symbol::DepsQuery; - - pub fn cmd_deps() { - run(DepsQuery); - } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::runner::run; - use crate::application::symbol::DepsQuery; - - pub fn handle_deps() { - run(DepsQuery); - } - "#, - ), - ]); - let findings = run_check_b( - &ws, - &three_layer(), - &cli_mcp_config_full(), - &empty_cfg_test(), - ); - - let collect_canonical = "crate::application::symbol::collect_callees"; - let missing = missing_adapters_for(&findings, collect_canonical); - - assert!( - missing.is_none(), - "`collect_callees` flagged as not-reached even though it's \ - called by an impl method that an adapter reaches via the \ - generic runner.\n\ - missing adapters for collect_callees: {missing:?}\n\ - all findings: {:?}", - findings - .iter() - .filter_map(|f| match &f.kind { - ViolationKind::CallParityMissingAdapter { target_fn, .. } => - Some(target_fn.as_str()), - _ => None, - }) - .collect::>(), - ); -} - -// ───────────────────────────────────────────────────────────────────── -// Promoted-attribute support — a private attributed fn (e.g. -// `#[tool] async fn ...`) inside an adapter impl block must be -// treated as a handler entry point when configured via -// `promoted_attributes`, so its body's calls count toward coverage. -// ───────────────────────────────────────────────────────────────────── - -#[test] -fn check_b_promoted_attribute_lifts_private_fn_onto_handler_surface() { - // Pattern: `async fn search` without a `pub` modifier inside an - // inherent impl block — a proc-macro is expected to generate the - // public dispatch wrapper at expansion time. Without - // `promoted_attributes` configured, the private fn is filtered - // out of the adapter's handler set and the call is invisible. - // With `promoted_attributes = ["tool"]`, the fn is promoted onto - // the surface and its body's calls satisfy coverage. - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - pub struct Session; - pub struct MyErr; - impl Session { - pub fn open(_p: &str) -> Result { todo!() } - } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::Session; - pub fn cmd_search() { - let _ = Session::open("/p"); - } - "#, - ), - ( - "src/mcp/server.rs", - r#" - use crate::application::session::{Session, MyErr}; - - #[derive(Clone)] - pub struct Server { - pub(super) project_root: std::path::PathBuf, - } - - pub struct Parameters(pub T); - pub struct SearchParams; - pub struct CallToolResult; - - #[tool_router(vis = "pub(super)")] - impl Server { - #[tool(description = "search")] - async fn search( - &self, - _params: Parameters, - ) -> Result { - let _session = Session::open("/p"); - todo!() - } - } - "#, - ), - ]); - let mut cp = cli_mcp_config_full(); - cp.promoted_attributes.insert("tool".to_string()); - let findings = run_check_b(&ws, &three_layer(), &cp, &empty_cfg_test()); - - let open = "crate::application::session::Session::open"; - let missing = missing_adapters_for(&findings, open); - - assert!( - missing - .as_ref() - .is_none_or(|m| !m.contains(&"mcp".to_string())), - "with promoted_attributes=[\"tool\"], Session::open is still \ - flagged as not reached from mcp. The promotion in \ - pub_fns.rs::visit_impl_item_fn isn't picking up the #[tool] \ - attribute on the private async fn.\n\ - missing adapters for Session::open: {missing:?}\n\ - all findings: {:?}", - findings - .iter() - .filter_map(|f| match &f.kind { - ViolationKind::CallParityMissingAdapter { target_fn, .. } => - Some(target_fn.as_str()), - _ => None, - }) - .collect::>(), - ); -} - -// ───────────────────────────────────────────────────────────────────── -// Hint surfacing — when a missing adapter has a private fn carrying -// a custom attribute (`#[tool]`, etc.) that would resolve the finding -// after promotion, the finding's `hint` field must name it. -// Negative cases ensure spurious suggestions don't fire. -// ───────────────────────────────────────────────────────────────────── - -#[test] -fn check_b_hint_suggests_private_attributed_fn_when_it_reaches_target() { - // Positive case: missing adapter mcp has a private `#[tool]` fn - // that transitively reaches the unreached target. Hint must name - // file + fn + attribute so the author can immediately add - // `promoted_attributes = ["tool"]`. - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - pub struct Session; - pub struct MyErr; - impl Session { - pub fn open(_p: &str) -> Result { todo!() } - } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::Session; - pub fn cmd_search() { - let _ = Session::open("/p"); - } - "#, - ), - ( - "src/mcp/server.rs", - r#" - use crate::application::session::{Session, MyErr}; - pub struct Server; - impl Server { - #[tool(description = "search")] - async fn search(&self) -> Result<(), MyErr> { - let _ = Session::open("/p"); - Ok(()) - } - } - "#, - ), - ]); - let cp = cli_mcp_config_full(); - let findings = run_check_b(&ws, &three_layer(), &cp, &empty_cfg_test()); - - let open = "crate::application::session::Session::open"; - let hint = hint_for(&findings, open).expect("expected hint on missing-adapter finding"); - assert!( - hint.contains("search") && hint.contains("tool") && hint.contains("mcp"), - "hint must name candidate fn `search`, its attribute `tool`, and \ - adapter `mcp`. Got:\n{hint}" - ); - assert!( - hint.contains("promoted_attributes"), - "hint must point the author at the `promoted_attributes` config knob. Got:\n{hint}" - ); -} - -#[test] -fn check_b_no_hint_when_no_private_attributed_fn_in_missing_adapter() { - // Missing adapter mcp has NO private fn carrying any attribute - // that reaches the target. Finding still fires but hint is None. - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - pub struct Session; - impl Session { - pub fn open(_p: &str) {} - } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::Session; - pub fn cmd_search() { Session::open("/p"); } - "#, - ), - ( - "src/mcp/server.rs", - r#" - pub fn handle_other() {} - "#, - ), - ]); - let cp = cli_mcp_config_full(); - let findings = run_check_b(&ws, &three_layer(), &cp, &empty_cfg_test()); - - let open = "crate::application::session::Session::open"; - let missing = - missing_adapters_for(&findings, open).expect("expected open to be missing from mcp"); - assert!(missing.contains(&"mcp".to_string())); - assert!( - hint_for(&findings, open).is_none(), - "no private attributed candidate in mcp → no hint expected" - ); -} - -#[test] -fn check_b_no_hint_when_only_stdlib_attribute_on_candidate() { - // Private fn carries only stdlib attributes (`#[allow]`, - // `#[deprecated]`, etc.) — those are noise, not framework-handler - // markers, so they must not trigger the hint. - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - pub struct Session; - impl Session { - pub fn open(_p: &str) {} - } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::Session; - pub fn cmd_search() { Session::open("/p"); } - "#, - ), - ( - "src/mcp/server.rs", - r#" - use crate::application::session::Session; - pub struct Server; - impl Server { - #[allow(dead_code)] - fn search_internal(&self) { - Session::open("/p"); - } - } - "#, - ), - ]); - let cp = cli_mcp_config_full(); - let findings = run_check_b(&ws, &three_layer(), &cp, &empty_cfg_test()); - - let open = "crate::application::session::Session::open"; - assert!( - hint_for(&findings, open).is_none(), - "stdlib attribute (#[allow]) must not qualify the fn as a promotion candidate" - ); -} - -#[test] -fn check_b_no_hint_when_candidate_body_does_not_reach_target() { - // Private + attributed fn exists in the missing adapter but its - // body doesn't reach the unreached target. Promoting it wouldn't - // resolve the finding, so no hint. - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - pub struct Session; - impl Session { - pub fn open(_p: &str) {} - pub fn other(&self) {} - } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::Session; - pub fn cmd_search() { Session::open("/p"); } - "#, - ), - ( - "src/mcp/server.rs", - r#" - pub struct Server; - impl Server { - #[tool(description = "unrelated")] - async fn unrelated(&self) { - // Doesn't call Session::open — calls nothing. - } - } - "#, - ), - ]); - let cp = cli_mcp_config_full(); - let findings = run_check_b(&ws, &three_layer(), &cp, &empty_cfg_test()); - - let open = "crate::application::session::Session::open"; - assert!( - hint_for(&findings, open).is_none(), - "the #[tool] fn `unrelated` doesn't reach Session::open → no hint expected" - ); -} - -#[test] -fn check_b_hint_excludes_adapters_already_covering_target() { - // cli reaches target, mcp doesn't. The hint must mention only - // mcp's candidate (if any), never cli's — cli already covers the - // target, so promoting a cli candidate is irrelevant. - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - pub struct Session; - impl Session { - pub fn stats(&self) {} - } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::Session; - pub struct CliCmds; - impl CliCmds { - #[tool(description = "diagnostic")] - fn diagnostic_stats(s: &Session) { s.stats(); } - } - pub fn cmd_stats(s: &Session) { s.stats(); } - "#, - ), - ( - "src/mcp/server.rs", - r#" - pub fn handle_other() {} - "#, - ), - ]); - let cp = cli_mcp_config_full(); - let findings = run_check_b(&ws, &three_layer(), &cp, &empty_cfg_test()); - - let stats = "crate::application::session::Session::stats"; - let missing = missing_adapters_for(&findings, stats).expect("stats must be missing from mcp"); - assert_eq!(missing, vec!["mcp".to_string()]); - // cli has a candidate but cli isn't a missing adapter → no hint. - assert!( - hint_for(&findings, stats).is_none(), - "candidate in cli (already covering) must not surface in the hint when only mcp is missing" - ); -} - -#[test] -fn check_b_no_hint_when_candidate_path_exceeds_call_depth() { - // A private #[tool] fn whose body chain reaches the target only - // via depth > call_depth must NOT produce a hint — promotion - // wouldn't help because compute_touchpoints stops at call_depth. - // - // call_depth = 1: handler (depth 0) → first callee (depth 1, - // boundary). With this fixture, `tool_a` reaches `Session::open` - // only via 2 hops, so even after promotion the walker stops at - // `helper1` and never sees `open`. - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - pub struct Session; - impl Session { pub fn open() {} } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::Session; - pub fn cmd_open() { Session::open(); } - "#, - ), - ( - "src/mcp/server.rs", - r#" - use crate::application::session::Session; - pub struct Server; - impl Server { - #[tool(description = "deep")] - fn tool_a(&self) { helper1(); } - } - fn helper1() { Session::open(); } - "#, - ), - ]); - let mut cp = cli_mcp_config_full(); - cp.call_depth = 1; - let findings = run_check_b(&ws, &three_layer(), &cp, &empty_cfg_test()); - let open = "crate::application::session::Session::open"; - assert!( - hint_for(&findings, open).is_none(), - "tool_a → helper1 → open is depth 2, exceeds call_depth=1 — \ - walker would not accept tool_a as touchpoint after promotion, \ - so no hint expected. Got: {:?}", - hint_for(&findings, open), - ); -} - -#[test] -fn check_b_no_hint_when_candidate_reaches_target_only_via_peer_adapter() { - // A candidate in adapter A whose only path to the target goes - // through adapter B's code must NOT produce a hint — touchpoint - // computation from A stops at peer-adapter boundaries, so - // promotion wouldn't add the target to A's coverage. - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - pub struct Session; - impl Session { pub fn open() {} } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::Session; - pub fn cli_helper() { Session::open(); } - pub fn cmd_open() { Session::open(); } - "#, - ), - ( - "src/mcp/server.rs", - r#" - pub struct Server; - impl Server { - #[tool(description = "via peer")] - fn tool_a(&self) { crate::cli::handlers::cli_helper(); } - } - "#, - ), - ]); - let cp = cli_mcp_config_full(); - let findings = run_check_b(&ws, &three_layer(), &cp, &empty_cfg_test()); - let open = "crate::application::session::Session::open"; - assert!( - hint_for(&findings, open).is_none(), - "tool_a reaches open only via cli (peer adapter from mcp) — \ - walker would not traverse past cli boundary after promotion, \ - so no hint expected. Got: {:?}", - hint_for(&findings, open), - ); -} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/anchor_coverage.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/anchor_coverage.rs new file mode 100644 index 00000000..05d47483 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/anchor_coverage.rs @@ -0,0 +1,255 @@ +use super::*; + +// Trait in `ports`, impl(s) in `application` (target); CLI + MCP may dispatch +// via `dyn Handler.handle()`, call the concrete impl-method directly, or not +// reach the capability at all. `target` is the canonical we look for (the +// trait-method anchor or a concrete impl-method); `present` is whether a +// missing-adapter finding for it should appear. +// (label, files, exclude_glob, target, present) +const ANCHOR_COVERAGE_CASES: &[AnchorCase] = &[ + ( + "anchor dispatched by all adapters → silent", + &[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self); }", + ), + ( + "src/application/logging.rs", + r#" + use crate::ports::handler::Handler; + pub struct LoggingHandler; + impl Handler for LoggingHandler { fn handle(&self) {} } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::ports::handler::Handler; + pub fn cmd_dispatch(h: &dyn Handler) { h.handle(); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::ports::handler::Handler; + pub fn mcp_dispatch(h: &dyn Handler) { h.handle(); } + "#, + ), + ], + &[], + "crate::ports::handler::Handler::handle", + false, + ), + ( + "concrete impl-method silent when only its anchor is dispatched", + &[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self); }", + ), + ( + "src/application/logging.rs", + r#" + use crate::ports::handler::Handler; + pub struct LoggingHandler; + impl Handler for LoggingHandler { fn handle(&self) {} } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::ports::handler::Handler; + pub fn cmd_dispatch(h: &dyn Handler) { h.handle(); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::ports::handler::Handler; + pub fn mcp_dispatch(h: &dyn Handler) { h.handle(); } + "#, + ), + ], + &[], + "crate::application::logging::LoggingHandler::handle", + false, + ), + ( + "inherent method collides with inherited default → still flagged", + &[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self) {} }", + ), + ( + "src/application/logging.rs", + r#" + use crate::ports::handler::Handler; + pub struct AppHandler; + impl Handler for AppHandler {} + impl AppHandler { pub fn handle(&self) {} } + "#, + ), + ("src/cli/handlers.rs", "pub fn cmd_other() {}"), + ("src/mcp/handlers.rs", "pub fn mcp_other() {}"), + ], + &[], + "crate::application::logging::AppHandler::handle", + true, + ), + ( + "anchor silent when all adapters cover via inherited-default concrete", + &[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self) {} }", + ), + ( + "src/application/logging.rs", + r#" + use crate::ports::handler::Handler; + pub struct AppHandler; + impl Handler for AppHandler {} + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::logging::AppHandler; + pub fn cmd_log() { AppHandler::handle(&AppHandler); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::logging::AppHandler; + pub fn mcp_log() { AppHandler::handle(&AppHandler); } + "#, + ), + ], + &[], + "crate::ports::handler::Handler::handle", + false, + ), + ( + "anchor finding silenced via impl-path exclude glob", + &[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self); }", + ), + ( + "src/application/admin.rs", + r#" + use crate::ports::handler::Handler; + pub struct AdminHandler; + impl Handler for AdminHandler { fn handle(&self) {} } + "#, + ), + ("src/cli/handlers.rs", "pub fn cmd_other() {}"), + ("src/mcp/handlers.rs", "pub fn mcp_other() {}"), + ], + &["application::admin::*"], + "crate::ports::handler::Handler::handle", + false, + ), + ( + "anchor silent when all adapters cover via direct concrete", + &[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self); }", + ), + ( + "src/application/logging.rs", + r#" + use crate::ports::handler::Handler; + pub struct LoggingHandler; + impl Handler for LoggingHandler { fn handle(&self) {} } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::logging::LoggingHandler; + pub fn cmd_log() { LoggingHandler::handle(&LoggingHandler); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::logging::LoggingHandler; + pub fn mcp_log() { LoggingHandler::handle(&LoggingHandler); } + "#, + ), + ], + &[], + "crate::ports::handler::Handler::handle", + false, + ), + ( + "anchor reached by no adapter → flagged orphan", + &[ + ( + "src/ports/orphan.rs", + "pub trait Orphan { fn handle(&self); }", + ), + ( + "src/application/orphan_impl.rs", + r#" + use crate::ports::orphan::Orphan; + pub struct OrphanImpl; + impl Orphan for OrphanImpl { fn handle(&self) {} } + "#, + ), + ("src/cli/handlers.rs", "pub fn cmd_other() {}"), + ("src/mcp/handlers.rs", "pub fn mcp_other() {}"), + ], + &[], + "crate::ports::orphan::Orphan::handle", + true, + ), + ( + "anchor reached transitively via an adapter-touched target fn → silent", + &[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self); }", + ), + ( + "src/application/wires.rs", + r#" + use crate::ports::handler::Handler; + pub struct LoggingHandler; + impl Handler for LoggingHandler { fn handle(&self) {} } + pub fn dispatch(h: &dyn Handler) { h.handle(); } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::wires::{dispatch, LoggingHandler}; + pub fn cmd_run() { dispatch(&LoggingHandler); } + "#, + ), + ("src/mcp/handlers.rs", "pub fn cmd_other() {}"), + ], + &[], + "crate::ports::handler::Handler::handle", + false, + ), +]; + +#[test] +fn check_b_trait_anchor_coverage() { + for (label, files, exclude, target, present) in ANCHOR_COVERAGE_CASES { + let mut cp = ports_cp(); + cp.exclude_targets = globset(exclude); + let ws = build_workspace(files); + let findings = run_check_b(&ws, &ports_app_cli_mcp(), &cp, &empty_cfg_test()); + let pairs = missing_pairs(&findings); + let found = pairs.iter().any(|(t, _)| t == *target); + assert_eq!(found, *present, "case {label}: pairs={pairs:?}"); + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/anchor_edge_cases.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/anchor_edge_cases.rs new file mode 100644 index 00000000..387ed0a8 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/anchor_edge_cases.rs @@ -0,0 +1,184 @@ +use super::*; + +#[test] +fn check_b_does_not_skip_concrete_when_an_adapter_calls_it_directly() { + // Mixed-form drift: cli direct concrete, mcp dispatch. The + // concrete pass must still run so the form-mismatch surfaces. + let pairs = missing_pairs(&run_b_ports(&[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self); }", + ), + ( + "src/application/logging.rs", + r#" + use crate::ports::handler::Handler; + pub struct LoggingHandler; + impl Handler for LoggingHandler { fn handle(&self) {} } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::logging::LoggingHandler; + pub fn cmd_log() { + LoggingHandler::handle(&LoggingHandler); + } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::ports::handler::Handler; + pub fn mcp_dispatch(h: &dyn Handler) { h.handle(); } + "#, + ), + ])); + let concrete = "crate::application::logging::LoggingHandler::handle"; + let concrete_finding = pairs.iter().find(|(t, _)| t == concrete); + assert!( + concrete_finding.is_some(), + "concrete impl-method must NOT be silently skipped when at least one adapter (cli) calls it directly — drift between cli (direct) and mcp (dispatch) must surface; got {pairs:?}" + ); + if let Some((_, missing)) = concrete_finding { + assert!( + missing.iter().any(|a| a == "mcp"), + "concrete pass must report mcp as missing (it reaches via dispatch, not direct concrete); got {missing:?}" + ); + } +} + +#[test] +fn anchor_finding_carries_trait_method_source_line() { + // Anchor findings must carry the trait method's real file + line + // (1-based) — line=0 placeholders break suppression-window matching, + // the orphan detector's window scan, and SARIF startLine validity. + let findings = run_b_ports(&[ + ( + // Lines: 1=blank, 2=trait header, 3=method decl + "src/ports/orphan.rs", + "\npub trait Orphan {\n fn handle(&self);\n}\n", + ), + ( + "src/application/orphan_impl.rs", + r#" + use crate::ports::orphan::Orphan; + pub struct OrphanImpl; + impl Orphan for OrphanImpl { fn handle(&self) {} } + "#, + ), + ("src/cli/handlers.rs", "pub fn cmd_other() {}"), + ("src/mcp/handlers.rs", "pub fn mcp_other() {}"), + ]); + let anchor = "crate::ports::orphan::Orphan::handle"; + let hit = findings + .iter() + .find(|f| match &f.kind { + ViolationKind::CallParityMissingAdapter { target_fn, .. } => target_fn == anchor, + _ => false, + }) + .unwrap_or_else(|| panic!("anchor orphan finding missing, got {findings:?}")); + assert_eq!( + hit.file, "src/ports/orphan.rs", + "anchor finding must carry the trait method's source file, got {hit:?}" + ); + assert_eq!( + hit.line, 3, + "anchor finding must carry the trait method's 1-based line number, got {hit:?}" + ); + // F6.3 cross-check: anchor finding line is non-zero AND a + // valid 1-based line number, matching SARIF startLine + // requirements and what suppression-window matchers expect. + assert!( + hit.line >= 1, + "anchor finding line must be 1-based (>=1), got {}", + hit.line + ); +} + +#[test] +fn check_b_anchor_only_target_surface_still_inspected() { + // Target layer has NO concrete pub fns — only a default-body trait + // declared there. The trait method is a target capability via the + // unified rule. Even though in practice `pub_fns_by_layer["application"]` + // is created (empty vec) by the collector's `or_default()`, the + // target-anchor branch must still fire a missing-adapter finding. + // Sister test below directly exercises the `None` branch via a + // hand-stripped pub_fns_by_layer. + let ws = build_workspace(&[ + ( + "src/application/cap.rs", + "pub trait Cap { fn run(&self) {} }", + ), + ("src/cli/handlers.rs", "pub fn cmd_other() {}"), + ("src/mcp/handlers.rs", "pub fn mcp_other() {}"), + ]); + let findings = run_check_b(&ws, &ports_app_cli_mcp(), &ports_cp(), &empty_cfg_test()); + let pairs = missing_pairs(&findings); + let anchor = "crate::application::cap::Cap::run"; + assert!( + pairs.iter().any(|(target, _)| target == anchor), + "anchor in anchor-only target layer must still fire missing-adapter, got {pairs:?}" + ); +} + +#[test] +fn check_b_anchor_inspected_even_when_target_layer_absent_from_pub_fns_map() { + // Strips the target entry from pub_fns_by_layer to exercise the + // `None` branch of `get(target)`. Anchor enumeration must still + // run. + use crate::adapters::analyzers::architecture::call_parity_rule::build_handler_touchpoints; + use crate::adapters::analyzers::architecture::call_parity_rule::check_b::check_missing_adapter; + use crate::adapters::analyzers::architecture::call_parity_rule::pub_fns::{ + collect_pub_fns_by_layer, PubFnInputs, + }; + use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::build_call_graph; + + let ws = build_workspace(&[ + ( + "src/application/cap.rs", + "pub trait Cap { fn run(&self) {} }", + ), + ("src/cli/handlers.rs", "pub fn cmd_other() {}"), + ("src/mcp/handlers.rs", "pub fn mcp_other() {}"), + ]); + let layers = ports_app_cli_mcp(); + let cp = ports_cp(); + let cfg_test = empty_cfg_test(); + let borrowed = borrowed_files(&ws); + let crate_root_modules = HashSet::new(); + let workspace_module_paths = HashSet::new(); + let workspace = crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { + cfg_test_files: &cfg_test, + crate_root_modules: &crate_root_modules, + workspace_module_paths: &workspace_module_paths, + }; + let mut pub_fns = collect_pub_fns_by_layer(PubFnInputs { + files: &borrowed, + aliases_per_file: &ws.aliases_per_file, + layers: &layers, + transparent_wrappers: &cp.transparent_wrappers, + promoted_attributes: &cp.promoted_attributes, + workspace: &workspace, + }); + let graph = build_call_graph( + &borrowed, + &ws.aliases_per_file, + &layers, + &cp.transparent_wrappers, + &workspace, + ); + let touchpoints = build_handler_touchpoints(&pub_fns, &graph, &cp); + pub_fns.remove("application"); + assert!( + !pub_fns.contains_key("application"), + "test precondition: target layer key must be absent before invoking check_missing_adapter" + ); + let findings = check_missing_adapter(&pub_fns, &graph, &touchpoints, &cp); + let pairs = missing_pairs(&findings); + let anchor = "crate::application::cap::Cap::run"; + assert!( + pairs.iter().any(|(target, _)| target == anchor), + "with target layer absent from pub_fns_by_layer, anchor enumeration must still run; got {pairs:?}" + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/coverage.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/coverage.rs new file mode 100644 index 00000000..1a583644 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/coverage.rs @@ -0,0 +1,234 @@ +use super::*; + +// ── Direct / transitive coverage ────────────────────────────── + +#[test] +fn target_fn_adapter_coverage() { + // (label, adapters that call get_stats, expected missing adapters) + let cases: &[(&str, &[&str], &[&str])] = &[ + ( + "called from all adapters → covered", + &["cli", "mcp", "rest"], + &[], + ), + ("missing one adapter", &["cli", "mcp"], &["rest"]), + ("missing two adapters", &["cli"], &["mcp", "rest"]), + ("not called from any adapter", &[], &["cli", "mcp", "rest"]), + ]; + let cp = make_config(3, &["cli", "mcp", "rest"], &[]); + for (label, present, expected_missing) in cases { + let pairs = missing_pairs(&run_b(&stats_ws(present), &cp)); + if expected_missing.is_empty() { + assert!( + pairs.is_empty(), + "case {label}: expected coverage, got {pairs:?}" + ); + } else { + assert_eq!(pairs.len(), 1, "case {label}: {pairs:?}"); + assert!(pairs[0].0.ends_with("get_stats"), "case {label}"); + let mut missing = pairs[0].1.clone(); + missing.sort(); + let mut exp: Vec = expected_missing.iter().map(|s| s.to_string()).collect(); + exp.sort(); + assert_eq!(missing, exp, "case {label}"); + } + } +} + +// Cases where Check B must produce NO missing-adapter finding: the target is +// reached by every configured adapter (directly, via a service wrapper, or via +// receiver-tracked / cross-file impl calls), is private (not on the parity +// surface), or is excluded by glob. (label, files, adapters, exclude_glob) +const SILENT_CASES: &[SilentCase] = &[ + ( + "rest reaches the target via a service wrapper (depth 2)", + &[ + ("src/application/stats.rs", "pub fn get_stats() {}"), + ( + "src/cli/handlers.rs", + r#" + use crate::application::stats::get_stats; + pub fn cmd_stats() { get_stats(); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::stats::get_stats; + pub fn handle_stats() { get_stats(); } + "#, + ), + ( + "src/rest/service.rs", + r#" + use crate::application::stats::get_stats; + pub fn wrap() { get_stats(); } + "#, + ), + ( + "src/rest/handlers.rs", + r#" + use crate::rest::service::wrap; + pub fn post_stats() { wrap(); } + "#, + ), + ], + &["cli", "mcp", "rest"], + &[], + ), + ( + "private target fn is not on the parity surface", + &[("src/application/stats.rs", "fn get_stats() {}")], + &["cli", "mcp", "rest"], + &[], + ), + ( + "method call via receiver binding counts as reaching the target", + &[ + ( + "src/application/session.rs", + r#" + pub struct Session; + impl Session { + pub fn open() -> Self { Session } + pub fn search(&self) {} + } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::Session; + pub fn cmd_search() { + let s = Session::open(); + s.search(); + } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::session::Session; + pub fn handle_search() { + let s = Session::open(); + s.search(); + } + "#, + ), + ], + &["cli", "mcp"], + &[], + ), + ( + "target matched by exclude_targets glob is ignored", + &[ + ("src/application/setup.rs", "pub fn run() {}"), + ( + "src/cli/handlers.rs", + r#" + use crate::application::setup::run; + pub fn cmd_setup() { run(); } + "#, + ), + ], + &["cli", "mcp", "rest"], + &["application::setup::*"], + ), + ( + "exclude glob uses canonical without the crate:: prefix", + &[("src/application/setup.rs", "pub fn run() {}")], + &["cli", "mcp"], + &["application::setup::run"], + ), + ( + "deeper application-internal chain fires nothing", + &[ + ( + "src/application/middleware.rs", + r#" + pub fn impact_count() -> u32 { 0 } + pub fn record_operation() { impact_count(); } + "#, + ), + ( + "src/application/session.rs", + r#" + use crate::application::middleware::record_operation; + pub fn search() { record_operation(); } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::search; + pub fn cmd_search() { search(); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::session::search; + pub fn handle_search() { search(); } + "#, + ), + ], + &["cli", "mcp"], + &[], + ), + ( + "cross-file impl via use matches receiver-tracked calls", + &[ + ("src/application/session.rs", "pub struct Session;"), + ( + "src/application/session_impls.rs", + r#" + use crate::application::session::Session; + impl Session { + pub fn open() -> Self { Session } + pub fn search(&self) {} + } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::Session; + pub fn cmd_search() { + let s = Session::open(); + s.search(); + } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::session::Session; + pub fn handle_search() { + let s = Session::open(); + s.search(); + } + "#, + ), + ], + &["cli", "mcp"], + &[], + ), +]; + +#[test] +fn check_b_silent_when_target_fully_covered_or_out_of_scope() { + for (label, files, adapters, exclude) in SILENT_CASES { + let cp = make_config(3, adapters, exclude); + let findings = run_b(&build_workspace(files), &cp); + assert!( + missing_pairs(&findings).is_empty(), + "case {label}: expected no findings, got {findings:?}" + ); + } +} + +// Cases where exactly one target is under-covered: a single finding names the +// target and the adapter(s) that fail to reach it. Covers shallow call_depth, +// unresolved method receivers, a partial exclude glob, and a capability present +// in one adapter only. +// (label, files, depth, adapters, exclude_glob, target_suffix, missing) diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/hints.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/hints.rs new file mode 100644 index 00000000..b40f4b2a --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/hints.rs @@ -0,0 +1,279 @@ +use super::*; + +#[test] +fn check_b_hint_suggests_private_attributed_fn_when_it_reaches_target() { + // Positive case: missing adapter mcp has a private `#[tool]` fn + // that transitively reaches the unreached target. Hint must name + // file + fn + attribute so the author can immediately add + // `promoted_attributes = ["tool"]`. + let ws = build_workspace(&[ + ( + "src/application/session.rs", + r#" + pub struct Session; + pub struct MyErr; + impl Session { + pub fn open(_p: &str) -> Result { todo!() } + } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::Session; + pub fn cmd_search() { + let _ = Session::open("/p"); + } + "#, + ), + ( + "src/mcp/server.rs", + r#" + use crate::application::session::{Session, MyErr}; + pub struct Server; + impl Server { + #[tool(description = "search")] + async fn search(&self) -> Result<(), MyErr> { + let _ = Session::open("/p"); + Ok(()) + } + } + "#, + ), + ]); + let cp = cli_mcp_config_full(); + let findings = run_check_b(&ws, &three_layer(), &cp, &empty_cfg_test()); + + let open = "crate::application::session::Session::open"; + let hint = hint_for(&findings, open).expect("expected hint on missing-adapter finding"); + assert!( + hint.contains("search") && hint.contains("tool") && hint.contains("mcp"), + "hint must name candidate fn `search`, its attribute `tool`, and \ + adapter `mcp`. Got:\n{hint}" + ); + assert!( + hint.contains("promoted_attributes"), + "hint must point the author at the `promoted_attributes` config knob. Got:\n{hint}" + ); +} + +// The missing-adapter finding fires (target is missing from mcp), but no hint +// is offered because no promotable private candidate in mcp would actually close +// the gap: there's no attributed candidate, only a stdlib attribute, the +// candidate body doesn't reach the target, the only candidate lives in an +// already-covering adapter, or its path to the target exceeds call_depth / +// leaves through a peer adapter. (label, files, depth, target) +const NO_HINT_CASES: &[NoHintCase] = &[ + ( + "no private attributed fn in the missing adapter", + &[ + ( + "src/application/session.rs", + r#" + pub struct Session; + impl Session { + pub fn open(_p: &str) {} + } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::Session; + pub fn cmd_search() { Session::open("/p"); } + "#, + ), + ("src/mcp/server.rs", "pub fn handle_other() {}"), + ], + 3, + "crate::application::session::Session::open", + ), + ( + "candidate carries only a stdlib attribute (#[allow])", + &[ + ( + "src/application/session.rs", + r#" + pub struct Session; + impl Session { + pub fn open(_p: &str) {} + } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::Session; + pub fn cmd_search() { Session::open("/p"); } + "#, + ), + ( + "src/mcp/server.rs", + r#" + use crate::application::session::Session; + pub struct Server; + impl Server { + #[allow(dead_code)] + fn search_internal(&self) { + Session::open("/p"); + } + } + "#, + ), + ], + 3, + "crate::application::session::Session::open", + ), + ( + "attributed candidate body does not reach the target", + &[ + ( + "src/application/session.rs", + r#" + pub struct Session; + impl Session { + pub fn open(_p: &str) {} + pub fn other(&self) {} + } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::Session; + pub fn cmd_search() { Session::open("/p"); } + "#, + ), + ( + "src/mcp/server.rs", + r#" + pub struct Server; + impl Server { + #[tool(description = "unrelated")] + async fn unrelated(&self) { + // Doesn't call Session::open — calls nothing. + } + } + "#, + ), + ], + 3, + "crate::application::session::Session::open", + ), + ( + "only candidate lives in an adapter already covering the target", + &[ + ( + "src/application/session.rs", + r#" + pub struct Session; + impl Session { + pub fn stats(&self) {} + } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::Session; + pub struct CliCmds; + impl CliCmds { + #[tool(description = "diagnostic")] + fn diagnostic_stats(s: &Session) { s.stats(); } + } + pub fn cmd_stats(s: &Session) { s.stats(); } + "#, + ), + ("src/mcp/server.rs", "pub fn handle_other() {}"), + ], + 3, + "crate::application::session::Session::stats", + ), + ( + "candidate path to target exceeds call_depth", + &[ + ( + "src/application/session.rs", + r#" + pub struct Session; + impl Session { pub fn open() {} } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::Session; + pub fn cmd_open() { Session::open(); } + "#, + ), + ( + "src/mcp/server.rs", + r#" + use crate::application::session::Session; + pub struct Server; + impl Server { + #[tool(description = "deep")] + fn tool_a(&self) { helper1(); } + } + fn helper1() { Session::open(); } + "#, + ), + ], + 1, + "crate::application::session::Session::open", + ), + ( + "candidate reaches the target only via a peer adapter", + &[ + ( + "src/application/session.rs", + r#" + pub struct Session; + impl Session { pub fn open() {} } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::Session; + pub fn cli_helper() { Session::open(); } + pub fn cmd_open() { Session::open(); } + "#, + ), + ( + "src/mcp/server.rs", + r#" + pub struct Server; + impl Server { + #[tool(description = "via peer")] + fn tool_a(&self) { crate::cli::handlers::cli_helper(); } + } + "#, + ), + ], + 3, + "crate::application::session::Session::open", + ), +]; + +#[test] +fn check_b_no_hint_when_promotion_would_not_resolve_the_finding() { + for (label, files, depth, target) in NO_HINT_CASES { + let mut cp = cli_mcp_config_full(); + cp.call_depth = *depth; + let findings = run_check_b( + &build_workspace(files), + &three_layer(), + &cp, + &empty_cfg_test(), + ); + let missing = missing_adapters_for(&findings, target) + .unwrap_or_else(|| panic!("case {label}: target must be missing from mcp")); + assert_eq!(missing, vec!["mcp".to_string()], "case {label}"); + assert!( + hint_for(&findings, target).is_none(), + "case {label}: expected no hint, got {:?}", + hint_for(&findings, target) + ); + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/missing_adapter.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/missing_adapter.rs new file mode 100644 index 00000000..474d7317 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/missing_adapter.rs @@ -0,0 +1,174 @@ +use super::*; + +const MISSING_ADAPTER_CASES: &[MissingCase] = &[ + ( + // REST only reaches the target through a layer-less intermediate + // (`src/shared/` is not a mapped layer), so call_depth = 1 stops + // the backward BFS at depth 1 while cli + mcp hit it directly. + "rest reaches target only past call_depth → rest missing", + &[ + ("src/application/stats.rs", "pub fn get_stats() {}"), + ( + "src/cli/handlers.rs", + r#" + use crate::application::stats::get_stats; + pub fn cmd_stats() { get_stats(); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::stats::get_stats; + pub fn handle_stats() { get_stats(); } + "#, + ), + ( + "src/shared/helpers.rs", + r#" + use crate::application::stats::get_stats; + pub fn deep_call() { get_stats(); } + "#, + ), + ( + "src/rest/handlers.rs", + r#" + use crate::shared::helpers::deep_call; + pub fn post_stats() { deep_call(); } + "#, + ), + ], + 1, + &["cli", "mcp", "rest"], + &[], + "get_stats", + &["rest"], + ), + ( + // `x.get_stats()` on an unknown-type receiver → `:…`, + // layer-unknown, so it doesn't count as reaching the target. + "unknown-type method receiver does not count as reaching target", + &[ + ("src/application/stats.rs", "pub fn get_stats() {}"), + ( + "src/cli/handlers.rs", + "pub fn cmd_stats(x: UnknownType) { x.get_stats(); }", + ), + ], + 3, + &["cli"], + &[], + "get_stats", + &["cli"], + ), + ( + "target outside the exclude glob is still checked → mcp missing", + &[ + ("src/application/setup.rs", "pub fn run() {}"), + ("src/application/stats.rs", "pub fn get_stats() {}"), + ( + "src/cli/handlers.rs", + r#" + use crate::application::setup::run; + use crate::application::stats::get_stats; + pub fn cmd_setup() { run(); } + pub fn cmd_stats() { get_stats(); } + "#, + ), + ], + 3, + &["cli", "mcp"], + &["application::setup::*"], + "get_stats", + &["mcp"], + ), + ( + "capability present in one adapter only fires for that target", + &[ + ( + "src/application/session.rs", + r#" + pub fn search() {} + pub fn admin_purge() {} + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::{search, admin_purge}; + pub fn cmd_search() { search(); } + pub fn cmd_admin() { admin_purge(); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::session::search; + pub fn handle_search() { search(); } + "#, + ), + ], + 3, + &["cli", "mcp"], + &[], + "admin_purge", + &["mcp"], + ), +]; + +#[test] +fn check_b_reports_specific_missing_adapter() { + for (label, files, depth, adapters, exclude, target_suffix, missing) in MISSING_ADAPTER_CASES { + let cp = make_config(*depth, adapters, exclude); + let pairs = missing_pairs(&run_b(&build_workspace(files), &cp)); + assert_eq!(pairs.len(), 1, "case {label}: {pairs:?}"); + assert!( + pairs[0].0.ends_with(target_suffix), + "case {label}: {pairs:?}" + ); + let mut got = pairs[0].1.clone(); + got.sort(); + let mut exp: Vec = missing.iter().map(|s| s.to_string()).collect(); + exp.sort(); + assert_eq!(got, exp, "case {label}"); + } +} + +#[test] +fn test_target_fn_only_called_from_tests_fails() { + let ws = build_workspace(&[ + ("src/application/stats.rs", "pub fn get_stats() {}"), + ( + "src/cli/handlers.rs", + r#" + use crate::application::stats::get_stats; + pub fn cmd_stats() { get_stats(); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::stats::get_stats; + pub fn handle_stats() { get_stats(); } + "#, + ), + ( + "src/rest/tests.rs", + r#" + use crate::application::stats::get_stats; + #[cfg(test)] + mod tests { + use super::*; + #[test] + fn test_stats() { get_stats(); } + } + "#, + ), + ]); + let cp = make_config(3, &["cli", "mcp", "rest"], &[]); + let mut cfg_test = HashSet::new(); + cfg_test.insert("src/rest/tests.rs".to_string()); + let findings = run_check_b(&ws, &four_layer(), &cp, &cfg_test); + let pairs = missing_pairs(&findings); + assert_eq!(pairs.len(), 1, "got {findings:?}"); + assert_eq!(pairs[0].1, vec!["rest".to_string()]); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/mod.rs new file mode 100644 index 00000000..c9264453 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/mod.rs @@ -0,0 +1,201 @@ +//! Tests for Check B (parity-coverage). Each test sets up a small +//! multi-file workspace and asserts the `missing_adapters` set produced by +//! `check_missing_adapter` for each target-layer pub-fn. Split into focused +//! sub-files (each ≤ the SRP file-length cap); shared imports, case-table +//! types, and run/assert helpers live here and reach the sub-modules via +//! `use super::*`. + +pub(super) use super::support::{ + borrowed_files, build_workspace, cli_mcp_config, empty_cfg_test, four_layer, globset, + ports_app_cli_mcp, run_check_b, three_layer, Workspace, +}; +pub(super) use crate::adapters::analyzers::architecture::compiled::CompiledCallParity; +pub(super) use crate::adapters::analyzers::architecture::{MatchLocation, ViolationKind}; +pub(super) use std::collections::HashSet; + +mod anchor_coverage; +mod anchor_edge_cases; +mod coverage; +mod hints; +mod missing_adapter; +mod promotion; +mod visibility; + +/// `(path, source)` file entries for a small workspace fixture. +pub(super) type WsFiles = &'static [(&'static str, &'static str)]; +/// Trait-anchor coverage case: `(label, files, exclude_glob, target, present)`. +pub(super) type AnchorCase = ( + &'static str, + WsFiles, + &'static [&'static str], + &'static str, + bool, +); +/// Orphan/boundary visibility case: `(label, files, target_suffix, flagged)`. +pub(super) type VisibilityCase = (&'static str, WsFiles, &'static str, bool); +/// No-finding case: `(label, files, adapters, exclude_glob)`. +pub(super) type SilentCase = ( + &'static str, + WsFiles, + &'static [&'static str], + &'static [&'static str], +); +/// Specific-missing case: +/// `(label, files, depth, adapters, exclude_glob, target_suffix, missing)`. +pub(super) type MissingCase = ( + &'static str, + WsFiles, + usize, + &'static [&'static str], + &'static [&'static str], + &'static str, + &'static [&'static str], +); +/// No-hint case: `(label, files, depth, target)`. +pub(super) type NoHintCase = (&'static str, WsFiles, usize, &'static str); + +/// Run Check B with the four-layer layout and no cfg-test files — the +/// shared call across most Check-B tests. Tests needing a different layout, +/// config, or a non-empty cfg-test set call `run_check_b` directly. +pub(super) fn run_b(ws: &Workspace, cp: &CompiledCallParity) -> Vec { + run_check_b(ws, &four_layer(), cp, &empty_cfg_test()) +} + +pub(super) fn make_config( + call_depth: usize, + adapters: &[&str], + exclude_targets: &[&str], +) -> CompiledCallParity { + CompiledCallParity { + adapters: adapters.iter().map(|s| s.to_string()).collect(), + target: "application".to_string(), + call_depth, + exclude_targets: globset(exclude_targets), + transparent_wrappers: HashSet::new(), + transparent_macros: HashSet::new(), + promoted_attributes: HashSet::new(), + single_touchpoint: crate::config::architecture::SingleTouchpointMode::default(), + } +} + +/// Build the standard stats workspace: `application::get_stats` plus one +/// handler per present adapter (cli→cmd_stats, mcp→handle_stats, +/// rest→post_stats), each delegating to `get_stats`. +pub(super) fn stats_ws(present_adapters: &[&str]) -> Workspace { + let mut entries = vec![( + "src/application/stats.rs".to_string(), + "pub fn get_stats() {}".to_string(), + )]; + for a in present_adapters { + let handler = match *a { + "cli" => "cmd_stats", + "mcp" => "handle_stats", + "rest" => "post_stats", + other => other, + }; + entries.push(( + format!("src/{a}/handlers.rs"), + format!( + "use crate::application::stats::get_stats;\npub fn {handler}() {{ get_stats(); }}" + ), + )); + } + let refs: Vec<(&str, &str)> = entries + .iter() + .map(|(p, s)| (p.as_str(), s.as_str())) + .collect(); + build_workspace(&refs) +} + +/// `missing_adapters` list for a specific `target_fn` — `None` when +/// no CallParityMissingAdapter finding exists for that target. +pub(super) fn missing_adapters_for( + findings: &[MatchLocation], + target_fn: &str, +) -> Option> { + findings.iter().find_map(|f| match &f.kind { + ViolationKind::CallParityMissingAdapter { + target_fn: tf, + missing_adapters, + .. + } if tf == target_fn => Some(missing_adapters.clone()), + _ => None, + }) +} + +/// Hint text for the missing-adapter finding on `target_fn`, if any. +/// Returns `None` if there's no finding or the finding has hint=None. +pub(super) fn hint_for(findings: &[MatchLocation], target_fn: &str) -> Option { + findings.iter().find_map(|f| match &f.kind { + ViolationKind::CallParityMissingAdapter { + target_fn: tf, + hint, + .. + } if tf == target_fn => hint.clone(), + _ => None, + }) +} + +/// Three-layer `cli + mcp + application` config with `application` as +/// target and an empty exclude_targets — the shared shape for the +/// hint/cascade/promoted-attribute tests further down. +pub(super) fn cli_mcp_config_full() -> CompiledCallParity { + let mut cp = cli_mcp_config(3); + cp.exclude_targets = globset(&[]); + cp +} + +/// Extract the `(target_fn, missing_adapters)` pair from a +/// CallParityMissingAdapter finding, as `String` for easy assertions. +pub(super) fn missing_pairs(findings: &[MatchLocation]) -> Vec<(String, Vec)> { + findings + .iter() + .filter_map(|f| match &f.kind { + ViolationKind::CallParityMissingAdapter { + target_fn, + missing_adapters, + .. + } => Some((target_fn.clone(), missing_adapters.clone())), + _ => None, + }) + .collect() +} + +// ── Trait-method anchor coverage ────────────────────────────── + +pub(super) fn ports_cp() -> CompiledCallParity { + CompiledCallParity { + adapters: vec!["cli".to_string(), "mcp".to_string()], + target: "application".to_string(), + call_depth: 3, + exclude_targets: globset(&[]), + transparent_wrappers: HashSet::new(), + transparent_macros: HashSet::new(), + promoted_attributes: HashSet::new(), + single_touchpoint: crate::config::architecture::SingleTouchpointMode::default(), + } +} + +/// Build a workspace and run Check B with the `ports + application + cli + +/// mcp` layout and the trait-anchor `ports_cp` config — the shared shape +/// for the trait-anchor coverage tests. +pub(super) fn run_b_ports(files: &[(&str, &str)]) -> Vec { + run_check_b( + &build_workspace(files), + &ports_app_cli_mcp(), + &ports_cp(), + &empty_cfg_test(), + ) +} + +/// Build a workspace and run Check B with the three-layer layout and the +/// full `cli + mcp` config (empty exclude) — the shared shape for the +/// cascade / generic-dispatch tests. +pub(super) fn run_b_three(files: &[(&str, &str)]) -> Vec { + run_check_b( + &build_workspace(files), + &three_layer(), + &cli_mcp_config_full(), + &empty_cfg_test(), + ) +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/promotion.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/promotion.rs new file mode 100644 index 00000000..11d4df53 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/promotion.rs @@ -0,0 +1,199 @@ +use super::*; + +// ───────────────────────────────────────────────────────────────────── +// Cascade clearance — when an adapter reaches a generic dispatcher +// that resolves to a trait-anchor edge, downstream callees of the +// impl method must be cleared from missing-adapter findings via the +// forward BFS through target-internal edges. +// ───────────────────────────────────────────────────────────────────── + +/// 4-file workspace for the cascade test: a generic `run` that +/// dispatches via `Q::execute` to a `DepsQuery` impl which calls +/// `collect_callees`, reached from both the CLI and MCP adapters. +fn cascade_workspace() -> Vec<(&'static str, &'static str)> { + vec![ + ( + "src/application/symbol.rs", + r#" + pub trait SymbolQuery { + fn execute(&self); + } + pub struct DepsQuery; + impl SymbolQuery for DepsQuery { + fn execute(&self) { + collect_callees(); + } + } + pub fn collect_callees() {} + "#, + ), + ( + "src/application/runner.rs", + r#" + use crate::application::symbol::SymbolQuery; + + pub fn run(q: Q) { + Q::execute(&q); + } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::runner::run; + use crate::application::symbol::DepsQuery; + + pub fn cmd_deps() { + run(DepsQuery); + } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::runner::run; + use crate::application::symbol::DepsQuery; + + pub fn handle_deps() { + run(DepsQuery); + } + "#, + ), + ] +} + +#[test] +fn check_b_cascade_clears_when_target_reached_via_generic_trait_dispatch() { + // An adapter reaches a generic runner that dispatches via + // `Q::execute(...)` to a trait impl. The impl body calls another + // application helper. With the trait-anchor edge in place, the + // helper must NOT show up as missing — the BFS from the boundary + // touchpoints follows the anchor to the impl, then onwards. + let findings = run_b_three(&cascade_workspace()); + + let collect_canonical = "crate::application::symbol::collect_callees"; + let missing = missing_adapters_for(&findings, collect_canonical); + + assert!( + missing.is_none(), + "`collect_callees` flagged as not-reached even though it's \ + called by an impl method that an adapter reaches via the \ + generic runner.\n\ + missing adapters for collect_callees: {missing:?}\n\ + all findings: {:?}", + findings + .iter() + .filter_map(|f| match &f.kind { + ViolationKind::CallParityMissingAdapter { target_fn, .. } => + Some(target_fn.as_str()), + _ => None, + }) + .collect::>(), + ); +} + +// ───────────────────────────────────────────────────────────────────── +// Promoted-attribute support — a private attributed fn (e.g. +// `#[tool] async fn ...`) inside an adapter impl block must be +// treated as a handler entry point when configured via +// `promoted_attributes`, so its body's calls count toward coverage. +// ───────────────────────────────────────────────────────────────────── + +/// 3-file workspace for the promoted-attribute test: a `Session::open` target, +/// a CLI handler reaching it, and an MCP `Server` whose PRIVATE `#[tool] async fn +/// search` reaches it (visible to coverage only once `#[tool]` is promoted). +fn promoted_attribute_workspace() -> Vec<(&'static str, &'static str)> { + vec![ + ( + "src/application/session.rs", + r#" + pub struct Session; + pub struct MyErr; + impl Session { + pub fn open(_p: &str) -> Result { todo!() } + } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::Session; + pub fn cmd_search() { + let _ = Session::open("/p"); + } + "#, + ), + ( + "src/mcp/server.rs", + r#" + use crate::application::session::{Session, MyErr}; + + #[derive(Clone)] + pub struct Server { + pub(super) project_root: std::path::PathBuf, + } + + pub struct Parameters(pub T); + pub struct SearchParams; + pub struct CallToolResult; + + #[tool_router(vis = "pub(super)")] + impl Server { + #[tool(description = "search")] + async fn search( + &self, + _params: Parameters, + ) -> Result { + let _session = Session::open("/p"); + todo!() + } + } + "#, + ), + ] +} + +#[test] +fn check_b_promoted_attribute_lifts_private_fn_onto_handler_surface() { + // Pattern: `async fn search` without a `pub` modifier inside an + // inherent impl block — a proc-macro is expected to generate the + // public dispatch wrapper at expansion time. Without + // `promoted_attributes` configured, the private fn is filtered + // out of the adapter's handler set and the call is invisible. + // With `promoted_attributes = ["tool"]`, the fn is promoted onto + // the surface and its body's calls satisfy coverage. + let ws = build_workspace(&promoted_attribute_workspace()); + let mut cp = cli_mcp_config_full(); + cp.promoted_attributes.insert("tool".to_string()); + let findings = run_check_b(&ws, &three_layer(), &cp, &empty_cfg_test()); + + let open = "crate::application::session::Session::open"; + let missing = missing_adapters_for(&findings, open); + + assert!( + missing + .as_ref() + .is_none_or(|m| !m.contains(&"mcp".to_string())), + "with promoted_attributes=[\"tool\"], Session::open is still \ + flagged as not reached from mcp. The promotion in \ + pub_fns.rs::visit_impl_item_fn isn't picking up the #[tool] \ + attribute on the private async fn.\n\ + missing adapters for Session::open: {missing:?}\n\ + all findings: {:?}", + findings + .iter() + .filter_map(|f| match &f.kind { + ViolationKind::CallParityMissingAdapter { target_fn, .. } => + Some(target_fn.as_str()), + _ => None, + }) + .collect::>(), + ); +} + +// ───────────────────────────────────────────────────────────────────── +// Hint surfacing — when a missing adapter has a private fn carrying +// a custom attribute (`#[tool]`, etc.) that would resolve the finding +// after promotion, the finding's `hint` field must name it. +// Negative cases ensure spurious suggestions don't fire. +// ───────────────────────────────────────────────────────────────────── diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/visibility.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/visibility.rs new file mode 100644 index 00000000..534cfe0b --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_b/visibility.rs @@ -0,0 +1,113 @@ +use super::*; + +// ── Orphan target-layer islands (v1.2.1) ─────────────────────── + +// Orphan target-layer islands (v1.2.1) + boundary semantic (v1.2.1): a target +// fn is flagged only when no adapter reaches it transitively (a dead island, or +// a self-only caller). A post-boundary internal helper that an adapter reaches +// through a boundary touchpoint — even asymmetrically — is application plumbing +// and must stay silent. (label, files, target_suffix, should_be_flagged) +const VISIBILITY_CASES: &[VisibilityCase] = &[ + ( + "orphan target with only a dead target-internal caller fires", + &[ + ( + "src/application/admin.rs", + r#" + pub fn admin_purge() {} + pub fn _legacy_wrapper() { admin_purge(); } + "#, + ), + ("src/cli/handlers.rs", "pub fn cmd_other() {}"), + ("src/mcp/handlers.rs", "pub fn handle_other() {}"), + ], + "admin_purge", + true, + ), + ( + "self-only caller orphan still fires", + &[( + "src/application/admin.rs", + "pub fn admin_purge() { admin_purge(); }", + )], + "admin_purge", + true, + ), + ( + "target reached transitively via target chain does not fire", + &[ + ( + "src/application/middleware.rs", + "pub fn record_operation() {}", + ), + ( + "src/application/session.rs", + r#" + use crate::application::middleware::record_operation; + pub fn search() { record_operation(); } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::search; + pub fn cmd_search() { search(); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::session::search; + pub fn handle_search() { search(); } + "#, + ), + ], + "record_operation", + false, + ), + ( + "post-boundary helper silent under asymmetric transitive reach", + &[ + ( + "src/application/middleware.rs", + "pub fn record_operation() {}", + ), + ( + "src/application/session.rs", + r#" + use crate::application::middleware::record_operation; + pub fn search() { record_operation(); } + pub fn admin() {} + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::search; + pub fn cmd_search() { search(); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::session::admin; + pub fn handle_admin() { admin(); } + "#, + ), + ], + "record_operation", + false, + ), +]; + +#[test] +fn check_b_orphan_and_boundary_target_visibility() { + let cp = make_config(3, &["cli", "mcp"], &[]); + for (label, files, target_suffix, flagged) in VISIBILITY_CASES { + let findings = run_b(&build_workspace(files), &cp); + let found = missing_pairs(&findings) + .iter() + .any(|(t, _)| t.ends_with(target_suffix)); + assert_eq!(found, *flagged, "case {label}: {findings:?}"); + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_c.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_c.rs index 119ab0cd..bc63765e 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_c.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_c.rs @@ -5,12 +5,20 @@ //! calls itself instead of wrapping them inside a single application //! method. Configurable severity via `single_touchpoint`. -use super::support::{build_workspace, empty_cfg_test, globset, run_check_c, three_layer}; +use super::support::{ + build_workspace, empty_cfg_test, globset, run_check_c, three_layer, Workspace, +}; use crate::adapters::analyzers::architecture::compiled::CompiledCallParity; use crate::adapters::analyzers::architecture::{MatchLocation, ViolationKind}; use crate::config::architecture::SingleTouchpointMode; use std::collections::HashSet; +/// Run Check C with the three-layer layout and no cfg-test files — the +/// shared call across the Check-C tests. +fn run_c(ws: &Workspace, cp: &CompiledCallParity) -> Vec { + run_check_c(ws, &three_layer(), cp, &empty_cfg_test()) +} + fn make_config(mode: SingleTouchpointMode) -> CompiledCallParity { CompiledCallParity { adapters: vec!["cli".to_string(), "mcp".to_string()], @@ -53,7 +61,7 @@ fn check_c_single_touchpoint_silent() { ), ]); let cp = make_config(SingleTouchpointMode::Warn); - let findings = run_check_c(&ws, &three_layer(), &cp, &empty_cfg_test()); + let findings = run_c(&ws, &cp); assert!( extract_c(&findings).is_empty(), "single-touchpoint handler should be silent, got {findings:?}" @@ -91,77 +99,51 @@ fn check_c_silent_for_single_trait_dispatch_with_multiple_impls() { ), ]); let cp = make_config(SingleTouchpointMode::Warn); - let findings = run_check_c(&ws, &three_layer(), &cp, &empty_cfg_test()); + let findings = run_c(&ws, &cp); assert!( extract_c(&findings).is_empty(), "single trait-dispatch call with multiple impls must collapse to one anchor (no Check C fire), got {findings:?}" ); } -// ── Two touchpoints, default severity warn ──────────────────── +// ── Two distinct targets from one handler (sequence or branch) → C fires ── #[test] -fn check_c_two_touchpoints_warn_default() { - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - pub fn foo() {} - pub fn bar() {} - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::{foo, bar}; - pub fn cmd_orchestrate() { foo(); bar(); } - "#, - ), - ]); - let cp = make_config(SingleTouchpointMode::Warn); - let findings = run_check_c(&ws, &three_layer(), &cp, &empty_cfg_test()); - let pairs = extract_c(&findings); - assert_eq!(pairs.len(), 1, "got {findings:?}"); - let mut tps = pairs[0].1.clone(); - tps.sort(); - assert_eq!( - tps, - vec![ - "crate::application::session::bar".to_string(), - "crate::application::session::foo".to_string(), - ] +fn check_c_reports_both_touchpoints_for_sequence_and_branch() { + // Two distinct targets reached from a single handler produce one C finding + // listing both touchpoints — whether they are called in sequence or split + // across the arms of an `if`/`else` (both branches are seen statically). + let session = ( + "src/application/session.rs", + r#" + pub fn foo() {} + pub fn bar() {} + "#, ); -} - -// ── Branch with two distinct targets → C fires ──────────────── - -#[test] -fn check_c_branch_two_targets() { - let ws = build_workspace(&[ + let cases: &[(&str, &str)] = &[ + ("sequence", "pub fn cmd_orchestrate() { foo(); bar(); }"), ( - "src/application/session.rs", - r#" - pub fn foo() {} - pub fn bar() {} - "#, + "branch", + "pub fn cmd_branch(cond: bool) { if cond { foo(); } else { bar(); } }", ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::{foo, bar}; - pub fn cmd_branch(cond: bool) { - if cond { foo(); } else { bar(); } - } - "#, - ), - ]); - let cp = make_config(SingleTouchpointMode::Warn); - let findings = run_check_c(&ws, &three_layer(), &cp, &empty_cfg_test()); - let pairs = extract_c(&findings); - assert_eq!(pairs.len(), 1, "got {findings:?}"); - let mut tps = pairs[0].1.clone(); - tps.sort(); - assert_eq!(tps.len(), 2); + ]; + for (label, handler_body) in cases { + let handler = format!("use crate::application::session::{{foo, bar}};\n{handler_body}"); + let ws = build_workspace(&[session, ("src/cli/handlers.rs", handler.as_str())]); + let findings = run_c(&ws, &make_config(SingleTouchpointMode::Warn)); + let pairs = extract_c(&findings); + assert_eq!(pairs.len(), 1, "case {label}: got {findings:?}"); + let mut tps = pairs[0].1.clone(); + tps.sort(); + assert_eq!( + tps, + vec![ + "crate::application::session::bar".to_string(), + "crate::application::session::foo".to_string(), + ], + "case {label}" + ); + } } // ── single_touchpoint mode dispatch (Off / Warn / Error) ───────── @@ -187,7 +169,7 @@ fn check_c_severity_off_skips_check() { ), ]); let cp = make_config(SingleTouchpointMode::Off); - let findings = run_check_c(&ws, &three_layer(), &cp, &empty_cfg_test()); + let findings = run_c(&ws, &cp); assert!( extract_c(&findings).is_empty(), "Off mode should skip the check entirely, got {findings:?}" @@ -215,7 +197,7 @@ fn check_c_severity_error_emits_finding() { ), ]); let cp = make_config(SingleTouchpointMode::Error); - let findings = run_check_c(&ws, &three_layer(), &cp, &empty_cfg_test()); + let findings = run_c(&ws, &cp); assert_eq!(extract_c(&findings).len(), 1, "got {findings:?}"); } @@ -236,7 +218,7 @@ fn check_c_loop_single_target_silent() { ), ]); let cp = make_config(SingleTouchpointMode::Warn); - let findings = run_check_c(&ws, &three_layer(), &cp, &empty_cfg_test()); + let findings = run_c(&ws, &cp); assert!( extract_c(&findings).is_empty(), "single target hit by multiple call sites is one touchpoint, got {findings:?}" @@ -265,7 +247,7 @@ fn check_c_finding_lists_touchpoints() { ), ]); let cp = make_config(SingleTouchpointMode::Warn); - let findings = run_check_c(&ws, &three_layer(), &cp, &empty_cfg_test()); + let findings = run_c(&ws, &cp); let pairs = extract_c(&findings); assert_eq!(pairs.len(), 1, "got {findings:?}"); assert_eq!(pairs[0].1.len(), 3); diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_d.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_d.rs deleted file mode 100644 index 45c10fb3..00000000 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_d.rs +++ /dev/null @@ -1,353 +0,0 @@ -//! Tests for Check D — multiplicity mismatch. -//! -//! Check D fires when a target pub-fn IS in every adapter's coverage -//! (so Check B is silent) but the per-adapter handler counts diverge -//! — typical case: cli has two handlers (`cmd_search`, `cmd_grep`) -//! both reaching `session.search` while mcp has only `handle_search`. - -use super::support::{ - build_workspace, empty_cfg_test, four_layer, globset, ports_app_cli_mcp, run_check_d, -}; -use crate::adapters::analyzers::architecture::compiled::CompiledCallParity; -use crate::adapters::analyzers::architecture::{MatchLocation, ViolationKind}; -use std::collections::HashSet; - -fn make_config(adapters: &[&str]) -> CompiledCallParity { - CompiledCallParity { - adapters: adapters.iter().map(|s| s.to_string()).collect(), - target: "application".to_string(), - call_depth: 3, - exclude_targets: globset(&[]), - transparent_wrappers: HashSet::new(), - transparent_macros: HashSet::new(), - promoted_attributes: HashSet::new(), - single_touchpoint: crate::config::architecture::SingleTouchpointMode::default(), - } -} - -fn extract_d(findings: &[MatchLocation]) -> Vec<(String, Vec<(String, usize)>)> { - findings - .iter() - .filter_map(|f| match &f.kind { - ViolationKind::CallParityMultiplicityMismatch { - target_fn, - counts_per_adapter, - .. - } => Some((target_fn.clone(), counts_per_adapter.clone())), - _ => None, - }) - .collect() -} - -// ── Two adapters, asymmetric multiplicity ──────────────────────── - -#[test] -fn check_d_alias_in_one_adapter() { - // cli has cmd_search and cmd_grep both → session.search. - // mcp has handle_search only → session.search. - // counts: cli=2, mcp=1 → finding for session.search. - let ws = build_workspace(&[ - ("src/application/session.rs", "pub fn search() {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::search; - pub fn cmd_search() { search(); } - pub fn cmd_grep() { search(); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::session::search; - pub fn handle_search() { search(); } - "#, - ), - ]); - let cp = make_config(&["cli", "mcp"]); - let findings = run_check_d(&ws, &four_layer(), &cp, &empty_cfg_test()); - let pairs = extract_d(&findings); - assert_eq!(pairs.len(), 1, "got {findings:?}"); - let (target, counts) = &pairs[0]; - assert!(target.ends_with("session::search")); - let cli_count = counts.iter().find(|(a, _)| a == "cli").map(|(_, c)| *c); - let mcp_count = counts.iter().find(|(a, _)| a == "mcp").map(|(_, c)| *c); - assert_eq!(cli_count, Some(2)); - assert_eq!(mcp_count, Some(1)); -} - -// ── Balanced multiplicity → silent ─────────────────────────────── - -#[test] -fn check_d_balanced_fan_in_no_finding() { - // cli: cmd_search + cmd_grep → search; mcp: handle_search + - // handle_grep → search. counts match (2,2) → no Check D finding. - let ws = build_workspace(&[ - ("src/application/session.rs", "pub fn search() {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::search; - pub fn cmd_search() { search(); } - pub fn cmd_grep() { search(); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::session::search; - pub fn handle_search() { search(); } - pub fn handle_grep() { search(); } - "#, - ), - ]); - let cp = make_config(&["cli", "mcp"]); - let findings = run_check_d(&ws, &four_layer(), &cp, &empty_cfg_test()); - assert!( - extract_d(&findings).is_empty(), - "balanced fan-in should be silent, got {findings:?}" - ); -} - -// ── Three adapters, one diverges ───────────────────────────────── - -#[test] -fn check_d_three_adapters_one_diverges() { - // cli=2, rest=2, mcp=1 → finding citing the divergence. - let ws = build_workspace(&[ - ("src/application/session.rs", "pub fn search() {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::search; - pub fn cmd_search() { search(); } - pub fn cmd_grep() { search(); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::session::search; - pub fn handle_search() { search(); } - "#, - ), - ( - "src/rest/handlers.rs", - r#" - use crate::application::session::search; - pub fn post_search() { search(); } - pub fn post_grep() { search(); } - "#, - ), - ]); - let cp = make_config(&["cli", "mcp", "rest"]); - let findings = run_check_d(&ws, &four_layer(), &cp, &empty_cfg_test()); - let pairs = extract_d(&findings); - assert_eq!(pairs.len(), 1, "got {findings:?}"); - let counts = &pairs[0].1; - let cli_count = counts.iter().find(|(a, _)| a == "cli").map(|(_, c)| *c); - let mcp_count = counts.iter().find(|(a, _)| a == "mcp").map(|(_, c)| *c); - let rest_count = counts.iter().find(|(a, _)| a == "rest").map(|(_, c)| *c); - assert_eq!(cli_count, Some(2)); - assert_eq!(mcp_count, Some(1)); - assert_eq!(rest_count, Some(2)); -} - -// ── Deprecated alias not counted (v1.2.1) ──────────────────────── - -#[test] -fn check_d_skips_deprecated_alias() { - // cli has cmd_search (live) + cmd_grep (deprecated alias) → both - // would touch session.search. With deprecation-exclusion, cmd_grep - // is filtered: cli effective count = 1, mcp = 1 → no D finding. - let ws = build_workspace(&[ - ("src/application/session.rs", "pub fn search() {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::search; - pub fn cmd_search() { search(); } - #[deprecated] - pub fn cmd_grep() { search(); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::session::search; - pub fn handle_search() { search(); } - "#, - ), - ]); - let cp = make_config(&["cli", "mcp"]); - let findings = run_check_d(&ws, &four_layer(), &cp, &empty_cfg_test()); - assert!( - extract_d(&findings).is_empty(), - "deprecated alias should be excluded from D's count, got {findings:?}" - ); -} - -// ── Distinct from B: capability missing entirely emits B not D ─── - -#[test] -fn check_d_distinct_from_b() { - // cli reaches session.search; mcp doesn't reach it at all. - // → Check B finding (capability missing). Check D MUST be silent - // because D only fires when target is in every adapter's coverage - // but counts differ. - let ws = build_workspace(&[ - ("src/application/session.rs", "pub fn search() {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::search; - pub fn cmd_search() { search(); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - // mcp doesn't touch search at all - pub fn handle_other() {} - "#, - ), - ]); - let cp = make_config(&["cli", "mcp"]); - let findings = run_check_d(&ws, &four_layer(), &cp, &empty_cfg_test()); - assert!( - extract_d(&findings).is_empty(), - "Check D should not fire when target missing entirely from an adapter (that's Check B's job), got {findings:?}" - ); -} - -#[test] -fn check_d_uses_anchor_as_capability_for_multiplicity() { - // cli has TWO handlers dispatching `dyn Handler.handle()`. - // mcp has ONE handler doing the same. Both adapters reach the - // anchor (Check B silent), but multiplicity diverges: cli=2, - // mcp=1. Check D must fire on the trait-method anchor as the - // capability — not on the concrete impl, which the dispatch - // never directly calls. Without anchor iteration this drift - // would be silent. - let ws = build_workspace(&[ - ( - "src/ports/handler.rs", - "pub trait Handler { fn handle(&self); }", - ), - ( - "src/application/logging.rs", - r#" - use crate::ports::handler::Handler; - pub struct LoggingHandler; - impl Handler for LoggingHandler { fn handle(&self) {} } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::ports::handler::Handler; - pub fn cmd_dispatch_a(h: &dyn Handler) { h.handle(); } - pub fn cmd_dispatch_b(h: &dyn Handler) { h.handle(); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::ports::handler::Handler; - pub fn mcp_dispatch(h: &dyn Handler) { h.handle(); } - "#, - ), - ]); - let cp = make_config(&["cli", "mcp"]); - let findings = run_check_d(&ws, &ports_app_cli_mcp(), &cp, &empty_cfg_test()); - let entries = extract_d(&findings); - let anchor = "crate::ports::handler::Handler::handle"; - let anchor_entry = entries - .iter() - .find(|(target, _)| target == anchor) - .unwrap_or_else(|| panic!("Check D missed anchor multiplicity drift, got {entries:?}")); - let counts: std::collections::HashMap<&str, usize> = anchor_entry - .1 - .iter() - .map(|(a, c)| (a.as_str(), *c)) - .collect(); - assert_eq!(counts.get("cli"), Some(&2)); - assert_eq!(counts.get("mcp"), Some(&1)); -} - -#[test] -fn check_d_surfaces_concrete_multiplicity_when_all_adapters_call_direct() { - // Sister-fix of check_b's mixed-form scenario, scoped to Check D's - // semantic ("all adapters reach the target, counts differ"). Both - // cli and mcp call the concrete `LoggingHandler::handle()` directly - // via UFCS — no `dyn Trait` dispatch anywhere. cli has TWO - // handlers, mcp has ONE → multiplicity drift on the concrete - // canonical. - // - // Without the conditional skip, `is_anchor_backed_concrete` - // unconditionally drops the concrete from Check D's iteration - // (the trait Handler has an overriding impl in target → the skip - // fires). With both adapters reaching only via concrete, the - // anchor pass produces no counts either, so Check D goes silent - // — masking a clear-cut multiplicity drift. - // - // Fix mirrors check_b: skip only when no adapter has the concrete - // in coverage. When adapters reach via direct concrete, the - // concrete pass runs and the counts diverge (cli=2, mcp=1). - let ws = build_workspace(&[ - ( - "src/ports/handler.rs", - "pub trait Handler { fn handle(&self); }", - ), - ( - "src/application/logging.rs", - r#" - use crate::ports::handler::Handler; - pub struct LoggingHandler; - impl Handler for LoggingHandler { fn handle(&self) {} } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::logging::LoggingHandler; - pub fn cmd_log_a() { LoggingHandler::handle(&LoggingHandler); } - pub fn cmd_log_b() { LoggingHandler::handle(&LoggingHandler); } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::logging::LoggingHandler; - pub fn mcp_log() { LoggingHandler::handle(&LoggingHandler); } - "#, - ), - ]); - let cp = make_config(&["cli", "mcp"]); - let findings = run_check_d(&ws, &ports_app_cli_mcp(), &cp, &empty_cfg_test()); - let entries = extract_d(&findings); - let concrete = "crate::application::logging::LoggingHandler::handle"; - let concrete_entry = entries - .iter() - .find(|(target, _)| target == concrete) - .unwrap_or_else(|| { - panic!( - "Check D must surface concrete multiplicity drift when all adapters reach via direct concrete; got {entries:?}" - ) - }); - let counts: std::collections::HashMap<&str, usize> = concrete_entry - .1 - .iter() - .map(|(a, c)| (a.as_str(), *c)) - .collect(); - assert_eq!( - counts.get("cli"), - Some(&2), - "concrete count for cli (two direct UFCS callers); got {counts:?}" - ); - assert_eq!( - counts.get("mcp"), - Some(&1), - "concrete count for mcp (one direct UFCS caller); got {counts:?}" - ); -} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_d/anchor_multiplicity.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_d/anchor_multiplicity.rs new file mode 100644 index 00000000..274cae13 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_d/anchor_multiplicity.rs @@ -0,0 +1,98 @@ +use super::*; + +// Under the hexagonal layout, multiplicity drift (cli=2, mcp=1) must surface +// whether all adapters dispatch via `dyn Handler.handle()` (the drift lands on +// the trait anchor) or all call the concrete impl method directly via UFCS (the +// drift lands on the concrete canonical). Without anchor iteration / the +// conditional concrete-skip, these would be silent. (label, files, target) +const ANCHOR_MULT_CASES: &[AnchorMultCase] = &[ + ( + "trait dispatch → drift on the anchor", + &[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self); }", + ), + ( + "src/application/logging.rs", + r#" + use crate::ports::handler::Handler; + pub struct LoggingHandler; + impl Handler for LoggingHandler { fn handle(&self) {} } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::ports::handler::Handler; + pub fn cmd_dispatch_a(h: &dyn Handler) { h.handle(); } + pub fn cmd_dispatch_b(h: &dyn Handler) { h.handle(); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::ports::handler::Handler; + pub fn mcp_dispatch(h: &dyn Handler) { h.handle(); } + "#, + ), + ], + "crate::ports::handler::Handler::handle", + ), + ( + "all-direct concrete → drift on the concrete canonical", + &[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self); }", + ), + ( + "src/application/logging.rs", + r#" + use crate::ports::handler::Handler; + pub struct LoggingHandler; + impl Handler for LoggingHandler { fn handle(&self) {} } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::logging::LoggingHandler; + pub fn cmd_log_a() { LoggingHandler::handle(&LoggingHandler); } + pub fn cmd_log_b() { LoggingHandler::handle(&LoggingHandler); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::logging::LoggingHandler; + pub fn mcp_log() { LoggingHandler::handle(&LoggingHandler); } + "#, + ), + ], + "crate::application::logging::LoggingHandler::handle", + ), +]; + +#[test] +fn multiplicity_mismatch_on_trait_dispatch_and_direct_concrete() { + for (label, files, target) in ANCHOR_MULT_CASES { + let entries = multiplicity_ports(files); + let entry = entries + .iter() + .find(|(t, _)| t == target) + .unwrap_or_else(|| { + panic!("case {label}: missed multiplicity drift on {target}; got {entries:?}") + }); + assert_eq!( + count_for(&entry.1, "cli"), + Some(2), + "case {label}: cli count" + ); + assert_eq!( + count_for(&entry.1, "mcp"), + Some(1), + "case {label}: mcp count" + ); + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_d/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_d/mod.rs new file mode 100644 index 00000000..3cf89b1d --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_d/mod.rs @@ -0,0 +1,91 @@ +//! Tests for Check D — multiplicity mismatch. +//! +//! Check D fires when a target pub-fn IS in every adapter's coverage +//! (so Check B is silent) but the per-adapter handler counts diverge +//! — typical case: cli has two handlers (`cmd_search`, `cmd_grep`) +//! both reaching `session.search` while mcp has only `handle_search`. +//! Split into focused sub-files (each ≤ the SRP file-length cap); shared +//! imports + helpers live here and reach the sub-modules via `use super::*`. + +pub(super) use super::support::{ + build_workspace, empty_cfg_test, four_layer, globset, ports_app_cli_mcp, run_check_d, Workspace, +}; +pub(super) use crate::adapters::analyzers::architecture::compiled::CompiledCallParity; +pub(super) use crate::adapters::analyzers::architecture::{MatchLocation, ViolationKind}; +pub(super) use std::collections::HashSet; + +/// `(path, source)` file entries for a small workspace fixture. +pub(super) type WsFiles = &'static [(&'static str, &'static str)]; +/// Multiplicity case: `(label, files, adapters, target_suffix, expected_counts)`. +/// An empty `expected_counts` means Check D must stay silent. +pub(super) type MultiplicityCase = ( + &'static str, + WsFiles, + &'static [&'static str], + &'static str, + &'static [(&'static str, usize)], +); +/// Anchor/concrete multiplicity case (ports layout, cli=2 / mcp=1): +/// `(label, files, target)`. +pub(super) type AnchorMultCase = (&'static str, WsFiles, &'static str); + +mod anchor_multiplicity; +mod multiplicity; + +/// Run Check D with the four-layer layout and no cfg-test files — the +/// shared call across most Check-D tests. +pub(super) fn run_d(ws: &Workspace, cp: &CompiledCallParity) -> Vec { + run_check_d(ws, &four_layer(), cp, &empty_cfg_test()) +} + +pub(super) fn make_config(adapters: &[&str]) -> CompiledCallParity { + CompiledCallParity { + adapters: adapters.iter().map(|s| s.to_string()).collect(), + target: "application".to_string(), + call_depth: 3, + exclude_targets: globset(&[]), + transparent_wrappers: HashSet::new(), + transparent_macros: HashSet::new(), + promoted_attributes: HashSet::new(), + single_touchpoint: crate::config::architecture::SingleTouchpointMode::default(), + } +} + +pub(super) fn extract_d(findings: &[MatchLocation]) -> Vec<(String, Vec<(String, usize)>)> { + findings + .iter() + .filter_map(|f| match &f.kind { + ViolationKind::CallParityMultiplicityMismatch { + target_fn, + counts_per_adapter, + .. + } => Some((target_fn.clone(), counts_per_adapter.clone())), + _ => None, + }) + .collect() +} + +/// Build a workspace, run Check D under the four-layer layout for the given +/// adapters, and return the multiplicity-mismatch `(target, counts)` pairs. +pub(super) fn multiplicity_4l( + files: WsFiles, + adapters: &[&str], +) -> Vec<(String, Vec<(String, usize)>)> { + extract_d(&run_d(&build_workspace(files), &make_config(adapters))) +} + +/// Like [`multiplicity_4l`] but under the hexagonal `ports_app_cli_mcp` +/// layout with the standard `cli + mcp` adapter set. +pub(super) fn multiplicity_ports(files: WsFiles) -> Vec<(String, Vec<(String, usize)>)> { + extract_d(&run_check_d( + &build_workspace(files), + &ports_app_cli_mcp(), + &make_config(&["cli", "mcp"]), + &empty_cfg_test(), + )) +} + +/// Look up an adapter's handler count in a multiplicity entry's count list. +pub(super) fn count_for(counts: &[(String, usize)], adapter: &str) -> Option { + counts.iter().find(|(a, _)| a == adapter).map(|(_, c)| *c) +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/check_d/multiplicity.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_d/multiplicity.rs new file mode 100644 index 00000000..fc6f4c1f --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/check_d/multiplicity.rs @@ -0,0 +1,167 @@ +use super::*; + +// Check D fires only when a target IS reached by every adapter but the +// per-adapter handler counts diverge. Balanced fan-in, deprecated-alias +// exclusion, and a target missing entirely from one adapter (Check B's job) +// must all stay silent. (label, files, adapters, target_suffix, expected_counts) +const MULTIPLICITY_CASES: &[MultiplicityCase] = &[ + ( + // cli: cmd_search + cmd_grep → search; mcp: handle_search → search + "asymmetric fan-in fires (cli=2, mcp=1)", + &[ + ("src/application/session.rs", "pub fn search() {}"), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::search; + pub fn cmd_search() { search(); } + pub fn cmd_grep() { search(); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::session::search; + pub fn handle_search() { search(); } + "#, + ), + ], + &["cli", "mcp"], + "session::search", + &[("cli", 2), ("mcp", 1)], + ), + ( + "balanced fan-in is silent", + &[ + ("src/application/session.rs", "pub fn search() {}"), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::search; + pub fn cmd_search() { search(); } + pub fn cmd_grep() { search(); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::session::search; + pub fn handle_search() { search(); } + pub fn handle_grep() { search(); } + "#, + ), + ], + &["cli", "mcp"], + "", + &[], + ), + ( + "three adapters, one diverges (cli=2, mcp=1, rest=2)", + &[ + ("src/application/session.rs", "pub fn search() {}"), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::search; + pub fn cmd_search() { search(); } + pub fn cmd_grep() { search(); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::session::search; + pub fn handle_search() { search(); } + "#, + ), + ( + "src/rest/handlers.rs", + r#" + use crate::application::session::search; + pub fn post_search() { search(); } + pub fn post_grep() { search(); } + "#, + ), + ], + &["cli", "mcp", "rest"], + "session::search", + &[("cli", 2), ("mcp", 1), ("rest", 2)], + ), + ( + // cmd_grep is `#[deprecated]` → excluded; cli=1, mcp=1 → silent + "deprecated alias is excluded from the count", + &[ + ("src/application/session.rs", "pub fn search() {}"), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::search; + pub fn cmd_search() { search(); } + #[deprecated] + pub fn cmd_grep() { search(); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::session::search; + pub fn handle_search() { search(); } + "#, + ), + ], + &["cli", "mcp"], + "", + &[], + ), + ( + // mcp never reaches search → Check B's job, Check D stays silent + "target missing entirely from an adapter is silent (Check B's job)", + &[ + ("src/application/session.rs", "pub fn search() {}"), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::search; + pub fn cmd_search() { search(); } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + // mcp doesn't touch search at all + pub fn handle_other() {} + "#, + ), + ], + &["cli", "mcp"], + "", + &[], + ), +]; + +#[test] +fn multiplicity_mismatch_detection() { + for (label, files, adapters, target_suffix, expected) in MULTIPLICITY_CASES { + let pairs = multiplicity_4l(files, adapters); + if expected.is_empty() { + assert!( + pairs.is_empty(), + "case {label}: expected silence, got {pairs:?}" + ); + } else { + assert_eq!(pairs.len(), 1, "case {label}: {pairs:?}"); + let (target, counts) = &pairs[0]; + assert!( + target.ends_with(target_suffix), + "case {label}: target {target} should end with {target_suffix}" + ); + for (adapter, want) in *expected { + assert_eq!( + count_for(counts, adapter), + Some(*want), + "case {label}: adapter {adapter} count" + ); + } + } + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/end_to_end_snapshot.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/end_to_end_snapshot.rs index 01cda247..ab4407bd 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/end_to_end_snapshot.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/end_to_end_snapshot.rs @@ -109,6 +109,26 @@ fn missing_adapters_for(findings: &[MatchLocation], target_fn: &str) -> Option Vec { + run_check_a( + &build_workspace(&session_handler_fixture()), + &three_layer(), + &cli_mcp_config(3), + &empty_cfg_test(), + ) +} + +/// Run Check B over the session/handler fixture (three-layer, cli+mcp, depth 3). +fn check_b_on_fixture() -> Vec { + run_check_b( + &build_workspace(&session_handler_fixture()), + &three_layer(), + &cli_mcp_config(3), + &empty_cfg_test(), + ) +} + // ═══════════════════════════════════════════════════════════════════ // Check A — every adapter pub fn must delegate into application // ═══════════════════════════════════════════════════════════════════ @@ -118,8 +138,7 @@ fn check_a_clean_on_session_handler_fixture() { // Every cli / mcp handler in the fixture reaches an application- // layer fn via inference, so Check A has no findings at all — // this is the primary receiver-inference regression guard. - let ws = build_workspace(&session_handler_fixture()); - let findings = run_check_a(&ws, &three_layer(), &cli_mcp_config(3), &empty_cfg_test()); + let findings = check_a_on_fixture(); assert!( findings.is_empty(), "Check A should be clean on the session/handler fixture, got {} findings: {:?}", @@ -136,34 +155,26 @@ fn check_a_clean_on_session_handler_fixture() { // ═══════════════════════════════════════════════════════════════════ #[test] -fn check_b_diff_reached_from_both_adapters() { - // The hero case: Session::diff is called from both cli (via chain - // inference) and mcp (via signature-param). Both adapters cover it - // → no finding. - let ws = build_workspace(&session_handler_fixture()); - let findings = run_check_b(&ws, &three_layer(), &cli_mcp_config(3), &empty_cfg_test()); - let missing = missing_adapters_for(&findings, "crate::application::session::Session::diff"); - assert!( - missing.is_none(), - "Session::diff should be reached from both adapters, got missing={:?}", - missing - ); -} - -#[test] -fn check_b_files_reached_from_both_adapters() { - let ws = build_workspace(&session_handler_fixture()); - let findings = run_check_b(&ws, &three_layer(), &cli_mcp_config(3), &empty_cfg_test()); - let missing = missing_adapters_for(&findings, "crate::application::session::Session::files"); - assert!(missing.is_none(), "Session::files should be reached"); +fn check_b_targets_reached_from_both_adapters() { + // Session::diff (cli via chain inference, mcp via signature-param) and + // Session::files are both covered by every configured adapter → no finding. + let findings = check_b_on_fixture(); + for target in [ + "crate::application::session::Session::diff", + "crate::application::session::Session::files", + ] { + assert!( + missing_adapters_for(&findings, target).is_none(), + "{target} should be reached from both adapters" + ); + } } #[test] fn check_b_asymmetric_coverage_is_flagged() { // `stats` is only called from cli (cmd_stats). mcp doesn't cover // it — legitimate Check B finding. - let ws = build_workspace(&session_handler_fixture()); - let findings = run_check_b(&ws, &three_layer(), &cli_mcp_config(3), &empty_cfg_test()); + let findings = check_b_on_fixture(); let missing = missing_adapters_for(&findings, "crate::application::session::Session::stats") .expect("stats should be missing from some adapter"); assert_eq!(missing, vec!["mcp".to_string()]); @@ -177,8 +188,7 @@ fn check_b_asymmetric_coverage_is_flagged() { #[test] fn check_b_unreached_pub_fn_is_flagged() { // `genuinely_unused` has no callers → missing from all adapters. - let ws = build_workspace(&session_handler_fixture()); - let findings = run_check_b(&ws, &three_layer(), &cli_mcp_config(3), &empty_cfg_test()); + let findings = check_b_on_fixture(); let missing = missing_adapters_for( &findings, "crate::application::session::Session::genuinely_unused", @@ -209,11 +219,8 @@ fn total_findings_budget_on_session_handler_fixture() { // If this budget ticks upward, inspect the new findings before // adjusting the number — the Stage 1 implementation should not // regress this count. - let ws = build_workspace(&session_handler_fixture()); - let layers = three_layer(); - let cp = cli_mcp_config(3); - let check_a = run_check_a(&ws, &layers, &cp, &empty_cfg_test()); - let check_b = run_check_b(&ws, &layers, &cp, &empty_cfg_test()); + let check_a = check_a_on_fixture(); + let check_b = check_b_on_fixture(); assert_eq!(check_a.len(), 0, "Check A: {:?}", check_a); assert_eq!( check_b.len(), diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/module_resolution.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/module_resolution.rs deleted file mode 100644 index 6222ae1e..00000000 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/module_resolution.rs +++ /dev/null @@ -1,514 +0,0 @@ -//! Workspace-level tests for module-path resolution as the call graph -//! canonicalises call sites and `use` imports. -//! -//! Each test sets up a multi-file (or inline-mod) workspace, builds -//! the call graph, and asserts whether a given import or call site -//! resolves to the expected canonical path. Coverage: -//! -//! - Sibling-submodule `use foo::X` taking precedence over a -//! crate-root `foo` with the same leaf name (Rust 2018+ resolution). -//! - Inline `mod foo { mod bar; use bar::X; }` blocks contributing -//! module-path entries equal to filesystem-derived siblings. -//! - Orphan files (no `mod` declaration backing them) NOT acting as -//! sibling submodules — Rust ignores them, so we must too. -//! - Private `mod X;` declarations inside a file whose ancestor chain -//! is hidden by a non-root private `mod` still acting as real -//! children for code inside the parent file. -//! - `pub use` re-exports forwarding the call site to the real fn -//! definition rather than dropping the edge at the re-export path. -//! - Concrete UFCS (`ConcreteType::new(...)`) where the type is -//! named-imported from a sibling submodule — common -//! middleware-/builder-pattern shape. - -use super::support::{ - build_graph_only, build_workspace, callees_of, empty_cfg_test, graph_contains_edge, three_layer, -}; -use std::collections::HashSet; - -#[test] -fn concrete_ufcs_via_sibling_submodule_import_traces_edge() { - // `dispatcher` body calls `ConcreteOutput::new(body)` where - // `ConcreteOutput` is imported via `use response::ConcreteOutput` - // (relative sibling-submodule). The edge must resolve to the - // sibling's inherent `new` even though the call lives in a - // generic-fn body. - let ws = build_workspace(&[ - ( - "src/application/mod.rs", - r#" - pub mod response; - - use serde::Serialize; - use response::ConcreteOutput; - - pub fn dispatcher(value: &T) -> ConcreteOutput { - let body = serde_json::to_string(value).unwrap_or_default(); - ConcreteOutput::new(body) - } - "#, - ), - ( - "src/application/response.rs", - r#" - pub struct ConcreteOutput { pub body: String } - impl ConcreteOutput { - pub fn new(body: String) -> Self { Self { body } } - } - "#, - ), - ( - "src/cli/mod.rs", - r#" - use crate::application::dispatcher; - - pub fn cmd_run() -> String { - let out = dispatcher(&42u32); - out.body - } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - - let dispatcher = "crate::application::dispatcher"; - let new_target = "crate::application::response::ConcreteOutput::new"; - assert!( - graph_contains_edge(&graph, dispatcher, new_target), - "concrete UFCS `ConcreteOutput::new(body)` inside generic \ - `dispatcher` body must emit edge to `{new_target}` when \ - `ConcreteOutput` is named-imported from a sibling submodule. \ - dispatcher callees: {:?}", - callees_of(&graph, dispatcher), - ); -} - -#[test] -fn sibling_submodule_wins_over_crate_root_with_same_leaf_name() { - // Rust 2018+: `use foo::X` inside `crate::application` resolves - // to `crate::application::foo::X` (local sibling) even when - // `crate::foo` also exists. The normaliser must check the sibling - // branch BEFORE crate-root modules. - let ws = build_workspace(&[ - ( - "src/response/mod.rs", - r#" - pub struct OuterRoot; - impl OuterRoot { - pub fn run() {} - } - "#, - ), - ( - "src/application/response.rs", - r#" - pub struct Local; - impl Local { - pub fn run() {} - } - "#, - ), - ( - "src/application/mod.rs", - r#" - pub mod response; - - use response::Local; - - pub fn dispatch() { - Local::run(); - } - "#, - ), - ( - "src/cli/mod.rs", - r#" - use crate::application::dispatch; - - pub fn cmd_run() { - dispatch(); - } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - let dispatch = "crate::application::dispatch"; - let local_target = "crate::application::response::Local::run"; - let crate_root_target = "crate::response::OuterRoot::run"; - assert!( - graph_contains_edge(&graph, dispatch, local_target), - "Rust 2018+: `use response::Local` in `application/mod.rs` must \ - resolve to local sibling `crate::application::response::Local`, \ - not crate-root `crate::response`. dispatch callees: {:?}", - callees_of(&graph, dispatch), - ); - assert!( - !graph_contains_edge(&graph, dispatch, crate_root_target), - "must NOT route to crate-root `{crate_root_target}` — that's \ - the wrong target. dispatch callees: {:?}", - callees_of(&graph, dispatch), - ); -} - -#[test] -fn inline_mod_sibling_import_traces_edge() { - // `mod outer { mod inner { ... } use inner::X; }` — inline `mod` - // blocks must contribute the same module-path entries as - // filesystem-derived modules so `use inner::Local` resolves to - // `crate::application::outer::inner::Local`. - let ws = build_workspace(&[ - ( - "src/application/mod.rs", - r#" - pub mod outer { - pub mod inner { - pub struct Local; - impl Local { - pub fn run() {} - } - } - - use inner::Local; - - pub fn dispatch() { - Local::run(); - } - } - "#, - ), - ( - "src/cli/mod.rs", - r#" - use crate::application::outer::dispatch; - - pub fn cmd_run() { - dispatch(); - } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - let dispatch = "crate::application::outer::dispatch"; - let target = "crate::application::outer::inner::Local::run"; - assert!( - graph_contains_edge(&graph, dispatch, target), - "inline-mod sibling import `use inner::Local` from `mod outer` \ - must trace to `{target}`. dispatch callees: {:?}", - callees_of(&graph, dispatch), - ); -} - -#[test] -fn orphan_file_does_not_act_as_sibling_submodule() { - // `application/orphan.rs` exists on disk but `application/mod.rs` - // never declares `mod orphan;` — Rust treats it as dead code. - // The sibling-submodule discriminator must filter by reachability - // through `mod` declarations, otherwise `use orphan::X` from a - // sibling fabricates a false edge to `crate::application::orphan::X`. - let ws = build_workspace(&[ - ( - "src/application/mod.rs", - r#" - use orphan::Local; - - pub fn dispatch() { - Local::run(); - } - "#, - ), - ( - "src/application/orphan.rs", - r#" - pub struct Local; - impl Local { - pub fn run() {} - } - "#, - ), - ( - "src/cli/mod.rs", - r#" - use crate::application::dispatch; - - pub fn cmd_run() { - dispatch(); - } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - let dispatch = "crate::application::dispatch"; - let phantom_target = "crate::application::orphan::Local::run"; - assert!( - !graph_contains_edge(&graph, dispatch, phantom_target), - "orphan file `application/orphan.rs` (no `mod orphan;` decl in \ - application/mod.rs) must NOT be treated as a real sibling \ - submodule — `use orphan::Local` is an external/unresolved \ - import, not a workspace canonical. dispatch callees: {:?}", - callees_of(&graph, dispatch), - ); -} - -#[test] -fn private_mod_sibling_import_resolves_even_when_ancestor_chain_is_hidden() { - // `src/lib.rs` declares `pub mod application;`. Inside that, - // `application/mod.rs` declares a private `mod hidden;` — that - // marks `application/hidden.rs` as not externally reachable per - // the file-root visibility chain. But from inside `hidden.rs`, - // `use response::Local;` must still normalise to - // `crate::application::hidden::response::Local`: `mod response;` - // is declared in `hidden.rs` itself, so it's a real child module - // for code inside the parent file, regardless of how the chain - // is filtered for external visibility. - let ws = build_workspace(&[ - ( - "src/lib.rs", - r#" - pub mod application; - "#, - ), - ( - "src/application/mod.rs", - r#" - mod hidden; - "#, - ), - ( - "src/application/hidden.rs", - r#" - mod response; - - use response::Local; - - pub fn dispatch() { - Local::run(); - } - "#, - ), - ( - "src/application/hidden/response.rs", - r#" - pub struct Local; - impl Local { - pub fn run() {} - } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - let dispatch = "crate::application::hidden::dispatch"; - let target = "crate::application::hidden::response::Local::run"; - assert!( - graph_contains_edge(&graph, dispatch, target), - "private `mod response;` declared INSIDE a file whose ancestor \ - chain is hidden by a non-root private `mod hidden;` is still a \ - real child module for code inside `hidden.rs`. \ - `use response::Local` must normalise to `{target}` regardless \ - of public-visibility filtering. dispatch callees: {:?}", - callees_of(&graph, dispatch), - ); -} - -#[test] -fn pub_use_reexport_call_resolves_to_real_definition() { - // Caller imports `middleware::record_operation` — re-exported via - // `pub use savings_recorder::record_operation;`. The canonicaliser - // must follow the `pub use` to the real definition or the edge - // is dropped. - let ws = build_workspace(&[ - ( - "src/application/middleware/mod.rs", - r#" - pub mod savings_recorder; - pub use savings_recorder::record_operation; - "#, - ), - ( - "src/application/middleware/savings_recorder.rs", - r#" - pub fn record_operation() {} - "#, - ), - ( - "src/application/session.rs", - r#" - use crate::application::middleware; - pub struct Session; - impl Session { - pub fn search(&self) { - middleware::record_operation(); - } - } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - - let search = "crate::application::session::Session::search"; - let real_target = "crate::application::middleware::savings_recorder::record_operation"; - - assert!( - graph_contains_edge(&graph, search, real_target), - "call site `middleware::record_operation()` not resolved through \ - the `pub use` re-export to the real definition `{real_target}`.\n\ - search callees: {:?}", - callees_of(&graph, search), - ); -} - -#[test] -fn fallback_walker_skips_stale_mod_rs_when_file_rs_is_the_winner() { - // Same stale-leftover scenario as the lib.rs-rooted case, but in - // the FALLBACK path: a workspace without `src/lib.rs` / `src/main.rs` - // (test-fixture shape). `build_module_segs_to_path_map` already - // picks `foo.rs` as the winner for `["foo"]`, but - // `walk_fallback_roots` iterates the raw `files` slice and treats - // BOTH `foo.rs` and `foo/mod.rs` as implicit roots — so the stale - // `foo/mod.rs`'s `mod beta;` declaration still landed in - // `workspace_module_paths` and `use beta::T;` from `foo.rs` then - // false-resolved to `crate::foo::beta::T` via the sibling-submodule - // discriminator. - // - // Fix: the fallback walker must consider only the tie-break - // winner as an implicit root, mirroring the precedence - // `build_module_segs_to_path_map` already established. - let ws = build_workspace(&[ - ( - "src/foo.rs", - r#" - // Live module file. Does NOT declare `mod beta;`. The - // legitimate behaviour for `use beta::T;` here is "extern - // import" — not a workspace edge. - use beta::T; - pub fn dispatch() { T::run(); } - "#, - ), - // Stale `mod.rs` from a long-ago refactor. Declares its own - // `mod beta;`. The walker must NOT trust this file's - // submodule declarations once `foo.rs` is the winner. - ("src/foo/mod.rs", "pub mod beta;\n"), - ( - "src/foo/beta.rs", - r#" - pub struct T; - impl T { pub fn run() {} } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - let dispatch = "crate::foo::dispatch"; - let stale_phantom = "crate::foo::beta::T::run"; - assert!( - !graph_contains_edge(&graph, dispatch, stale_phantom), - "in the fallback (no `src/lib.rs` / `src/main.rs`) walker, a \ - stale `src/foo/mod.rs` must NOT register its submodules once \ - `src/foo.rs` is the tie-break winner — otherwise \ - `use beta::T;` inside `foo.rs` false-resolves to \ - `{stale_phantom}`. dispatch callees: {:?}", - callees_of(&graph, dispatch), - ); -} - -#[test] -fn absolute_use_alias_does_not_re_canonicalise_to_workspace() { - // `use ::ext::A as Local;` is a Rust 2018+ absolute path. The - // leading colon says: "this is the extern-crate `ext`, not our - // workspace's `ext`." So `Local::m()` must NOT silently route to - // `crate::ext::A::m` even when a same-named workspace module - // exists. - // - // The bug: `gather_alias_map` / `gather_alias_map_scoped` only - // pass `u.tree` into `collect_alias_entries`, dropping - // `u.leading_colon`. The use-site canonicaliser then treats the - // alias as relative, and `normalize_after_alias` happily prepends - // `crate::` once it spots `ext` as a workspace top-level module. - // Result: a false workspace edge to a symbol that the program - // never actually addressed. - let ws = build_workspace(&[ - ("src/lib.rs", "pub mod ext;\npub mod app;\n"), - ( - "src/ext.rs", - r#" - pub struct A; - impl A { pub fn m() {} } - "#, - ), - ( - "src/app.rs", - r#" - // Absolute path — refers to the extern crate `ext`, NOT - // the workspace's `crate::ext`. - use ::ext::A as Local; - pub fn dispatch() { Local::m(); } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - let dispatch = "crate::app::dispatch"; - let workspace_phantom = "crate::ext::A::m"; - assert!( - !graph_contains_edge(&graph, dispatch, workspace_phantom), - "`use ::ext::A as Local;` is an extern-rooted import (the \ - leading `::` means extern crate `ext`, not the workspace's \ - `crate::ext`). `Local::m()` must NOT route to \ - `{workspace_phantom}` even when a same-named workspace \ - module exists. dispatch callees: {:?}", - callees_of(&graph, dispatch), - ); -} - -#[test] -fn file_rs_wins_over_dir_mod_rs_when_both_back_the_same_module_path() { - // Stale-leftover scenario: both `src/foo.rs` and `src/foo/mod.rs` - // exist in the workspace (e.g. after a refactor that switched - // legacy `mod.rs` style to single-file style but forgot to delete - // the old file). `file_to_module_segments` maps both paths to - // `["foo"]`, so the `segs_to_path` lookup in - // `collect_workspace_module_paths` saw a collision and silently - // kept whichever entry happened to land last in iteration order. - // Whichever AST won determined which submodule declarations got - // registered — driving non-deterministic graph results and - // dropped call edges when the "wrong" file's submodules were - // walked. - // - // After the fix, `foo.rs` deterministically wins (matches modern - // Rust precedence), so `mod alpha;` declared in `foo.rs` always - // ends up in `workspace_module_paths` and the sibling-submodule - // discriminator routes `use alpha::Local;` correctly. - // - // Test ordering: putting `foo/mod.rs` AFTER `foo.rs` in the input - // slice reproduces the bug deterministically — the later insert - // wins the HashMap collision in the buggy code. - let ws = build_workspace(&[ - ("src/lib.rs", "pub mod foo;\n"), - ( - "src/foo.rs", - r#" - pub mod alpha; - use alpha::Local; - pub fn dispatch() { Local::run(); } - "#, - ), - ( - "src/foo/alpha.rs", - r#" - pub struct Local; - impl Local { pub fn run() {} } - "#, - ), - // Stale leftover from a legacy mod.rs layout. Declares a - // *different* submodule. Must NOT shadow `foo.rs`. - ("src/foo/mod.rs", "pub mod beta;\n"), - ("src/foo/beta.rs", "pub fn unused() {}\n"), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - let dispatch = "crate::foo::dispatch"; - let target = "crate::foo::alpha::Local::run"; - assert!( - graph_contains_edge(&graph, dispatch, target), - "when both `src/foo.rs` and `src/foo/mod.rs` exist, the analyser \ - must deterministically prefer `foo.rs` (Rust 2018+ convention) \ - and walk its declared submodules. `use alpha::Local;` inside \ - `foo.rs` must resolve to `{target}`. dispatch callees: {:?}", - callees_of(&graph, dispatch), - ); -} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/module_resolution/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/module_resolution/mod.rs new file mode 100644 index 00000000..a15f52a1 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/module_resolution/mod.rs @@ -0,0 +1,38 @@ +//! Workspace-level tests for module-path resolution as the call graph +//! canonicalises call sites and `use` imports. Each case sets up a +//! multi-file (or inline-mod) workspace, builds the call graph, and asserts +//! whether an import / call site resolves to the expected canonical path. +//! Split into focused sub-files (each ≤ the SRP file-length cap); the shared +//! `EdgeCase` table is partitioned across them and driven by `run_edge_cases`. + +pub(super) use super::support::{build_workspace, callees_of, graph_3l, graph_contains_edge}; + +/// `(path, source)` file entries for a workspace fixture. +pub(super) type WsFiles = &'static [(&'static str, &'static str)]; +/// Module-resolution edge case: `(label, files, caller, target, present)` +/// where `present` = the edge must exist. +pub(super) type EdgeCase = (&'static str, WsFiles, &'static str, &'static str, bool); + +mod part_a; +mod part_b; + +/// Build a workspace and its call graph under the three-layer layout. +pub(super) fn graph_3l_of( + files: WsFiles, +) -> crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::CallGraph { + graph_3l(&build_workspace(files)) +} + +/// Assert each `EdgeCase` resolves (or not) to its expected edge. Shared by the +/// partitioned case tables so neither part re-duplicates the loop body. +pub(super) fn run_edge_cases(cases: &[EdgeCase]) { + for (label, files, caller, target, present) in cases { + let graph = graph_3l_of(files); + assert_eq!( + graph_contains_edge(&graph, caller, target), + *present, + "case {label}: edge {caller} → {target}; callees: {:?}", + callees_of(&graph, caller), + ); + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/module_resolution/part_a.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/module_resolution/part_a.rs new file mode 100644 index 00000000..cafb23f3 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/module_resolution/part_a.rs @@ -0,0 +1,186 @@ +use super::*; + +const MODULE_EDGE_CASES_A: &[EdgeCase] = &[ + ( + "concrete UFCS via sibling-submodule import", + &[ + ( + "src/application/mod.rs", + r#" + pub mod response; + + use serde::Serialize; + use response::ConcreteOutput; + + pub fn dispatcher(value: &T) -> ConcreteOutput { + let body = serde_json::to_string(value).unwrap_or_default(); + ConcreteOutput::new(body) + } + "#, + ), + ( + "src/application/response.rs", + r#" + pub struct ConcreteOutput { pub body: String } + impl ConcreteOutput { + pub fn new(body: String) -> Self { Self { body } } + } + "#, + ), + ( + "src/cli/mod.rs", + r#" + use crate::application::dispatcher; + + pub fn cmd_run() -> String { + let out = dispatcher(&42u32); + out.body + } + "#, + ), + ], + "crate::application::dispatcher", + "crate::application::response::ConcreteOutput::new", + true, + ), + ( + // Rust 2018+: `use response::Local` resolves to the local + // sibling, NOT crate-root `crate::response`. + "sibling submodule wins over same-leaf crate root (local)", + &[ + ( + "src/response/mod.rs", + r#" + pub struct OuterRoot; + impl OuterRoot { + pub fn run() {} + } + "#, + ), + ( + "src/application/response.rs", + r#" + pub struct Local; + impl Local { + pub fn run() {} + } + "#, + ), + ( + "src/application/mod.rs", + r#" + pub mod response; + + use response::Local; + + pub fn dispatch() { + Local::run(); + } + "#, + ), + ( + "src/cli/mod.rs", + r#" + use crate::application::dispatch; + + pub fn cmd_run() { + dispatch(); + } + "#, + ), + ], + "crate::application::dispatch", + "crate::application::response::Local::run", + true, + ), + ( + "sibling submodule wins over same-leaf crate root (crate-root NOT routed)", + &[ + ( + "src/response/mod.rs", + r#" + pub struct OuterRoot; + impl OuterRoot { + pub fn run() {} + } + "#, + ), + ( + "src/application/response.rs", + r#" + pub struct Local; + impl Local { + pub fn run() {} + } + "#, + ), + ( + "src/application/mod.rs", + r#" + pub mod response; + + use response::Local; + + pub fn dispatch() { + Local::run(); + } + "#, + ), + ( + "src/cli/mod.rs", + r#" + use crate::application::dispatch; + + pub fn cmd_run() { + dispatch(); + } + "#, + ), + ], + "crate::application::dispatch", + "crate::response::OuterRoot::run", + false, + ), + ( + "inline-mod sibling import traces the edge", + &[ + ( + "src/application/mod.rs", + r#" + pub mod outer { + pub mod inner { + pub struct Local; + impl Local { + pub fn run() {} + } + } + + use inner::Local; + + pub fn dispatch() { + Local::run(); + } + } + "#, + ), + ( + "src/cli/mod.rs", + r#" + use crate::application::outer::dispatch; + + pub fn cmd_run() { + dispatch(); + } + "#, + ), + ], + "crate::application::outer::dispatch", + "crate::application::outer::inner::Local::run", + true, + ), +]; + +#[test] +fn module_path_resolution_edges_part_a() { + run_edge_cases(MODULE_EDGE_CASES_A); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/module_resolution/part_b.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/module_resolution/part_b.rs new file mode 100644 index 00000000..9b8b58b4 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/module_resolution/part_b.rs @@ -0,0 +1,191 @@ +use super::*; + +const MODULE_EDGE_CASES_B: &[EdgeCase] = &[ + ( + // `application/orphan.rs` exists but `mod orphan;` is never + // declared → not a real sibling submodule. + "orphan file does not act as a sibling submodule", + &[ + ( + "src/application/mod.rs", + r#" + use orphan::Local; + + pub fn dispatch() { + Local::run(); + } + "#, + ), + ( + "src/application/orphan.rs", + r#" + pub struct Local; + impl Local { + pub fn run() {} + } + "#, + ), + ( + "src/cli/mod.rs", + r#" + use crate::application::dispatch; + + pub fn cmd_run() { + dispatch(); + } + "#, + ), + ], + "crate::application::dispatch", + "crate::application::orphan::Local::run", + false, + ), + ( + // `mod response;` declared inside `hidden.rs` is a real child + // for code in that file, even though the ancestor chain is + // hidden by a non-root private `mod hidden;`. + "private-mod sibling import resolves with a hidden ancestor chain", + &[ + ("src/lib.rs", "pub mod application;\n"), + ("src/application/mod.rs", "mod hidden;\n"), + ( + "src/application/hidden.rs", + r#" + mod response; + + use response::Local; + + pub fn dispatch() { + Local::run(); + } + "#, + ), + ( + "src/application/hidden/response.rs", + r#" + pub struct Local; + impl Local { + pub fn run() {} + } + "#, + ), + ], + "crate::application::hidden::dispatch", + "crate::application::hidden::response::Local::run", + true, + ), + ( + "pub use re-export forwards the call to the real definition", + &[ + ( + "src/application/middleware/mod.rs", + r#" + pub mod savings_recorder; + pub use savings_recorder::record_operation; + "#, + ), + ( + "src/application/middleware/savings_recorder.rs", + "pub fn record_operation() {}", + ), + ( + "src/application/session.rs", + r#" + use crate::application::middleware; + pub struct Session; + impl Session { + pub fn search(&self) { + middleware::record_operation(); + } + } + "#, + ), + ], + "crate::application::session::Session::search", + "crate::application::middleware::savings_recorder::record_operation", + true, + ), + ( + // fallback walker (no lib.rs/main.rs): stale `foo/mod.rs` must + // not register submodules once `foo.rs` is the tie-break winner + "fallback walker skips a stale mod.rs when file.rs wins", + &[ + ( + "src/foo.rs", + r#" + use beta::T; + pub fn dispatch() { T::run(); } + "#, + ), + ("src/foo/mod.rs", "pub mod beta;\n"), + ( + "src/foo/beta.rs", + r#" + pub struct T; + impl T { pub fn run() {} } + "#, + ), + ], + "crate::foo::dispatch", + "crate::foo::beta::T::run", + false, + ), + ( + // `use ::ext::A` is extern-rooted (leading `::`) → must not + // re-canonicalise to a same-named workspace module + "extern-rooted use alias does not re-canonicalise to the workspace", + &[ + ("src/lib.rs", "pub mod ext;\npub mod app;\n"), + ( + "src/ext.rs", + r#" + pub struct A; + impl A { pub fn m() {} } + "#, + ), + ( + "src/app.rs", + r#" + use ::ext::A as Local; + pub fn dispatch() { Local::m(); } + "#, + ), + ], + "crate::app::dispatch", + "crate::ext::A::m", + false, + ), + ( + // both `foo.rs` and `foo/mod.rs` back `["foo"]`; `foo.rs` must + // deterministically win and its `mod alpha;` be walked + "file.rs wins over dir/mod.rs for the same module path", + &[ + ("src/lib.rs", "pub mod foo;\n"), + ( + "src/foo.rs", + r#" + pub mod alpha; + use alpha::Local; + pub fn dispatch() { Local::run(); } + "#, + ), + ( + "src/foo/alpha.rs", + r#" + pub struct Local; + impl Local { pub fn run() {} } + "#, + ), + ("src/foo/mod.rs", "pub mod beta;\n"), + ("src/foo/beta.rs", "pub fn unused() {}\n"), + ], + "crate::foo::dispatch", + "crate::foo::alpha::Local::run", + true, + ), +]; + +#[test] +fn module_path_resolution_edges_part_b() { + run_edge_cases(MODULE_EDGE_CASES_B); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns.rs deleted file mode 100644 index f54ba5e2..00000000 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns.rs +++ /dev/null @@ -1,1087 +0,0 @@ -//! Tests for `collect_pub_fns_by_layer` — workspace-wide pub-fn -//! enumeration grouped by architecture layer. - -use super::support::three_layer; -use crate::adapters::analyzers::architecture::call_parity_rule::pub_fns::{ - collect_pub_fns_by_layer, PubFnInfo, PubFnInputs, -}; -use crate::adapters::shared::use_tree::{gather_alias_map, AliasMap}; -use std::collections::{HashMap, HashSet}; - -/// Build an `aliases_per_file` map from a workspace slice — mirrors -/// what the call-parity entry point computes. -fn aliases_from_files(files: &[(&str, &syn::File)]) -> HashMap { - files - .iter() - .map(|(p, f)| (p.to_string(), gather_alias_map(f))) - .collect() -} - -fn parse(src: &str) -> syn::File { - syn::parse_str(src).expect("parse file") -} - -fn names_for_layer<'ast>( - by_layer: &std::collections::HashMap>>, - layer: &str, -) -> HashSet { - by_layer - .get(layer) - .map(|fns| fns.iter().map(|f| f.fn_name.clone()).collect()) - .unwrap_or_default() -} - -/// Collect pub fns by layer for the common test case — empty wrapper, -/// promoted-attribute, and workspace-lookup sets. Tests that need a -/// non-empty set call `collect_pub_fns_by_layer` directly. -fn pub_fns_by_layer<'ast>( - files: &[(&'ast str, &'ast syn::File)], -) -> HashMap>> { - let aliases = aliases_from_files(files); - collect_pub_fns_by_layer(PubFnInputs { - files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) -} - -#[test] -fn test_collect_pub_fns_in_layer_free_fn() { - let file = parse( - r#" - pub fn cmd_stats() {} - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!(cli.contains("cmd_stats"), "cli = {cli:?}"); -} - -#[test] -fn test_collect_pub_fns_skips_private_fns() { - let file = parse( - r#" - fn helper() {} - pub fn cmd_stats() {} - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!(cli.contains("cmd_stats")); - assert!(!cli.contains("helper"), "private fn must be skipped"); -} - -#[test] -fn test_pub_crate_is_treated_as_public_for_intra_crate_layers() { - // Workspace-internal crates rely on `pub(crate)` for their architecture - // surface; the check must treat any visibility-modified fn as - // "visible enough" — only the implicit (no-modifier) case is private. - let file = parse( - r#" - pub(crate) fn cmd_stats() {} - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!(cli.contains("cmd_stats"), "pub(crate) must be collected"); -} - -#[test] -fn test_pub_super_and_pub_in_path_treated_as_public() { - let file = parse( - r#" - pub(super) fn cmd_a() {} - pub(in crate::cli) fn cmd_b() {} - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!(cli.contains("cmd_a")); - assert!(cli.contains("cmd_b")); -} - -#[test] -fn test_collect_pub_fns_collects_pub_impl_methods_for_pub_type() { - let file = parse( - r#" - pub struct Session; - impl Session { - pub fn search(&self) {} - fn helper(&self) {} - } - "#, - ); - let files = vec![("src/application/session.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let app = names_for_layer(&by_layer, "application"); - assert!(app.contains("search"), "pub impl method must be collected"); - assert!( - !app.contains("helper"), - "private impl method must be skipped" - ); -} - -#[test] -fn test_collect_pub_fns_recognises_impl_across_files() { - // Regression: `pub struct Session` in one file, `impl Session { pub - // fn search() }` in another — both sides resolve to the same - // canonical via the impl-file's `use` statement, so Check B sees - // the impl methods as adapter surface. (Without the `use`, the - // impl wouldn't compile in real Rust either.) - let decl_file = parse("pub struct Session;"); - let impl_file = parse( - r#" - use crate::application::session::Session; - impl Session { - pub fn search(&self) {} - } - "#, - ); - let files = vec![ - ("src/application/session.rs", &decl_file), - ("src/application/session_impls.rs", &impl_file), - ]; - let by_layer = pub_fns_by_layer(&files); - let app = names_for_layer(&by_layer, "application"); - assert!( - app.contains("search"), - "cross-file impl on pub type must be collected, got {app:?}" - ); -} - -#[test] -fn test_collect_pub_fns_skips_impl_methods_on_private_type() { - // Conservative: if the enclosing `impl Type { ... }` is for a private - // (no-modifier) type, its pub methods aren't really reachable from - // outside the file, so they're excluded from the call-parity scope. - let file = parse( - r#" - struct Session; - impl Session { - pub fn search(&self) {} - } - "#, - ); - let files = vec![("src/application/session.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let app = names_for_layer(&by_layer, "application"); - assert!( - !app.contains("search"), - "impl on private type must be skipped" - ); -} - -#[test] -fn test_collect_pub_fns_groups_by_layer() { - let cli_file = parse("pub fn cmd_stats() {}"); - let mcp_file = parse("pub fn handle_stats() {}"); - let app_file = parse("pub fn get_stats() {}"); - let files = vec![ - ("src/cli/handlers.rs", &cli_file), - ("src/mcp/handlers.rs", &mcp_file), - ("src/application/stats.rs", &app_file), - ]; - let by_layer = pub_fns_by_layer(&files); - assert_eq!( - names_for_layer(&by_layer, "cli"), - ["cmd_stats".to_string()].into() - ); - assert_eq!( - names_for_layer(&by_layer, "mcp"), - ["handle_stats".to_string()].into() - ); - assert_eq!( - names_for_layer(&by_layer, "application"), - ["get_stats".to_string()].into() - ); -} - -#[test] -fn test_collect_pub_fns_skips_cfg_test_files() { - let file = parse("pub fn cmd_stats() {}"); - let files = vec![("src/cli/handlers.rs", &file)]; - let mut cfg_test = HashSet::new(); - cfg_test.insert("src/cli/handlers.rs".to_string()); - let aliases = aliases_from_files(&files); - let by_layer = collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &HashSet::new(), - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &cfg_test, - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }); - assert!( - names_for_layer(&by_layer, "cli").is_empty(), - "cfg-test file must be skipped wholesale" - ); -} - -#[test] -fn test_collect_pub_fns_skips_test_attr_fns() { - let file = parse( - r#" - #[test] - pub fn not_a_handler() {} - pub fn cmd_stats() {} - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!(cli.contains("cmd_stats")); - assert!(!cli.contains("not_a_handler"), "#[test] fn must be skipped"); -} - -#[test] -fn test_collect_pub_fns_skips_unmatched_files() { - // File not covered by any layer — its pub fns are not part of the - // call-parity scope (neither as adapter member nor as target). - let file = parse("pub fn free_floating() {}"); - let files = vec![("src/utils/misc.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - for layer in ["application", "cli", "mcp"] { - assert!( - names_for_layer(&by_layer, layer).is_empty(), - "layer {layer} must be empty" - ); - } -} - -#[test] -fn test_collect_pub_fns_skips_pub_fn_inside_private_inline_mod() { - // `mod private { pub fn helper() {} }` — `helper` is `pub` but - // its parent `mod private` has inherited visibility, so the fn - // isn't reachable from outside the parent module. Must not be - // recorded as adapter / target surface. - let file = parse( - r#" - mod private { - pub fn helper() {} - } - pub fn visible_top() {} - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!( - cli.contains("visible_top"), - "top-level pub fn must be recorded, got {cli:?}" - ); - assert!( - !cli.contains("helper"), - "pub fn inside private inline mod must be skipped, got {cli:?}" - ); -} - -#[test] -fn test_collect_pub_fns_treats_pub_self_as_private() { - // `pub(self) fn helper()` is semantically private — equivalent to - // inherited visibility. Must not be recorded. - let file = parse( - r#" - pub(self) fn helper() {} - pub fn visible() {} - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!( - cli.contains("visible"), - "plain `pub fn` must be recorded, got {cli:?}" - ); - assert!( - !cli.contains("helper"), - "`pub(self) fn` is private-equivalent and must be skipped, got {cli:?}" - ); -} - -#[test] -fn test_collect_pub_fns_skips_impl_method_on_type_in_private_inline_mod() { - // `mod private { pub struct Hidden; impl Hidden { pub fn op() {} } }` - // — `Hidden` is pub but only inside a private mod, so its - // workspace-visible-types entry must NOT register, and the impl - // method `op` must not appear as adapter surface. - let file = parse( - r#" - mod private { - pub struct Hidden; - impl Hidden { - pub fn op(&self) {} - } - } - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!( - !cli.contains("op"), - "impl method on type in private mod must be skipped, got {cli:?}" - ); -} - -#[test] -fn test_collect_pub_fns_records_impl_in_private_mod_for_public_type() { - // `pub struct Session` at file level, but its `impl` block lives - // inside a private inline mod via `super::Session`. Rust treats - // `s.diff()` as callable from any caller that can name `Session`, - // so the public type's pub inherent methods must be recorded as - // adapter surface — even though the impl block itself sits in a - // private mod. - let file = parse( - r#" - pub struct Session; - mod methods { - impl super::Session { - pub fn diff(&self) {} - } - } - "#, - ); - let files = vec![("src/application/session.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let app = names_for_layer(&by_layer, "application"); - assert!( - app.contains("diff"), - "impl in private mod for public type must be recorded, got {app:?}" - ); -} - -#[test] -fn test_collect_pub_fns_records_impl_via_nested_pub_use_export_path() { - // `pub mod outer { pub use self::private::Hidden; }` re-exports - // `Hidden` at `crate::file::outer::Hidden`. An impl written - // against the export path must be recognised — visible_canonicals - // needs both the source path *and* the export path so impl - // resolution doesn't miss it. - let file = parse( - r#" - pub mod outer { - mod private { - pub struct Hidden; - } - pub use self::private::Hidden; - } - impl outer::Hidden { - pub fn op(&self) {} - } - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!( - cli.contains("op"), - "impl on nested-mod re-export path must be recorded, got {cli:?}" - ); -} - -#[test] -fn test_collect_pub_fns_records_impl_via_chained_type_alias() { - // `type Inner = private::Hidden; pub type Public = Inner;` — - // the alias chain must be followed to the source type, otherwise - // visible_canonicals only contains `Inner` and the impl on - // `Hidden` stays out of scope. - let file = parse( - r#" - mod private { - pub struct Hidden; - impl Hidden { - pub fn op(&self) {} - } - } - type Inner = private::Hidden; - pub type Public = Inner; - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!( - cli.contains("op"), - "alias chain target's impl method must be recorded, got {cli:?}" - ); -} - -#[test] -fn test_collect_pub_fns_does_not_promote_bare_local_arc() { - // `use crate::wrap::Arc; pub type Public = Arc;` - // — bare `Arc` is shadowed by the local `use`. Visibility must - // canonicalise first and refuse to auto-peel local Arcs. - let file = parse( - r#" - mod wrap { pub struct Arc(T); } - use crate::wrap::Arc; - mod private { - pub struct Hidden; - impl Hidden { - pub fn op(&self) {} - } - } - pub type Public = Arc; - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!( - !cli.contains("op"), - "bare Arc shadowed by local must not auto-peel, got {cli:?}" - ); -} - -#[test] -fn test_collect_pub_fns_peels_qualified_user_wrapper() { - // `pub type Public = axum::extract::State;` with - // `transparent_wrappers = ["State"]`. External `axum::*` paths - // can't be canonicalised, so the visibility pass must fall back - // to last-segment matching for user-transparent wrappers. - let file = parse( - r#" - mod private { - pub struct Hidden; - impl Hidden { - pub fn op(&self) {} - } - } - pub type Public = axum::extract::State; - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let mut wrappers = HashSet::new(); - wrappers.insert("State".to_string()); - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &wrappers, - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; - let cli = names_for_layer(&by_layer, "cli"); - assert!( - cli.contains("op"), - "fully-qualified user wrapper must peel via leaf, got {cli:?}" - ); -} - -#[test] -fn test_collect_pub_fns_does_not_promote_qualified_local_arc() { - // `pub type Public = wrap::Arc;` — `wrap::Arc` - // is a *local* wrapper, not stdlib. Direct dispatch on the leaf - // `Arc` must NOT peel; otherwise Check B would require coverage - // for methods on `private::Hidden` that aren't actually exposed. - let file = parse( - r#" - mod wrap { pub struct Arc(T); } - mod private { - pub struct Hidden; - impl Hidden { - pub fn op(&self) {} - } - } - pub type Public = wrap::Arc; - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!( - !cli.contains("op"), - "qualified local Arc must not auto-peel as stdlib Arc, got {cli:?}" - ); -} - -#[test] -fn test_collect_pub_fns_does_not_promote_local_wrapper_alias() { - // `use crate::wrap::Arc as Shared;` aliases a *local* wrapper - // type — its canonical (`crate::wrap::Arc`) doesn't start with - // std/core/alloc, so the visibility pass must NOT auto-peel it - // when it appears in `pub type Public = Shared<…>`. Only stdlib - // wrappers are auto-peeled; user-configured wrappers stay - // last-segment based. - let file = parse( - r#" - use crate::wrap::Arc as Shared; - mod private { - pub struct Hidden; - impl Hidden { - pub fn op(&self) {} - } - } - pub type Public = Shared; - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!( - !cli.contains("op"), - "local wrapper alias must not auto-peel as stdlib Arc, got {cli:?}" - ); -} - -#[test] -fn test_collect_pub_fns_records_impl_via_renamed_stdlib_wrapper() { - // `use std::sync::Arc as Shared; pub type Public = Shared;` - // — the visibility pass must follow the import alias when peeling - // wrappers, otherwise `Shared` is treated as a non-wrapper and - // `private::Hidden` never enters `visible_canonicals`. - let file = parse( - r#" - use std::sync::Arc as Shared; - mod private { - pub struct Hidden; - impl Hidden { - pub fn op(&self) {} - } - } - pub type Public = Shared; - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!( - cli.contains("op"), - "renamed stdlib wrapper alias must peel in visibility pass, got {cli:?}" - ); -} - -#[test] -fn test_collect_pub_fns_records_impl_via_pub_type_alias_through_user_wrapper() { - // `pub type Public = State;` with a - // user-configured transparent wrapper `State`. The visibility - // pass must consult the same wrapper set the receiver resolver - // uses, otherwise Check B drops the public target. - let file = parse( - r#" - mod private { - pub struct Hidden; - impl Hidden { - pub fn op(&self) {} - } - } - pub type Public = State; - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let mut wrappers = HashSet::new(); - wrappers.insert("State".to_string()); - let by_layer = { - let aliases = aliases_from_files(&files); - collect_pub_fns_by_layer(PubFnInputs { - files: &files, - aliases_per_file: &aliases, - layers: &three_layer(), - transparent_wrappers: &wrappers, - promoted_attributes: &HashSet::new(), - workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { - cfg_test_files: &HashSet::new(), - crate_root_modules: &HashSet::new(), - workspace_module_paths: &HashSet::new(), - }, - }) - }; - let cli = names_for_layer(&by_layer, "cli"); - assert!( - cli.contains("op"), - "user-wrapper alias target's impl method must be recorded, got {cli:?}" - ); -} - -#[test] -fn test_collect_pub_fns_records_impl_via_pub_type_alias_through_wrapper() { - // `pub type Public = Box;` — the alias target - // is wrapped in a Deref-transparent smart pointer. Receiver - // resolution peels Box/Arc/Rc/Cow, so the visible-types pass - // must do the same to reach the inner `private::Hidden` and - // recognise its impl methods as adapter surface. - let file = parse( - r#" - mod private { - pub struct Hidden; - impl Hidden { - pub fn op(&self) {} - } - } - pub type Public = Box; - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!( - cli.contains("op"), - "wrapper-alias target's impl method must be recorded, got {cli:?}" - ); -} - -#[test] -fn test_collect_pub_fns_records_impl_via_pub_type_alias() { - // `pub type Public = private::Hidden;` exposes a hidden source - // type's methods through the alias. Receiver-type inference - // already resolves `Public` to its target, so the only piece - // missing for Check B was visibility — register the target's - // canonical alongside the alias path. - let file = parse( - r#" - mod private { - pub struct Hidden; - impl Hidden { - pub fn op(&self) {} - } - } - pub type Public = private::Hidden; - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!( - cli.contains("op"), - "impl on pub-type-alias target must be recorded, got {cli:?}" - ); -} - -#[test] -fn test_collect_pub_fns_records_renamed_reexport_impl_methods() { - // `pub use private::Hidden as PublicHidden;` re-exports the - // source type under a new name. The impl uses the original - // `Hidden`, so visibility must resolve through the re-export - // path — short-name matching against `PublicHidden` would miss - // the impl. Recording must work via the source-canonical path - // that both sides agree on. - let file = parse( - r#" - mod private { - pub struct Hidden; - } - impl private::Hidden { - pub fn op(&self) {} - } - pub use private::Hidden as PublicHidden; - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!( - cli.contains("op"), - "renamed re-export must still expose impl method, got {cli:?}" - ); -} - -#[test] -fn test_collect_pub_fns_chases_reexported_type_alias_to_target() { - // `pub use private::Public;` where `Public` is a type alias for - // `private::Hidden` and `op` is defined on `Hidden`. Receiver-type - // inference resolves callers `x: Public` to `Hidden::op`, so the - // visibility set must contain BOTH `Public` (the alias) and - // `Hidden` (its target) — otherwise Check B would drop `Hidden::op` - // even though it is reachable through the public alias. - let file = parse( - r#" - mod private { - pub struct Hidden; - pub type Public = Hidden; - impl Hidden { - pub fn op(&self) {} - } - } - pub use private::Public; - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!( - cli.contains("op"), - "re-exported type alias must surface its target's impl methods, got {cli:?}" - ); -} - -#[test] -fn test_collect_pub_fns_records_pub_use_reexport_with_qualified_impl() { - // `pub use private::Hidden;` with the impl at file level - // (qualified `impl private::Hidden { … }`) — the re-export - // resolves to the source-canonical `crate::file::private::Hidden` - // and registers in `visible_canonicals`. The impl resolves to - // the same canonical, so the methods record. With canonical-path - // matching, impls *inside* `mod private` for the same re-exported - // type also record correctly (the mod's own visibility no longer - // gates impl methods). - let file = parse( - r#" - mod private { - pub struct Hidden; - } - impl private::Hidden { - pub fn op(&self) {} - } - pub use private::Hidden; - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!( - cli.contains("op"), - "re-exported type with file-level impl must be recorded, got {cli:?}" - ); -} - -#[test] -fn test_collect_pub_fns_skips_trait_impl_method_on_private_self_type() { - // `impl PubTrait for Hidden { fn handle() }` — `Hidden` is private, - // so `Hidden::handle` is NOT registered as a target pub-fn. - // Dispatch through `dyn PubTrait` no longer emits `Hidden::handle` - // either; instead it emits the synthetic anchor - // `::handle` which represents the capability. - // Registering private-self-type impl-methods as target pub-fns - // would force adapter coverage checks for implementation details - // that are unreachable through the public API. - let file = parse( - r#" - pub trait PubTrait { - fn handle(&self); - } - struct Hidden; - impl PubTrait for Hidden { - fn handle(&self) {} - } - "#, - ); - let files = vec![("src/application/mod.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let app = names_for_layer(&by_layer, "application"); - assert!( - !app.contains("handle"), - "trait-impl method on private self type must stay out of pub-fn set; dispatch reaches it via the trait-method anchor, not as a concrete target pub-fn. Got {app:?}" - ); -} - -#[test] -fn test_collect_pub_fns_records_inherited_trait_impl_methods() { - // `impl PubTrait for X { fn handle(&self) {} }` — the impl-item - // `vis` is `Inherited`, but the method is part of the public - // surface because the trait is public. Otherwise dispatch could - // emit `X::handle` as a touchpoint while `X::handle` never enters - // the target pub-fn set, hiding peer-adapter coverage gaps in - // Check B/D. - let file = parse( - r#" - pub trait PubTrait { - fn handle(&self); - } - pub struct X; - impl PubTrait for X { - fn handle(&self) {} - } - "#, - ); - let files = vec![("src/application/mod.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let app = names_for_layer(&by_layer, "application"); - assert!( - app.contains("handle"), - "trait-impl method must be recorded as pub fn even with Inherited vis, got {app:?}" - ); -} - -#[test] -fn test_collect_pub_fns_excludes_orphan_file_not_declared_in_crate_root() { - // `src/lib.rs` doesn't declare `mod application;`, but - // `src/application/mod.rs` exists with a `pub fn helper()`. - // The file is not actually part of any module tree — its pub - // fns must NOT be recorded as adapter/target surface. - let lib = parse("mod cli;"); - let cli = parse("pub fn cmd() {}"); - let app = parse("pub fn helper() {}"); - let files = vec![ - ("src/lib.rs", &lib), - ("src/cli/mod.rs", &cli), - ("src/application/mod.rs", &app), - ]; - let by_layer = pub_fns_by_layer(&files); - let app_fns = names_for_layer(&by_layer, "application"); - assert!( - !app_fns.contains("helper"), - "orphan file (no `mod application;` decl in lib.rs) must not contribute pub fns, got {app_fns:?}" - ); -} - -#[test] -fn test_collect_pub_fns_unions_lib_and_main_root_trees() { - // Workspace with both `src/lib.rs` and `src/main.rs`. `lib.rs` - // declares `mod application;` privately (visible at crate-root - // level per the relaxation), `main.rs` declares `mod cli;` - // privately. A file is visible in its respective tree; the two - // trees stay independent. - let lib = parse("mod application;"); - let main = parse("mod cli;"); - let app = parse("pub fn search() {}"); - let cli = parse("pub fn cmd() {}"); - let files = vec![ - ("src/lib.rs", &lib), - ("src/main.rs", &main), - ("src/application/mod.rs", &app), - ("src/cli/mod.rs", &cli), - ]; - let by_layer = pub_fns_by_layer(&files); - let app_fns = names_for_layer(&by_layer, "application"); - let cli_fns = names_for_layer(&by_layer, "cli"); - assert!( - app_fns.contains("search"), - "application module declared in lib.rs root must surface its pub fns, got {app_fns:?}" - ); - assert!( - cli_fns.contains("cmd"), - "cli module declared in main.rs root must surface its pub fns, got {cli_fns:?}" - ); -} - -#[test] -fn test_collect_pub_fns_includes_crate_root_mod_decl_without_pub() { - // `src/lib.rs` typically writes `mod cli; mod application;` — - // sibling modules still reach them via `crate::cli::…`, and - // call-parity is an internal architecture check. The visibility - // pass must therefore treat crate-root `mod X;` (without `pub`) - // as visible so adapter handlers in `src/cli/handlers.rs` are - // recorded as pub-fns and Checks A/B/C/D run against them. - let lib = parse("mod cli; mod application;"); - let cli_mod = parse("pub fn cmd_search() {}"); - let app_mod = parse("pub fn search() {}"); - let files = vec![ - ("src/lib.rs", &lib), - ("src/cli/mod.rs", &cli_mod), - ("src/application/mod.rs", &app_mod), - ]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - let app = names_for_layer(&by_layer, "application"); - assert!( - cli.contains("cmd_search"), - "crate-root `mod cli;` (no pub) must still expose adapter pub-fns, got {cli:?}" - ); - assert!( - app.contains("search"), - "crate-root `mod application;` (no pub) must still expose target pub-fns, got {app:?}" - ); -} - -#[test] -fn test_collect_pub_fns_excludes_pub_fn_under_private_ancestor_chain() { - // `mod internal;` at depth 1 (private) + `pub mod deep;` at depth 2. - // Even though deep's direct parent says `pub`, the `internal` - // ancestor is private — the whole subtree must be excluded. - let app = parse("mod internal;"); - let internal = parse("pub mod deep;"); - let deep = parse("pub fn helper() {}"); - let files = vec![ - ("src/application/mod.rs", &app), - ("src/application/internal/mod.rs", &internal), - ("src/application/internal/deep.rs", &deep), - ]; - let by_layer = pub_fns_by_layer(&files); - let app_fns = names_for_layer(&by_layer, "application"); - assert!( - !app_fns.contains("helper"), - "private ancestor `mod internal;` must hide pub fns in deep descendants, got {app_fns:?}" - ); -} - -#[test] -fn test_collect_pub_fns_excludes_pub_fn_in_file_backed_private_module() { - // `mod internal;` (without `pub`) keeps `src/application/internal.rs` - // private to the parent. `pub fn helper()` inside that file must - // NOT be recorded as a target-layer pub fn — otherwise Check B/D - // would require adapter coverage for a private helper. - let parent = parse("mod internal;"); - let child = parse("pub fn helper() {}"); - let files = vec![ - ("src/application/mod.rs", &parent), - ("src/application/internal.rs", &child), - ]; - let by_layer = pub_fns_by_layer(&files); - let app = names_for_layer(&by_layer, "application"); - assert!( - !app.contains("helper"), - "pub fn in a file-backed private module must not enter the target-layer surface, got {app:?}" - ); -} - -#[test] -fn test_collect_pub_fns_includes_pub_fn_in_file_backed_public_module() { - // Sanity counterpart: `pub mod internal;` makes the file public, - // so `pub fn helper()` IS recorded. - let parent = parse("pub mod internal;"); - let child = parse("pub fn helper() {}"); - let files = vec![ - ("src/application/mod.rs", &parent), - ("src/application/internal.rs", &child), - ]; - let by_layer = pub_fns_by_layer(&files); - let app = names_for_layer(&by_layer, "application"); - assert!( - app.contains("helper"), - "pub fn in a file-backed public module must be recorded, got {app:?}" - ); -} - -#[test] -fn test_collect_pub_fns_skips_impl_methods_under_short_name_collision() { - // Two distinct types named `Session` (one public, one in a - // private inline mod) must NOT collide. The canonical-path-based - // `visible_canonicals` set keys on full paths, so - // `crate::cli::handlers::api::Session` and - // `crate::cli::handlers::internal::Session` are distinct entries - // — only the former is recorded (private mod's recursion is - // skipped during the collection pass). - let file = parse( - r#" - pub mod api { - pub struct Session; - impl Session { - pub fn run(&self) {} - } - } - mod internal { - pub struct Session; - impl Session { - pub fn cleanup(&self) {} - } - } - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let cli = names_for_layer(&by_layer, "cli"); - assert!( - cli.contains("run"), - "public-mod impl method must be recorded, got {cli:?}" - ); - assert!( - !cli.contains("cleanup"), - "private-mod impl method must not leak via short-name collision, got {cli:?}" - ); -} - -// ── Deprecated-attribute detection (v1.2.1) ──────────────────────── - -fn deprecated_for_layer<'ast>( - by_layer: &std::collections::HashMap>>, - layer: &str, -) -> HashMap { - by_layer - .get(layer) - .map(|fns| { - fns.iter() - .map(|f| (f.fn_name.clone(), f.deprecated)) - .collect() - }) - .unwrap_or_default() -} - -#[test] -fn pub_fn_records_deprecated_attribute_bare() { - let file = parse( - r#" - #[deprecated] - pub fn cmd_old() {} - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - let dep = deprecated_for_layer(&by_layer, "cli"); - assert_eq!(dep.get("cmd_old"), Some(&true)); -} - -#[test] -fn pub_fn_records_deprecated_with_message() { - let file = parse( - r#" - #[deprecated = "use cmd_new instead"] - pub fn cmd_old() {} - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - assert_eq!( - deprecated_for_layer(&by_layer, "cli").get("cmd_old"), - Some(&true) - ); -} - -#[test] -fn pub_fn_records_deprecated_with_args() { - let file = parse( - r#" - #[deprecated(since = "1.0", note = "use cmd_new")] - pub fn cmd_old() {} - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - assert_eq!( - deprecated_for_layer(&by_layer, "cli").get("cmd_old"), - Some(&true) - ); -} - -#[test] -fn pub_fn_no_attribute_not_deprecated() { - let file = parse( - r#" - pub fn cmd_active() {} - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - assert_eq!( - deprecated_for_layer(&by_layer, "cli").get("cmd_active"), - Some(&false) - ); -} - -#[test] -fn pub_fn_other_attribute_not_deprecated() { - // `#[allow(unused)]` must NOT be misidentified as deprecation. - let file = parse( - r#" - #[allow(unused)] - pub fn cmd_active() {} - "#, - ); - let files = vec![("src/cli/handlers.rs", &file)]; - let by_layer = pub_fns_by_layer(&files); - assert_eq!( - deprecated_for_layer(&by_layer, "cli").get("cmd_active"), - Some(&false) - ); -} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/classification.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/classification.rs new file mode 100644 index 00000000..5b3b207f --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/classification.rs @@ -0,0 +1,202 @@ +use super::*; + +const PUB_FN_CASES: &[PubFnCase] = &[ + // ── visibility on free / impl fns (single file) ────────────── + ( + "private (no-modifier) fn is skipped; pub sibling kept", + &[( + "src/cli/handlers.rs", + "fn helper() {} pub fn cmd_stats() {}", + )], + "cli", + &[], + &["cmd_stats"], + &["helper"], + ), + ( + "pub(super) and pub(in path) are public enough", + &[( + "src/cli/handlers.rs", + "pub(super) fn cmd_a() {} pub(in crate::cli) fn cmd_b() {}", + )], + "cli", + &[], + &["cmd_a", "cmd_b"], + &[], + ), + ( + "pub impl method on a pub type kept; private method skipped", + &[( + "src/application/session.rs", + "pub struct Session; impl Session { pub fn search(&self) {} fn helper(&self) {} }", + )], + "application", + &[], + &["search"], + &["helper"], + ), + ( + "#[test] fn is skipped; pub sibling kept", + &[( + "src/cli/handlers.rs", + "#[test] pub fn not_a_handler() {} pub fn cmd_stats() {}", + )], + "cli", + &[], + &["cmd_stats"], + &["not_a_handler"], + ), + ( + "pub fn inside a private inline mod is not reachable", + &[( + "src/cli/handlers.rs", + "mod private { pub fn helper() {} } pub fn visible_top() {}", + )], + "cli", + &[], + &["visible_top"], + &["helper"], + ), + ( + "pub(self) is private-equivalent and skipped", + &[( + "src/cli/handlers.rs", + "pub(self) fn helper() {} pub fn visible() {}", + )], + "cli", + &[], + &["visible"], + &["helper"], + ), + ( + // Distinct types named `Session` (public mod vs private mod) key on + // full canonical paths, so the private one's method can't leak. + "short-name type collision does not leak the private-mod method", + &[( + "src/cli/handlers.rs", + "pub mod api { pub struct Session; impl Session { pub fn run(&self) {} } } \ + mod internal { pub struct Session; impl Session { pub fn cleanup(&self) {} } }", + )], + "cli", + &[], + &["run"], + &["cleanup"], + ), + // ── module-tree reachability (multi-file) ──────────────────── + ( + // `pub struct` in one file, `impl` (via `use`) in another — both + // resolve to the same canonical, so the impl methods are surface. + "cross-file impl on a pub type is collected", + &[ + ("src/application/session.rs", "pub struct Session;"), + ( + "src/application/session_impls.rs", + "use crate::application::session::Session; impl Session { pub fn search(&self) {} }", + ), + ], + "application", + &[], + &["search"], + &[], + ), + ( + "pub fn in a file-backed private module (`mod internal;`) is skipped", + &[ + ("src/application/mod.rs", "mod internal;"), + ("src/application/internal.rs", "pub fn helper() {}"), + ], + "application", + &[], + &[], + &["helper"], + ), + ( + "pub fn in a file-backed public module (`pub mod internal;`) is kept", + &[ + ("src/application/mod.rs", "pub mod internal;"), + ("src/application/internal.rs", "pub fn helper() {}"), + ], + "application", + &[], + &["helper"], + &[], + ), + ( + // lib.rs never declares `mod application;`, so the file is an orphan + // not part of any module tree. + "orphan file not declared in the crate root contributes nothing", + &[ + ("src/lib.rs", "mod cli;"), + ("src/cli/mod.rs", "pub fn cmd() {}"), + ("src/application/mod.rs", "pub fn helper() {}"), + ], + "application", + &[], + &[], + &["helper"], + ), + ( + // A private `mod internal;` ancestor hides the whole subtree even + // though the direct parent of `deep` says `pub`. + "private ancestor in the chain hides pub fns in deep descendants", + &[ + ("src/application/mod.rs", "mod internal;"), + ("src/application/internal/mod.rs", "pub mod deep;"), + ("src/application/internal/deep.rs", "pub fn helper() {}"), + ], + "application", + &[], + &[], + &["helper"], + ), + // ── user-configured transparent wrappers ───────────────────── + ( + // External `axum::*` paths can't be canonicalised, so the + // visibility pass falls back to last-segment matching for the + // user-transparent `State` wrapper. + "fully-qualified user wrapper peels via leaf segment", + &[( + "src/cli/handlers.rs", + "mod private { pub struct Hidden; impl Hidden { pub fn op(&self) {} } } \ + pub type Public = axum::extract::State;", + )], + "cli", + &["State"], + &["op"], + &[], + ), + ( + "bare user-wrapper alias target's impl method is recorded", + &[( + "src/cli/handlers.rs", + "mod private { pub struct Hidden; impl Hidden { pub fn op(&self) {} } } \ + pub type Public = State;", + )], + "cli", + &["State"], + &["op"], + &[], + ), +]; + +#[test] +fn pub_fn_layer_membership_classification() { + // One table over the visibility / module-tree / wrapper rules that decide + // whether a pub fn enters a layer's call-parity surface. Each row asserts + // the `present` names appear and the `absent` names don't, for `layer`. + for (label, files, layer, wrappers, present, absent) in PUB_FN_CASES { + let names = layer_names_w(files, layer, wrappers); + for n in *present { + assert!( + names.contains(*n), + "case {label}: {n} must be present in {layer}, got {names:?}" + ); + } + for n in *absent { + assert!( + !names.contains(*n), + "case {label}: {n} must be absent from {layer}, got {names:?}" + ); + } + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/deprecated.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/deprecated.rs new file mode 100644 index 00000000..5746bf85 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/deprecated.rs @@ -0,0 +1,95 @@ +use super::*; + +// ── Deprecated-attribute detection (v1.2.1) ──────────────────────── + +fn deprecated_for_layer<'ast>( + by_layer: &std::collections::HashMap>>, + layer: &str, +) -> HashMap { + by_layer + .get(layer) + .map(|fns| { + fns.iter() + .map(|f| (f.fn_name.clone(), f.deprecated)) + .collect() + }) + .unwrap_or_default() +} + +#[test] +fn pub_fn_records_deprecated_attribute_bare() { + let file = parse( + r#" + #[deprecated] + pub fn cmd_old() {} + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let dep = deprecated_for_layer(&by_layer, "cli"); + assert_eq!(dep.get("cmd_old"), Some(&true)); +} + +#[test] +fn pub_fn_records_deprecated_with_message() { + let file = parse( + r#" + #[deprecated = "use cmd_new instead"] + pub fn cmd_old() {} + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + assert_eq!( + deprecated_for_layer(&by_layer, "cli").get("cmd_old"), + Some(&true) + ); +} + +#[test] +fn pub_fn_records_deprecated_with_args() { + let file = parse( + r#" + #[deprecated(since = "1.0", note = "use cmd_new")] + pub fn cmd_old() {} + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + assert_eq!( + deprecated_for_layer(&by_layer, "cli").get("cmd_old"), + Some(&true) + ); +} + +#[test] +fn pub_fn_no_attribute_not_deprecated() { + let file = parse( + r#" + pub fn cmd_active() {} + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + assert_eq!( + deprecated_for_layer(&by_layer, "cli").get("cmd_active"), + Some(&false) + ); +} + +#[test] +fn pub_fn_other_attribute_not_deprecated() { + // `#[allow(unused)]` must NOT be misidentified as deprecation. + let file = parse( + r#" + #[allow(unused)] + pub fn cmd_active() {} + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + assert_eq!( + deprecated_for_layer(&by_layer, "cli").get("cmd_active"), + Some(&false) + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/free_and_groups.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/free_and_groups.rs new file mode 100644 index 00000000..1a7a4c94 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/free_and_groups.rs @@ -0,0 +1,117 @@ +use super::*; + +#[test] +fn test_collect_pub_fns_in_layer_free_fn() { + let file = parse( + r#" + pub fn cmd_stats() {} + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let cli = names_for_layer(&by_layer, "cli"); + assert!(cli.contains("cmd_stats"), "cli = {cli:?}"); +} + +#[test] +fn test_pub_crate_is_treated_as_public_for_intra_crate_layers() { + // Workspace-internal crates rely on `pub(crate)` for their architecture + // surface; the check must treat any visibility-modified fn as + // "visible enough" — only the implicit (no-modifier) case is private. + let file = parse( + r#" + pub(crate) fn cmd_stats() {} + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let cli = names_for_layer(&by_layer, "cli"); + assert!(cli.contains("cmd_stats"), "pub(crate) must be collected"); +} + +#[test] +fn test_collect_pub_fns_skips_impl_methods_on_private_type() { + // Conservative: if the enclosing `impl Type { ... }` is for a private + // (no-modifier) type, its pub methods aren't really reachable from + // outside the file, so they're excluded from the call-parity scope. + let file = parse( + r#" + struct Session; + impl Session { + pub fn search(&self) {} + } + "#, + ); + let files = vec![("src/application/session.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let app = names_for_layer(&by_layer, "application"); + assert!( + !app.contains("search"), + "impl on private type must be skipped" + ); +} + +#[test] +fn test_collect_pub_fns_groups_by_layer() { + let cli_file = parse("pub fn cmd_stats() {}"); + let mcp_file = parse("pub fn handle_stats() {}"); + let app_file = parse("pub fn get_stats() {}"); + let files = vec![ + ("src/cli/handlers.rs", &cli_file), + ("src/mcp/handlers.rs", &mcp_file), + ("src/application/stats.rs", &app_file), + ]; + let by_layer = pub_fns_by_layer(&files); + assert_eq!( + names_for_layer(&by_layer, "cli"), + ["cmd_stats".to_string()].into() + ); + assert_eq!( + names_for_layer(&by_layer, "mcp"), + ["handle_stats".to_string()].into() + ); + assert_eq!( + names_for_layer(&by_layer, "application"), + ["get_stats".to_string()].into() + ); +} + +#[test] +fn test_collect_pub_fns_skips_cfg_test_files() { + let file = parse("pub fn cmd_stats() {}"); + let files = vec![("src/cli/handlers.rs", &file)]; + let mut cfg_test = HashSet::new(); + cfg_test.insert("src/cli/handlers.rs".to_string()); + let aliases = aliases_from_files(&files); + let by_layer = collect_pub_fns_by_layer(PubFnInputs { + files: &files, + aliases_per_file: &aliases, + layers: &three_layer(), + transparent_wrappers: &HashSet::new(), + promoted_attributes: &HashSet::new(), + workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { + cfg_test_files: &cfg_test, + crate_root_modules: &HashSet::new(), + workspace_module_paths: &HashSet::new(), + }, + }); + assert!( + names_for_layer(&by_layer, "cli").is_empty(), + "cfg-test file must be skipped wholesale" + ); +} + +#[test] +fn test_collect_pub_fns_skips_unmatched_files() { + // File not covered by any layer — its pub fns are not part of the + // call-parity scope (neither as adapter member nor as target). + let file = parse("pub fn free_floating() {}"); + let files = vec![("src/utils/misc.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + for layer in ["application", "cli", "mcp"] { + assert!( + names_for_layer(&by_layer, layer).is_empty(), + "layer {layer} must be empty" + ); + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/mod.rs new file mode 100644 index 00000000..e6181e49 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/mod.rs @@ -0,0 +1,106 @@ +//! Tests for `collect_pub_fns_by_layer` — workspace-wide pub-fn enumeration +//! grouped by architecture layer. Split into focused sub-files (each ≤ the +//! SRP file-length cap); shared imports, the parse/alias/layer helpers, and +//! the `PubFnCase` table type live here and reach the sub-modules via +//! `use super::*`. + +pub(super) use super::support::three_layer; +pub(super) use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup; +pub(super) use crate::adapters::analyzers::architecture::call_parity_rule::pub_fns::{ + collect_pub_fns_by_layer, PubFnInfo, PubFnInputs, +}; +pub(super) use crate::adapters::shared::use_tree::{gather_alias_map, AliasMap}; +pub(super) use std::collections::{HashMap, HashSet}; + +mod classification; +mod deprecated; +mod free_and_groups; +mod private_mods; +mod reexport_aliases; + +/// Build an `aliases_per_file` map from a workspace slice — mirrors +/// what the call-parity entry point computes. +pub(super) fn aliases_from_files(files: &[(&str, &syn::File)]) -> HashMap { + files + .iter() + .map(|(p, f)| (p.to_string(), gather_alias_map(f))) + .collect() +} + +pub(super) fn parse(src: &str) -> syn::File { + syn::parse_str(src).expect("parse file") +} + +pub(super) fn names_for_layer<'ast>( + by_layer: &std::collections::HashMap>>, + layer: &str, +) -> HashSet { + by_layer + .get(layer) + .map(|fns| fns.iter().map(|f| f.fn_name.clone()).collect()) + .unwrap_or_default() +} + +/// Collect pub fns by layer for the common test case — empty wrapper, +/// promoted-attribute, and workspace-lookup sets. Tests that need a +/// non-empty set call `collect_pub_fns_by_layer` directly. +pub(super) fn pub_fns_by_layer<'ast>( + files: &[(&'ast str, &'ast syn::File)], +) -> HashMap>> { + let aliases = aliases_from_files(files); + collect_pub_fns_by_layer(PubFnInputs { + files, + aliases_per_file: &aliases, + layers: &three_layer(), + transparent_wrappers: &HashSet::new(), + promoted_attributes: &HashSet::new(), + workspace: &crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::WorkspaceLookup { + cfg_test_files: &HashSet::new(), + crate_root_modules: &HashSet::new(), + workspace_module_paths: &HashSet::new(), + }, + }) +} + +/// Parse each `(path, src)` into a workspace, collect pub fns for `layer` +/// honouring `wrappers` as transparent wrappers, and return that layer's fn +/// names. Covers the single-file, multi-file, and user-wrapper test shapes +/// with the default (empty) cfg-test / crate-root / workspace-path sets. +pub(super) fn layer_names_w( + file_srcs: &[(&str, &str)], + layer: &str, + wrappers: &[&str], +) -> HashSet { + let parsed: Vec = file_srcs.iter().map(|(_, s)| parse(s)).collect(); + let files: Vec<(&str, &syn::File)> = file_srcs + .iter() + .zip(&parsed) + .map(|((p, _), f)| (*p, f)) + .collect(); + let aliases = aliases_from_files(&files); + let wrapper_set: HashSet = wrappers.iter().map(|w| w.to_string()).collect(); + let by_layer = collect_pub_fns_by_layer(PubFnInputs { + files: &files, + aliases_per_file: &aliases, + layers: &three_layer(), + transparent_wrappers: &wrapper_set, + promoted_attributes: &HashSet::new(), + workspace: &WorkspaceLookup { + cfg_test_files: &HashSet::new(), + crate_root_modules: &HashSet::new(), + workspace_module_paths: &HashSet::new(), + }, + }); + names_for_layer(&by_layer, layer) +} + +// (label, files[(path, src)], layer, transparent wrappers, present names, absent names) + +pub(super) type PubFnCase = ( + &'static str, + &'static [(&'static str, &'static str)], + &'static str, + &'static [&'static str], + &'static [&'static str], + &'static [&'static str], +); diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/private_mods.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/private_mods.rs new file mode 100644 index 00000000..c96f1d39 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/private_mods.rs @@ -0,0 +1,192 @@ +use super::*; + +#[test] +fn test_collect_pub_fns_skips_impl_method_on_type_in_private_inline_mod() { + // `mod private { pub struct Hidden; impl Hidden { pub fn op() {} } }` + // — `Hidden` is pub but only inside a private mod, so its + // workspace-visible-types entry must NOT register, and the impl + // method `op` must not appear as adapter surface. + let file = parse( + r#" + mod private { + pub struct Hidden; + impl Hidden { + pub fn op(&self) {} + } + } + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let cli = names_for_layer(&by_layer, "cli"); + assert!( + !cli.contains("op"), + "impl method on type in private mod must be skipped, got {cli:?}" + ); +} + +#[test] +fn test_collect_pub_fns_records_impl_in_private_mod_for_public_type() { + // `pub struct Session` at file level, but its `impl` block lives + // inside a private inline mod via `super::Session`. Rust treats + // `s.diff()` as callable from any caller that can name `Session`, + // so the public type's pub inherent methods must be recorded as + // adapter surface — even though the impl block itself sits in a + // private mod. + let file = parse( + r#" + pub struct Session; + mod methods { + impl super::Session { + pub fn diff(&self) {} + } + } + "#, + ); + let files = vec![("src/application/session.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let app = names_for_layer(&by_layer, "application"); + assert!( + app.contains("diff"), + "impl in private mod for public type must be recorded, got {app:?}" + ); +} + +#[test] +fn test_collect_pub_fns_records_impl_via_nested_pub_use_export_path() { + // `pub mod outer { pub use self::private::Hidden; }` re-exports + // `Hidden` at `crate::file::outer::Hidden`. An impl written + // against the export path must be recognised — visible_canonicals + // needs both the source path *and* the export path so impl + // resolution doesn't miss it. + let file = parse( + r#" + pub mod outer { + mod private { + pub struct Hidden; + } + pub use self::private::Hidden; + } + impl outer::Hidden { + pub fn op(&self) {} + } + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let cli = names_for_layer(&by_layer, "cli"); + assert!( + cli.contains("op"), + "impl on nested-mod re-export path must be recorded, got {cli:?}" + ); +} + +#[test] +fn test_collect_pub_fns_records_impl_via_chained_type_alias() { + // `type Inner = private::Hidden; pub type Public = Inner;` — + // the alias chain must be followed to the source type, otherwise + // visible_canonicals only contains `Inner` and the impl on + // `Hidden` stays out of scope. + let file = parse( + r#" + mod private { + pub struct Hidden; + impl Hidden { + pub fn op(&self) {} + } + } + type Inner = private::Hidden; + pub type Public = Inner; + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let cli = names_for_layer(&by_layer, "cli"); + assert!( + cli.contains("op"), + "alias chain target's impl method must be recorded, got {cli:?}" + ); +} + +#[test] +fn test_collect_pub_fns_does_not_promote_bare_local_arc() { + // `use crate::wrap::Arc; pub type Public = Arc;` + // — bare `Arc` is shadowed by the local `use`. Visibility must + // canonicalise first and refuse to auto-peel local Arcs. + let file = parse( + r#" + mod wrap { pub struct Arc(T); } + use crate::wrap::Arc; + mod private { + pub struct Hidden; + impl Hidden { + pub fn op(&self) {} + } + } + pub type Public = Arc; + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let cli = names_for_layer(&by_layer, "cli"); + assert!( + !cli.contains("op"), + "bare Arc shadowed by local must not auto-peel, got {cli:?}" + ); +} + +#[test] +fn test_collect_pub_fns_does_not_promote_qualified_local_arc() { + // `pub type Public = wrap::Arc;` — `wrap::Arc` + // is a *local* wrapper, not stdlib. Direct dispatch on the leaf + // `Arc` must NOT peel; otherwise Check B would require coverage + // for methods on `private::Hidden` that aren't actually exposed. + let file = parse( + r#" + mod wrap { pub struct Arc(T); } + mod private { + pub struct Hidden; + impl Hidden { + pub fn op(&self) {} + } + } + pub type Public = wrap::Arc; + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let cli = names_for_layer(&by_layer, "cli"); + assert!( + !cli.contains("op"), + "qualified local Arc must not auto-peel as stdlib Arc, got {cli:?}" + ); +} + +#[test] +fn test_collect_pub_fns_does_not_promote_local_wrapper_alias() { + // `use crate::wrap::Arc as Shared;` aliases a *local* wrapper + // type — its canonical (`crate::wrap::Arc`) doesn't start with + // std/core/alloc, so the visibility pass must NOT auto-peel it + // when it appears in `pub type Public = Shared<…>`. Only stdlib + // wrappers are auto-peeled; user-configured wrappers stay + // last-segment based. + let file = parse( + r#" + use crate::wrap::Arc as Shared; + mod private { + pub struct Hidden; + impl Hidden { + pub fn op(&self) {} + } + } + pub type Public = Shared; + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let cli = names_for_layer(&by_layer, "cli"); + assert!( + !cli.contains("op"), + "local wrapper alias must not auto-peel as stdlib Arc, got {cli:?}" + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/reexport_aliases.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/reexport_aliases.rs new file mode 100644 index 00000000..fd92dd96 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/pub_fns/reexport_aliases.rs @@ -0,0 +1,286 @@ +use super::*; + +#[test] +fn test_collect_pub_fns_records_impl_via_renamed_stdlib_wrapper() { + // `use std::sync::Arc as Shared; pub type Public = Shared;` + // — the visibility pass must follow the import alias when peeling + // wrappers, otherwise `Shared` is treated as a non-wrapper and + // `private::Hidden` never enters `visible_canonicals`. + let file = parse( + r#" + use std::sync::Arc as Shared; + mod private { + pub struct Hidden; + impl Hidden { + pub fn op(&self) {} + } + } + pub type Public = Shared; + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let cli = names_for_layer(&by_layer, "cli"); + assert!( + cli.contains("op"), + "renamed stdlib wrapper alias must peel in visibility pass, got {cli:?}" + ); +} + +#[test] +fn test_collect_pub_fns_records_impl_via_pub_type_alias_through_wrapper() { + // `pub type Public = Box;` — the alias target + // is wrapped in a Deref-transparent smart pointer. Receiver + // resolution peels Box/Arc/Rc/Cow, so the visible-types pass + // must do the same to reach the inner `private::Hidden` and + // recognise its impl methods as adapter surface. + let file = parse( + r#" + mod private { + pub struct Hidden; + impl Hidden { + pub fn op(&self) {} + } + } + pub type Public = Box; + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let cli = names_for_layer(&by_layer, "cli"); + assert!( + cli.contains("op"), + "wrapper-alias target's impl method must be recorded, got {cli:?}" + ); +} + +#[test] +fn test_collect_pub_fns_records_impl_via_pub_type_alias() { + // `pub type Public = private::Hidden;` exposes a hidden source + // type's methods through the alias. Receiver-type inference + // already resolves `Public` to its target, so the only piece + // missing for Check B was visibility — register the target's + // canonical alongside the alias path. + let file = parse( + r#" + mod private { + pub struct Hidden; + impl Hidden { + pub fn op(&self) {} + } + } + pub type Public = private::Hidden; + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let cli = names_for_layer(&by_layer, "cli"); + assert!( + cli.contains("op"), + "impl on pub-type-alias target must be recorded, got {cli:?}" + ); +} + +#[test] +fn test_collect_pub_fns_records_renamed_reexport_impl_methods() { + // `pub use private::Hidden as PublicHidden;` re-exports the + // source type under a new name. The impl uses the original + // `Hidden`, so visibility must resolve through the re-export + // path — short-name matching against `PublicHidden` would miss + // the impl. Recording must work via the source-canonical path + // that both sides agree on. + let file = parse( + r#" + mod private { + pub struct Hidden; + } + impl private::Hidden { + pub fn op(&self) {} + } + pub use private::Hidden as PublicHidden; + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let cli = names_for_layer(&by_layer, "cli"); + assert!( + cli.contains("op"), + "renamed re-export must still expose impl method, got {cli:?}" + ); +} + +#[test] +fn test_collect_pub_fns_chases_reexported_type_alias_to_target() { + // `pub use private::Public;` where `Public` is a type alias for + // `private::Hidden` and `op` is defined on `Hidden`. Receiver-type + // inference resolves callers `x: Public` to `Hidden::op`, so the + // visibility set must contain BOTH `Public` (the alias) and + // `Hidden` (its target) — otherwise Check B would drop `Hidden::op` + // even though it is reachable through the public alias. + let file = parse( + r#" + mod private { + pub struct Hidden; + pub type Public = Hidden; + impl Hidden { + pub fn op(&self) {} + } + } + pub use private::Public; + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let cli = names_for_layer(&by_layer, "cli"); + assert!( + cli.contains("op"), + "re-exported type alias must surface its target's impl methods, got {cli:?}" + ); +} + +#[test] +fn test_collect_pub_fns_records_pub_use_reexport_with_qualified_impl() { + // `pub use private::Hidden;` with the impl at file level + // (qualified `impl private::Hidden { … }`) — the re-export + // resolves to the source-canonical `crate::file::private::Hidden` + // and registers in `visible_canonicals`. The impl resolves to + // the same canonical, so the methods record. With canonical-path + // matching, impls *inside* `mod private` for the same re-exported + // type also record correctly (the mod's own visibility no longer + // gates impl methods). + let file = parse( + r#" + mod private { + pub struct Hidden; + } + impl private::Hidden { + pub fn op(&self) {} + } + pub use private::Hidden; + "#, + ); + let files = vec![("src/cli/handlers.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let cli = names_for_layer(&by_layer, "cli"); + assert!( + cli.contains("op"), + "re-exported type with file-level impl must be recorded, got {cli:?}" + ); +} + +#[test] +fn test_collect_pub_fns_skips_trait_impl_method_on_private_self_type() { + // `impl PubTrait for Hidden { fn handle() }` — `Hidden` is private, + // so `Hidden::handle` is NOT registered as a target pub-fn. + // Dispatch through `dyn PubTrait` no longer emits `Hidden::handle` + // either; instead it emits the synthetic anchor + // `::handle` which represents the capability. + // Registering private-self-type impl-methods as target pub-fns + // would force adapter coverage checks for implementation details + // that are unreachable through the public API. + let file = parse( + r#" + pub trait PubTrait { + fn handle(&self); + } + struct Hidden; + impl PubTrait for Hidden { + fn handle(&self) {} + } + "#, + ); + let files = vec![("src/application/mod.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let app = names_for_layer(&by_layer, "application"); + assert!( + !app.contains("handle"), + "trait-impl method on private self type must stay out of pub-fn set; dispatch reaches it via the trait-method anchor, not as a concrete target pub-fn. Got {app:?}" + ); +} + +#[test] +fn test_collect_pub_fns_records_inherited_trait_impl_methods() { + // `impl PubTrait for X { fn handle(&self) {} }` — the impl-item + // `vis` is `Inherited`, but the method is part of the public + // surface because the trait is public. Otherwise dispatch could + // emit `X::handle` as a touchpoint while `X::handle` never enters + // the target pub-fn set, hiding peer-adapter coverage gaps in + // Check B/D. + let file = parse( + r#" + pub trait PubTrait { + fn handle(&self); + } + pub struct X; + impl PubTrait for X { + fn handle(&self) {} + } + "#, + ); + let files = vec![("src/application/mod.rs", &file)]; + let by_layer = pub_fns_by_layer(&files); + let app = names_for_layer(&by_layer, "application"); + assert!( + app.contains("handle"), + "trait-impl method must be recorded as pub fn even with Inherited vis, got {app:?}" + ); +} + +#[test] +fn test_collect_pub_fns_unions_lib_and_main_root_trees() { + // Workspace with both `src/lib.rs` and `src/main.rs`. `lib.rs` + // declares `mod application;` privately (visible at crate-root + // level per the relaxation), `main.rs` declares `mod cli;` + // privately. A file is visible in its respective tree; the two + // trees stay independent. + let lib = parse("mod application;"); + let main = parse("mod cli;"); + let app = parse("pub fn search() {}"); + let cli = parse("pub fn cmd() {}"); + let files = vec![ + ("src/lib.rs", &lib), + ("src/main.rs", &main), + ("src/application/mod.rs", &app), + ("src/cli/mod.rs", &cli), + ]; + let by_layer = pub_fns_by_layer(&files); + let app_fns = names_for_layer(&by_layer, "application"); + let cli_fns = names_for_layer(&by_layer, "cli"); + assert!( + app_fns.contains("search"), + "application module declared in lib.rs root must surface its pub fns, got {app_fns:?}" + ); + assert!( + cli_fns.contains("cmd"), + "cli module declared in main.rs root must surface its pub fns, got {cli_fns:?}" + ); +} + +#[test] +fn test_collect_pub_fns_includes_crate_root_mod_decl_without_pub() { + // `src/lib.rs` typically writes `mod cli; mod application;` — + // sibling modules still reach them via `crate::cli::…`, and + // call-parity is an internal architecture check. The visibility + // pass must therefore treat crate-root `mod X;` (without `pub`) + // as visible so adapter handlers in `src/cli/handlers.rs` are + // recorded as pub-fns and Checks A/B/C/D run against them. + let lib = parse("mod cli; mod application;"); + let cli_mod = parse("pub fn cmd_search() {}"); + let app_mod = parse("pub fn search() {}"); + let files = vec![ + ("src/lib.rs", &lib), + ("src/cli/mod.rs", &cli_mod), + ("src/application/mod.rs", &app_mod), + ]; + let by_layer = pub_fns_by_layer(&files); + let cli = names_for_layer(&by_layer, "cli"); + let app = names_for_layer(&by_layer, "application"); + assert!( + cli.contains("cmd_search"), + "crate-root `mod cli;` (no pub) must still expose adapter pub-fns, got {cli:?}" + ); + assert!( + app.contains("search"), + "crate-root `mod application;` (no pub) must still expose target pub-fns, got {app:?}" + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/receiver_tracing.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/receiver_tracing.rs deleted file mode 100644 index 615a129b..00000000 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/receiver_tracing.rs +++ /dev/null @@ -1,417 +0,0 @@ -//! Workspace-level tests for method-call tracing through receivers, -//! locally-bound bindings, parameter-bound generics, async fn bodies, -//! generic-fn path calls, and inline attribute-decorated impl blocks. -//! -//! Each test builds a multi-file workspace via `build_workspace`, -//! produces the full call graph through `build_graph_only`, and -//! asserts the expected `crate::…::Type::method` (or free-fn) edge. -//! Coverage targets the inference paths that turn a syntactic call -//! site into a canonical edge: `self.helper()` chains, locally-bound -//! `let x = open()?; x.method()`, parameter-typed receivers, and -//! `path::call()` inside generic / `match` / async bodies. - -use super::support::{ - build_graph_only, build_workspace, callees_of, empty_cfg_test, graph_contains_edge, three_layer, -}; -use std::collections::HashSet; - -// ───────────────────────────────────────────────────────────────────── -// Self-receiver chains: `self.helper()` reaches an associated fn on -// a different type two hops away. -// ───────────────────────────────────────────────────────────────────── - -#[test] -fn self_method_chain_traces_through_helper_to_associated_fn_on_other_type() { - // Shape: - // impl Server { - // fn ensure_session(&self) -> Session { Session::open("/p") } - // } - // impl Server { - // pub fn search(&self) { self.ensure_session(); } - // } - // - // Asserts both edges exist: - // Server::search → Server::ensure_session - // Server::ensure_session → Session::open - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - pub struct Session; - pub struct MyErr; - impl Session { - pub fn open(_p: &str) -> Result { todo!() } - } - "#, - ), - ( - "src/mcp/server.rs", - r#" - use crate::application::session::{Session, MyErr}; - - pub struct Server; - - impl Server { - pub(crate) fn ensure_session(&self) -> Result { - Session::open("/p") - } - } - - impl Server { - pub fn search(&self) -> Result<(), MyErr> { - self.ensure_session()?; - Ok(()) - } - } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - - let search = "crate::mcp::server::Server::search"; - let ensure = "crate::mcp::server::Server::ensure_session"; - let open = "crate::application::session::Session::open"; - - let edge1 = graph_contains_edge(&graph, search, ensure); - let edge2 = graph_contains_edge(&graph, ensure, open); - - assert!( - edge1 && edge2, - "self-method chain `search → ensure_session → Session::open` broken.\n\ - search → ensure_session: {edge1}\n\ - ensure_session → Session::open: {edge2}\n\ - search callees: {:?}\n\ - ensure_session callees: {:?}", - callees_of(&graph, search), - callees_of(&graph, ensure), - ); -} - -#[test] -fn async_self_method_chain_traces_through_helper_to_associated_fn() { - // Same chain as the sync variant, but `pub async fn search` — - // async fn lowering must not break the edge. - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - pub struct Session; - pub struct MyErr; - impl Session { - pub fn open(_p: &str) -> Result { todo!() } - } - "#, - ), - ( - "src/mcp/server.rs", - r#" - use crate::application::session::{Session, MyErr}; - - pub struct Server; - - impl Server { - pub(crate) fn ensure_session(&self) -> Result { - Session::open("/p") - } - } - - impl Server { - pub async fn search(&self) -> Result<(), MyErr> { - self.ensure_session()?; - Ok(()) - } - } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - - let search = "crate::mcp::server::Server::search"; - let ensure = "crate::mcp::server::Server::ensure_session"; - let open = "crate::application::session::Session::open"; - - let edge1 = graph_contains_edge(&graph, search, ensure); - let edge2 = graph_contains_edge(&graph, ensure, open); - - assert!( - edge1 && edge2, - "async self-method chain broken.\n\ - search → ensure_session: {edge1}\n\ - ensure_session → Session::open: {edge2}\n\ - search callees: {:?}\n\ - ensure_session callees: {:?}", - callees_of(&graph, search), - callees_of(&graph, ensure), - ); -} - -// ───────────────────────────────────────────────────────────────────── -// Locally-bound and parameter-bound receivers: `let s = open()?; s.m()` -// and `fn h(s: &Session) { s.m() }` must both produce method edges. -// ───────────────────────────────────────────────────────────────────── - -#[test] -fn locally_bound_let_receiver_traces_multiple_method_calls() { - // `let session = open_session_in_cwd()?;` followed by branches - // calling `session.replace_preview()` and `session.replace_apply()` - // must produce TWO edges from the enclosing fn. - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - pub struct Session; - pub struct MyErr; - impl Session { - pub fn replace_preview(&self) {} - pub fn replace_apply(&self) {} - } - "#, - ), - ( - "src/cli/helpers.rs", - r#" - use crate::application::session::{Session, MyErr}; - pub fn open_session_in_cwd() -> Result { todo!() } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::cli::helpers::open_session_in_cwd; - use crate::application::session::MyErr; - - pub fn cmd_replace(preview: bool) -> Result<(), MyErr> { - let session = open_session_in_cwd()?; - if preview { - session.replace_preview(); - } else { - session.replace_apply(); - } - Ok(()) - } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - - let cmd = "crate::cli::handlers::cmd_replace"; - let preview = "crate::application::session::Session::replace_preview"; - let apply = "crate::application::session::Session::replace_apply"; - - let has_preview = graph_contains_edge(&graph, cmd, preview); - let has_apply = graph_contains_edge(&graph, cmd, apply); - - assert!( - has_preview && has_apply, - "locally-bound `session.X()` calls not traced.\n\ - cmd_replace → replace_preview: {has_preview}\n\ - cmd_replace → replace_apply: {has_apply}\n\ - cmd_replace callees: {:?}", - callees_of(&graph, cmd), - ); -} - -#[test] -fn parameter_bound_receiver_traces_multiple_method_calls() { - // `pub fn handle_replace(session: &Session, preview: bool)` — - // calls inside both `if` branches must produce edges. - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - pub struct Session; - impl Session { - pub fn replace_preview(&self) {} - pub fn replace_apply(&self) {} - } - "#, - ), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::session::Session; - - pub fn handle_replace(session: &Session, preview: bool) { - if preview { - session.replace_preview(); - } else { - session.replace_apply(); - } - } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - - let h = "crate::mcp::handlers::handle_replace"; - let preview = "crate::application::session::Session::replace_preview"; - let apply = "crate::application::session::Session::replace_apply"; - - let has_preview = graph_contains_edge(&graph, h, preview); - let has_apply = graph_contains_edge(&graph, h, apply); - - assert!( - has_preview && has_apply, - "parameter-bound `session.X()` calls not traced.\n\ - handle_replace → replace_preview: {has_preview}\n\ - handle_replace → replace_apply: {has_apply}\n\ - handle_replace callees: {:?}", - callees_of(&graph, h), - ); -} - -// ───────────────────────────────────────────────────────────────────── -// Generic-fn bodies: a path call `savings::record_file_op(result, p)` -// inside a generic fn body must emit a path-call edge regardless of -// the surrounding generics. -// ───────────────────────────────────────────────────────────────────── - -#[test] -fn generic_fn_body_traces_path_call_to_generic_target() { - let ws = build_workspace(&[ - ( - "src/application/savings.rs", - r#" - pub fn record_file_op(_r: &T, _meta: &str) {} - "#, - ), - ( - "src/application/middleware.rs", - r#" - use crate::application::savings; - - pub fn record_operation(meta: &str, result: &T) { - savings::record_file_op(result, meta); - } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - - let outer = "crate::application::middleware::record_operation"; - let inner = "crate::application::savings::record_file_op"; - - assert!( - graph_contains_edge(&graph, outer, inner), - "direct path-call edge from generic `record_operation` to \ - generic `record_file_op` missing.\n\ - record_operation callees: {:?}", - callees_of(&graph, outer), - ); -} - -#[test] -fn path_call_inside_generic_match_arm_traces_edge() { - // Outer call lives inside a `match` arm body — must still produce - // the edge for each arm. - let ws = build_workspace(&[ - ( - "src/application/savings.rs", - r#" - pub fn record_file_op(_r: &T, _meta: &str) {} - pub fn record_symbol_op(_r: &T, _meta: &str) {} - "#, - ), - ( - "src/application/middleware.rs", - r#" - use crate::application::savings; - - pub enum AlternativeCost { SingleFile(String), SymbolFiles(String) } - - pub fn record_operation(meta: &str, result: &T, alt: &AlternativeCost) { - let _ = match alt { - AlternativeCost::SingleFile(p) => { - savings::record_file_op(result, p); - } - AlternativeCost::SymbolFiles(s) => { - savings::record_symbol_op(result, s); - } - }; - } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - - let outer = "crate::application::middleware::record_operation"; - let inner_file = "crate::application::savings::record_file_op"; - let inner_sym = "crate::application::savings::record_symbol_op"; - - let has_file = graph_contains_edge(&graph, outer, inner_file); - let has_sym = graph_contains_edge(&graph, outer, inner_sym); - - assert!( - has_file && has_sym, - "calls inside match-arm bodies not traced.\n\ - record_operation → record_file_op: {has_file}\n\ - record_operation → record_symbol_op: {has_sym}\n\ - record_operation callees: {:?}", - callees_of(&graph, outer), - ); -} - -// ───────────────────────────────────────────────────────────────────── -// Inline impl-block attributes (`#[tool_router]` / `#[tool]`) must not -// hide the inner method bodies from the call graph. syn stores unknown -// attrs verbatim — the walker must descend into the impl regardless. -// ───────────────────────────────────────────────────────────────────── - -#[test] -fn unknown_attribute_on_impl_block_does_not_hide_inner_calls() { - // Method bodies inside an impl block decorated with a non-cfg - // unknown attribute must still contribute edges to the call graph. - // The attributes here are unknown to syn (no proc-macro expansion - // happens — syn just records them) so this test verifies the - // visitor doesn't skip attribute-decorated impl blocks. - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - pub struct Session; - pub struct MyErr; - impl Session { - pub fn open(_p: &str) -> Result { todo!() } - } - "#, - ), - ( - "src/mcp/server.rs", - r#" - use crate::application::session::{Session, MyErr}; - - pub struct Server; - pub struct Parameters(pub T); - pub struct SearchParams; - pub struct CallToolResult; - pub struct McpError; - - #[tool_router] - impl Server { - #[tool] - pub async fn search( - &self, - _params: Parameters, - ) -> Result { - let _session = Session::open("/p"); - todo!() - } - } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - - let search = "crate::mcp::server::Server::search"; - let open = "crate::application::session::Session::open"; - - let edge = graph_contains_edge(&graph, search, open); - - assert!( - edge, - "Session::open is invisible from inside the \ - #[tool_router]-decorated impl block.\n\ - search callees: {:?}", - callees_of(&graph, search), - ); -} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/receiver_tracing/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/receiver_tracing/mod.rs new file mode 100644 index 00000000..f58e03c8 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/receiver_tracing/mod.rs @@ -0,0 +1,45 @@ +//! Workspace-level tests for method-call tracing through receivers, +//! locally-bound bindings, parameter-bound generics, async fn bodies, +//! generic-fn path calls, and inline attribute-decorated impl blocks. Each +//! case builds a multi-file workspace, produces the call graph through the +//! three-layer layout, and asserts the expected `crate::…::Type::method` (or +//! free-fn) edges all exist. Split into focused sub-files (each ≤ the SRP +//! file-length cap); the `EdgeCase` table is partitioned and driven by +//! `run_edge_cases`. + +pub(super) use super::support::{build_workspace, callees_of, graph_3l, graph_contains_edge}; + +/// `(path, source)` file entries for a workspace fixture. +pub(super) type WsFiles = &'static [(&'static str, &'static str)]; +/// Receiver-tracing case: `(label, files, edges)` — every `(from, to)` edge +/// must exist in the call graph. +pub(super) type EdgeCase = ( + &'static str, + WsFiles, + &'static [(&'static str, &'static str)], +); + +mod part_a; +mod part_b; + +/// Build a workspace and its call graph under the three-layer layout. +pub(super) fn graph_3l_of( + files: WsFiles, +) -> crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::CallGraph { + graph_3l(&build_workspace(files)) +} + +/// Assert every `(from, to)` edge of each case exists. Shared by the +/// partitioned tables so neither part re-duplicates the loop body. +pub(super) fn run_edge_cases(cases: &[EdgeCase]) { + for (label, files, edges) in cases { + let graph = graph_3l_of(files); + for (from, to) in *edges { + assert!( + graph_contains_edge(&graph, from, to), + "case {label}: edge {from} → {to} missing; {from} callees: {:?}", + callees_of(&graph, from), + ); + } + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/receiver_tracing/part_a.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/receiver_tracing/part_a.rs new file mode 100644 index 00000000..52bbe7ce --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/receiver_tracing/part_a.rs @@ -0,0 +1,195 @@ +use super::*; + +const RECEIVER_EDGE_CASES_A: &[EdgeCase] = &[ + ( + // self.ensure_session()? then Session::open inside it — two hops + "self-method chain through a helper to an associated fn", + &[ + ( + "src/application/session.rs", + r#" + pub struct Session; + pub struct MyErr; + impl Session { + pub fn open(_p: &str) -> Result { todo!() } + } + "#, + ), + ( + "src/mcp/server.rs", + r#" + use crate::application::session::{Session, MyErr}; + + pub struct Server; + + impl Server { + pub(crate) fn ensure_session(&self) -> Result { + Session::open("/p") + } + } + + impl Server { + pub fn search(&self) -> Result<(), MyErr> { + self.ensure_session()?; + Ok(()) + } + } + "#, + ), + ], + &[ + ( + "crate::mcp::server::Server::search", + "crate::mcp::server::Server::ensure_session", + ), + ( + "crate::mcp::server::Server::ensure_session", + "crate::application::session::Session::open", + ), + ], + ), + ( + // same chain, but `pub async fn search` — async lowering must + // not break the edge + "async self-method chain traces the same edges", + &[ + ( + "src/application/session.rs", + r#" + pub struct Session; + pub struct MyErr; + impl Session { + pub fn open(_p: &str) -> Result { todo!() } + } + "#, + ), + ( + "src/mcp/server.rs", + r#" + use crate::application::session::{Session, MyErr}; + + pub struct Server; + + impl Server { + pub(crate) fn ensure_session(&self) -> Result { + Session::open("/p") + } + } + + impl Server { + pub async fn search(&self) -> Result<(), MyErr> { + self.ensure_session()?; + Ok(()) + } + } + "#, + ), + ], + &[ + ( + "crate::mcp::server::Server::search", + "crate::mcp::server::Server::ensure_session", + ), + ( + "crate::mcp::server::Server::ensure_session", + "crate::application::session::Session::open", + ), + ], + ), + ( + // `let session = open()?; session.X()` in both `if` branches + "locally-bound let receiver traces multiple method calls", + &[ + ( + "src/application/session.rs", + r#" + pub struct Session; + pub struct MyErr; + impl Session { + pub fn replace_preview(&self) {} + pub fn replace_apply(&self) {} + } + "#, + ), + ( + "src/cli/helpers.rs", + r#" + use crate::application::session::{Session, MyErr}; + pub fn open_session_in_cwd() -> Result { todo!() } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::cli::helpers::open_session_in_cwd; + use crate::application::session::MyErr; + + pub fn cmd_replace(preview: bool) -> Result<(), MyErr> { + let session = open_session_in_cwd()?; + if preview { + session.replace_preview(); + } else { + session.replace_apply(); + } + Ok(()) + } + "#, + ), + ], + &[ + ( + "crate::cli::handlers::cmd_replace", + "crate::application::session::Session::replace_preview", + ), + ( + "crate::cli::handlers::cmd_replace", + "crate::application::session::Session::replace_apply", + ), + ], + ), + ( + // `fn handle_replace(session: &Session, ...)` — param-typed receiver + "parameter-bound receiver traces multiple method calls", + &[ + ( + "src/application/session.rs", + r#" + pub struct Session; + impl Session { + pub fn replace_preview(&self) {} + pub fn replace_apply(&self) {} + } + "#, + ), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::session::Session; + + pub fn handle_replace(session: &Session, preview: bool) { + if preview { + session.replace_preview(); + } else { + session.replace_apply(); + } + } + "#, + ), + ], + &[ + ( + "crate::mcp::handlers::handle_replace", + "crate::application::session::Session::replace_preview", + ), + ( + "crate::mcp::handlers::handle_replace", + "crate::application::session::Session::replace_apply", + ), + ], + ), +]; + +#[test] +fn receiver_tracing_emits_expected_edges_part_a() { + run_edge_cases(RECEIVER_EDGE_CASES_A); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/receiver_tracing/part_b.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/receiver_tracing/part_b.rs new file mode 100644 index 00000000..8eae56a4 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/receiver_tracing/part_b.rs @@ -0,0 +1,120 @@ +use super::*; + +const RECEIVER_EDGE_CASES_B: &[EdgeCase] = &[ + ( + // path call inside a generic fn body + "generic-fn body traces a path call to a generic target", + &[ + ( + "src/application/savings.rs", + "pub fn record_file_op(_r: &T, _meta: &str) {}", + ), + ( + "src/application/middleware.rs", + r#" + use crate::application::savings; + + pub fn record_operation(meta: &str, result: &T) { + savings::record_file_op(result, meta); + } + "#, + ), + ], + &[( + "crate::application::middleware::record_operation", + "crate::application::savings::record_file_op", + )], + ), + ( + // path calls inside `match` arm bodies (one edge per arm) + "path calls inside generic match-arm bodies trace edges", + &[ + ( + "src/application/savings.rs", + r#" + pub fn record_file_op(_r: &T, _meta: &str) {} + pub fn record_symbol_op(_r: &T, _meta: &str) {} + "#, + ), + ( + "src/application/middleware.rs", + r#" + use crate::application::savings; + + pub enum AlternativeCost { SingleFile(String), SymbolFiles(String) } + + pub fn record_operation(meta: &str, result: &T, alt: &AlternativeCost) { + let _ = match alt { + AlternativeCost::SingleFile(p) => { + savings::record_file_op(result, p); + } + AlternativeCost::SymbolFiles(s) => { + savings::record_symbol_op(result, s); + } + }; + } + "#, + ), + ], + &[ + ( + "crate::application::middleware::record_operation", + "crate::application::savings::record_file_op", + ), + ( + "crate::application::middleware::record_operation", + "crate::application::savings::record_symbol_op", + ), + ], + ), + ( + // method bodies inside an `#[tool_router]`-decorated impl must + // still contribute edges (syn records unknown attrs verbatim) + "unknown attribute on an impl block does not hide inner calls", + &[ + ( + "src/application/session.rs", + r#" + pub struct Session; + pub struct MyErr; + impl Session { + pub fn open(_p: &str) -> Result { todo!() } + } + "#, + ), + ( + "src/mcp/server.rs", + r#" + use crate::application::session::{Session, MyErr}; + + pub struct Server; + pub struct Parameters(pub T); + pub struct SearchParams; + pub struct CallToolResult; + pub struct McpError; + + #[tool_router] + impl Server { + #[tool] + pub async fn search( + &self, + _params: Parameters, + ) -> Result { + let _session = Session::open("/p"); + todo!() + } + } + "#, + ), + ], + &[( + "crate::mcp::server::Server::search", + "crate::application::session::Session::open", + )], + ), +]; + +#[test] +fn receiver_tracing_emits_expected_edges_part_b() { + run_edge_cases(RECEIVER_EDGE_CASES_B); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/reexport_resolution.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/reexport_resolution.rs deleted file mode 100644 index f548d8f3..00000000 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/reexport_resolution.rs +++ /dev/null @@ -1,515 +0,0 @@ -//! Workspace-level tests for `pub use` re-export resolution. -//! -//! Mirrors the four external repros under `/mnt/d/KI/rustqual-repros/`: -//! -//! 1. `non_pub_helper_resolves` — Repro 01 (non-pub helper canonicalises). -//! Smoke-test that the v1.2.2 fix still holds. -//! 2. `pub_use_free_fn_resolves` — Repro 02 (`pub use foo::bar;` for a -//! free fn). Smoke-test that the v1.2.4 fix still holds. -//! 3. `pub_use_trait_dispatch_routes_to_decl` — Repro 03. `pub use -//! Trait;` + generic dispatch `Q::method()` / `q.method()`. The -//! dispatch edge must land on the trait's DECL canonical, matching -//! the anchor index built from `trait_methods` (DECL-keyed) so -//! `propagate_anchor_impls` fans out to the impls. The 2×2 matrix -//! (re-exported vs. direct path × `&self` vs. associated fn) is -//! exercised in one workspace; all four variants must resolve. -//! 4. `pub_use_struct_assoc_fn_routes_to_decl` — Repro 04. `pub use -//! Struct;` + `Struct::new()`. The associated-fn callee must land -//! on `crate::decl::Struct::new`, not the re-export path. - -use super::support::{ - build_graph_only, build_workspace, callees_of, cli_mcp_config, empty_cfg_test, - graph_contains_edge, run_check_b, three_layer, -}; -use std::collections::HashSet; - -#[test] -fn non_pub_helper_resolves_after_v122_fix() { - // Smoke-test mirroring repro `01-pass-non-pub-helper`: a non-pub - // helper in `application/` is called by a pub fn in the same - // module. The walker must canonicalise both and emit the edge. - let ws = build_workspace(&[ - ( - "src/lib.rs", - r#" - pub mod application; - pub mod cli; - "#, - ), - ( - "src/application/mod.rs", - r#" - pub fn dispatch() -> u32 { helper() } - fn helper() -> u32 { 42 } - "#, - ), - ( - "src/cli/mod.rs", - r#" - use crate::application::dispatch; - pub fn run() -> u32 { dispatch() } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - let dispatch = "crate::application::dispatch"; - let helper = "crate::application::helper"; - assert!( - graph_contains_edge(&graph, dispatch, helper), - "non-pub helper edge `{dispatch}` → `{helper}` must be \ - emitted. dispatch callees: {:?}", - callees_of(&graph, dispatch), - ); -} - -#[test] -fn pub_use_free_fn_resolves_after_v124_fix() { - // Smoke-test mirroring repro `02-pass-pub-use-free-fn`: a free fn - // re-exported via `pub use` is callable through the re-export path. - // The post-pass `rewrite_reexport_edges` already handles this since - // v1.2.4 (exact-match on free-fn callees). - let ws = build_workspace(&[ - ( - "src/lib.rs", - r#" - pub mod application; - pub mod cli; - "#, - ), - ( - "src/application/mod.rs", - r#" - pub mod helpers; - pub use helpers::record_op; - "#, - ), - ( - "src/application/helpers.rs", - r#" - pub fn record_op() -> u32 { 7 } - "#, - ), - ( - "src/cli/mod.rs", - r#" - use crate::application::record_op; - pub fn run() -> u32 { record_op() } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - let run = "crate::cli::run"; - let target = "crate::application::helpers::record_op"; - assert!( - graph_contains_edge(&graph, run, target), - "`pub use helpers::record_op;` must let `run` → `{target}` \ - resolve via the decl path, not the re-export path. \ - run callees: {:?}", - callees_of(&graph, run), - ); -} - -#[test] -fn pub_use_trait_dispatch_routes_to_decl() { - // Repro 03 — 2×2 matrix in one workspace: - // Axis 1: trait reached via `pub use` vs. via decl path. - // Axis 2: dispatch via `q.run()` (&self) vs. `Q::run()` (UFCS). - // - // All four dispatcher fns must produce an edge to the matching - // impl method, regardless of how the trait is named at the impl - // site or the dispatcher's bound. Today (pre-fix), variants A+B - // (re-export side) fail because dispatch edges land on - // `::run` while anchor index is keyed on - // `::run` — no fan-out. - let ws = build_workspace(&[ - ( - "src/lib.rs", - r#" - pub mod application; - "#, - ), - ( - "src/application/mod.rs", - r#" - pub mod reexport_self; - pub mod reexport_assoc; - pub mod direct_self; - pub mod direct_assoc; - pub mod impls; - pub mod dispatchers; - - // Re-export the two "reexport-side" traits — this is the - // bug-triggering shape. - pub use reexport_self::ReexportSelf; - pub use reexport_assoc::ReexportAssoc; - "#, - ), - ( - "src/application/reexport_self.rs", - r#" - pub trait ReexportSelf { - fn run(&self) -> u32; - } - "#, - ), - ( - "src/application/reexport_assoc.rs", - r#" - pub trait ReexportAssoc { - fn run() -> u32; - } - "#, - ), - ( - "src/application/direct_self.rs", - r#" - pub trait DirectSelf { - fn run(&self) -> u32; - } - "#, - ), - ( - "src/application/direct_assoc.rs", - r#" - pub trait DirectAssoc { - fn run() -> u32; - } - "#, - ), - ( - "src/application/impls.rs", - r#" - // Impl side: reach the trait through the re-export OR - // the decl path, matching each test variant. - use crate::application::direct_assoc::DirectAssoc; - use crate::application::direct_self::DirectSelf; - use crate::application::ReexportAssoc; - use crate::application::ReexportSelf; - - pub struct QueryA; - pub struct QueryB; - pub struct QueryC; - pub struct QueryD; - - impl ReexportSelf for QueryA { - fn run(&self) -> u32 { 1 } - } - impl ReexportAssoc for QueryB { - fn run() -> u32 { 2 } - } - impl DirectSelf for QueryC { - fn run(&self) -> u32 { 3 } - } - impl DirectAssoc for QueryD { - fn run() -> u32 { 4 } - } - "#, - ), - ( - "src/application/dispatchers.rs", - r#" - use crate::application::direct_assoc::DirectAssoc; - use crate::application::direct_self::DirectSelf; - use crate::application::ReexportAssoc; - use crate::application::ReexportSelf; - - pub fn dispatch_a(q: &Q) -> u32 { q.run() } - pub fn dispatch_b() -> u32 { Q::run() } - pub fn dispatch_c(q: &Q) -> u32 { q.run() } - pub fn dispatch_d() -> u32 { Q::run() } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - - // All four dispatchers must dispatch to their trait's DECL canonical - // (the anchor key). After fan-out the concrete impl method becomes - // reachable, but at the dispatch-edge level we assert against the - // trait-method anchor canonical. - let checks = [ - ( - "dispatch_a (re-export, &self)", - "crate::application::dispatchers::dispatch_a", - "crate::application::reexport_self::ReexportSelf::run", - ), - ( - "dispatch_b (re-export, assoc fn)", - "crate::application::dispatchers::dispatch_b", - "crate::application::reexport_assoc::ReexportAssoc::run", - ), - ( - "dispatch_c (decl path, &self)", - "crate::application::dispatchers::dispatch_c", - "crate::application::direct_self::DirectSelf::run", - ), - ( - "dispatch_d (decl path, assoc fn)", - "crate::application::dispatchers::dispatch_d", - "crate::application::direct_assoc::DirectAssoc::run", - ), - ]; - for (label, caller, target) in &checks { - assert!( - graph_contains_edge(&graph, caller, target), - "{label}: `{caller}` must emit a dispatch edge to the \ - trait's DECL canonical `{target}`. Today the re-export-side \ - variants land on `crate::application::ReexportSelf::run` \ - (re-export path), which doesn't match the anchor index. \ - caller callees: {:?}", - callees_of(&graph, caller), - ); - } -} - -#[test] -fn pub_fns_impl_self_type_resolves_through_reexport() { - // Codex P2 sister-site: the graph collector resolves `impl - // crate::application::Hidden { pub fn op() }` through the - // reexport map (gate sees `Hidden → private_mod::Hidden`), but - // the pub-fn surface collector (`pub_fns.rs:273`) was - // constructing its `CanonScope` with `reexports: None`. Result: - // the graph edge lands on `crate::application::private_mod::Hidden::op` - // (DECL) while pub-fn enumeration emits - // `crate::application::Hidden::op` (REEXPORT). Check B/D then - // produce a phantom "is not reached" finding because the - // enumerated pub-fn target doesn't match any graph callee. - // - // Test triggers the bug by putting the inherent impl in a SEPARATE - // file using an ABSOLUTE crate-path (which bypasses the file - // alias map and hits the bare `resolve_to_crate_absolute` branch - // → REEXPORT path without gate substitution). The check_b run - // must report zero findings after the fix. - let ws = build_workspace(&[ - ( - "src/lib.rs", - "pub mod application;\npub mod cli;\npub mod mcp;\n", - ), - ( - "src/application/mod.rs", - r#" - pub mod private_mod; - pub mod extras; - pub use private_mod::Hidden; - "#, - ), - ( - "src/application/private_mod.rs", - r#" - pub struct Hidden; - "#, - ), - ( - "src/application/extras.rs", - r#" - // Inherent impl on a re-exported type, written via the - // absolute crate path. This is the bug-trigger shape: - // without the gate's reexport substitution applied to - // BOTH the graph collector AND the pub_fns collector, - // they disagree on the canonical. - impl crate::application::Hidden { - pub fn op(&self) -> u32 { 42 } - } - "#, - ), - ( - "src/cli/mod.rs", - r#" - use crate::application::Hidden; - pub fn handle(h: &Hidden) -> u32 { Hidden::op(h) } - "#, - ), - ( - "src/mcp/mod.rs", - r#" - use crate::application::Hidden; - pub fn handle(h: &Hidden) -> u32 { Hidden::op(h) } - "#, - ), - ]); - let cp = cli_mcp_config(5); - let findings = run_check_b(&ws, &three_layer(), &cp, &empty_cfg_test()); - // The bug-triggering finding is on `Hidden::op` specifically: - // pub_fns enumerates it under the REEXPORT canonical, while the - // graph edges land on the DECL canonical, so Check B reports it - // as unreached. After the fix, no findings on Hidden::op at all. - let bug_findings: Vec<_> = findings - .iter() - .filter(|f| format!("{f:?}").contains("Hidden::op")) - .collect(); - assert!( - bug_findings.is_empty(), - "`impl crate::application::Hidden {{ pub fn op() }}` (absolute \ - path on a re-exported type) must produce a pub-fn canonical \ - that matches the graph edge — both go through the same \ - reexport-aware gate. Otherwise Check B reports phantom \ - missing-adapter findings on Hidden::op. bug findings: {bug_findings:?}", - ); -} - -#[test] -#[ignore = "Known limitation v1.2.5 — namespace-aware canonicals land in \ - WorkspaceCanonical migration (docs/plan-workspace-canonical-newtype.md). \ - Same-name type+value pub-use collides on both the file-level alias_map \ - (HashMap, last-write-wins) AND the workspace \ - reexport map (HashMap, last-write-wins). Codex P2 \ - reproducer kept here as regression target for the upcoming migration."] -fn value_reexport_does_not_hijack_trait_bound() { - // Codex P2 reproducer (kept as ignored regression target): - // - // mod handler_trait { pub trait Handler { fn handle(&self) -> u32; } } - // mod handler_fn { pub fn Handler() -> u32 { 1 } } - // pub use handler_trait::Handler; // TYPE re-export - // pub use handler_fn::Handler; // VALUE re-export — same visible name - // - // This is valid Rust because type and value namespaces are - // separate; the compiler resolves `Q: Handler` to the TRAIT - // because the bound position is a type-context. rustqual loses - // that context the moment it inserts both entries into a - // namespace-blind `HashMap` — last write wins, so the - // VALUE entry ends up as the resolved canonical and the trait - // bound silently dispatches to a function path. - // - // The full fix requires namespace-aware canonicals at two - // layers: - // 1. file-level `AliasMap`: needs `Vec` per name - // (or namespace-classified entries) so same-name type+value - // `use` items don't overwrite each other. - // 2. workspace `ReexportMap`: same — split into `type_ns` and - // `value_ns` maps with namespace classification at the - // `pub use`-leaf collection site. - // 3. `CanonScope`: gains a `namespace: Namespace` field set - // by the caller (Type for trait bounds / impl self-types, - // Value for call expressions). - // - // Both layers are converging in the planned - // `WorkspaceCanonical { path, namespace }` newtype: the gate is - // the sole constructor and produces canonicals that carry their - // namespace at the type level, so the entire bug class becomes - // compile-time impossible. - // - // See `docs/plan-workspace-canonical-newtype.md` Phase 1 for the - // structural fix. Unignore this test once that lands. - let ws = build_workspace(&[ - ("src/lib.rs", "pub mod application;\npub mod cli;\n"), - ( - "src/application/mod.rs", - r#" - pub mod handler_trait; - pub mod handler_fn; - pub mod impl_a; - - // Codex's reproducer: two `pub use ... Handler` items - // collide on the same string key but live in different - // Rust namespaces (TYPE + VALUE). - pub use handler_trait::Handler; - pub use handler_fn::Handler; - - pub fn dispatch(q: &Q) -> u32 { q.handle() } - "#, - ), - ( - "src/application/handler_trait.rs", - r#" - pub trait Handler { - fn handle(&self) -> u32; - } - "#, - ), - ( - "src/application/handler_fn.rs", - r#" - #[allow(non_snake_case)] - pub fn Handler() -> u32 { 1 } - "#, - ), - ( - "src/application/impl_a.rs", - r#" - use crate::application::Handler; - pub struct QueryA; - impl Handler for QueryA { - fn handle(&self) -> u32 { 7 } - } - "#, - ), - ( - "src/cli/mod.rs", - r#" - use crate::application::{dispatch, impl_a::QueryA}; - pub fn run(q: &QueryA) -> u32 { dispatch(q) } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - let dispatch_canonical = "crate::application::dispatch"; - let trait_method = "crate::application::handler_trait::Handler::handle"; - assert!( - graph_contains_edge(&graph, dispatch_canonical, trait_method), - "`Q: Handler` trait-bound dispatch must resolve to the \ - trait's DECL canonical `{trait_method}`. A value-side \ - re-export in the same map must NOT hijack the type-context \ - resolution. dispatch callees: {:?}", - callees_of(&graph, dispatch_canonical), - ); -} - -#[test] -fn pub_use_struct_assoc_fn_routes_to_decl() { - // Repro 04: `pub use Struct;` + `Struct::new()`. The associated-fn - // callee must land on the struct's DECL canonical, matching the - // inherent-impl entry registered in the type index. Today the - // callee carries the re-export path and the inherent-impl lookup - // misses — `Struct::new` is reported as unreached. - let ws = build_workspace(&[ - ( - "src/lib.rs", - r#" - pub mod application; - pub mod cli; - "#, - ), - ( - "src/application/mod.rs", - r#" - pub mod response; - pub mod consumer; - pub use response::OperationResponse; - "#, - ), - ( - "src/application/response.rs", - r#" - pub struct OperationResponse { pub body: String } - impl OperationResponse { - pub fn new(body: String) -> Self { Self { body } } - } - "#, - ), - ( - "src/application/consumer.rs", - r#" - use super::OperationResponse; - pub fn record_op() -> OperationResponse { - OperationResponse::new("ok".to_string()) - } - "#, - ), - ( - "src/cli/mod.rs", - r#" - use crate::application::consumer::record_op; - pub fn run() -> String { record_op().body } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - let record_op = "crate::application::consumer::record_op"; - let target = "crate::application::response::OperationResponse::new"; - assert!( - graph_contains_edge(&graph, record_op, target), - "`OperationResponse::new()` called via the `pub use`-imported \ - alias must resolve to the DECL canonical `{target}`, not the \ - re-export-rooted path. record_op callees: {:?}", - callees_of(&graph, record_op), - ); -} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/reexport_resolution/basic_and_trait_dispatch.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/reexport_resolution/basic_and_trait_dispatch.rs new file mode 100644 index 00000000..a77098a6 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/reexport_resolution/basic_and_trait_dispatch.rs @@ -0,0 +1,235 @@ +use super::*; + +#[test] +fn non_pub_helper_resolves_after_v122_fix() { + // Smoke-test mirroring repro `01-pass-non-pub-helper`: a non-pub + // helper in `application/` is called by a pub fn in the same + // module. The walker must canonicalise both and emit the edge. + let ws = build_workspace(&[ + ( + "src/lib.rs", + r#" + pub mod application; + pub mod cli; + "#, + ), + ( + "src/application/mod.rs", + r#" + pub fn dispatch() -> u32 { helper() } + fn helper() -> u32 { 42 } + "#, + ), + ( + "src/cli/mod.rs", + r#" + use crate::application::dispatch; + pub fn run() -> u32 { dispatch() } + "#, + ), + ]); + let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); + let dispatch = "crate::application::dispatch"; + let helper = "crate::application::helper"; + assert!( + graph_contains_edge(&graph, dispatch, helper), + "non-pub helper edge `{dispatch}` → `{helper}` must be \ + emitted. dispatch callees: {:?}", + callees_of(&graph, dispatch), + ); +} + +#[test] +fn pub_use_free_fn_resolves_after_v124_fix() { + // Smoke-test mirroring repro `02-pass-pub-use-free-fn`: a free fn + // re-exported via `pub use` is callable through the re-export path. + // The post-pass `rewrite_reexport_edges` already handles this since + // v1.2.4 (exact-match on free-fn callees). + let ws = build_workspace(&[ + ( + "src/lib.rs", + r#" + pub mod application; + pub mod cli; + "#, + ), + ( + "src/application/mod.rs", + r#" + pub mod helpers; + pub use helpers::record_op; + "#, + ), + ( + "src/application/helpers.rs", + r#" + pub fn record_op() -> u32 { 7 } + "#, + ), + ( + "src/cli/mod.rs", + r#" + use crate::application::record_op; + pub fn run() -> u32 { record_op() } + "#, + ), + ]); + let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); + let run = "crate::cli::run"; + let target = "crate::application::helpers::record_op"; + assert!( + graph_contains_edge(&graph, run, target), + "`pub use helpers::record_op;` must let `run` → `{target}` \ + resolve via the decl path, not the re-export path. \ + run callees: {:?}", + callees_of(&graph, run), + ); +} + +// Repro-03 workspace — a 2×2 matrix: a trait reached via `pub use` vs. the decl +// path × dispatch via `q.run()` (&self) vs. `Q::run()` (UFCS). All four +// dispatchers must edge to the trait's DECL canonical (the anchor key); pre-fix +// the re-export-side variants landed on `::run` and missed the anchor. +const PUB_USE_DISPATCH_WS: &[(&str, &str)] = &[ + ( + "src/lib.rs", + r#" + pub mod application; + "#, + ), + ( + "src/application/mod.rs", + r#" + pub mod reexport_self; + pub mod reexport_assoc; + pub mod direct_self; + pub mod direct_assoc; + pub mod impls; + pub mod dispatchers; + + // Re-export the two "reexport-side" traits — this is the + // bug-triggering shape. + pub use reexport_self::ReexportSelf; + pub use reexport_assoc::ReexportAssoc; + "#, + ), + ( + "src/application/reexport_self.rs", + r#" + pub trait ReexportSelf { + fn run(&self) -> u32; + } + "#, + ), + ( + "src/application/reexport_assoc.rs", + r#" + pub trait ReexportAssoc { + fn run() -> u32; + } + "#, + ), + ( + "src/application/direct_self.rs", + r#" + pub trait DirectSelf { + fn run(&self) -> u32; + } + "#, + ), + ( + "src/application/direct_assoc.rs", + r#" + pub trait DirectAssoc { + fn run() -> u32; + } + "#, + ), + ( + "src/application/impls.rs", + r#" + // Impl side: reach the trait through the re-export OR + // the decl path, matching each test variant. + use crate::application::direct_assoc::DirectAssoc; + use crate::application::direct_self::DirectSelf; + use crate::application::ReexportAssoc; + use crate::application::ReexportSelf; + + pub struct QueryA; + pub struct QueryB; + pub struct QueryC; + pub struct QueryD; + + impl ReexportSelf for QueryA { + fn run(&self) -> u32 { 1 } + } + impl ReexportAssoc for QueryB { + fn run() -> u32 { 2 } + } + impl DirectSelf for QueryC { + fn run(&self) -> u32 { 3 } + } + impl DirectAssoc for QueryD { + fn run() -> u32 { 4 } + } + "#, + ), + ( + "src/application/dispatchers.rs", + r#" + use crate::application::direct_assoc::DirectAssoc; + use crate::application::direct_self::DirectSelf; + use crate::application::ReexportAssoc; + use crate::application::ReexportSelf; + + pub fn dispatch_a(q: &Q) -> u32 { q.run() } + pub fn dispatch_b() -> u32 { Q::run() } + pub fn dispatch_c(q: &Q) -> u32 { q.run() } + pub fn dispatch_d() -> u32 { Q::run() } + "#, + ), +]; + +#[test] +fn pub_use_trait_dispatch_routes_to_decl() { + let ws = build_workspace(PUB_USE_DISPATCH_WS); + let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); + + // All four dispatchers must dispatch to their trait's DECL canonical + // (the anchor key). After fan-out the concrete impl method becomes + // reachable, but at the dispatch-edge level we assert against the + // trait-method anchor canonical. + let checks = [ + ( + "dispatch_a (re-export, &self)", + "crate::application::dispatchers::dispatch_a", + "crate::application::reexport_self::ReexportSelf::run", + ), + ( + "dispatch_b (re-export, assoc fn)", + "crate::application::dispatchers::dispatch_b", + "crate::application::reexport_assoc::ReexportAssoc::run", + ), + ( + "dispatch_c (decl path, &self)", + "crate::application::dispatchers::dispatch_c", + "crate::application::direct_self::DirectSelf::run", + ), + ( + "dispatch_d (decl path, assoc fn)", + "crate::application::dispatchers::dispatch_d", + "crate::application::direct_assoc::DirectAssoc::run", + ), + ]; + for (label, caller, target) in &checks { + assert!( + graph_contains_edge(&graph, caller, target), + "{label}: `{caller}` must emit a dispatch edge to the \ + trait's DECL canonical `{target}`. Today the re-export-side \ + variants land on `crate::application::ReexportSelf::run` \ + (re-export path), which doesn't match the anchor index. \ + caller callees: {:?}", + callees_of(&graph, caller), + ); + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/reexport_resolution/impl_and_value_reexport.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/reexport_resolution/impl_and_value_reexport.rs new file mode 100644 index 00000000..c448c36f --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/reexport_resolution/impl_and_value_reexport.rs @@ -0,0 +1,254 @@ +use super::*; + +// Codex P2 sister-site workspace: the graph collector resolves `impl +// crate::application::Hidden { pub fn op() }` through the reexport map, but the +// pub-fn surface collector built its `CanonScope` with `reexports: None` — so the +// graph edge landed on the DECL canonical while pub-fn enumeration used the +// REEXPORT canonical, and Check B/D produced a phantom "not reached" finding. The +// inherent impl lives in a SEPARATE file via an ABSOLUTE crate-path (bypasses the +// file alias map → bare `resolve_to_crate_absolute` → REEXPORT path). After the +// fix, check_b reports zero findings on `Hidden::op`. +const IMPL_SELF_TYPE_WS: &[(&str, &str)] = &[ + ( + "src/lib.rs", + "pub mod application;\npub mod cli;\npub mod mcp;\n", + ), + ( + "src/application/mod.rs", + r#" + pub mod private_mod; + pub mod extras; + pub use private_mod::Hidden; + "#, + ), + ( + "src/application/private_mod.rs", + r#" + pub struct Hidden; + "#, + ), + ( + "src/application/extras.rs", + r#" + // Inherent impl on a re-exported type, written via the + // absolute crate path. This is the bug-trigger shape: + // without the gate's reexport substitution applied to + // BOTH the graph collector AND the pub_fns collector, + // they disagree on the canonical. + impl crate::application::Hidden { + pub fn op(&self) -> u32 { 42 } + } + "#, + ), + ( + "src/cli/mod.rs", + r#" + use crate::application::Hidden; + pub fn handle(h: &Hidden) -> u32 { Hidden::op(h) } + "#, + ), + ( + "src/mcp/mod.rs", + r#" + use crate::application::Hidden; + pub fn handle(h: &Hidden) -> u32 { Hidden::op(h) } + "#, + ), +]; + +#[test] +fn pub_fns_impl_self_type_resolves_through_reexport() { + let ws = build_workspace(IMPL_SELF_TYPE_WS); + let cp = cli_mcp_config(5); + let findings = run_check_b(&ws, &three_layer(), &cp, &empty_cfg_test()); + // The bug-triggering finding is on `Hidden::op` specifically: + // pub_fns enumerates it under the REEXPORT canonical, while the + // graph edges land on the DECL canonical, so Check B reports it + // as unreached. After the fix, no findings on Hidden::op at all. + let bug_findings: Vec<_> = findings + .iter() + .filter(|f| format!("{f:?}").contains("Hidden::op")) + .collect(); + assert!( + bug_findings.is_empty(), + "`impl crate::application::Hidden {{ pub fn op() }}` (absolute \ + path on a re-exported type) must produce a pub-fn canonical \ + that matches the graph edge — both go through the same \ + reexport-aware gate. Otherwise Check B reports phantom \ + missing-adapter findings on Hidden::op. bug findings: {bug_findings:?}", + ); +} + +#[test] +#[ignore = "Known limitation v1.2.5 — namespace-aware canonicals land in \ + WorkspaceCanonical migration (docs/plan-workspace-canonical-newtype.md). \ + Same-name type+value pub-use collides on both the file-level alias_map \ + (HashMap, last-write-wins) AND the workspace \ + reexport map (HashMap, last-write-wins). Codex P2 \ + reproducer kept here as regression target for the upcoming migration."] +fn value_reexport_does_not_hijack_trait_bound() { + // Codex P2 reproducer (kept as ignored regression target): + // + // mod handler_trait { pub trait Handler { fn handle(&self) -> u32; } } + // mod handler_fn { pub fn Handler() -> u32 { 1 } } + // pub use handler_trait::Handler; // TYPE re-export + // pub use handler_fn::Handler; // VALUE re-export — same visible name + // + // This is valid Rust because type and value namespaces are + // separate; the compiler resolves `Q: Handler` to the TRAIT + // because the bound position is a type-context. rustqual loses + // that context the moment it inserts both entries into a + // namespace-blind `HashMap` — last write wins, so the + // VALUE entry ends up as the resolved canonical and the trait + // bound silently dispatches to a function path. + // + // The full fix requires namespace-aware canonicals at two + // layers: + // 1. file-level `AliasMap`: needs `Vec` per name + // (or namespace-classified entries) so same-name type+value + // `use` items don't overwrite each other. + // 2. workspace `ReexportMap`: same — split into `type_ns` and + // `value_ns` maps with namespace classification at the + // `pub use`-leaf collection site. + // 3. `CanonScope`: gains a `namespace: Namespace` field set + // by the caller (Type for trait bounds / impl self-types, + // Value for call expressions). + // + // Both layers are converging in the planned + // `WorkspaceCanonical { path, namespace }` newtype: the gate is + // the sole constructor and produces canonicals that carry their + // namespace at the type level, so the entire bug class becomes + // compile-time impossible. + // + // See `docs/plan-workspace-canonical-newtype.md` Phase 1 for the + // structural fix. Unignore this test once that lands. + let ws = build_workspace(VALUE_REEXPORT_WS); + let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); + let dispatch_canonical = "crate::application::dispatch"; + let trait_method = "crate::application::handler_trait::Handler::handle"; + assert!( + graph_contains_edge(&graph, dispatch_canonical, trait_method), + "`Q: Handler` trait-bound dispatch must resolve to the \ + trait's DECL canonical `{trait_method}`. A value-side \ + re-export in the same map must NOT hijack the type-context \ + resolution. dispatch callees: {:?}", + callees_of(&graph, dispatch_canonical), + ); +} + +// Codex P2 reproducer workspace: a TYPE re-export (`pub use handler_trait::Handler`) +// and a VALUE re-export (`pub use handler_fn::Handler`) collide on the same visible +// name in different Rust namespaces; `Q: Handler` (type-context) must still resolve +// to the trait DECL canonical, not the value-side function path. +const VALUE_REEXPORT_WS: &[(&str, &str)] = &[ + ("src/lib.rs", "pub mod application;\npub mod cli;\n"), + ( + "src/application/mod.rs", + r#" + pub mod handler_trait; + pub mod handler_fn; + pub mod impl_a; + + // Codex's reproducer: two `pub use ... Handler` items + // collide on the same string key but live in different + // Rust namespaces (TYPE + VALUE). + pub use handler_trait::Handler; + pub use handler_fn::Handler; + + pub fn dispatch(q: &Q) -> u32 { q.handle() } + "#, + ), + ( + "src/application/handler_trait.rs", + r#" + pub trait Handler { + fn handle(&self) -> u32; + } + "#, + ), + ( + "src/application/handler_fn.rs", + r#" + #[allow(non_snake_case)] + pub fn Handler() -> u32 { 1 } + "#, + ), + ( + "src/application/impl_a.rs", + r#" + use crate::application::Handler; + pub struct QueryA; + impl Handler for QueryA { + fn handle(&self) -> u32 { 7 } + } + "#, + ), + ( + "src/cli/mod.rs", + r#" + use crate::application::{dispatch, impl_a::QueryA}; + pub fn run(q: &QueryA) -> u32 { dispatch(q) } + "#, + ), +]; + +#[test] +fn pub_use_struct_assoc_fn_routes_to_decl() { + // Repro 04: `pub use Struct;` + `Struct::new()`. The associated-fn + // callee must land on the struct's DECL canonical, matching the + // inherent-impl entry registered in the type index. Today the + // callee carries the re-export path and the inherent-impl lookup + // misses — `Struct::new` is reported as unreached. + let ws = build_workspace(&[ + ( + "src/lib.rs", + r#" + pub mod application; + pub mod cli; + "#, + ), + ( + "src/application/mod.rs", + r#" + pub mod response; + pub mod consumer; + pub use response::OperationResponse; + "#, + ), + ( + "src/application/response.rs", + r#" + pub struct OperationResponse { pub body: String } + impl OperationResponse { + pub fn new(body: String) -> Self { Self { body } } + } + "#, + ), + ( + "src/application/consumer.rs", + r#" + use super::OperationResponse; + pub fn record_op() -> OperationResponse { + OperationResponse::new("ok".to_string()) + } + "#, + ), + ( + "src/cli/mod.rs", + r#" + use crate::application::consumer::record_op; + pub fn run() -> String { record_op().body } + "#, + ), + ]); + let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); + let record_op = "crate::application::consumer::record_op"; + let target = "crate::application::response::OperationResponse::new"; + assert!( + graph_contains_edge(&graph, record_op, target), + "`OperationResponse::new()` called via the `pub use`-imported \ + alias must resolve to the DECL canonical `{target}`, not the \ + re-export-rooted path. record_op callees: {:?}", + callees_of(&graph, record_op), + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/reexport_resolution/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/reexport_resolution/mod.rs new file mode 100644 index 00000000..ad7a486a --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/reexport_resolution/mod.rs @@ -0,0 +1,16 @@ +//! Workspace-level tests for `pub use` re-export resolution. Mirrors the +//! external repros: non-pub helper canonicalisation (v1.2.2), `pub use` of a +//! free fn (v1.2.4), `pub use Trait;` + generic dispatch routing to the trait +//! DECL canonical, impl-Self-type resolution through re-export, value-reexport +//! trait-bound guard, and `pub use Struct;` associated-fn routing. Split into +//! focused sub-files (each ≤ the SRP file-length cap); shared imports reach the +//! sub-modules via `use super::*`. + +pub(super) use super::support::{ + build_graph_only, build_workspace, callees_of, cli_mcp_config, empty_cfg_test, + graph_contains_edge, run_check_b, three_layer, +}; +pub(super) use std::collections::HashSet; + +mod basic_and_trait_dispatch; +mod impl_and_value_reexport; diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions.rs deleted file mode 100644 index 64e6176f..00000000 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions.rs +++ /dev/null @@ -1,1305 +0,0 @@ -//! Regression harness for call-parity receiver-type inference at the -//! `collect_canonical_calls` level. -//! -//! Each test sets up a workspace type-index with a `Session` type -//! (`open()`/`diff()`/… methods) and a `Ctx` struct carrying a -//! `session` field, then runs a minimal fn body through -//! `collect_canonical_calls`. Positive tests assert the expected -//! `crate::…::Type::method` edge appears in the output; negative -//! tests assert that documented limits correctly fall back to -//! `:name` instead of producing a spurious edge. -//! -//! Coverage targets two pattern families: method-chain constructors -//! (`Type::ctor().chain()?.method()`) and cascading struct-field -//! access (`self.field.method()`), plus the fast-path patterns that -//! must stay green. - -use crate::adapters::analyzers::architecture::call_parity_rule::calls::{ - collect_canonical_calls, FnContext, -}; -use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; -use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::{ - CanonicalType, WorkspaceTypeIndex, -}; -use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::collect_local_symbols; -use crate::adapters::shared::use_tree::{ - gather_alias_map, gather_alias_map_scoped, AliasMap, ScopedAliasMap, -}; -use std::collections::{HashMap, HashSet}; - -const SESSION_PATH: &str = "crate::app::session::Session"; -const CTX_PATH: &str = "crate::app::Ctx"; - -/// RegFixture bundling a parsed file plus the resolution inputs -/// (`alias_map`, `local_symbols`, `crate_root_modules`) that -/// `collect_canonical_calls` expects. -struct RegFixture { - file: syn::File, - alias_map: AliasMap, - local_symbols: HashSet, - crate_roots: HashSet, -} - -fn parse(src: &str) -> RegFixture { - let file: syn::File = syn::parse_str(src).expect("parse fixture"); - let alias_map = gather_alias_map(&file); - let local_symbols = collect_local_symbols(&file); - RegFixture { - file, - alias_map, - local_symbols, - crate_roots: HashSet::new(), - } -} - -/// Pre-populated workspace index modelling a Session + Ctx shape. -fn sample_session_index() -> WorkspaceTypeIndex { - let session = CanonicalType::path(["crate", "app", "session", "Session"]); - let response = CanonicalType::path(["crate", "app", "Response"]); - let error = CanonicalType::path(["crate", "app", "Error"]); - let mut index = WorkspaceTypeIndex::new(); - // Session::open() -> Result - index.insert_method_return( - SESSION_PATH, - "open", - CanonicalType::Result(Box::new(session.clone())), - ); - // Session::open_cwd() -> Result - index.insert_method_return( - SESSION_PATH, - "open_cwd", - CanonicalType::Result(Box::new(session.clone())), - ); - // Session::diff() -> Response - index.insert_method_return(SESSION_PATH, "diff", response.clone()); - // Session::files() -> Response - index.insert_method_return(SESSION_PATH, "files", response.clone()); - // Session::insert() -> Result - index.insert_method_return( - SESSION_PATH, - "insert", - CanonicalType::Result(Box::new(response.clone())), - ); - // Ctx { session: Session } - index.insert_struct_field(CTX_PATH, "session", session); - // Free fn make_session() -> Result - index.fn_returns.insert( - "crate::app::make_session".to_string(), - CanonicalType::Result(Box::new(CanonicalType::path([ - "crate", "app", "session", "Session", - ]))), - ); - let _ = error; // keep in scope if extensions need it - index -} - -fn find_fn<'a>(file: &'a syn::File, name: &str) -> &'a syn::ItemFn { - file.items - .iter() - .find_map(|item| match item { - syn::Item::Fn(f) if f.sig.ident == name => Some(f), - _ => None, - }) - .unwrap_or_else(|| panic!("fn {name} not in fixture")) -} - -fn sig_params(sig: &syn::Signature) -> Vec<(String, &syn::Type)> { - sig.inputs - .iter() - .filter_map(|arg| match arg { - syn::FnArg::Typed(pt) => match pt.pat.as_ref() { - syn::Pat::Ident(pi) => Some((pi.ident.to_string(), pt.ty.as_ref())), - _ => None, - }, - _ => None, - }) - .collect() -} - -/// Run the fn body through `collect_canonical_calls` with the given -/// workspace index. Returns the set of canonical call targets. -fn run(fx: &RegFixture, index: &WorkspaceTypeIndex, fn_name: &str) -> HashSet { - let f = find_fn(&fx.file, fn_name); - run_with_self(fx, index, &f.sig, &f.block, None) -} - -/// Run an `impl Type { fn name(&self, …) { … } }` body through the -/// collector with `self_type` set to crate-rooted segments. The -/// caller passes the canonical path so the test can bind to whichever -/// module the workspace index models for `Type` (e.g. Session lives -/// under `crate::app::session::*` in `sample_session_index()`). -fn run_impl_method( - fx: &RegFixture, - index: &WorkspaceTypeIndex, - type_name: &str, - fn_name: &str, - self_segs: Vec, -) -> HashSet { - let (_, f) = find_impl_method(&fx.file, type_name, fn_name); - run_with_self(fx, index, &f.sig, &f.block, Some(self_segs)) -} - -fn run_with_self( - fx: &RegFixture, - index: &WorkspaceTypeIndex, - sig: &syn::Signature, - body: &syn::Block, - self_type: Option>, -) -> HashSet { - let ctx = FnContext { - file: &FileScope { - path: "src/cli/handlers.rs", - alias_map: &fx.alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &fx.local_symbols, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &fx.crate_roots, - workspace_module_paths: None, - }, - mod_stack: &[], - body, - signature_params: sig_params(sig), - generic_params: std::collections::HashMap::new(), - self_type, - workspace_index: Some(index), - workspace_files: None, - reexports: None, - }; - collect_canonical_calls(&ctx) -} - -fn find_impl_method<'a>( - file: &'a syn::File, - type_name: &str, - fn_name: &str, -) -> (Vec, &'a syn::ImplItemFn) { - file.items - .iter() - .filter_map(|item| match item { - syn::Item::Impl(i) => Some(i), - _ => None, - }) - .find_map(|item_impl| { - let segs = impl_self_segments(item_impl)?; - if segs.last().map(String::as_str) != Some(type_name) { - return None; - } - item_impl.items.iter().find_map(|it| match it { - syn::ImplItem::Fn(f) if f.sig.ident == fn_name => Some((segs.clone(), f)), - _ => None, - }) - }) - .unwrap_or_else(|| panic!("impl {type_name}::{fn_name} not in fixture")) -} - -fn impl_self_segments(item: &syn::ItemImpl) -> Option> { - let syn::Type::Path(p) = item.self_ty.as_ref() else { - return None; - }; - Some( - p.path - .segments - .iter() - .map(|s| s.ident.to_string()) - .collect(), - ) -} - -// ═══════════════════════════════════════════════════════════════════ -// Positive: method-chain constructor patterns -// ═══════════════════════════════════════════════════════════════════ - -#[test] -fn method_chain_ctor_open_map_err_unwrap_resolves_receiver() { - let fx = parse( - r#" - use crate::app::session::Session; - pub fn cmd() { - let s = Session::open().map_err(handle).unwrap(); - s.diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "cmd"); - assert!( - calls.contains("crate::app::session::Session::diff"), - "expected Session::diff edge, got {calls:?}" - ); -} - -#[test] -fn method_chain_ctor_open_cwd_map_err_try_resolves_receiver() { - // The exact pattern that motivated this inference work: - // `let session = open_cwd().map_err(f)?` then `session.method()`. - let fx = parse( - r#" - use crate::app::session::Session; - pub fn cmd() { - let s = Session::open_cwd().map_err(map_err)?; - s.diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "cmd"); - assert!( - calls.contains("crate::app::session::Session::diff"), - "expected Session::diff edge, got {calls:?}" - ); -} - -#[test] -fn method_chain_ctor_plain_unwrap_resolves_receiver() { - let fx = parse( - r#" - use crate::app::session::Session; - pub fn cmd() { - let s = Session::open().unwrap(); - s.files(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "cmd"); - assert!(calls.contains("crate::app::session::Session::files")); -} - -#[test] -fn method_chain_ctor_expect_message_resolves_receiver() { - let fx = parse( - r#" - use crate::app::session::Session; - pub fn cmd() { - let s = Session::open().expect("session must open"); - s.diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "cmd"); - assert!(calls.contains("crate::app::session::Session::diff")); -} - -#[test] -fn method_chain_ctor_unwrap_or_else_closure_resolves_receiver() { - let fx = parse( - r#" - use crate::app::session::Session; - pub fn cmd() { - let s = Session::open().unwrap_or_else(|e| fallback(e)); - s.diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "cmd"); - assert!(calls.contains("crate::app::session::Session::diff")); -} - -#[test] -fn method_chain_ctor_chained_inline_call_resolves_receiver() { - // No intermediate `let` — the chain resolves inside a single - // method-call expression. - let fx = parse( - r#" - use crate::app::session::Session; - pub fn cmd() { - Session::open().unwrap().diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "cmd"); - assert!(calls.contains("crate::app::session::Session::diff")); -} - -#[test] -fn method_chain_ctor_insert_returning_result_chained_resolves_receiver() { - // Session::insert returns Result — verify the outer - // call edge is recorded even on a Result-wrapped receiver chain. - let fx = parse( - r#" - use crate::app::session::Session; - pub fn cmd() { - Session::open().unwrap().insert(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "cmd"); - assert!(calls.contains("crate::app::session::Session::insert")); -} - -// ═══════════════════════════════════════════════════════════════════ -// Positive: cascading struct-field access patterns -// ═══════════════════════════════════════════════════════════════════ - -#[test] -fn cascading_struct_field_access_resolves_receiver() { - let fx = parse( - r#" - use crate::app::Ctx; - pub fn handle(ctx: &Ctx) { - ctx.session.diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "handle"); - assert!(calls.contains("crate::app::session::Session::diff")); -} - -#[test] -fn cascading_struct_field_access_via_let_binding_resolves_receiver() { - let fx = parse( - r#" - use crate::app::Ctx; - pub fn handle(ctx: &Ctx) { - let s = &ctx.session; - s.diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "handle"); - // `&ctx.session` inferred as Session (Reference is transparent). - assert!(calls.contains("crate::app::session::Session::diff")); -} - -// ═══════════════════════════════════════════════════════════════════ -// Positive: self receiver inside impl methods -// ═══════════════════════════════════════════════════════════════════ - -#[test] -fn self_method_call_resolves_via_impl_type() { - // `impl Session { fn run(&self) { self.diff() } }` — `self` must - // bind to the enclosing impl's canonical type so `self.diff()` - // routes through `method_returns[Session::diff]` instead of - // collapsing to `:diff`. - let fx = parse( - r#" - impl Session { - pub fn run(&self) { - self.diff(); - } - } - "#, - ); - let self_segs = vec![ - "crate".to_string(), - "app".to_string(), - "session".to_string(), - "Session".to_string(), - ]; - let calls = run_impl_method(&fx, &sample_session_index(), "Session", "run", self_segs); - assert!( - calls.contains("crate::app::session::Session::diff"), - "self.diff() must route through workspace_index, got {calls:?}" - ); -} - -#[test] -fn self_field_access_resolves_via_impl_type() { - // `self.session.diff()` — Self::session field, then Session::diff. - // Needs both the Self → Ctx binding and the field-type lookup - // chain to fire. - let fx = parse( - r#" - impl Ctx { - pub fn run(&self) { - self.session.diff(); - } - } - "#, - ); - let self_segs = vec!["crate".to_string(), "app".to_string(), "Ctx".to_string()]; - let calls = run_impl_method(&fx, &sample_session_index(), "Ctx", "run", self_segs); - assert!( - calls.contains("crate::app::session::Session::diff"), - "self.session.diff() must chain through field type, got {calls:?}" - ); -} - -#[test] -fn signature_param_typed_self_resolves() { - // `fn merge(&self, other: Self)` inside `impl Session` — `other` - // is declared as `Self`, must bind to `Session` so `other.diff()` - // routes through `method_returns`. - let fx = parse( - r#" - impl Session { - pub fn merge(&self, other: Self) { - other.diff(); - } - } - "#, - ); - let self_segs = vec![ - "crate".to_string(), - "app".to_string(), - "session".to_string(), - "Session".to_string(), - ]; - let calls = run_impl_method(&fx, &sample_session_index(), "Session", "merge", self_segs); - assert!( - calls.contains("crate::app::session::Session::diff"), - "param `other: Self` must resolve to Session, got {calls:?}" - ); -} - -#[test] -fn let_annotation_self_resolves() { - // `let other: Self = make();` inside `impl Session` — annotation - // must substitute Self before resolving. - let fx = parse( - r#" - impl Session { - pub fn run(&self) { - let other: Self = make(); - other.diff(); - } - } - "#, - ); - let self_segs = vec![ - "crate".to_string(), - "app".to_string(), - "session".to_string(), - "Session".to_string(), - ]; - let calls = run_impl_method(&fx, &sample_session_index(), "Session", "run", self_segs); - assert!( - calls.contains("crate::app::session::Session::diff"), - "`let other: Self = …` must bind to Session, got {calls:?}" - ); -} - -#[test] -fn turbofish_self_inside_impl_resolves() { - // `let s = get::(); s.diff();` inside `impl Session`. The - // turbofish-as-return-type fallback must substitute Self before - // resolving the type argument so the binding pins to Session. - let fx = parse( - r#" - impl Session { - pub fn run(&self) { - let s = get::(); - s.diff(); - } - } - "#, - ); - let self_segs = vec![ - "crate".to_string(), - "app".to_string(), - "session".to_string(), - "Session".to_string(), - ]; - let calls = run_impl_method(&fx, &sample_session_index(), "Session", "run", self_segs); - assert!( - calls.contains("crate::app::session::Session::diff"), - "`get::()` turbofish must resolve to Session, got {calls:?}" - ); -} - -#[test] -fn annotated_destructuring_self_resolves() { - // `let Some(other): Option = maybe() else { return; };` — - // the annotation goes through `bind_annotated` in the destructure - // walker, which must substitute Self before resolving. - let fx = parse( - r#" - impl Session { - pub fn run(&self) { - let Some(other): Option = maybe() else { return; }; - other.diff(); - } - } - "#, - ); - let self_segs = vec![ - "crate".to_string(), - "app".to_string(), - "session".to_string(), - "Session".to_string(), - ]; - let calls = run_impl_method(&fx, &sample_session_index(), "Session", "run", self_segs); - assert!( - calls.contains("crate::app::session::Session::diff"), - "annotated destructuring with Self must bind to Session, got {calls:?}" - ); -} - -#[test] -fn cast_as_self_resolves() { - // `(expr as Self).diff()` inside `impl Session` — `infer_cast` - // resolves the target type, which must substitute Self. - let fx = parse( - r#" - impl Session { - pub fn run(&self) { - let s = (raw() as Self); - s.diff(); - } - } - "#, - ); - let self_segs = vec![ - "crate".to_string(), - "app".to_string(), - "session".to_string(), - "Session".to_string(), - ]; - let calls = run_impl_method(&fx, &sample_session_index(), "Session", "run", self_segs); - assert!( - calls.contains("crate::app::session::Session::diff"), - "`as Self` cast must resolve to Session, got {calls:?}" - ); -} - -#[test] -fn qualified_path_does_not_alias_promote_through_leaf() { - // `use std::sync::Arc as Shared;` is in scope, but the use site - // is `wrap::Shared` — a *qualified* path. The leaf - // `Shared` matches the alias name, but the prefix `wrap::` makes - // the type unrelated. Receiver inference must NOT peel - // `wrap::Shared` to `Session::diff` just because the - // bare-`Shared` alias resolves to `Arc`. (Session is in scope - // here so alias-promotion would otherwise produce a real edge.) - let fx = parse( - r#" - use std::sync::Arc as Shared; - use crate::app::session::Session; - pub fn handle(s: wrap::Shared) { - s.diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "handle"); - assert!( - !calls.contains("crate::app::session::Session::diff"), - "qualified path must not be alias-promoted, got {calls:?}" - ); -} - -#[test] -fn qualified_local_arc_does_not_auto_peel() { - // `wrap::Arc` where `wrap::Arc` is a *local* type that - // happens to be named `Arc`. Direct wrapper dispatch must NOT - // peel just because the leaf is `Arc`. Only stdlib-rooted - // qualifications (`std::sync::Arc`) auto-peel. - let fx = parse( - r#" - use crate::app::session::Session; - mod wrap { pub struct Arc(T); } - pub fn handle(s: wrap::Arc) { - s.diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "handle"); - assert!( - !calls.contains("crate::app::session::Session::diff"), - "qualified local Arc must not auto-peel as stdlib Arc, got {calls:?}" - ); -} - -#[test] -fn bare_local_arc_does_not_auto_peel() { - // `use crate::wrap::Arc;` then `s: Arc` — `Arc` is - // single-segment and matches the stdlib wrapper list, but the - // active `use` resolves it to a *local* type. The bare-name - // fast path must canonicalise first and skip auto-peeling for - // non-stdlib targets. - let fx = parse( - r#" - use crate::wrap::Arc; - use crate::app::session::Session; - pub fn handle(s: Arc) { - s.diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "handle"); - assert!( - !calls.contains("crate::app::session::Session::diff"), - "bare Arc shadowed by local must not auto-peel, got {calls:?}" - ); -} - -#[test] -fn fully_qualified_user_wrapper_peels_via_leaf_match() { - // `axum::extract::State` with - // `transparent_wrappers = ["State"]`. The canonicaliser can't - // resolve external `axum::*` paths, so the user-transparent - // matching must fall back to the leaf segment. - let fx = parse( - r#" - use crate::app::session::Session; - pub fn handle(s: axum::extract::State) { - s.diff(); - } - "#, - ); - let mut index = sample_session_index(); - index.transparent_wrappers.insert("State".to_string()); - let calls = run(&fx, &index, "handle"); - assert!( - calls.contains("crate::app::session::Session::diff"), - "fully-qualified user wrapper must peel via leaf-name, got {calls:?}" - ); -} - -#[test] -fn renamed_external_user_wrapper_peels_via_user_config() { - // `use axum::extract::State as ExtractState;` with - // `transparent_wrappers = ["State"]`. The alias resolves to - // `axum::extract::State` (external path), the last segment is - // "State", which IS in the user-transparent set → peel. Already - // works through the existing alias-resolution path; this test - // pins that. - let fx = parse( - r#" - use axum::extract::State as ExtractState; - use crate::app::session::Session; - pub fn handle(s: ExtractState) { - s.diff(); - } - "#, - ); - let mut index = sample_session_index(); - index.transparent_wrappers.insert("State".to_string()); - let calls = run(&fx, &index, "handle"); - assert!( - calls.contains("crate::app::session::Session::diff"), - "renamed external user wrapper must peel, got {calls:?}" - ); -} - -#[test] -fn aliased_local_wrapper_does_not_auto_peel() { - // `use crate::wrap::Arc as Shared;` aliases a *local* wrapper - // type to `Shared`. The local `crate::wrap::Arc` may not be - // Deref-transparent like stdlib Arc, so receiver inference must - // NOT auto-peel `Shared` just because the alias's leaf - // segment is `Arc`. Only when the alias canonical lives in - // `std`/`core`/`alloc` do we trust the auto-peel. - let fx = parse( - r#" - use crate::wrap::Arc as Shared; - use crate::app::session::Session; - pub fn handle(s: Shared) { - s.diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "handle"); - assert!( - !calls.contains("crate::app::session::Session::diff"), - "aliased local wrapper must not auto-peel as stdlib Arc, got {calls:?}" - ); -} - -#[test] -fn aliased_stdlib_wrapper_inside_inline_mod_peels_to_inner() { - // Same renamed-Arc test, but the `use` statement lives inside an - // inline mod. Top-level `alias_map` doesn't see it; the scoped - // overlay does. Receiver resolution must consult the scoped - // overlay for wrapper-name promotion. - let fx = parse( - r#" - mod inner { - use std::sync::Arc as Shared; - use crate::app::session::Session; - pub fn handle(s: Shared) { - s.diff(); - } - } - "#, - ); - let f = find_fn_in_mod(&fx.file, "inner", "handle"); - let ctx = FnContext { - file: &FileScope { - path: "src/cli/handlers.rs", - alias_map: &fx.alias_map, - aliases_per_scope: &gather_alias_map_scoped(&fx.file), - local_symbols: &fx.local_symbols, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &fx.crate_roots, - workspace_module_paths: None, - }, - mod_stack: &["inner".to_string()], - body: &f.block, - signature_params: sig_params(&f.sig), - generic_params: std::collections::HashMap::new(), - self_type: None, - workspace_index: Some(&sample_session_index()), - workspace_files: None, - reexports: None, - }; - let calls = collect_canonical_calls(&ctx); - assert!( - calls.contains("crate::app::session::Session::diff"), - "scoped Arc-alias inside inline mod must peel to Session, got {calls:?}" - ); -} - -fn find_fn_in_mod<'a>(file: &'a syn::File, mod_name: &str, fn_name: &str) -> &'a syn::ItemFn { - file.items - .iter() - .find_map(|item| match item { - syn::Item::Mod(m) if m.ident == mod_name => m.content.as_ref(), - _ => None, - }) - .and_then(|(_, items)| { - items.iter().find_map(|i| match i { - syn::Item::Fn(f) if f.sig.ident == fn_name => Some(f), - _ => None, - }) - }) - .unwrap_or_else(|| panic!("fn {mod_name}::{fn_name} not found")) -} - -#[test] -fn aliased_stdlib_wrapper_peels_to_inner() { - // `use std::sync::Arc as Shared;` then `fn h(s: Shared)` - // — the receiver resolver must follow the alias to recognise - // `Shared` as `Arc`, peel it, and reach `Session::diff`. - let fx = parse( - r#" - use std::sync::Arc as Shared; - use crate::app::session::Session; - pub fn handle(s: Shared) { - s.diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "handle"); - assert!( - calls.contains("crate::app::session::Session::diff"), - "aliased Arc wrapper must peel to Session, got {calls:?}" - ); -} - -// ═══════════════════════════════════════════════════════════════════ -// Positive: free-fn return-type chain -// ═══════════════════════════════════════════════════════════════════ - -#[test] -fn free_fn_result_chain() { - let fx = parse( - r#" - pub fn cmd() { - let s = crate::app::make_session().unwrap(); - s.diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "cmd"); - assert!(calls.contains("crate::app::session::Session::diff")); -} - -// ═══════════════════════════════════════════════════════════════════ -// Positive: fast-path patterns (no workspace_index needed, but still work) -// ═══════════════════════════════════════════════════════════════════ - -#[test] -fn fast_path_signature_param_resolves() { - let fx = parse( - r#" - use crate::app::session::Session; - pub fn handle(s: &Session) { - s.diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "handle"); - assert!(calls.contains("crate::app::session::Session::diff")); -} - -#[test] -fn fast_path_let_type_annotation() { - let fx = parse( - r#" - use crate::app::session::Session; - pub fn cmd() { - let s: Session = make_it(); - s.diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "cmd"); - assert!(calls.contains("crate::app::session::Session::diff")); -} - -#[test] -fn fast_path_direct_constructor() { - let fx = parse( - r#" - use crate::app::session::Session; - pub fn cmd() { - let s = Session::open_cwd(); - // No unwrap — s is Result, not Session. - // Fast path on the bare-ident fails; inference fallback on - // `s.diff()` receiver infers Result, which doesn't - // have `diff` in the combinator table → :diff. - s.diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "cmd"); - // This pattern is pathological (caller should `?` or `unwrap`), but - // we verify the resolver doesn't invent a false Session::diff edge. - assert!( - calls.contains(":diff") || calls.contains("crate::app::session::Session::diff"), - "pathological Result.method() must either fall back or correctly unwrap, got {calls:?}" - ); -} - -// ═══════════════════════════════════════════════════════════════════ -// Negative: documented Stage 1 limits (unresolved stays unresolved) -// ═══════════════════════════════════════════════════════════════════ - -#[test] -fn negative_external_type_method_is_bare() { - // `u32` is stdlib — no workspace entry. Calling a made-up method - // on it must land as `:name` rather than confabulate. - let fx = parse( - r#" - pub fn cmd() { - let x: u32 = 42; - x.custom_method(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "cmd"); - assert!( - calls.contains(":custom_method"), - "expected :custom_method fallback, got {calls:?}" - ); - assert!( - !calls.iter().any(|c| c.contains("u32::custom_method")), - "must not fabricate stdlib method edges, got {calls:?}" - ); -} - -#[test] -fn negative_unannotated_generic_stays_unresolved() { - // `fn get() -> T` yields Opaque; `x.m()` falls back. - let fx = parse( - r#" - pub fn cmd() { - let x = get(); - x.some_method(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "cmd"); - assert!(calls.contains(":some_method")); -} - -#[test] -fn negative_stdlib_map_closure_is_unresolved() { - // `.map(|r| r.diff())` inner call on the closure argument — the - // closure body is visited, `r` has no binding → :diff. The - // outer `.map()` itself also yields :map (stdlib - // closure-dependent combinator). - let fx = parse( - r#" - use crate::app::session::Session; - pub fn cmd() { - Session::open().map(|r| r.diff()); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "cmd"); - // The inner `r.diff()` is unresolved; assert it stays :diff. - assert!( - calls.iter().any(|c| c == ":diff"), - "closure-body call should stay :diff without binding, got {calls:?}" - ); -} - -#[test] -fn negative_tuple_destructuring_is_limit() { - // Stage 1 doesn't track tuple element types. `let (a, s) = setup(); - // s.m()` leaves `s` unresolved. - let fx = parse( - r#" - pub fn cmd() { - let (a, s) = setup(); - s.diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "cmd"); - // Documented limit: tuple-destructured bindings are Opaque. - assert!( - calls.contains(":diff"), - "tuple destructuring is a Stage 1 limit — expected :diff, got {calls:?}" - ); -} - -// ═══════════════════════════════════════════════════════════════════ -// Robustness: mixed positive + negative in one fn body -// ═══════════════════════════════════════════════════════════════════ - -// ═══════════════════════════════════════════════════════════════════ -// Stage 2: Trait-Dispatch Over-Approximation -// ═══════════════════════════════════════════════════════════════════ - -#[test] -fn trait_dispatch_emits_trait_method_anchor() { - // `dyn Handler.handle()` records ONE edge: the synthetic trait-method - // anchor `::`. Concrete impls (`LoggingHandler::handle`, - // …) are NOT emitted as separate edges from the dispatch site — - // fanout would create N-way touchpoint sets that fire Check C - // false-positives for a single boundary call. The anchor represents - // the logical capability; impl-level reachability is wired in a - // separate graph pass via `:: → ::`. - let fx = parse( - r#" - use crate::ports::Handler; - pub fn dispatch(h: &dyn Handler) { - h.handle(); - } - "#, - ); - let mut index = WorkspaceTypeIndex::new(); - index.trait_methods.insert( - "crate::ports::Handler".to_string(), - std::iter::once("handle".to_string()).collect(), - ); - index.trait_impls.insert( - "crate::ports::Handler".to_string(), - vec![ - "crate::app::LoggingHandler".to_string(), - "crate::app::MetricsHandler".to_string(), - "crate::app::AuditHandler".to_string(), - ], - ); - let calls = run(&fx, &index, "dispatch"); - assert!( - calls.contains("crate::ports::Handler::handle"), - "expected single trait-method anchor edge, got {calls:?}" - ); - assert!( - !calls.contains("crate::app::LoggingHandler::handle"), - "must not emit per-impl fanout edges from dispatch (Check C false-positive source), got {calls:?}" - ); - assert!(!calls.contains("crate::app::MetricsHandler::handle")); - assert!(!calls.contains("crate::app::AuditHandler::handle")); -} - -#[test] -fn trait_dispatch_skips_unrelated_methods() { - // `dyn Handler.unrelated()` — the method isn't on the trait, so no - // anchor is emitted. Falls back to :name. - let fx = parse( - r#" - use crate::ports::Handler; - pub fn dispatch(h: &dyn Handler) { - h.unrelated(); - } - "#, - ); - let mut index = WorkspaceTypeIndex::new(); - index.trait_methods.insert( - "crate::ports::Handler".to_string(), - std::iter::once("handle".to_string()).collect(), - ); - index.trait_impls.insert( - "crate::ports::Handler".to_string(), - vec!["crate::app::X".to_string()], - ); - let calls = run(&fx, &index, "dispatch"); - assert!( - calls.contains(":unrelated"), - "unrelated method on trait must fall through, got {calls:?}" - ); - assert!( - !calls.contains("crate::app::X::unrelated"), - "must not fabricate edge for non-trait method, got {calls:?}" - ); -} - -#[test] -fn trait_dispatch_emits_anchor_regardless_of_default_status() { - // `trait Handler { fn handle(&self) {} } impl Handler for AppHandler {}` - // — the impl has no `handle` body and inherits the default. With - // the trait-method anchor model, the dispatch still emits the - // synthetic `::` anchor; whether the body lives in - // the impl or the trait is no longer the dispatch site's problem - // (the boundary walker treats the anchor as the capability the - // adapter reaches). Concrete impl-edges are NEVER emitted from - // dispatch — they would fabricate touchpoint fanout that fires - // Check C false-positives. - let fx = parse( - r#" - use crate::ports::Handler; - pub fn dispatch(h: &dyn Handler) { - h.handle(); - } - "#, - ); - let mut index = WorkspaceTypeIndex::new(); - index.trait_methods.insert( - "crate::ports::Handler".to_string(), - std::iter::once("handle".to_string()).collect(), - ); - index.trait_impls.insert( - "crate::ports::Handler".to_string(), - vec!["crate::app::AppHandler".to_string()], - ); - let mut by_impl: std::collections::HashMap> = - std::collections::HashMap::new(); - by_impl.insert( - "crate::app::AppHandler".to_string(), - std::collections::HashSet::new(), - ); - index - .trait_impl_overrides - .insert("crate::ports::Handler".to_string(), by_impl); - let calls = run(&fx, &index, "dispatch"); - assert!( - calls.contains("crate::ports::Handler::handle"), - "expected trait-method anchor edge, got {calls:?}" - ); - assert!( - !calls.contains("crate::app::AppHandler::handle"), - "must not fabricate impl-method edge from dispatch, got {calls:?}" - ); -} - -#[test] -fn trait_dispatch_with_send_marker_emits_anchor() { - // `dyn Handler + Send + 'static` — marker traits skipped, Handler wins. - let fx = parse( - r#" - use crate::ports::Handler; - pub fn dispatch(h: &(dyn Handler + Send)) { - h.handle(); - } - "#, - ); - let mut index = WorkspaceTypeIndex::new(); - index.trait_methods.insert( - "crate::ports::Handler".to_string(), - std::iter::once("handle".to_string()).collect(), - ); - index.trait_impls.insert( - "crate::ports::Handler".to_string(), - vec!["crate::app::X".to_string()], - ); - let calls = run(&fx, &index, "dispatch"); - assert!( - calls.contains("crate::ports::Handler::handle"), - "expected anchor edge, got {calls:?}" - ); - assert!(!calls.contains("crate::app::X::handle")); -} - -#[test] -fn trait_dispatch_box_dyn_emits_anchor() { - // `Box` — Box is peeled, then dyn Handler → TraitBound. - let fx = parse( - r#" - use crate::ports::Handler; - pub fn dispatch(h: Box) { - h.handle(); - } - "#, - ); - let mut index = WorkspaceTypeIndex::new(); - index.trait_methods.insert( - "crate::ports::Handler".to_string(), - std::iter::once("handle".to_string()).collect(), - ); - index.trait_impls.insert( - "crate::ports::Handler".to_string(), - vec!["crate::app::Y".to_string()], - ); - let calls = run(&fx, &index, "dispatch"); - assert!( - calls.contains("crate::ports::Handler::handle"), - "Box must be peeled and emit anchor, got {calls:?}" - ); - assert!(!calls.contains("crate::app::Y::handle")); -} - -// ═══════════════════════════════════════════════════════════════════ -// Stage 3: User-Wrapper-Config -// ═══════════════════════════════════════════════════════════════════ - -#[test] -fn user_wrapper_is_peeled_on_signature_param() { - // Axum-style `fn h(State(db): State) { db.query() }`. - // Stage 3: configure `State` as a transparent wrapper so the - // inference peels it to reach `Db`, and `db.query()` resolves. - // Note: our current `extract_pat_ident_name` handles `db: State` - // pattern via `Pat::Ident` with type, not `State(db)` tuple-struct - // destructuring — so we use the plain form here. - let fx = parse( - r#" - use crate::app::Db; - pub fn handle(db: State) { - db.query(); - } - "#, - ); - let db = CanonicalType::path(["crate", "app", "Db"]); - let mut index = WorkspaceTypeIndex::new(); - index.insert_method_return( - "crate::app::Db", - "query", - CanonicalType::path(["crate", "app", "Rows"]), - ); - // Register `State` as a transparent wrapper. - index.transparent_wrappers.insert("State".to_string()); - let calls = run(&fx, &index, "handle"); - let _ = db; - assert!( - calls.contains("crate::app::Db::query"), - "user-wrapper State should peel to Db, got {calls:?}" - ); -} - -#[test] -fn user_wrapper_unconfigured_stays_unresolved() { - // Same fixture but WITHOUT registering State as transparent. Falls - // through to :query. - let fx = parse( - r#" - use crate::app::Db; - pub fn handle(db: State) { - db.query(); - } - "#, - ); - let index = WorkspaceTypeIndex::new(); - let calls = run(&fx, &index, "handle"); - assert!( - calls.contains(":query"), - "unconfigured wrapper must not be peeled, got {calls:?}" - ); -} - -// ═══════════════════════════════════════════════════════════════════ -// Stage 3: Type-Alias-Expansion -// ═══════════════════════════════════════════════════════════════════ - -#[test] -fn type_alias_expands_to_target_via_signature_param() { - // `type DbRef = std::sync::Arc;` — `fn h(db: DbRef) { db.read() }` - // Inference expands DbRef → Arc → Store (Arc wrapper peeled). - // Store has a `read` method in our fixture. - let fx = parse( - r#" - type DbRef = std::sync::Arc; - pub fn handle(db: DbRef) { - db.read(); - } - "#, - ); - let store = CanonicalType::path(["crate", "cli", "handlers", "Store"]); - let mut index = WorkspaceTypeIndex::new(); - // Pre-populate the alias: `crate::cli::handlers::DbRef` → syn::Type - // for `std::sync::Arc`. - let aliased: syn::Type = syn::parse_str("std::sync::Arc").expect("parse alias target"); - // Non-generic alias — no params to substitute. - index.type_aliases.insert( - "crate::cli::handlers::DbRef".to_string(), - crate::adapters::analyzers::architecture::call_parity_rule::type_infer::workspace_index::AliasDef { - params: Vec::new(), - target: aliased, - decl_file: "src/cli/handlers.rs".to_string(), - decl_mod_stack: Vec::new(), - }, - ); - // Store::read() method. - index.insert_method_return( - "crate::cli::handlers::Store", - "read", - CanonicalType::path(["crate", "cli", "handlers", "Data"]), - ); - // Include `DbRef` in local symbols so the alias key resolves. - let mut fx = fx; - fx.local_symbols.insert("DbRef".to_string()); - fx.local_symbols.insert("Store".to_string()); - let calls = run(&fx, &index, "handle"); - let _ = store; - assert!( - calls.contains("crate::cli::handlers::Store::read"), - "type-alias should expand DbRef → Store, got {calls:?}" - ); -} - -// ═══════════════════════════════════════════════════════════════════ -// Stage 2: Turbofish-as-Return-Type -// ═══════════════════════════════════════════════════════════════════ - -#[test] -fn turbofish_gives_concrete_return_type() { - // `get::()` — generic fn with single turbofish type arg. - // No fn_returns entry (generic returns are Opaque), so the - // turbofish fallback fires and the return type is Session. - let fx = parse( - r#" - use crate::app::session::Session; - pub fn cmd() { - let s = get::(); - s.diff(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "cmd"); - assert!( - calls.contains("crate::app::session::Session::diff"), - "turbofish should resolve generic-ctor return type, got {calls:?}" - ); -} - -#[test] -fn turbofish_on_type_method_is_not_overridden() { - // `Vec::::new()` — turbofish is on the type segment, not the - // method. Path has 2 segments, so the turbofish fallback doesn't - // fire. `new` isn't in our index → falls through cleanly. - let fx = parse( - r#" - pub fn cmd() { - let v = Vec::::new(); - v.custom_method(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "cmd"); - // Important: we must NOT fabricate a `crate::…::u32::custom_method` - // edge from the turbofish arg. - assert!( - calls.contains(":custom_method"), - "Vec::::new() turbofish must not override, got {calls:?}" - ); -} - -// ═══════════════════════════════════════════════════════════════════ - -#[test] -fn mixed_resolutions_in_single_body() { - let fx = parse( - r#" - use crate::app::session::Session; - pub fn cmd() { - let s = Session::open().unwrap(); - s.diff(); - let x: u32 = 0; - x.random(); - crate::app::make_session().unwrap().files(); - } - "#, - ); - let calls = run(&fx, &sample_session_index(), "cmd"); - assert!( - calls.contains("crate::app::session::Session::diff"), - "resolved: Session::diff missing, got {calls:?}" - ); - assert!( - calls.contains("crate::app::session::Session::files"), - "resolved: Session::files missing, got {calls:?}" - ); - assert!( - calls.contains(":random"), - "unresolved: :random expected, got {calls:?}" - ); -} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/fast_path_and_negative.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/fast_path_and_negative.rs new file mode 100644 index 00000000..a46480c8 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/fast_path_and_negative.rs @@ -0,0 +1,146 @@ +use super::*; + +#[test] +fn fast_path_signature_param_resolves() { + let fx = parse( + r#" + use crate::app::session::Session; + pub fn handle(s: &Session) { + s.diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "handle"); + assert!(calls.contains("crate::app::session::Session::diff")); +} + +#[test] +fn fast_path_let_type_annotation() { + let fx = parse( + r#" + use crate::app::session::Session; + pub fn cmd() { + let s: Session = make_it(); + s.diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "cmd"); + assert!(calls.contains("crate::app::session::Session::diff")); +} + +#[test] +fn fast_path_direct_constructor() { + let fx = parse( + r#" + use crate::app::session::Session; + pub fn cmd() { + let s = Session::open_cwd(); + // No unwrap — s is Result, not Session. + // Fast path on the bare-ident fails; inference fallback on + // `s.diff()` receiver infers Result, which doesn't + // have `diff` in the combinator table → :diff. + s.diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "cmd"); + // This pattern is pathological (caller should `?` or `unwrap`), but + // we verify the resolver doesn't invent a false Session::diff edge. + assert!( + calls.contains(":diff") || calls.contains("crate::app::session::Session::diff"), + "pathological Result.method() must either fall back or correctly unwrap, got {calls:?}" + ); +} + +// ═══════════════════════════════════════════════════════════════════ +// Negative: documented Stage 1 limits (unresolved stays unresolved) +// ═══════════════════════════════════════════════════════════════════ + +#[test] +fn negative_external_type_method_is_bare() { + // `u32` is stdlib — no workspace entry. Calling a made-up method + // on it must land as `:name` rather than confabulate. + let fx = parse( + r#" + pub fn cmd() { + let x: u32 = 42; + x.custom_method(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "cmd"); + assert!( + calls.contains(":custom_method"), + "expected :custom_method fallback, got {calls:?}" + ); + assert!( + !calls.iter().any(|c| c.contains("u32::custom_method")), + "must not fabricate stdlib method edges, got {calls:?}" + ); +} + +#[test] +fn negative_unannotated_generic_stays_unresolved() { + // `fn get() -> T` yields Opaque; `x.m()` falls back. + let fx = parse( + r#" + pub fn cmd() { + let x = get(); + x.some_method(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "cmd"); + assert!(calls.contains(":some_method")); +} + +#[test] +fn negative_stdlib_map_closure_is_unresolved() { + // `.map(|r| r.diff())` inner call on the closure argument — the + // closure body is visited, `r` has no binding → :diff. The + // outer `.map()` itself also yields :map (stdlib + // closure-dependent combinator). + let fx = parse( + r#" + use crate::app::session::Session; + pub fn cmd() { + Session::open().map(|r| r.diff()); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "cmd"); + // The inner `r.diff()` is unresolved; assert it stays :diff. + assert!( + calls.iter().any(|c| c == ":diff"), + "closure-body call should stay :diff without binding, got {calls:?}" + ); +} + +#[test] +fn negative_tuple_destructuring_is_limit() { + // Stage 1 doesn't track tuple element types. `let (a, s) = setup(); + // s.m()` leaves `s` unresolved. + let fx = parse( + r#" + pub fn cmd() { + let (a, s) = setup(); + s.diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "cmd"); + // Documented limit: tuple-destructured bindings are Opaque. + assert!( + calls.contains(":diff"), + "tuple destructuring is a Stage 1 limit — expected :diff, got {calls:?}" + ); +} + +// ═══════════════════════════════════════════════════════════════════ +// Robustness: mixed positive + negative in one fn body +// ═══════════════════════════════════════════════════════════════════ + +// ═══════════════════════════════════════════════════════════════════ +// Stage 2: Trait-Dispatch Over-Approximation +// ═══════════════════════════════════════════════════════════════════ diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/method_chains.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/method_chains.rs new file mode 100644 index 00000000..33640082 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/method_chains.rs @@ -0,0 +1,154 @@ +use super::*; + +#[test] +fn method_chain_ctor_open_map_err_unwrap_resolves_receiver() { + let fx = parse( + r#" + use crate::app::session::Session; + pub fn cmd() { + let s = Session::open().map_err(handle).unwrap(); + s.diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "cmd"); + assert!( + calls.contains("crate::app::session::Session::diff"), + "expected Session::diff edge, got {calls:?}" + ); +} + +#[test] +fn method_chain_ctor_open_cwd_map_err_try_resolves_receiver() { + // The exact pattern that motivated this inference work: + // `let session = open_cwd().map_err(f)?` then `session.method()`. + let fx = parse( + r#" + use crate::app::session::Session; + pub fn cmd() { + let s = Session::open_cwd().map_err(map_err)?; + s.diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "cmd"); + assert!( + calls.contains("crate::app::session::Session::diff"), + "expected Session::diff edge, got {calls:?}" + ); +} + +#[test] +fn method_chain_ctor_plain_unwrap_resolves_receiver() { + let fx = parse( + r#" + use crate::app::session::Session; + pub fn cmd() { + let s = Session::open().unwrap(); + s.files(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "cmd"); + assert!(calls.contains("crate::app::session::Session::files")); +} + +#[test] +fn method_chain_ctor_expect_message_resolves_receiver() { + let fx = parse( + r#" + use crate::app::session::Session; + pub fn cmd() { + let s = Session::open().expect("session must open"); + s.diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "cmd"); + assert!(calls.contains("crate::app::session::Session::diff")); +} + +#[test] +fn method_chain_ctor_unwrap_or_else_closure_resolves_receiver() { + let fx = parse( + r#" + use crate::app::session::Session; + pub fn cmd() { + let s = Session::open().unwrap_or_else(|e| fallback(e)); + s.diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "cmd"); + assert!(calls.contains("crate::app::session::Session::diff")); +} + +#[test] +fn method_chain_ctor_chained_inline_call_resolves_receiver() { + // No intermediate `let` — the chain resolves inside a single + // method-call expression. + let fx = parse( + r#" + use crate::app::session::Session; + pub fn cmd() { + Session::open().unwrap().diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "cmd"); + assert!(calls.contains("crate::app::session::Session::diff")); +} + +#[test] +fn method_chain_ctor_insert_returning_result_chained_resolves_receiver() { + // Session::insert returns Result — verify the outer + // call edge is recorded even on a Result-wrapped receiver chain. + let fx = parse( + r#" + use crate::app::session::Session; + pub fn cmd() { + Session::open().unwrap().insert(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "cmd"); + assert!(calls.contains("crate::app::session::Session::insert")); +} + +// ═══════════════════════════════════════════════════════════════════ +// Positive: cascading struct-field access patterns +// ═══════════════════════════════════════════════════════════════════ + +#[test] +fn cascading_struct_field_access_resolves_receiver() { + let fx = parse( + r#" + use crate::app::Ctx; + pub fn handle(ctx: &Ctx) { + ctx.session.diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "handle"); + assert!(calls.contains("crate::app::session::Session::diff")); +} + +#[test] +fn cascading_struct_field_access_via_let_binding_resolves_receiver() { + let fx = parse( + r#" + use crate::app::Ctx; + pub fn handle(ctx: &Ctx) { + let s = &ctx.session; + s.diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "handle"); + // `&ctx.session` inferred as Session (Reference is transparent). + assert!(calls.contains("crate::app::session::Session::diff")); +} + +// ═══════════════════════════════════════════════════════════════════ +// Positive: self receiver inside impl methods +// ═══════════════════════════════════════════════════════════════════ diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/mod.rs new file mode 100644 index 00000000..c2e30940 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/mod.rs @@ -0,0 +1,209 @@ +//! Regression harness for call-parity receiver-type inference at the +//! `collect_canonical_calls` level. Each test sets up a workspace type-index +//! with a `Session` type + a `Ctx` struct, then runs a minimal fn body and +//! asserts the expected edge (or documented fall-back) appears. Split into +//! focused sub-files (each ≤ the SRP file-length cap); shared imports, the +//! `RegFixture` fixture, and the parse/run/index helpers live here and reach +//! the sub-modules via `use super::*`. + +pub(super) use crate::adapters::analyzers::architecture::call_parity_rule::calls::{ + collect_canonical_calls, FnContext, +}; +pub(super) use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; +pub(super) use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::{ + CanonicalType, WorkspaceTypeIndex, +}; +pub(super) use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::collect_local_symbols; +pub(super) use crate::adapters::shared::use_tree::{ + gather_alias_map, gather_alias_map_scoped, AliasMap, ScopedAliasMap, +}; +pub(super) use std::collections::{HashMap, HashSet}; + +mod fast_path_and_negative; +mod method_chains; +mod self_resolution; +mod trait_dispatch; +mod wrapper_peeling; +mod wrappers_and_aliases; + +pub(super) const SESSION_PATH: &str = "crate::app::session::Session"; +pub(super) const CTX_PATH: &str = "crate::app::Ctx"; + +/// RegFixture bundling a parsed file plus the resolution inputs +/// (`alias_map`, `local_symbols`, `crate_root_modules`) that +/// `collect_canonical_calls` expects. +pub(super) struct RegFixture { + pub(super) file: syn::File, + pub(super) alias_map: AliasMap, + pub(super) local_symbols: HashSet, + pub(super) crate_roots: HashSet, +} + +pub(super) fn parse(src: &str) -> RegFixture { + let file: syn::File = syn::parse_str(src).expect("parse fixture"); + let alias_map = gather_alias_map(&file); + let local_symbols = collect_local_symbols(&file); + RegFixture { + file, + alias_map, + local_symbols, + crate_roots: HashSet::new(), + } +} + +/// Pre-populated workspace index modelling a Session + Ctx shape. +pub(super) fn sample_session_index() -> WorkspaceTypeIndex { + let session = CanonicalType::path(["crate", "app", "session", "Session"]); + let response = CanonicalType::path(["crate", "app", "Response"]); + let error = CanonicalType::path(["crate", "app", "Error"]); + let mut index = WorkspaceTypeIndex::new(); + // Session::open() -> Result + index.insert_method_return( + SESSION_PATH, + "open", + CanonicalType::Result(Box::new(session.clone())), + ); + // Session::open_cwd() -> Result + index.insert_method_return( + SESSION_PATH, + "open_cwd", + CanonicalType::Result(Box::new(session.clone())), + ); + // Session::diff() -> Response + index.insert_method_return(SESSION_PATH, "diff", response.clone()); + // Session::files() -> Response + index.insert_method_return(SESSION_PATH, "files", response.clone()); + // Session::insert() -> Result + index.insert_method_return( + SESSION_PATH, + "insert", + CanonicalType::Result(Box::new(response.clone())), + ); + // Ctx { session: Session } + index.insert_struct_field(CTX_PATH, "session", session); + // Free fn make_session() -> Result + index.fn_returns.insert( + "crate::app::make_session".to_string(), + CanonicalType::Result(Box::new(CanonicalType::path([ + "crate", "app", "session", "Session", + ]))), + ); + let _ = error; // keep in scope if extensions need it + index +} + +pub(super) fn find_fn<'a>(file: &'a syn::File, name: &str) -> &'a syn::ItemFn { + file.items + .iter() + .find_map(|item| match item { + syn::Item::Fn(f) if f.sig.ident == name => Some(f), + _ => None, + }) + .unwrap_or_else(|| panic!("fn {name} not in fixture")) +} + +pub(super) fn sig_params(sig: &syn::Signature) -> Vec<(String, &syn::Type)> { + sig.inputs + .iter() + .filter_map(|arg| match arg { + syn::FnArg::Typed(pt) => match pt.pat.as_ref() { + syn::Pat::Ident(pi) => Some((pi.ident.to_string(), pt.ty.as_ref())), + _ => None, + }, + _ => None, + }) + .collect() +} + +/// Run the fn body through `collect_canonical_calls` with the given +/// workspace index. Returns the set of canonical call targets. +pub(super) fn run(fx: &RegFixture, index: &WorkspaceTypeIndex, fn_name: &str) -> HashSet { + let f = find_fn(&fx.file, fn_name); + run_with_self(fx, index, &f.sig, &f.block, None) +} + +/// Run an `impl Type { fn name(&self, …) { … } }` body through the +/// collector with `self_type` set to crate-rooted segments. The +/// caller passes the canonical path so the test can bind to whichever +/// module the workspace index models for `Type` (e.g. Session lives +/// under `crate::app::session::*` in `sample_session_index()`). +pub(super) fn run_impl_method( + fx: &RegFixture, + index: &WorkspaceTypeIndex, + type_name: &str, + fn_name: &str, + self_segs: Vec, +) -> HashSet { + let (_, f) = find_impl_method(&fx.file, type_name, fn_name); + run_with_self(fx, index, &f.sig, &f.block, Some(self_segs)) +} + +pub(super) fn run_with_self( + fx: &RegFixture, + index: &WorkspaceTypeIndex, + sig: &syn::Signature, + body: &syn::Block, + self_type: Option>, +) -> HashSet { + let ctx = FnContext { + file: &FileScope { + path: "src/cli/handlers.rs", + alias_map: &fx.alias_map, + aliases_per_scope: &ScopedAliasMap::new(), + local_symbols: &fx.local_symbols, + local_decl_scopes: &HashMap::new(), + crate_root_modules: &fx.crate_roots, + workspace_module_paths: None, + }, + mod_stack: &[], + body, + signature_params: sig_params(sig), + generic_params: std::collections::HashMap::new(), + self_type, + workspace_index: Some(index), + workspace_files: None, + reexports: None, + }; + collect_canonical_calls(&ctx) +} + +pub(super) fn find_impl_method<'a>( + file: &'a syn::File, + type_name: &str, + fn_name: &str, +) -> (Vec, &'a syn::ImplItemFn) { + file.items + .iter() + .filter_map(|item| match item { + syn::Item::Impl(i) => Some(i), + _ => None, + }) + .find_map(|item_impl| { + let segs = impl_self_segments(item_impl)?; + if segs.last().map(String::as_str) != Some(type_name) { + return None; + } + item_impl.items.iter().find_map(|it| match it { + syn::ImplItem::Fn(f) if f.sig.ident == fn_name => Some((segs.clone(), f)), + _ => None, + }) + }) + .unwrap_or_else(|| panic!("impl {type_name}::{fn_name} not in fixture")) +} + +pub(super) fn impl_self_segments(item: &syn::ItemImpl) -> Option> { + let syn::Type::Path(p) = item.self_ty.as_ref() else { + return None; + }; + Some( + p.path + .segments + .iter() + .map(|s| s.ident.to_string()) + .collect(), + ) +} + +// ═══════════════════════════════════════════════════════════════════ +// Positive: method-chain constructor patterns +// ═══════════════════════════════════════════════════════════════════ diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/self_resolution.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/self_resolution.rs new file mode 100644 index 00000000..0a2263c4 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/self_resolution.rs @@ -0,0 +1,188 @@ +use super::*; + +#[test] +fn self_method_call_resolves_via_impl_type() { + // `impl Session { fn run(&self) { self.diff() } }` — `self` must + // bind to the enclosing impl's canonical type so `self.diff()` + // routes through `method_returns[Session::diff]` instead of + // collapsing to `:diff`. + let fx = parse( + r#" + impl Session { + pub fn run(&self) { + self.diff(); + } + } + "#, + ); + let self_segs = vec![ + "crate".to_string(), + "app".to_string(), + "session".to_string(), + "Session".to_string(), + ]; + let calls = run_impl_method(&fx, &sample_session_index(), "Session", "run", self_segs); + assert!( + calls.contains("crate::app::session::Session::diff"), + "self.diff() must route through workspace_index, got {calls:?}" + ); +} + +#[test] +fn self_field_access_resolves_via_impl_type() { + // `self.session.diff()` — Self::session field, then Session::diff. + // Needs both the Self → Ctx binding and the field-type lookup + // chain to fire. + let fx = parse( + r#" + impl Ctx { + pub fn run(&self) { + self.session.diff(); + } + } + "#, + ); + let self_segs = vec!["crate".to_string(), "app".to_string(), "Ctx".to_string()]; + let calls = run_impl_method(&fx, &sample_session_index(), "Ctx", "run", self_segs); + assert!( + calls.contains("crate::app::session::Session::diff"), + "self.session.diff() must chain through field type, got {calls:?}" + ); +} + +#[test] +fn signature_param_typed_self_resolves() { + // `fn merge(&self, other: Self)` inside `impl Session` — `other` + // is declared as `Self`, must bind to `Session` so `other.diff()` + // routes through `method_returns`. + let fx = parse( + r#" + impl Session { + pub fn merge(&self, other: Self) { + other.diff(); + } + } + "#, + ); + let self_segs = vec![ + "crate".to_string(), + "app".to_string(), + "session".to_string(), + "Session".to_string(), + ]; + let calls = run_impl_method(&fx, &sample_session_index(), "Session", "merge", self_segs); + assert!( + calls.contains("crate::app::session::Session::diff"), + "param `other: Self` must resolve to Session, got {calls:?}" + ); +} + +#[test] +fn let_annotation_self_resolves() { + // `let other: Self = make();` inside `impl Session` — annotation + // must substitute Self before resolving. + let fx = parse( + r#" + impl Session { + pub fn run(&self) { + let other: Self = make(); + other.diff(); + } + } + "#, + ); + let self_segs = vec![ + "crate".to_string(), + "app".to_string(), + "session".to_string(), + "Session".to_string(), + ]; + let calls = run_impl_method(&fx, &sample_session_index(), "Session", "run", self_segs); + assert!( + calls.contains("crate::app::session::Session::diff"), + "`let other: Self = …` must bind to Session, got {calls:?}" + ); +} + +#[test] +fn turbofish_self_inside_impl_resolves() { + // `let s = get::(); s.diff();` inside `impl Session`. The + // turbofish-as-return-type fallback must substitute Self before + // resolving the type argument so the binding pins to Session. + let fx = parse( + r#" + impl Session { + pub fn run(&self) { + let s = get::(); + s.diff(); + } + } + "#, + ); + let self_segs = vec![ + "crate".to_string(), + "app".to_string(), + "session".to_string(), + "Session".to_string(), + ]; + let calls = run_impl_method(&fx, &sample_session_index(), "Session", "run", self_segs); + assert!( + calls.contains("crate::app::session::Session::diff"), + "`get::()` turbofish must resolve to Session, got {calls:?}" + ); +} + +#[test] +fn annotated_destructuring_self_resolves() { + // `let Some(other): Option = maybe() else { return; };` — + // the annotation goes through `bind_annotated` in the destructure + // walker, which must substitute Self before resolving. + let fx = parse( + r#" + impl Session { + pub fn run(&self) { + let Some(other): Option = maybe() else { return; }; + other.diff(); + } + } + "#, + ); + let self_segs = vec![ + "crate".to_string(), + "app".to_string(), + "session".to_string(), + "Session".to_string(), + ]; + let calls = run_impl_method(&fx, &sample_session_index(), "Session", "run", self_segs); + assert!( + calls.contains("crate::app::session::Session::diff"), + "annotated destructuring with Self must bind to Session, got {calls:?}" + ); +} + +#[test] +fn cast_as_self_resolves() { + // `(expr as Self).diff()` inside `impl Session` — `infer_cast` + // resolves the target type, which must substitute Self. + let fx = parse( + r#" + impl Session { + pub fn run(&self) { + let s = (raw() as Self); + s.diff(); + } + } + "#, + ); + let self_segs = vec![ + "crate".to_string(), + "app".to_string(), + "session".to_string(), + "Session".to_string(), + ]; + let calls = run_impl_method(&fx, &sample_session_index(), "Session", "run", self_segs); + assert!( + calls.contains("crate::app::session::Session::diff"), + "`as Self` cast must resolve to Session, got {calls:?}" + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/trait_dispatch.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/trait_dispatch.rs new file mode 100644 index 00000000..21386458 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/trait_dispatch.rs @@ -0,0 +1,169 @@ +use super::*; + +#[test] +fn trait_dispatch_emits_trait_method_anchor() { + // `dyn Handler.handle()` records ONE edge: the synthetic trait-method + // anchor `::`. Concrete impls (`LoggingHandler::handle`, + // …) are NOT emitted as separate edges from the dispatch site — + // fanout would create N-way touchpoint sets that fire Check C + // false-positives for a single boundary call. The anchor represents + // the logical capability; impl-level reachability is wired in a + // separate graph pass via `:: → ::`. + let fx = parse( + r#" + use crate::ports::Handler; + pub fn dispatch(h: &dyn Handler) { + h.handle(); + } + "#, + ); + let mut index = WorkspaceTypeIndex::new(); + index.trait_methods.insert( + "crate::ports::Handler".to_string(), + std::iter::once("handle".to_string()).collect(), + ); + index.trait_impls.insert( + "crate::ports::Handler".to_string(), + vec![ + "crate::app::LoggingHandler".to_string(), + "crate::app::MetricsHandler".to_string(), + "crate::app::AuditHandler".to_string(), + ], + ); + let calls = run(&fx, &index, "dispatch"); + assert!( + calls.contains("crate::ports::Handler::handle"), + "expected single trait-method anchor edge, got {calls:?}" + ); + assert!( + !calls.contains("crate::app::LoggingHandler::handle"), + "must not emit per-impl fanout edges from dispatch (Check C false-positive source), got {calls:?}" + ); + assert!(!calls.contains("crate::app::MetricsHandler::handle")); + assert!(!calls.contains("crate::app::AuditHandler::handle")); +} + +/// A `WorkspaceTypeIndex` with the trait `crate::ports::Handler` (one method +/// `handle`) implemented by `impl_path`. +fn handler_index(impl_path: &str) -> WorkspaceTypeIndex { + let mut index = WorkspaceTypeIndex::new(); + index.trait_methods.insert( + "crate::ports::Handler".to_string(), + std::iter::once("handle".to_string()).collect(), + ); + index.trait_impls.insert( + "crate::ports::Handler".to_string(), + vec![impl_path.to_string()], + ); + index +} + +#[test] +fn trait_dispatch_emits_anchor_not_impl_edges() { + // `dyn Handler` dispatch emits the synthetic trait-method anchor (never a + // concrete impl edge, which would fabricate Check-C touchpoint fanout): + // an unrelated method falls through to `:name`; `+ Send` markers + // and `Box` peeling don't change the anchor. + // (label, src, impl_path, expected, forbidden) + let cases: &[(&str, &str, &str, &str, &str)] = &[ + ( + "unrelated method falls through to :", + r#" + use crate::ports::Handler; + pub fn dispatch(h: &dyn Handler) { + h.unrelated(); + } + "#, + "crate::app::X", + ":unrelated", + "crate::app::X::unrelated", + ), + ( + "dyn Handler + Send marker → anchor", + r#" + use crate::ports::Handler; + pub fn dispatch(h: &(dyn Handler + Send)) { + h.handle(); + } + "#, + "crate::app::X", + "crate::ports::Handler::handle", + "crate::app::X::handle", + ), + ( + "Box peeled → anchor", + r#" + use crate::ports::Handler; + pub fn dispatch(h: Box) { + h.handle(); + } + "#, + "crate::app::Y", + "crate::ports::Handler::handle", + "crate::app::Y::handle", + ), + ]; + for (label, src, impl_path, expected, forbidden) in cases { + let calls = run(&parse(src), &handler_index(impl_path), "dispatch"); + assert!( + calls.contains(*expected), + "case {label}: expected `{expected}` in {calls:?}" + ); + assert!( + !calls.contains(*forbidden), + "case {label}: must not fabricate `{forbidden}` in {calls:?}" + ); + } +} + +#[test] +fn trait_dispatch_emits_anchor_regardless_of_default_status() { + // `trait Handler { fn handle(&self) {} } impl Handler for AppHandler {}` + // — the impl has no `handle` body and inherits the default. With + // the trait-method anchor model, the dispatch still emits the + // synthetic `::` anchor; whether the body lives in + // the impl or the trait is no longer the dispatch site's problem + // (the boundary walker treats the anchor as the capability the + // adapter reaches). Concrete impl-edges are NEVER emitted from + // dispatch — they would fabricate touchpoint fanout that fires + // Check C false-positives. + let fx = parse( + r#" + use crate::ports::Handler; + pub fn dispatch(h: &dyn Handler) { + h.handle(); + } + "#, + ); + let mut index = WorkspaceTypeIndex::new(); + index.trait_methods.insert( + "crate::ports::Handler".to_string(), + std::iter::once("handle".to_string()).collect(), + ); + index.trait_impls.insert( + "crate::ports::Handler".to_string(), + vec!["crate::app::AppHandler".to_string()], + ); + let mut by_impl: std::collections::HashMap> = + std::collections::HashMap::new(); + by_impl.insert( + "crate::app::AppHandler".to_string(), + std::collections::HashSet::new(), + ); + index + .trait_impl_overrides + .insert("crate::ports::Handler".to_string(), by_impl); + let calls = run(&fx, &index, "dispatch"); + assert!( + calls.contains("crate::ports::Handler::handle"), + "expected trait-method anchor edge, got {calls:?}" + ); + assert!( + !calls.contains("crate::app::AppHandler::handle"), + "must not fabricate impl-method edge from dispatch, got {calls:?}" + ); +} + +// ═══════════════════════════════════════════════════════════════════ +// Stage 3: User-Wrapper-Config +// ═══════════════════════════════════════════════════════════════════ diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/wrapper_peeling.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/wrapper_peeling.rs new file mode 100644 index 00000000..ebc0ebcb --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/wrapper_peeling.rs @@ -0,0 +1,237 @@ +use super::*; + +#[test] +fn qualified_path_does_not_alias_promote_through_leaf() { + // `use std::sync::Arc as Shared;` is in scope, but the use site + // is `wrap::Shared` — a *qualified* path. The leaf + // `Shared` matches the alias name, but the prefix `wrap::` makes + // the type unrelated. Receiver inference must NOT peel + // `wrap::Shared` to `Session::diff` just because the + // bare-`Shared` alias resolves to `Arc`. (Session is in scope + // here so alias-promotion would otherwise produce a real edge.) + let fx = parse( + r#" + use std::sync::Arc as Shared; + use crate::app::session::Session; + pub fn handle(s: wrap::Shared) { + s.diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "handle"); + assert!( + !calls.contains("crate::app::session::Session::diff"), + "qualified path must not be alias-promoted, got {calls:?}" + ); +} + +#[test] +fn qualified_local_arc_does_not_auto_peel() { + // `wrap::Arc` where `wrap::Arc` is a *local* type that + // happens to be named `Arc`. Direct wrapper dispatch must NOT + // peel just because the leaf is `Arc`. Only stdlib-rooted + // qualifications (`std::sync::Arc`) auto-peel. + let fx = parse( + r#" + use crate::app::session::Session; + mod wrap { pub struct Arc(T); } + pub fn handle(s: wrap::Arc) { + s.diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "handle"); + assert!( + !calls.contains("crate::app::session::Session::diff"), + "qualified local Arc must not auto-peel as stdlib Arc, got {calls:?}" + ); +} + +#[test] +fn bare_local_arc_does_not_auto_peel() { + // `use crate::wrap::Arc;` then `s: Arc` — `Arc` is + // single-segment and matches the stdlib wrapper list, but the + // active `use` resolves it to a *local* type. The bare-name + // fast path must canonicalise first and skip auto-peeling for + // non-stdlib targets. + let fx = parse( + r#" + use crate::wrap::Arc; + use crate::app::session::Session; + pub fn handle(s: Arc) { + s.diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "handle"); + assert!( + !calls.contains("crate::app::session::Session::diff"), + "bare Arc shadowed by local must not auto-peel, got {calls:?}" + ); +} + +#[test] +fn user_transparent_wrapper_peels_to_inner_receiver() { + // With `transparent_wrappers = ["State"]`, an external `State` + // wrapper (whose `axum::*` path the canonicaliser can't resolve) must + // peel via the leaf segment so `s.diff()` resolves to the inner Session + // — whether the wrapper is fully qualified or a renamed import. (label, src) + let cases: &[(&str, &str)] = &[ + ( + "fully-qualified axum::extract::State", + r#" + use crate::app::session::Session; + pub fn handle(s: axum::extract::State) { + s.diff(); + } + "#, + ), + ( + "renamed State as ExtractState", + r#" + use axum::extract::State as ExtractState; + use crate::app::session::Session; + pub fn handle(s: ExtractState) { + s.diff(); + } + "#, + ), + ]; + for (label, src) in cases { + let fx = parse(src); + let mut index = sample_session_index(); + index.transparent_wrappers.insert("State".to_string()); + let calls = run(&fx, &index, "handle"); + assert!( + calls.contains("crate::app::session::Session::diff"), + "case {label}: user-transparent wrapper must peel; got {calls:?}" + ); + } +} + +#[test] +fn aliased_local_wrapper_does_not_auto_peel() { + // `use crate::wrap::Arc as Shared;` aliases a *local* wrapper + // type to `Shared`. The local `crate::wrap::Arc` may not be + // Deref-transparent like stdlib Arc, so receiver inference must + // NOT auto-peel `Shared` just because the alias's leaf + // segment is `Arc`. Only when the alias canonical lives in + // `std`/`core`/`alloc` do we trust the auto-peel. + let fx = parse( + r#" + use crate::wrap::Arc as Shared; + use crate::app::session::Session; + pub fn handle(s: Shared) { + s.diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "handle"); + assert!( + !calls.contains("crate::app::session::Session::diff"), + "aliased local wrapper must not auto-peel as stdlib Arc, got {calls:?}" + ); +} + +#[test] +fn aliased_stdlib_wrapper_inside_inline_mod_peels_to_inner() { + // Same renamed-Arc test, but the `use` statement lives inside an + // inline mod. Top-level `alias_map` doesn't see it; the scoped + // overlay does. Receiver resolution must consult the scoped + // overlay for wrapper-name promotion. + let fx = parse( + r#" + mod inner { + use std::sync::Arc as Shared; + use crate::app::session::Session; + pub fn handle(s: Shared) { + s.diff(); + } + } + "#, + ); + let f = find_fn_in_mod(&fx.file, "inner", "handle"); + let ctx = FnContext { + file: &FileScope { + path: "src/cli/handlers.rs", + alias_map: &fx.alias_map, + aliases_per_scope: &gather_alias_map_scoped(&fx.file), + local_symbols: &fx.local_symbols, + local_decl_scopes: &HashMap::new(), + crate_root_modules: &fx.crate_roots, + workspace_module_paths: None, + }, + mod_stack: &["inner".to_string()], + body: &f.block, + signature_params: sig_params(&f.sig), + generic_params: std::collections::HashMap::new(), + self_type: None, + workspace_index: Some(&sample_session_index()), + workspace_files: None, + reexports: None, + }; + let calls = collect_canonical_calls(&ctx); + assert!( + calls.contains("crate::app::session::Session::diff"), + "scoped Arc-alias inside inline mod must peel to Session, got {calls:?}" + ); +} + +fn find_fn_in_mod<'a>(file: &'a syn::File, mod_name: &str, fn_name: &str) -> &'a syn::ItemFn { + file.items + .iter() + .find_map(|item| match item { + syn::Item::Mod(m) if m.ident == mod_name => m.content.as_ref(), + _ => None, + }) + .and_then(|(_, items)| { + items.iter().find_map(|i| match i { + syn::Item::Fn(f) if f.sig.ident == fn_name => Some(f), + _ => None, + }) + }) + .unwrap_or_else(|| panic!("fn {mod_name}::{fn_name} not found")) +} + +#[test] +fn aliased_stdlib_wrapper_peels_to_inner() { + // `use std::sync::Arc as Shared;` then `fn h(s: Shared)` + // — the receiver resolver must follow the alias to recognise + // `Shared` as `Arc`, peel it, and reach `Session::diff`. + let fx = parse( + r#" + use std::sync::Arc as Shared; + use crate::app::session::Session; + pub fn handle(s: Shared) { + s.diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "handle"); + assert!( + calls.contains("crate::app::session::Session::diff"), + "aliased Arc wrapper must peel to Session, got {calls:?}" + ); +} + +// ═══════════════════════════════════════════════════════════════════ +// Positive: free-fn return-type chain +// ═══════════════════════════════════════════════════════════════════ + +#[test] +fn free_fn_result_chain() { + let fx = parse( + r#" + pub fn cmd() { + let s = crate::app::make_session().unwrap(); + s.diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "cmd"); + assert!(calls.contains("crate::app::session::Session::diff")); +} + +// ═══════════════════════════════════════════════════════════════════ +// Positive: fast-path patterns (no workspace_index needed, but still work) +// ═══════════════════════════════════════════════════════════════════ diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/wrappers_and_aliases.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/wrappers_and_aliases.rs new file mode 100644 index 00000000..d06c4a06 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/regressions/wrappers_and_aliases.rs @@ -0,0 +1,182 @@ +use super::*; + +#[test] +fn user_wrapper_is_peeled_on_signature_param() { + // Axum-style `fn h(State(db): State) { db.query() }`. + // Stage 3: configure `State` as a transparent wrapper so the + // inference peels it to reach `Db`, and `db.query()` resolves. + // Note: our current `extract_pat_ident_name` handles `db: State` + // pattern via `Pat::Ident` with type, not `State(db)` tuple-struct + // destructuring — so we use the plain form here. + let fx = parse( + r#" + use crate::app::Db; + pub fn handle(db: State) { + db.query(); + } + "#, + ); + let db = CanonicalType::path(["crate", "app", "Db"]); + let mut index = WorkspaceTypeIndex::new(); + index.insert_method_return( + "crate::app::Db", + "query", + CanonicalType::path(["crate", "app", "Rows"]), + ); + // Register `State` as a transparent wrapper. + index.transparent_wrappers.insert("State".to_string()); + let calls = run(&fx, &index, "handle"); + let _ = db; + assert!( + calls.contains("crate::app::Db::query"), + "user-wrapper State should peel to Db, got {calls:?}" + ); +} + +#[test] +fn user_wrapper_unconfigured_stays_unresolved() { + // Same fixture but WITHOUT registering State as transparent. Falls + // through to :query. + let fx = parse( + r#" + use crate::app::Db; + pub fn handle(db: State) { + db.query(); + } + "#, + ); + let index = WorkspaceTypeIndex::new(); + let calls = run(&fx, &index, "handle"); + assert!( + calls.contains(":query"), + "unconfigured wrapper must not be peeled, got {calls:?}" + ); +} + +// ═══════════════════════════════════════════════════════════════════ +// Stage 3: Type-Alias-Expansion +// ═══════════════════════════════════════════════════════════════════ + +#[test] +fn type_alias_expands_to_target_via_signature_param() { + // `type DbRef = std::sync::Arc;` — `fn h(db: DbRef) { db.read() }` + // Inference expands DbRef → Arc → Store (Arc wrapper peeled). + // Store has a `read` method in our fixture. + let fx = parse( + r#" + type DbRef = std::sync::Arc; + pub fn handle(db: DbRef) { + db.read(); + } + "#, + ); + let store = CanonicalType::path(["crate", "cli", "handlers", "Store"]); + let mut index = WorkspaceTypeIndex::new(); + // Pre-populate the alias: `crate::cli::handlers::DbRef` → syn::Type + // for `std::sync::Arc`. + let aliased: syn::Type = syn::parse_str("std::sync::Arc").expect("parse alias target"); + // Non-generic alias — no params to substitute. + index.type_aliases.insert( + "crate::cli::handlers::DbRef".to_string(), + crate::adapters::analyzers::architecture::call_parity_rule::type_infer::workspace_index::AliasDef { + params: Vec::new(), + target: aliased, + decl_file: "src/cli/handlers.rs".to_string(), + decl_mod_stack: Vec::new(), + }, + ); + // Store::read() method. + index.insert_method_return( + "crate::cli::handlers::Store", + "read", + CanonicalType::path(["crate", "cli", "handlers", "Data"]), + ); + // Include `DbRef` in local symbols so the alias key resolves. + let mut fx = fx; + fx.local_symbols.insert("DbRef".to_string()); + fx.local_symbols.insert("Store".to_string()); + let calls = run(&fx, &index, "handle"); + let _ = store; + assert!( + calls.contains("crate::cli::handlers::Store::read"), + "type-alias should expand DbRef → Store, got {calls:?}" + ); +} + +// ═══════════════════════════════════════════════════════════════════ +// Stage 2: Turbofish-as-Return-Type +// ═══════════════════════════════════════════════════════════════════ + +#[test] +fn turbofish_gives_concrete_return_type() { + // `get::()` — generic fn with single turbofish type arg. + // No fn_returns entry (generic returns are Opaque), so the + // turbofish fallback fires and the return type is Session. + let fx = parse( + r#" + use crate::app::session::Session; + pub fn cmd() { + let s = get::(); + s.diff(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "cmd"); + assert!( + calls.contains("crate::app::session::Session::diff"), + "turbofish should resolve generic-ctor return type, got {calls:?}" + ); +} + +#[test] +fn turbofish_on_type_method_is_not_overridden() { + // `Vec::::new()` — turbofish is on the type segment, not the + // method. Path has 2 segments, so the turbofish fallback doesn't + // fire. `new` isn't in our index → falls through cleanly. + let fx = parse( + r#" + pub fn cmd() { + let v = Vec::::new(); + v.custom_method(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "cmd"); + // Important: we must NOT fabricate a `crate::…::u32::custom_method` + // edge from the turbofish arg. + assert!( + calls.contains(":custom_method"), + "Vec::::new() turbofish must not override, got {calls:?}" + ); +} + +// ═══════════════════════════════════════════════════════════════════ + +#[test] +fn mixed_resolutions_in_single_body() { + let fx = parse( + r#" + use crate::app::session::Session; + pub fn cmd() { + let s = Session::open().unwrap(); + s.diff(); + let x: u32 = 0; + x.random(); + crate::app::make_session().unwrap().files(); + } + "#, + ); + let calls = run(&fx, &sample_session_index(), "cmd"); + assert!( + calls.contains("crate::app::session::Session::diff"), + "resolved: Session::diff missing, got {calls:?}" + ); + assert!( + calls.contains("crate::app::session::Session::files"), + "resolved: Session::files missing, got {calls:?}" + ); + assert!( + calls.contains(":random"), + "unresolved: :random expected, got {calls:?}" + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/support.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/support.rs index 3f9cbe9b..671344d6 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/support.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/support.rs @@ -175,6 +175,23 @@ pub(super) fn build_graph_only( ) } +/// Build a call graph for the common test case: the `ports_app_cli_mcp` +/// layer layout, no cfg-test files, no transparent wrappers. Tests that +/// need a different layout / cfg-test set / wrappers call `build_graph_only` +/// directly. +pub(super) fn graph_of( + ws: &Workspace, +) -> crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::CallGraph { + build_graph_only(ws, &ports_app_cli_mcp(), &empty_cfg_test(), &HashSet::new()) +} + +/// Like [`graph_of`] but with the simpler `three_layer` layout. +pub(super) fn graph_3l( + ws: &Workspace, +) -> crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::CallGraph { + build_graph_only(ws, &three_layer(), &empty_cfg_test(), &HashSet::new()) +} + /// Build the workspace's pub-fns map and call graph. Integration: /// shared by `run_check` and `compute_touchpoints_for`. fn build_pub_fns_and_graph<'ws>( diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors.rs deleted file mode 100644 index bea08485..00000000 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors.rs +++ /dev/null @@ -1,765 +0,0 @@ -//! Tests for the target-anchor capability surface — the set of -//! synthetic `::` anchors that count as target-layer -//! capabilities for Check B/D coverage decisions. Anchors are -//! capabilities (not concrete fns), and adapter coverage of a -//! `dyn Trait.method()` dispatch must be checked against them, not -//! against the concrete impls those dispatches reach. - -use super::support::{ - build_graph_only, build_workspace, callees_of, empty_cfg_test, graph_contains_edge, - ports_app_cli_mcp, three_layer, -}; -use std::collections::HashSet; - -#[test] -fn target_capabilities_include_trait_anchor_when_overriding_impl_in_target_layer() { - // Hexagonal layout: trait in `ports`, overriding impl in - // `application` (target). Adapter dispatch via `dyn Handler` - // reaches the anchor — so the anchor MUST appear in the target - // capability set, otherwise Check B/D have no way to enumerate - // it as a target-side capability. - let ws = build_workspace(&[ - ( - "src/ports/handler.rs", - "pub trait Handler { fn handle(&self); }", - ), - ( - "src/application/logging.rs", - r#" - use crate::ports::handler::Handler; - pub struct LoggingHandler; - impl Handler for LoggingHandler { fn handle(&self) {} } - "#, - ), - ]); - let graph = build_graph_only( - &ws, - &ports_app_cli_mcp(), - &empty_cfg_test(), - &HashSet::new(), - ); - let caps: std::collections::HashSet<&str> = graph - .target_anchor_capabilities("application", &[]) - .map(|(name, _)| name) - .collect(); - assert!( - caps.contains("crate::ports::handler::Handler::handle"), - "anchor for trait with overriding impl in target layer must appear in target capabilities; got {caps:?}" - ); -} - -#[test] -fn populate_anchor_index_resolves_impl_layers_for_cross_file_impls() { - // Trait declared in `ports/handler.rs`, two impls in different - // application files. The anchor's resolved layer set MUST include - // `application` even though the trait and impls live in distinct - // files — `populate_anchor_index` resolves each impl canonical - // through `LayerDefinitions::layer_of_crate_path`, not via the - // graph's per-node layer cache (which is built from edges, not - // bare struct types). - let ws = build_workspace(&[ - ( - "src/ports/handler.rs", - "pub trait Handler { fn handle(&self); }", - ), - ( - "src/application/a.rs", - r#" - use crate::ports::handler::Handler; - pub struct A; - impl Handler for A { fn handle(&self) {} } - "#, - ), - ( - "src/application/b.rs", - r#" - use crate::ports::handler::Handler; - pub struct B; - impl Handler for B { fn handle(&self) {} } - "#, - ), - ]); - let graph = build_graph_only( - &ws, - &ports_app_cli_mcp(), - &empty_cfg_test(), - &HashSet::new(), - ); - let anchor = "crate::ports::handler::Handler::handle"; - let info = graph.trait_method_anchors.get(anchor).unwrap_or_else(|| { - panic!( - "anchor not registered, got {:?}", - graph.trait_method_anchors - ) - }); - assert!( - info.impl_layers.contains("application"), - "cross-file impls in application must resolve to layer `application`, got {:?}", - info.impl_layers - ); -} - -#[test] -fn target_capabilities_exclude_trait_anchor_without_target_layer_impl() { - // Trait declared in ports, impl in `cli` (an adapter layer, NOT - // target). The anchor reaches NO target capability — so it must - // NOT appear in the target capability set; otherwise Check B - // would falsely demand adapter coverage for a trait that isn't - // a target-side capability. - let ws = build_workspace(&[ - ( - "src/ports/cli_only.rs", - "pub trait CliOnly { fn handle(&self); }", - ), - ( - "src/cli/impls.rs", - r#" - use crate::ports::cli_only::CliOnly; - pub struct CliImpl; - impl CliOnly for CliImpl { fn handle(&self) {} } - "#, - ), - ]); - let graph = build_graph_only( - &ws, - &ports_app_cli_mcp(), - &empty_cfg_test(), - &HashSet::new(), - ); - let caps: std::collections::HashSet<&str> = graph - .target_anchor_capabilities("application", &[]) - .map(|(name, _)| name) - .collect(); - assert!( - !caps.contains("crate::ports::cli_only::CliOnly::handle"), - "anchor with no impl in target layer must NOT appear in target capabilities; got {caps:?}" - ); -} - -#[test] -fn target_anchor_capabilities_rejects_peer_adapter_declared_anchor() { - // Trait declared INSIDE a peer-adapter layer (`mcp`), with an - // overriding impl in `application` (target). Without the - // peer-adapter filter, a `cli` walk could enumerate this anchor - // as a target capability and fire false missing-adapter findings - // for an MCP-internal contract that has no business in CLI's - // surface. - let ws = build_workspace(&[ - ( - "src/mcp/handler.rs", - "pub trait Handler { fn handle(&self); }", - ), - ( - "src/application/logging.rs", - r#" - use crate::mcp::handler::Handler; - pub struct LoggingHandler; - impl Handler for LoggingHandler { fn handle(&self) {} } - "#, - ), - ]); - let graph = build_graph_only( - &ws, - &ports_app_cli_mcp(), - &empty_cfg_test(), - &HashSet::new(), - ); - let adapters = ["cli".to_string(), "mcp".to_string()]; - let caps: std::collections::HashSet<&str> = graph - .target_anchor_capabilities("application", &adapters) - .map(|(name, _)| name) - .collect(); - assert!( - !caps.contains("crate::mcp::handler::Handler::handle"), - "peer-adapter-declared anchor must NOT appear in target capabilities; got {caps:?}" - ); -} - -#[test] -fn target_anchor_capabilities_includes_default_only_target_layer_trait() { - // Trait declared in the target layer with a default body, no - // overriding impls anywhere. The default body IS the capability — - // the anchor must be enumerated as target capability so Check B/D - // require adapter coverage. - let ws = build_workspace(&[( - "src/application/handler.rs", - // Default body in the trait itself; no impls. - "pub trait Handler { fn handle(&self) {} }", - )]); - let graph = build_graph_only( - &ws, - &ports_app_cli_mcp(), - &empty_cfg_test(), - &HashSet::new(), - ); - let caps: std::collections::HashSet<&str> = graph - .target_anchor_capabilities("application", &[]) - .map(|(name, _)| name) - .collect(); - assert!( - caps.contains("crate::application::handler::Handler::handle"), - "default-only trait method in target layer must be a target capability; got {caps:?}" - ); -} - -#[test] -fn target_anchor_capabilities_excludes_private_target_layer_trait() { - // A private (non-`pub`) trait isn't workspace-visible and must - // never count as architectural surface, even with a default body. - let ws = build_workspace(&[( - "src/application/internal.rs", - // `trait`, not `pub trait` — private. - "trait Internal { fn run(&self) {} }", - )]); - let graph = build_graph_only( - &ws, - &ports_app_cli_mcp(), - &empty_cfg_test(), - &HashSet::new(), - ); - let caps: std::collections::HashSet<&str> = graph - .target_anchor_capabilities("application", &[]) - .map(|(name, _)| name) - .collect(); - assert!( - !caps.contains("crate::application::internal::Internal::run"), - "private target-layer trait must NOT be a target capability anchor; got {caps:?}" - ); -} - -#[test] -fn target_anchor_capabilities_excludes_private_ports_trait_with_target_impl() { - // Private ports trait isn't usable outside its module; even a - // target-impl shouldn't promote it to a target capability. - let ws = build_workspace(&[ - ( - "src/ports/internal.rs", - // `trait`, not `pub trait` — private. - "trait Hidden { fn run(&self); }", - ), - ( - "src/application/impls.rs", - r#" - use crate::ports::internal::Hidden; - pub struct Impl; - impl Hidden for Impl { fn run(&self) {} } - "#, - ), - ]); - let graph = build_graph_only( - &ws, - &ports_app_cli_mcp(), - &empty_cfg_test(), - &HashSet::new(), - ); - let caps: std::collections::HashSet<&str> = graph - .target_anchor_capabilities("application", &[]) - .map(|(name, _)| name) - .collect(); - assert!( - !caps.contains("crate::ports::internal::Hidden::run"), - "private ports trait (even with target-layer impl) must NOT be a target capability anchor; got {caps:?}" - ); -} - -#[test] -fn target_anchor_capabilities_excludes_inherited_default_when_body_lives_outside_target() { - // Empty `impl Handler for AppHandler {}` in target inherits the - // default body, but that body lives on the ports trait — the - // graph doesn't model it as a target-layer node. The anchor must - // NOT count as a target capability; otherwise B/D would require - // adapter coverage for a body that never crosses into target. - let ws = build_workspace(&[ - ( - "src/ports/handler.rs", - "pub trait Handler { fn handle(&self) {} }", - ), - ( - "src/application/logging.rs", - r#" - use crate::ports::handler::Handler; - pub struct AppHandler; - impl Handler for AppHandler {} - "#, - ), - ]); - let graph = build_graph_only( - &ws, - &ports_app_cli_mcp(), - &empty_cfg_test(), - &HashSet::new(), - ); - let caps: std::collections::HashSet<&str> = graph - .target_anchor_capabilities("application", &[]) - .map(|(name, _)| name) - .collect(); - assert!( - !caps.contains("crate::ports::handler::Handler::handle"), - "ports default body + empty target impl must NOT promote the anchor to a target capability; got {caps:?}" - ); -} - -#[test] -fn target_anchor_capabilities_includes_pub_crate_trait_with_target_impl() { - // `pub(crate)` traits are workspace-visible per the shared - // `visible_canonicals` set; the anchor must be enumerated. - let ws = build_workspace(&[ - ( - "src/ports/handler.rs", - "pub(crate) trait Handler { fn handle(&self); }", - ), - ( - "src/application/logging.rs", - r#" - use crate::ports::handler::Handler; - pub struct LoggingHandler; - impl Handler for LoggingHandler { fn handle(&self) {} } - "#, - ), - ]); - let graph = build_graph_only( - &ws, - &ports_app_cli_mcp(), - &empty_cfg_test(), - &HashSet::new(), - ); - let caps: std::collections::HashSet<&str> = graph - .target_anchor_capabilities("application", &[]) - .map(|(name, _)| name) - .collect(); - assert!( - caps.contains("crate::ports::handler::Handler::handle"), - "pub(crate) trait with target-layer impl must be a target capability anchor (workspace-visible per `is_visible` model); got {caps:?}" - ); -} - -#[test] -fn target_anchor_capabilities_excludes_pub_trait_inside_private_mod() { - // Round-3 follow-up (A14 visibility-pre-pass gap class): - // `pub trait T { ... }` inside a private `mod inner { … }` is - // syntactically `Public`, but workspace-invisible — the enclosing - // mod has no `pub`, so external code can't reach the trait via - // `use crate::application::wrapper::inner::T;`. The simple - // `matches!(node.vis, Public(_))` check accepts this trait as - // visible, which lets a private-mod trait surface as a Check B/D - // capability anchor. The trait-collector must track enclosing-mod - // visibility (mirroring `pub_fns::PubFnCollector::enclosing_mod_visible`) - // so a pub trait inside any private ancestor mod is rejected. - let ws = build_workspace(&[( - "src/application/wrapper.rs", - r#" - mod inner { - pub trait T { fn run(&self) {} } - } - "#, - )]); - let graph = build_graph_only( - &ws, - &ports_app_cli_mcp(), - &empty_cfg_test(), - &HashSet::new(), - ); - let caps: std::collections::HashSet<&str> = graph - .target_anchor_capabilities("application", &[]) - .map(|(name, _)| name) - .collect(); - assert!( - !caps.contains("crate::application::wrapper::inner::T::run"), - "pub trait inside a private mod must NOT be a target capability anchor (workspace-invisible); got {caps:?}" - ); -} - -#[test] -fn target_anchor_capabilities_excludes_signature_only_target_layer_trait() { - // Trait declared in target layer but with NO default body and NO - // overriding impls. Pure signature is uncallable — must NOT count - // as a capability (regression guard for the cfg-test scenario - // that tripped during F1 design). - let ws = build_workspace(&[( - "src/application/handler.rs", - // Signature only — no default body. - "pub trait Handler { fn handle(&self); }", - )]); - let graph = build_graph_only( - &ws, - &ports_app_cli_mcp(), - &empty_cfg_test(), - &HashSet::new(), - ); - let caps: std::collections::HashSet<&str> = graph - .target_anchor_capabilities("application", &[]) - .map(|(name, _)| name) - .collect(); - assert!( - !caps.contains("crate::application::handler::Handler::handle"), - "pure-signature trait method (no default, no impl) must NOT be a target capability; got {caps:?}" - ); -} - -// ───────────────────────────────────────────────────────────────────── -// Generic-param dispatch (`Q: Trait`) must emit trait-anchor edges -// regardless of bound spelling (inline, where-clause, impl-level) or -// call shape (UFCS path-call vs method-call receiver). -// ───────────────────────────────────────────────────────────────────── - -#[test] -fn ufcs_path_call_on_generic_param_emits_trait_anchor_edge() { - // `pub fn run(q: Q) { Q::execute(&q); }` must emit - // an edge to the trait anchor `SymbolQuery::execute`, the same - // form that `populate_anchor_index` registers. - let ws = build_workspace(&[ - ( - "src/application/symbol.rs", - r#" - pub trait SymbolQuery { - fn execute(&self); - } - pub struct DepsQuery; - impl SymbolQuery for DepsQuery { - fn execute(&self) {} - } - "#, - ), - ( - "src/application/runner.rs", - r#" - use crate::application::symbol::SymbolQuery; - - pub fn run(q: Q) { - Q::execute(&q); - } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - - let runner = "crate::application::runner::run"; - let anchor = "crate::application::symbol::SymbolQuery::execute"; - let impl_method = "crate::application::symbol::DepsQuery::execute"; - - let has_anchor = graph_contains_edge(&graph, runner, anchor); - let has_impl = graph_contains_edge(&graph, runner, impl_method); - - // Sanity: where-clause spelling must produce the same edge — both - // forms are semantically identical. - let ws_where = build_workspace(&[ - ( - "src/application/symbol.rs", - r#" - pub trait SymbolQuery { fn execute(&self); } - pub struct DepsQuery; - impl SymbolQuery for DepsQuery { fn execute(&self) {} } - "#, - ), - ( - "src/application/runner.rs", - r#" - use crate::application::symbol::SymbolQuery; - pub fn run(q: Q) where Q: SymbolQuery { Q::execute(&q); } - "#, - ), - ]); - let graph_where = build_graph_only( - &ws_where, - &three_layer(), - &empty_cfg_test(), - &HashSet::new(), - ); - assert!( - graph_contains_edge(&graph_where, runner, anchor), - "where-clause variant must emit the same trait-anchor edge as inline-bound. \ - run callees: {:?}", - callees_of(&graph_where, runner), - ); - - // Impl-level bound: `impl Runner { fn run(...) }`. - // The Q bound lives on the IMPL block, not the method sig. - let ws_impl = build_workspace(&[ - ( - "src/application/symbol.rs", - r#" - pub trait SymbolQuery { fn execute(&self); } - pub struct DepsQuery; - impl SymbolQuery for DepsQuery { fn execute(&self) {} } - "#, - ), - ( - "src/application/runner.rs", - r#" - use crate::application::symbol::SymbolQuery; - pub struct Runner(pub Q); - impl Runner { - pub fn run(&self, q: &Q) { Q::execute(q); } - } - "#, - ), - ]); - let graph_impl = build_graph_only(&ws_impl, &three_layer(), &empty_cfg_test(), &HashSet::new()); - let runner_impl = "crate::application::runner::Runner::run"; - assert!( - graph_contains_edge(&graph_impl, runner_impl, anchor), - "impl-level generic bound must emit trait-anchor edge for Q::method() inside method body. \ - Runner::run callees: {:?}", - callees_of(&graph_impl, runner_impl), - ); - - assert!( - has_anchor || has_impl, - "`Q::execute(&q)` emits no edge to either the trait anchor \ - `{anchor}` or the impl method `{impl_method}`.\n\ - run callees: {:?}", - callees_of(&graph, runner), - ); - - // Method-level where clause on impl-level generic: bound only in - // the method's where clause, not on the impl. Without merging the - // method-where against impl-level names, the predicate would drop. - let ws_method_where = build_workspace(&[ - ( - "src/application/symbol.rs", - r#" - pub trait SymbolQuery { fn execute(&self); } - pub struct DepsQuery; - impl SymbolQuery for DepsQuery { fn execute(&self) {} } - "#, - ), - ( - "src/application/runner.rs", - r#" - use crate::application::symbol::SymbolQuery; - pub struct Runner(pub Q); - impl Runner { - pub fn run(&self, q: &Q) where Q: SymbolQuery { Q::execute(q); } - } - "#, - ), - ]); - let graph_method_where = build_graph_only( - &ws_method_where, - &three_layer(), - &empty_cfg_test(), - &HashSet::new(), - ); - assert!( - graph_contains_edge(&graph_method_where, runner_impl, anchor), - "method-level where clause on impl-level generic must emit \ - trait-anchor edge. Runner::run callees: {:?}", - callees_of(&graph_method_where, runner_impl), - ); -} - -#[test] -fn method_call_on_generic_receiver_emits_trait_anchor_edge() { - // Side-by-side control + bug pair: UFCS form (`Q::execute(input)`) - // and method-call form (`q.execute(input)`) go through different - // resolution paths. Both must emit the trait-anchor edge. - let ws = build_workspace(&[ - ( - "src/application/mod.rs", - r#" - use serde::Serialize; - - // Control: trait with associated function (no &self). - pub trait UfcsTrait { - type Output: Serialize; - fn execute(input: &str) -> Self::Output; - } - - pub fn ufcs_inner(input: &str) -> String { - format!("ufcs:{input}") - } - - pub struct UfcsTraitImpl; - impl UfcsTrait for UfcsTraitImpl { - type Output = String; - fn execute(input: &str) -> Self::Output { - ufcs_inner(input) - } - } - - pub fn dispatch_ufcs(input: &str) -> Q::Output { - Q::execute(input) - } - - // Bug shape: trait with `&self` receiver. - pub trait MethodTrait { - type Output: Serialize; - fn execute(&self, input: &str) -> Self::Output; - } - - pub fn method_inner(input: &str) -> String { - format!("method:{input}") - } - - pub struct MethodTraitImpl; - impl MethodTrait for MethodTraitImpl { - type Output = String; - fn execute(&self, input: &str) -> Self::Output { - method_inner(input) - } - } - - pub fn dispatch_method(query: &Q, input: &str) -> Q::Output { - query.execute(input) - } - "#, - ), - ( - "src/cli/mod.rs", - r#" - use crate::application::{ - dispatch_method, dispatch_ufcs, MethodTraitImpl, UfcsTraitImpl, - }; - - pub fn cmd_ufcs() -> String { - dispatch_ufcs::("hi") - } - - pub fn cmd_method() -> String { - dispatch_method(&MethodTraitImpl, "hi") - } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - - let dispatch_method = "crate::application::dispatch_method"; - let method_anchor = "crate::application::MethodTrait::execute"; - - // Control: UFCS form must already trace. - let dispatch_ufcs = "crate::application::dispatch_ufcs"; - let ufcs_anchor = "crate::application::UfcsTrait::execute"; - assert!( - graph_contains_edge(&graph, dispatch_ufcs, ufcs_anchor), - "control: UFCS form must already trace. \ - dispatch_ufcs callees: {:?}", - callees_of(&graph, dispatch_ufcs), - ); - - // The actual coverage: method-call form on generic-param receiver - // must also emit the trait-anchor edge. - assert!( - graph_contains_edge(&graph, dispatch_method, method_anchor), - "method-call on generic receiver `query.execute(input)` where \ - `query: &Q` and `Q: MethodTrait` must emit trait-anchor edge \ - `{method_anchor}`. dispatch_method callees: {:?}", - callees_of(&graph, dispatch_method), - ); -} - -#[test] -fn method_call_on_where_clause_bound_generic_emits_trait_anchor_edge() { - // `where Q: T` instead of inline ``. Same edge expected — - // bound spelling shouldn't affect dispatch resolution. - let ws = build_workspace(&[( - "src/application/mod.rs", - r#" - pub trait MethodTrait { - fn execute(&self, input: &str) -> String; - } - - pub fn dispatch_method(query: &Q, input: &str) -> String - where - Q: MethodTrait, - { - query.execute(input) - } - "#, - )]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - let dispatch_method = "crate::application::dispatch_method"; - let anchor = "crate::application::MethodTrait::execute"; - assert!( - graph_contains_edge(&graph, dispatch_method, anchor), - "where-clause bound on generic-param receiver must emit \ - trait-anchor edge. dispatch_method callees: {:?}", - callees_of(&graph, dispatch_method), - ); -} - -#[test] -fn method_call_on_impl_level_generic_emits_trait_anchor_edge() { - // Bound lives on the impl block, method-call inside the method - // body: `impl Foo { fn run(&self, q: &Q) { q.execute(...) } }`. - let ws = build_workspace(&[( - "src/application/mod.rs", - r#" - pub trait MethodTrait { - fn execute(&self, input: &str) -> String; - } - - pub struct Runner(pub Q); - - impl Runner { - pub fn run(&self, q: &Q, input: &str) -> String { - q.execute(input) - } - } - "#, - )]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - let runner_run = "crate::application::Runner::run"; - let anchor = "crate::application::MethodTrait::execute"; - assert!( - graph_contains_edge(&graph, runner_run, anchor), - "impl-level generic bound on method-call receiver must emit \ - trait-anchor edge. Runner::run callees: {:?}", - callees_of(&graph, runner_run), - ); -} - -#[test] -fn multi_bound_generic_receiver_method_call_emits_anchor_for_defining_bound() { - // `Q: Audit + Handler` where `Audit` has no `handle` method but - // `Handler` does. `q.handle()` must emit edge to `Handler::handle` - // even though `Handler` is the SECOND bound and `Audit` (first) - // doesn't define the method. UFCS form (`Q::handle()`) already - // emits one edge per bound; the receiver form must be symmetric. - let ws = build_workspace(&[ - ( - "src/application/mod.rs", - r#" - pub trait Audit { - fn audit(&self); - } - - pub trait Handler { - fn handle(&self); - } - - pub fn dispatch(q: &Q) { - q.handle(); - } - "#, - ), - ( - "src/cli/mod.rs", - r#" - use crate::application::{dispatch, Audit, Handler}; - - pub struct Real; - impl Audit for Real { - fn audit(&self) {} - } - impl Handler for Real { - fn handle(&self) {} - } - - pub fn cmd_run() { - dispatch(&Real); - } - "#, - ), - ]); - let graph = build_graph_only(&ws, &three_layer(), &empty_cfg_test(), &HashSet::new()); - let dispatch = "crate::application::dispatch"; - let handler_anchor = "crate::application::Handler::handle"; - assert!( - graph_contains_edge(&graph, dispatch, handler_anchor), - "multi-bound generic receiver `q: &Q` where `Q: Audit + Handler`: \ - `q.handle()` must emit edge to `{handler_anchor}` even though \ - `Handler` is the SECOND bound and `Audit` (first) doesn't define \ - the method. dispatch callees: {:?}", - callees_of(&graph, dispatch), - ); -} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors/across_bound_spellings.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors/across_bound_spellings.rs new file mode 100644 index 00000000..6749fbb5 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors/across_bound_spellings.rs @@ -0,0 +1,108 @@ +use super::*; + +const ACROSS_BOUND_SPELLINGS_CASES: &[EdgeCase] = &[ + ( + // `where Q: T` instead of inline `` — spelling must not matter + "where-clause bound on generic-param receiver", + &[( + "src/application/mod.rs", + r#" + pub trait MethodTrait { + fn execute(&self, input: &str) -> String; + } + + pub fn dispatch_method(query: &Q, input: &str) -> String + where + Q: MethodTrait, + { + query.execute(input) + } + "#, + )], + "crate::application::dispatch_method", + "crate::application::MethodTrait::execute", + ), + ( + // bound lives on the impl block, method-call inside the body + "impl-level generic bound on method-call receiver", + &[( + "src/application/mod.rs", + r#" + pub trait MethodTrait { + fn execute(&self, input: &str) -> String; + } + + pub struct Runner(pub Q); + + impl Runner { + pub fn run(&self, q: &Q, input: &str) -> String { + q.execute(input) + } + } + "#, + )], + "crate::application::Runner::run", + "crate::application::MethodTrait::execute", + ), + ( + // `Q: Audit + Handler` — `q.handle()` must hit the SECOND bound + // `Handler`, even though `Audit` (first) lacks the method + "multi-bound generic receiver hits the defining bound", + &[ + ( + "src/application/mod.rs", + r#" + pub trait Audit { + fn audit(&self); + } + + pub trait Handler { + fn handle(&self); + } + + pub fn dispatch(q: &Q) { + q.handle(); + } + "#, + ), + ( + "src/cli/mod.rs", + r#" + use crate::application::{dispatch, Audit, Handler}; + + pub struct Real; + impl Audit for Real { + fn audit(&self) {} + } + impl Handler for Real { + fn handle(&self) {} + } + + pub fn cmd_run() { + dispatch(&Real); + } + "#, + ), + ], + "crate::application::dispatch", + "crate::application::Handler::handle", + ), +]; + +#[test] +fn method_call_on_generic_receiver_emits_anchor_across_bound_spellings() { + for (label, files, caller, anchor) in ACROSS_BOUND_SPELLINGS_CASES { + let graph = build_graph_only( + &build_workspace(files), + &three_layer(), + &empty_cfg_test(), + &HashSet::new(), + ); + assert!( + graph_contains_edge(&graph, caller, anchor), + "case {label}: generic-param dispatch must emit trait-anchor edge \ + {caller} → {anchor}; callees: {:?}", + callees_of(&graph, caller), + ); + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors/capability.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors/capability.rs new file mode 100644 index 00000000..6f9b3473 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors/capability.rs @@ -0,0 +1,240 @@ +use super::*; + +// Which `::` anchors count as target-layer (application) +// capabilities for Check B/D. An anchor qualifies when the trait is +// workspace-visible AND its callable body (default body, or an overriding impl) +// lives in the target layer; it's rejected when the body is outside target, the +// trait is private/peer-adapter-declared, or the method is pure signature with +// no body anywhere. (label, files, adapters, anchor, present) +const ANCHOR_CAP_CASES: &[AnchorCapCase] = &[ + ( + // trait in ports, overriding impl in application (target) + "ports trait + overriding target impl", + &[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self); }", + ), + ( + "src/application/logging.rs", + r#" + use crate::ports::handler::Handler; + pub struct LoggingHandler; + impl Handler for LoggingHandler { fn handle(&self) {} } + "#, + ), + ], + &[], + "crate::ports::handler::Handler::handle", + true, + ), + ( + // impl in cli (adapter layer), not target → no target capability + "ports trait + impl in adapter layer only", + &[ + ( + "src/ports/cli_only.rs", + "pub trait CliOnly { fn handle(&self); }", + ), + ( + "src/cli/impls.rs", + r#" + use crate::ports::cli_only::CliOnly; + pub struct CliImpl; + impl CliOnly for CliImpl { fn handle(&self) {} } + "#, + ), + ], + &[], + "crate::ports::cli_only::CliOnly::handle", + false, + ), + ( + // trait declared inside a peer-adapter (mcp) layer → filtered out + "peer-adapter-declared trait (target impl) rejected", + &[ + ( + "src/mcp/handler.rs", + "pub trait Handler { fn handle(&self); }", + ), + ( + "src/application/logging.rs", + r#" + use crate::mcp::handler::Handler; + pub struct LoggingHandler; + impl Handler for LoggingHandler { fn handle(&self) {} } + "#, + ), + ], + &["cli", "mcp"], + "crate::mcp::handler::Handler::handle", + false, + ), + ( + // default body in the target-layer trait itself, no impls + "default-only target-layer trait", + &[( + "src/application/handler.rs", + "pub trait Handler { fn handle(&self) {} }", + )], + &[], + "crate::application::handler::Handler::handle", + true, + ), + ( + // private (non-pub) trait isn't workspace-visible + "private target-layer trait", + &[( + "src/application/internal.rs", + "trait Internal { fn run(&self) {} }", + )], + &[], + "crate::application::internal::Internal::run", + false, + ), + ( + // private ports trait, even with a target impl, stays invisible + "private ports trait + target impl", + &[ + ("src/ports/internal.rs", "trait Hidden { fn run(&self); }"), + ( + "src/application/impls.rs", + r#" + use crate::ports::internal::Hidden; + pub struct Impl; + impl Hidden for Impl { fn run(&self) {} } + "#, + ), + ], + &[], + "crate::ports::internal::Hidden::run", + false, + ), + ( + // empty target impl inherits a ports default body that never + // crosses into target → not a target capability + "inherited default body lives outside target", + &[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self) {} }", + ), + ( + "src/application/logging.rs", + r#" + use crate::ports::handler::Handler; + pub struct AppHandler; + impl Handler for AppHandler {} + "#, + ), + ], + &[], + "crate::ports::handler::Handler::handle", + false, + ), + ( + // pub(crate) traits are workspace-visible per `is_visible` + "pub(crate) ports trait + target impl", + &[ + ( + "src/ports/handler.rs", + "pub(crate) trait Handler { fn handle(&self); }", + ), + ( + "src/application/logging.rs", + r#" + use crate::ports::handler::Handler; + pub struct LoggingHandler; + impl Handler for LoggingHandler { fn handle(&self) {} } + "#, + ), + ], + &[], + "crate::ports::handler::Handler::handle", + true, + ), + ( + // `pub trait` inside a private `mod` is workspace-invisible + "pub trait inside a private mod", + &[( + "src/application/wrapper.rs", + r#" + mod inner { + pub trait T { fn run(&self) {} } + } + "#, + )], + &[], + "crate::application::wrapper::inner::T::run", + false, + ), + ( + // pure signature, no default body and no impl → uncallable + "signature-only target-layer trait", + &[( + "src/application/handler.rs", + "pub trait Handler { fn handle(&self); }", + )], + &[], + "crate::application::handler::Handler::handle", + false, + ), +]; + +#[test] +fn target_anchor_capability_enumeration() { + for (label, files, adapters, anchor, present) in ANCHOR_CAP_CASES { + let caps = anchor_caps(files, adapters); + assert_eq!( + caps.contains(*anchor), + *present, + "case {label}: anchor {anchor} presence; got {caps:?}" + ); + } +} + +#[test] +fn populate_anchor_index_resolves_impl_layers_for_cross_file_impls() { + // Trait declared in `ports/handler.rs`, two impls in different + // application files. The anchor's resolved layer set MUST include + // `application` even though the trait and impls live in distinct + // files — `populate_anchor_index` resolves each impl canonical + // through `LayerDefinitions::layer_of_crate_path`, not via the + // graph's per-node layer cache (which is built from edges, not + // bare struct types). + let ws = build_workspace(&[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self); }", + ), + ( + "src/application/a.rs", + r#" + use crate::ports::handler::Handler; + pub struct A; + impl Handler for A { fn handle(&self) {} } + "#, + ), + ( + "src/application/b.rs", + r#" + use crate::ports::handler::Handler; + pub struct B; + impl Handler for B { fn handle(&self) {} } + "#, + ), + ]); + let graph = graph_of(&ws); + let anchor = "crate::ports::handler::Handler::handle"; + let info = graph.trait_method_anchors.get(anchor).unwrap_or_else(|| { + panic!( + "anchor not registered, got {:?}", + graph.trait_method_anchors + ) + }); + assert!( + info.impl_layers.contains("application"), + "cross-file impls in application must resolve to layer `application`, got {:?}", + info.impl_layers + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors/mod.rs new file mode 100644 index 00000000..dfcd3291 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors/mod.rs @@ -0,0 +1,49 @@ +//! Tests for the target-anchor capability surface — the set of synthetic +//! `::` anchors that count as target-layer capabilities for +//! Check B/D coverage decisions. Anchors are capabilities (not concrete fns), +//! and adapter coverage of a `dyn Trait.method()` dispatch must be checked +//! against them, not against the concrete impls those dispatches reach. Split +//! into focused sub-files (each ≤ the SRP file-length cap); shared imports, +//! case-table types, and the `anchor_caps`/`graph_3l_of` helpers live here and +//! reach the sub-modules via `use super::*`. + +pub(super) use super::support::{ + build_graph_only, build_workspace, callees_of, empty_cfg_test, graph_3l, graph_contains_edge, + graph_of, three_layer, +}; +pub(super) use std::collections::HashSet; + +mod across_bound_spellings; +mod capability; +mod trait_anchor_edges; + +/// `(path, source)` file entries for a small workspace fixture. +pub(super) type WsFiles = &'static [(&'static str, &'static str)]; +/// Target-anchor capability case: `(label, files, adapters, anchor, present)`. +pub(super) type AnchorCapCase = ( + &'static str, + WsFiles, + &'static [&'static str], + &'static str, + bool, +); +/// Generic-dispatch trait-anchor edge case: `(label, files, caller, anchor)`. +pub(super) type EdgeCase = (&'static str, WsFiles, &'static str, &'static str); + +/// Build a workspace and return the target-layer anchor capability names +/// for the `application` target with the given adapter set. +pub(super) fn anchor_caps(files: WsFiles, adapters: &[&str]) -> HashSet { + let owned: Vec = adapters.iter().map(|s| s.to_string()).collect(); + graph_of(&build_workspace(files)) + .target_anchor_capabilities("application", &owned) + .map(|(name, _)| name.to_string()) + .collect() +} + +/// Build a workspace and its call graph under the `three_layer` layout — +/// the shared shape for the generic-param trait-anchor edge tests. +pub(super) fn graph_3l_of( + files: WsFiles, +) -> crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::CallGraph { + graph_3l(&build_workspace(files)) +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors/trait_anchor_edges.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors/trait_anchor_edges.rs new file mode 100644 index 00000000..cdb537d1 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/target_anchors/trait_anchor_edges.rs @@ -0,0 +1,248 @@ +use super::*; + +// ───────────────────────────────────────────────────────────────────── +// Generic-param dispatch (`Q: Trait`) must emit trait-anchor edges +// regardless of bound spelling (inline, where-clause, impl-level) or +// call shape (UFCS path-call vs method-call receiver). +// ───────────────────────────────────────────────────────────────────── + +/// Bound-spelling variants for the UFCS/generic-dispatch trait-anchor test: +/// `Q: SymbolQuery` as a where-clause on a free fn, an impl-level bound, and a +/// method-level where-clause on an impl-level generic. A `const` (string-literal +/// fixtures) so it stays `'static` for `graph_3l_of` and never trips LONG_FN. +const UFCS_BOUND_VARIANTS: &[(&str, WsFiles, &str)] = &[ + ( + "where-clause on a free fn", + &[ + ( + "src/application/symbol.rs", + r#" + pub trait SymbolQuery { fn execute(&self); } + pub struct DepsQuery; + impl SymbolQuery for DepsQuery { fn execute(&self) {} } + "#, + ), + ( + "src/application/runner.rs", + r#" + use crate::application::symbol::SymbolQuery; + pub fn run(q: Q) where Q: SymbolQuery { Q::execute(&q); } + "#, + ), + ], + "crate::application::runner::run", + ), + ( + // The Q bound lives on the IMPL block, not the method sig. + "impl-level bound on the impl block", + &[ + ( + "src/application/symbol.rs", + r#" + pub trait SymbolQuery { fn execute(&self); } + pub struct DepsQuery; + impl SymbolQuery for DepsQuery { fn execute(&self) {} } + "#, + ), + ( + "src/application/runner.rs", + r#" + use crate::application::symbol::SymbolQuery; + pub struct Runner(pub Q); + impl Runner { + pub fn run(&self, q: &Q) { Q::execute(q); } + } + "#, + ), + ], + "crate::application::runner::Runner::run", + ), + ( + // Bound only in the method's where clause, not on the impl — + // requires merging the method-where against impl-level names. + "method-level where clause on an impl-level generic", + &[ + ( + "src/application/symbol.rs", + r#" + pub trait SymbolQuery { fn execute(&self); } + pub struct DepsQuery; + impl SymbolQuery for DepsQuery { fn execute(&self) {} } + "#, + ), + ( + "src/application/runner.rs", + r#" + use crate::application::symbol::SymbolQuery; + pub struct Runner(pub Q); + impl Runner { + pub fn run(&self, q: &Q) where Q: SymbolQuery { Q::execute(q); } + } + "#, + ), + ], + "crate::application::runner::Runner::run", + ), +]; + +#[test] +fn ufcs_path_call_on_generic_param_emits_trait_anchor_edge() { + // `pub fn run(q: Q) { Q::execute(&q); }` must emit + // an edge to the trait anchor `SymbolQuery::execute`, the same + // form that `populate_anchor_index` registers. + let anchor = "crate::application::symbol::SymbolQuery::execute"; + + // Inline-bound free fn `pub fn run(q: Q)`: the edge may + // land on the anchor OR the concrete impl method (both acceptable here). + let runner = "crate::application::runner::run"; + let impl_method = "crate::application::symbol::DepsQuery::execute"; + let graph = graph_3l_of(&[ + ( + "src/application/symbol.rs", + r#" + pub trait SymbolQuery { + fn execute(&self); + } + pub struct DepsQuery; + impl SymbolQuery for DepsQuery { + fn execute(&self) {} + } + "#, + ), + ( + "src/application/runner.rs", + r#" + use crate::application::symbol::SymbolQuery; + + pub fn run(q: Q) { + Q::execute(&q); + } + "#, + ), + ]); + assert!( + graph_contains_edge(&graph, runner, anchor) + || graph_contains_edge(&graph, runner, impl_method), + "`Q::execute(&q)` emits no edge to either the trait anchor `{anchor}` \ + or the impl method `{impl_method}`.\n run callees: {:?}", + callees_of(&graph, runner), + ); + + // The bound-spelling variants (`UFCS_BOUND_VARIANTS`) must each emit the + // edge straight to the anchor, regardless of where the `Q: SymbolQuery` + // bound is written. + for (label, files, caller) in UFCS_BOUND_VARIANTS { + let graph = graph_3l_of(files); + assert!( + graph_contains_edge(&graph, caller, anchor), + "case {label}: bound-spelling variant must emit trait-anchor edge \ + {caller} → {anchor}; callees: {:?}", + callees_of(&graph, caller), + ); + } +} + +/// The `application` source for the method-call-vs-UFCS control/bug pair: +/// `UfcsTrait::execute` (associated fn) + `MethodTrait::execute` (`&self`), each +/// with an impl and a generic `dispatch_*` runner. A `const` (not a +/// fn) so it stays `'static` for `graph_3l_of`'s `WsFiles` and never trips LONG_FN. +const METHOD_CALL_APP_SRC: &str = r#" + use serde::Serialize; + + // Control: trait with associated function (no &self). + pub trait UfcsTrait { + type Output: Serialize; + fn execute(input: &str) -> Self::Output; + } + + pub fn ufcs_inner(input: &str) -> String { + format!("ufcs:{input}") + } + + pub struct UfcsTraitImpl; + impl UfcsTrait for UfcsTraitImpl { + type Output = String; + fn execute(input: &str) -> Self::Output { + ufcs_inner(input) + } + } + + pub fn dispatch_ufcs(input: &str) -> Q::Output { + Q::execute(input) + } + + // Bug shape: trait with `&self` receiver. + pub trait MethodTrait { + type Output: Serialize; + fn execute(&self, input: &str) -> Self::Output; + } + + pub fn method_inner(input: &str) -> String { + format!("method:{input}") + } + + pub struct MethodTraitImpl; + impl MethodTrait for MethodTraitImpl { + type Output = String; + fn execute(&self, input: &str) -> Self::Output { + method_inner(input) + } + } + + pub fn dispatch_method(query: &Q, input: &str) -> Q::Output { + query.execute(input) + } + "#; + +#[test] +fn method_call_on_generic_receiver_emits_trait_anchor_edge() { + // Side-by-side control + bug pair: UFCS form (`Q::execute(input)`) + // and method-call form (`q.execute(input)`) go through different + // resolution paths. Both must emit the trait-anchor edge. + let graph = graph_3l_of(&[ + ("src/application/mod.rs", METHOD_CALL_APP_SRC), + ( + "src/cli/mod.rs", + r#" + use crate::application::{ + dispatch_method, dispatch_ufcs, MethodTraitImpl, UfcsTraitImpl, + }; + + pub fn cmd_ufcs() -> String { + dispatch_ufcs::("hi") + } + + pub fn cmd_method() -> String { + dispatch_method(&MethodTraitImpl, "hi") + } + "#, + ), + ]); + + let dispatch_method = "crate::application::dispatch_method"; + let method_anchor = "crate::application::MethodTrait::execute"; + + // Control: UFCS form must already trace. + let dispatch_ufcs = "crate::application::dispatch_ufcs"; + let ufcs_anchor = "crate::application::UfcsTrait::execute"; + assert!( + graph_contains_edge(&graph, dispatch_ufcs, ufcs_anchor), + "control: UFCS form must already trace. \ + dispatch_ufcs callees: {:?}", + callees_of(&graph, dispatch_ufcs), + ); + + // The actual coverage: method-call form on generic-param receiver + // must also emit the trait-anchor edge. + assert!( + graph_contains_edge(&graph, dispatch_method, method_anchor), + "method-call on generic receiver `query.execute(input)` where \ + `query: &Q` and `Q: MethodTrait` must emit trait-anchor edge \ + `{method_anchor}`. dispatch_method callees: {:?}", + callees_of(&graph, dispatch_method), + ); +} + +// `q.method()` on a generic-param receiver must emit the trait-anchor edge +// regardless of where the bound is spelled (where-clause, impl-level) or which +// bound in a multi-bound list defines the method. (label, files, caller, anchor) diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/touchpoints.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/touchpoints.rs deleted file mode 100644 index c48b9831..00000000 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/touchpoints.rs +++ /dev/null @@ -1,639 +0,0 @@ -//! Tests for `compute_touchpoints` — the boundary-only forward BFS that -//! computes, for one adapter handler, the set of target-layer canonicals -//! it reaches before stopping at the boundary. -//! -//! These tests exercise the algorithm via small multi-file workspaces -//! built through `support::compute_touchpoints_for`, which mirrors the -//! `run_check_a/b` style used elsewhere. - -use super::support::{ - build_workspace, cli_mcp_config, compute_touchpoints_for, empty_cfg_test, ports_app_cli_mcp, - three_layer, -}; -use std::collections::HashSet; - -fn assert_set(actual: HashSet, expected: &[&str]) { - let expected_set: HashSet = expected.iter().map(|s| s.to_string()).collect(); - assert_eq!( - actual, expected_set, - "touchpoint set mismatch — actual={actual:?} expected={expected_set:?}" - ); -} - -// ── Direct call ────────────────────────────────────────────────── - -#[test] -fn touchpoints_direct_call() { - let ws = build_workspace(&[ - ("src/application/session.rs", "pub fn search() {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::search; - pub fn cmd_search() { search(); } - "#, - ), - ]); - let touchpoints = compute_touchpoints_for( - &ws, - &three_layer(), - &cli_mcp_config(3), - "cmd_search", - &empty_cfg_test(), - ); - assert_set(touchpoints, &["crate::application::session::search"]); -} - -// ── Adapter helper traversed before boundary ───────────────────── - -#[test] -fn touchpoints_via_adapter_helper() { - let ws = build_workspace(&[ - ("src/application/session.rs", "pub fn search() {}"), - ( - "src/cli/helpers.rs", - r#" - use crate::application::session::search; - pub fn format_query() { search(); } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::cli::helpers::format_query; - pub fn cmd_search() { format_query(); } - "#, - ), - ]); - let touchpoints = compute_touchpoints_for( - &ws, - &three_layer(), - &cli_mcp_config(3), - "cmd_search", - &empty_cfg_test(), - ); - assert_set(touchpoints, &["crate::application::session::search"]); -} - -// ── No delegation: handler stays in adapter layer ──────────────── - -#[test] -fn touchpoints_no_delegation() { - let ws = build_workspace(&[ - ("src/application/session.rs", "pub fn search() {}"), - ( - "src/cli/helpers.rs", - r#" - pub fn adapter_helper2() {} - pub fn adapter_helper() { adapter_helper2(); } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::cli::helpers::adapter_helper; - pub fn cmd_local_only() { adapter_helper(); } - "#, - ), - ]); - let touchpoints = compute_touchpoints_for( - &ws, - &three_layer(), - &cli_mcp_config(3), - "cmd_local_only", - &empty_cfg_test(), - ); - assert!( - touchpoints.is_empty(), - "no-delegation handler should produce empty touchpoint set, got {touchpoints:?}" - ); -} - -// ── Branch with two distinct target functions ──────────────────── - -#[test] -fn touchpoints_branch_two_targets() { - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - pub fn foo() {} - pub fn bar() {} - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::{foo, bar}; - pub fn cmd_branch(cond: bool) { - if cond { foo(); } else { bar(); } - } - "#, - ), - ]); - let touchpoints = compute_touchpoints_for( - &ws, - &three_layer(), - &cli_mcp_config(3), - "cmd_branch", - &empty_cfg_test(), - ); - assert_set( - touchpoints, - &[ - "crate::application::session::foo", - "crate::application::session::bar", - ], - ); -} - -// ── Loop: same target multiple call sites → single touchpoint ──── - -#[test] -fn touchpoints_loop_same_target() { - let ws = build_workspace(&[ - ("src/application/session.rs", "pub fn process(_x: u32) {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::process; - pub fn cmd_batch() { - for x in 0..10 { process(x); } - } - "#, - ), - ]); - let touchpoints = compute_touchpoints_for( - &ws, - &three_layer(), - &cli_mcp_config(3), - "cmd_batch", - &empty_cfg_test(), - ); - assert_set(touchpoints, &["crate::application::session::process"]); -} - -// ── Stop at boundary: target callees not in the set ────────────── - -#[test] -fn touchpoints_stop_at_target_boundary() { - let ws = build_workspace(&[ - ( - "src/application/session.rs", - r#" - use crate::application::middleware::record_operation; - pub fn search() { record_operation(); } - "#, - ), - ( - "src/application/middleware.rs", - r#" - pub fn record_operation() {} - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::session::search; - pub fn cmd_search() { search(); } - "#, - ), - ]); - let touchpoints = compute_touchpoints_for( - &ws, - &three_layer(), - &cli_mcp_config(3), - "cmd_search", - &empty_cfg_test(), - ); - // Only session::search — the boundary semantic stops here. The - // application-internal `record_operation` MUST NOT appear in the set. - assert_set(touchpoints, &["crate::application::session::search"]); -} - -// ── Depth limit: chain too deep returns empty ──────────────────── - -#[test] -fn touchpoints_call_depth_exceeded() { - // cmd → h1 → h2 → h3 → h4 → search (5 hops). depth=3 stops short. - let ws = build_workspace(&[ - ("src/application/session.rs", "pub fn search() {}"), - ( - "src/cli/helpers.rs", - r#" - use crate::application::session::search; - pub fn h4() { search(); } - pub fn h3() { h4(); } - pub fn h2() { h3(); } - pub fn h1() { h2(); } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::cli::helpers::h1; - pub fn cmd_deep() { h1(); } - "#, - ), - ]); - let touchpoints = compute_touchpoints_for( - &ws, - &three_layer(), - &cli_mcp_config(3), - "cmd_deep", - &empty_cfg_test(), - ); - assert!( - touchpoints.is_empty(), - "depth=3 should not reach a 5-hop target, got {touchpoints:?}" - ); -} - -// ── Depth limit: chain just inside limit returns target ────────── - -#[test] -fn touchpoints_call_depth_just_inside() { - // cmd → h1 → h2 → search (3 hops). depth=3 reaches target. - let ws = build_workspace(&[ - ("src/application/session.rs", "pub fn search() {}"), - ( - "src/cli/helpers.rs", - r#" - use crate::application::session::search; - pub fn h2() { search(); } - pub fn h1() { h2(); } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::cli::helpers::h1; - pub fn cmd_depth3() { h1(); } - "#, - ), - ]); - let touchpoints = compute_touchpoints_for( - &ws, - &three_layer(), - &cli_mcp_config(3), - "cmd_depth3", - &empty_cfg_test(), - ); - assert_set(touchpoints, &["crate::application::session::search"]); -} - -// ── Trait-dispatch anchor ──────────────────────────────────────── - -#[test] -fn touchpoints_trait_dispatch_collapses_to_anchor() { - // CLI handler calls `dyn Handler.handle()` where Handler has THREE - // overriding impls in the application layer. Touchpoint set must be - // ONE anchor `::`, not three impl edges. Otherwise - // Check C fires multi-touchpoint for what is semantically a single - // boundary call. - let ws = build_workspace(&[ - ( - "src/application/handler.rs", - r#" - pub trait Handler { fn handle(&self); } - pub struct LoggingHandler; - impl Handler for LoggingHandler { fn handle(&self) {} } - pub struct MetricsHandler; - impl Handler for MetricsHandler { fn handle(&self) {} } - pub struct AuditHandler; - impl Handler for AuditHandler { fn handle(&self) {} } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::handler::Handler; - pub fn cmd_dispatch(h: &dyn Handler) { h.handle(); } - "#, - ), - ]); - let touchpoints = compute_touchpoints_for( - &ws, - &three_layer(), - &cli_mcp_config(3), - "cmd_dispatch", - &empty_cfg_test(), - ); - assert_set( - touchpoints, - &["crate::application::handler::Handler::handle"], - ); -} - -#[test] -fn touchpoints_trait_anchor_recognized_when_trait_lives_in_ports_layer() { - // Hexagonal/Ports&Adapters case: trait declared in `ports` layer, - // impls in `application` (target) layer. Dispatch emits anchor - // `crate::ports::Handler::handle` (anchor lives in ports). Walker - // must still register the anchor as a target boundary because - // its impls reach the target layer — otherwise Check A would - // falsely fire "no delegation" for a CLI command that legitimately - // crosses into the target via trait dispatch. - let ws = build_workspace(&[ - ( - "src/ports/handler.rs", - "pub trait Handler { fn handle(&self); }", - ), - ( - "src/application/logging.rs", - r#" - use crate::ports::handler::Handler; - pub struct LoggingHandler; - impl Handler for LoggingHandler { fn handle(&self) {} } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::ports::handler::Handler; - pub fn cmd_dispatch(h: &dyn Handler) { h.handle(); } - "#, - ), - ]); - let mut config = cli_mcp_config(3); - config.target = "application".to_string(); - let touchpoints = compute_touchpoints_for( - &ws, - &ports_app_cli_mcp(), - &config, - "cmd_dispatch", - &empty_cfg_test(), - ); - assert_set(touchpoints, &["crate::ports::handler::Handler::handle"]); -} - -#[test] -fn touchpoints_skip_anchor_declared_in_peer_adapter_layer() { - // Trait declared in peer-adapter layer (`mcp`), with an overriding - // impl in the target layer (`application`). CLI handler calls - // `dyn mcp::Handler.handle()`. The anchor lives in `mcp` (peer - // adapter), so the walker MUST refuse to register it as a target - // boundary — otherwise CLI inherits MCP's reachability into - // application via the anchor and fakes adapter delegation. - let ws = build_workspace(&[ - ( - "src/mcp/handler.rs", - "pub trait Handler { fn handle(&self); }", - ), - ( - "src/application/logging.rs", - r#" - use crate::mcp::handler::Handler; - pub struct LoggingHandler; - impl Handler for LoggingHandler { fn handle(&self) {} } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::mcp::handler::Handler; - pub fn cmd_via_dyn_peer(h: &dyn Handler) { h.handle(); } - "#, - ), - ]); - let touchpoints = compute_touchpoints_for( - &ws, - &three_layer(), - &cli_mcp_config(3), - "cmd_via_dyn_peer", - &empty_cfg_test(), - ); - assert_set(touchpoints, &[]); -} - -#[test] -fn touchpoints_reject_phantom_inherited_default_concrete_canonical() { - // Adapter calls AppHandler::handle (UFCS) where the impl is - // empty `impl Handler for AppHandler {}`. The fabricated - // canonical `crate::application::logging::AppHandler::handle` - // is added as an edge sink and `layer_of` caches `application` - // for it, but no graph node exists with that body (the default - // lives on the trait in ports). The walker must NOT treat the - // phantom as a target boundary — otherwise Check A passes on a - // touchpoint that B/D can't enumerate consistently. - let ws = build_workspace(&[ - ( - "src/ports/handler.rs", - "pub trait Handler { fn handle(&self) {} }", - ), - ( - "src/application/logging.rs", - r#" - use crate::ports::handler::Handler; - pub struct AppHandler; - impl Handler for AppHandler {} - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::logging::AppHandler; - pub fn cmd_log() { AppHandler::handle(&AppHandler); } - "#, - ), - ]); - let tps = compute_touchpoints_for( - &ws, - &ports_app_cli_mcp(), - &cli_mcp_config(3), - "cmd_log", - &empty_cfg_test(), - ); - let phantom = "crate::application::logging::AppHandler::handle"; - assert!( - !tps.contains(phantom), - "phantom inherited-default canonical must NOT be registered as touchpoint (no real fn node); got {tps:?}" - ); -} - -#[test] -fn touchpoints_route_inherited_default_concrete_to_anchor() { - // Target-layer trait with default body + inherited impl in target. - // Adapter calls via UFCS on the concrete impl. The concrete - // canonical is phantom (rejected by the walker), but the anchor - // IS a valid target capability (default body lives in target). - // The call-site emission must route this case to the anchor so - // the capability surfaces in the adapter's touchpoint set. - let ws = build_workspace(&[ - ( - "src/application/handler.rs", - "pub trait Handler { fn handle(&self) {} }", - ), - ( - "src/application/logging.rs", - r#" - use crate::application::handler::Handler; - pub struct AppHandler; - impl Handler for AppHandler {} - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::logging::AppHandler; - pub fn cmd_log() { AppHandler::handle(&AppHandler); } - "#, - ), - ]); - let tps = compute_touchpoints_for( - &ws, - &ports_app_cli_mcp(), - &cli_mcp_config(3), - "cmd_log", - &empty_cfg_test(), - ); - let anchor = "crate::application::handler::Handler::handle"; - assert!( - tps.contains(anchor), - "inherited-default concrete call must route to the trait anchor when the anchor is a target capability; got {tps:?}" - ); -} - -#[test] -fn touchpoints_skip_rewrite_when_multiple_traits_share_default_method_name() { - // Ambiguity guard: if the impl-type implements two traits with the - // SAME default method name, Rust requires UFCS disambiguation - // (`::handle(&x)`). The phantom canonical alone doesn't - // tell us which trait was selected, so the edge-rewrite pass must - // NOT pick the first map-iteration match — that would make - // touchpoints depend on HashMap iteration order. Conservative - // choice: leave the canonical phantom (walker phantom-gate will - // suppress it), so neither anchor is incorrectly registered. - let ws = build_workspace(&[ - ( - "src/application/handler.rs", - r#" - pub trait Greeting { fn handle(&self) {} } - pub trait Logging { fn handle(&self) {} } - "#, - ), - ( - "src/application/logging.rs", - r#" - use crate::application::handler::{Greeting, Logging}; - pub struct AppHandler; - impl Greeting for AppHandler {} - impl Logging for AppHandler {} - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::application::logging::AppHandler; - pub fn cmd_log() { AppHandler::handle(&AppHandler); } - "#, - ), - ]); - let tps = compute_touchpoints_for( - &ws, - &ports_app_cli_mcp(), - &cli_mcp_config(3), - "cmd_log", - &empty_cfg_test(), - ); - let greeting_anchor = "crate::application::handler::Greeting::handle"; - let logging_anchor = "crate::application::handler::Logging::handle"; - assert!( - !tps.contains(greeting_anchor) && !tps.contains(logging_anchor), - "ambiguous inherited-default rewrite must leave the call unresolved (non-deterministic otherwise); got {tps:?}" - ); -} - -#[test] -fn touchpoints_recognise_real_target_fn_node() { - // Sanity check: a real `pub fn` in target IS a boundary. Gates - // the round-6 phantom filter to the right side — we must not - // accidentally drop legitimate concrete target fns. - let ws = build_workspace(&[ - ("src/application/stats.rs", "pub fn get_stats() {}"), - ( - "src/cli/handlers.rs", - r#" - use crate::application::stats::get_stats; - pub fn cmd_stats() { get_stats(); } - "#, - ), - ]); - let tps = compute_touchpoints_for( - &ws, - &ports_app_cli_mcp(), - &cli_mcp_config(3), - "cmd_stats", - &empty_cfg_test(), - ); - let real = "crate::application::stats::get_stats"; - assert!( - tps.contains(real), - "real target-layer pub fn must be a touchpoint; got {tps:?}" - ); - let ws = build_workspace(&[ - ( - "src/mcp/handler.rs", - "pub trait Handler { fn handle(&self); }", - ), - ( - "src/application/logging.rs", - r#" - use crate::mcp::handler::Handler; - pub struct LoggingHandler; - impl Handler for LoggingHandler { fn handle(&self) {} } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::mcp::handler::Handler; - pub fn cmd_via_dyn_peer(h: &dyn Handler) { h.handle(); } - "#, - ), - ]); - let touchpoints = compute_touchpoints_for( - &ws, - &three_layer(), - &cli_mcp_config(3), - "cmd_via_dyn_peer", - &empty_cfg_test(), - ); - assert_set(touchpoints, &[]); -} - -// ── Peer-adapter blocking ──────────────────────────────────────── - -#[test] -fn touchpoints_do_not_traverse_peer_adapter() { - // CLI handler `cmd_via_mcp` calls into an MCP handler `mcp_search`, - // which itself crosses into the application layer. The CLI walk - // must NOT inherit MCP's touchpoint — otherwise Check A/B/D would - // be masked even though the CLI adapter never crossed into the - // target itself. - let ws = build_workspace(&[ - ("src/application/session.rs", "pub fn search() {}"), - ( - "src/mcp/handlers.rs", - r#" - use crate::application::session::search; - pub fn mcp_search() { search(); } - "#, - ), - ( - "src/cli/handlers.rs", - r#" - use crate::mcp::handlers::mcp_search; - pub fn cmd_via_mcp() { mcp_search(); } - "#, - ), - ]); - let touchpoints = compute_touchpoints_for( - &ws, - &three_layer(), - &cli_mcp_config(3), - "cmd_via_mcp", - &empty_cfg_test(), - ); - assert_set(touchpoints, &[]); -} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/touchpoints/anchor_membership.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/touchpoints/anchor_membership.rs new file mode 100644 index 00000000..6ce007e0 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/touchpoints/anchor_membership.rs @@ -0,0 +1,196 @@ +use super::*; + +#[test] +fn touchpoints_trait_anchor_recognized_when_trait_lives_in_ports_layer() { + // Hexagonal/Ports&Adapters case: trait declared in `ports`, impls in + // `application` (target). Dispatch emits the anchor `ports::Handler:: + // handle`; the walker must still register it as a target boundary + // because its impls reach the target — otherwise Check A would falsely + // fire "no delegation" for a CLI command that crosses via trait dispatch. + let touchpoints = tp_ports( + &[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self); }", + ), + ( + "src/application/logging.rs", + r#" + use crate::ports::handler::Handler; + pub struct LoggingHandler; + impl Handler for LoggingHandler { fn handle(&self) {} } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::ports::handler::Handler; + pub fn cmd_dispatch(h: &dyn Handler) { h.handle(); } + "#, + ), + ], + "cmd_dispatch", + ); + assert_set(touchpoints, &["crate::ports::handler::Handler::handle"]); +} + +// Whether a specific canonical is registered as a touchpoint under the +// hexagonal layout: a phantom inherited-default concrete canonical is rejected +// (no real fn node); the same call routes to the trait anchor when the anchor is +// a valid target capability; an ambiguous multi-trait default leaves the call +// unresolved (non-deterministic otherwise); and a real concrete target pub-fn IS +// a boundary. (label, files, handler, anchor, present) +const TOUCHPOINT_ANCHOR_CASES: &[ContainsCase] = &[ + ( + // empty `impl Handler for AppHandler {}`; default body lives on + // the ports trait, so the concrete canonical is phantom + "phantom inherited-default concrete canonical is rejected", + &[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self) {} }", + ), + ( + "src/application/logging.rs", + r#" + use crate::ports::handler::Handler; + pub struct AppHandler; + impl Handler for AppHandler {} + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::logging::AppHandler; + pub fn cmd_log() { AppHandler::handle(&AppHandler); } + "#, + ), + ], + "cmd_log", + "crate::application::logging::AppHandler::handle", + false, + ), + ( + // target-layer trait with default body: the anchor IS a valid + // target capability, so the concrete call routes to it + "inherited-default concrete call routes to the target anchor", + &[ + ( + "src/application/handler.rs", + "pub trait Handler { fn handle(&self) {} }", + ), + ( + "src/application/logging.rs", + r#" + use crate::application::handler::Handler; + pub struct AppHandler; + impl Handler for AppHandler {} + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::logging::AppHandler; + pub fn cmd_log() { AppHandler::handle(&AppHandler); } + "#, + ), + ], + "cmd_log", + "crate::application::handler::Handler::handle", + true, + ), + ( + // AppHandler implements two traits with the same default method + // name; rewrite must not pick one (HashMap-order dependent) → + // neither anchor is registered + "ambiguous multi-trait default leaves Greeting unresolved", + &[ + ( + "src/application/handler.rs", + r#" + pub trait Greeting { fn handle(&self) {} } + pub trait Logging { fn handle(&self) {} } + "#, + ), + ( + "src/application/logging.rs", + r#" + use crate::application::handler::{Greeting, Logging}; + pub struct AppHandler; + impl Greeting for AppHandler {} + impl Logging for AppHandler {} + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::logging::AppHandler; + pub fn cmd_log() { AppHandler::handle(&AppHandler); } + "#, + ), + ], + "cmd_log", + "crate::application::handler::Greeting::handle", + false, + ), + ( + "ambiguous multi-trait default leaves Logging unresolved", + &[ + ( + "src/application/handler.rs", + r#" + pub trait Greeting { fn handle(&self) {} } + pub trait Logging { fn handle(&self) {} } + "#, + ), + ( + "src/application/logging.rs", + r#" + use crate::application::handler::{Greeting, Logging}; + pub struct AppHandler; + impl Greeting for AppHandler {} + impl Logging for AppHandler {} + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::logging::AppHandler; + pub fn cmd_log() { AppHandler::handle(&AppHandler); } + "#, + ), + ], + "cmd_log", + "crate::application::handler::Logging::handle", + false, + ), + ( + // sanity: a real concrete target pub-fn must remain a boundary + "real target-layer pub fn is a touchpoint", + &[ + ("src/application/stats.rs", "pub fn get_stats() {}"), + ( + "src/cli/handlers.rs", + r#" + use crate::application::stats::get_stats; + pub fn cmd_stats() { get_stats(); } + "#, + ), + ], + "cmd_stats", + "crate::application::stats::get_stats", + true, + ), +]; + +#[test] +fn touchpoint_anchor_membership() { + for (label, files, handler, anchor, present) in TOUCHPOINT_ANCHOR_CASES { + let tps = tp_ports(files, handler); + assert_eq!( + tps.contains(*anchor), + *present, + "case {label}: anchor {anchor} membership; got {tps:?}" + ); + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/touchpoints/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/touchpoints/mod.rs new file mode 100644 index 00000000..d95ade7d --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/touchpoints/mod.rs @@ -0,0 +1,59 @@ +//! Tests for `compute_touchpoints` — the boundary-only forward BFS that +//! computes, for one adapter handler, the set of target-layer canonicals it +//! reaches before stopping at the boundary. Split into focused sub-files +//! (each ≤ the SRP file-length cap); shared imports + helpers live here and +//! reach the sub-modules via `use super::*`. + +pub(super) use super::support::{ + build_workspace, cli_mcp_config, compute_touchpoints_for, empty_cfg_test, ports_app_cli_mcp, + three_layer, +}; +pub(super) use std::collections::HashSet; + +mod anchor_membership; +mod sets; + +/// `(path, source)` file entries for a small workspace fixture. +pub(super) type WsFiles = &'static [(&'static str, &'static str)]; +/// Touchpoint-set case: `(label, files, depth, handler, expected)`. +pub(super) type TouchpointCase = ( + &'static str, + WsFiles, + usize, + &'static str, + &'static [&'static str], +); +/// Anchor-membership case: `(label, files, handler, anchor, present)`. +pub(super) type ContainsCase = (&'static str, WsFiles, &'static str, &'static str, bool); + +pub(super) fn assert_set(actual: HashSet, expected: &[&str]) { + let expected_set: HashSet = expected.iter().map(|s| s.to_string()).collect(); + assert_eq!( + actual, expected_set, + "touchpoint set mismatch — actual={actual:?} expected={expected_set:?}" + ); +} + +/// Compute the touchpoint set for `handler` under the three-layer layout +/// and a `cli_mcp_config(depth)` config (no cfg-test files). +pub(super) fn tp_3l(files: WsFiles, depth: usize, handler: &str) -> HashSet { + compute_touchpoints_for( + &build_workspace(files), + &three_layer(), + &cli_mcp_config(depth), + handler, + &empty_cfg_test(), + ) +} + +/// Like [`tp_3l`] but under the hexagonal `ports_app_cli_mcp` layout at +/// call_depth 3 — the shared shape for the trait-anchor membership tests. +pub(super) fn tp_ports(files: WsFiles, handler: &str) -> HashSet { + compute_touchpoints_for( + &build_workspace(files), + &ports_app_cli_mcp(), + &cli_mcp_config(3), + handler, + &empty_cfg_test(), + ) +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/touchpoints/sets.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/touchpoints/sets.rs new file mode 100644 index 00000000..a2ca449d --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/touchpoints/sets.rs @@ -0,0 +1,290 @@ +use super::*; + +// The exact target-layer canonical set an adapter handler reaches before the +// boundary BFS stops: direct calls, adapter-helper hops, branches/loops +// collapsing to distinct targets, the boundary cutoff (target callees excluded), +// call_depth limits, trait-dispatch collapsing to one anchor, and peer-adapter +// walks producing nothing. (label, files, depth, handler, expected) +const TOUCHPOINT_SET_CASES: &[TouchpointCase] = &[ + ( + "direct call to a target fn", + &[ + ("src/application/session.rs", "pub fn search() {}"), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::search; + pub fn cmd_search() { search(); } + "#, + ), + ], + 3, + "cmd_search", + &["crate::application::session::search"], + ), + ( + "adapter helper traversed before the boundary", + &[ + ("src/application/session.rs", "pub fn search() {}"), + ( + "src/cli/helpers.rs", + r#" + use crate::application::session::search; + pub fn format_query() { search(); } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::cli::helpers::format_query; + pub fn cmd_search() { format_query(); } + "#, + ), + ], + 3, + "cmd_search", + &["crate::application::session::search"], + ), + ( + "no delegation: handler stays in the adapter layer", + &[ + ("src/application/session.rs", "pub fn search() {}"), + ( + "src/cli/helpers.rs", + r#" + pub fn adapter_helper2() {} + pub fn adapter_helper() { adapter_helper2(); } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::cli::helpers::adapter_helper; + pub fn cmd_local_only() { adapter_helper(); } + "#, + ), + ], + 3, + "cmd_local_only", + &[], + ), + ( + "branch with two distinct target fns", + &[ + ( + "src/application/session.rs", + r#" + pub fn foo() {} + pub fn bar() {} + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::{foo, bar}; + pub fn cmd_branch(cond: bool) { + if cond { foo(); } else { bar(); } + } + "#, + ), + ], + 3, + "cmd_branch", + &[ + "crate::application::session::foo", + "crate::application::session::bar", + ], + ), + ( + "loop: same target at many call sites collapses to one", + &[ + ("src/application/session.rs", "pub fn process(_x: u32) {}"), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::process; + pub fn cmd_batch() { + for x in 0..10 { process(x); } + } + "#, + ), + ], + 3, + "cmd_batch", + &["crate::application::session::process"], + ), + ( + // boundary semantic: application-internal `record_operation` + // reached past `search` must NOT appear in the set + "stop at the target boundary", + &[ + ( + "src/application/session.rs", + r#" + use crate::application::middleware::record_operation; + pub fn search() { record_operation(); } + "#, + ), + ( + "src/application/middleware.rs", + "pub fn record_operation() {}", + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::session::search; + pub fn cmd_search() { search(); } + "#, + ), + ], + 3, + "cmd_search", + &["crate::application::session::search"], + ), + ( + // cmd → h1 → h2 → h3 → h4 → search (5 hops); depth 3 stops short + "call_depth exceeded returns the empty set", + &[ + ("src/application/session.rs", "pub fn search() {}"), + ( + "src/cli/helpers.rs", + r#" + use crate::application::session::search; + pub fn h4() { search(); } + pub fn h3() { h4(); } + pub fn h2() { h3(); } + pub fn h1() { h2(); } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::cli::helpers::h1; + pub fn cmd_deep() { h1(); } + "#, + ), + ], + 3, + "cmd_deep", + &[], + ), + ( + // cmd → h1 → h2 → search (3 hops); depth 3 just reaches it + "call_depth just inside the limit reaches the target", + &[ + ("src/application/session.rs", "pub fn search() {}"), + ( + "src/cli/helpers.rs", + r#" + use crate::application::session::search; + pub fn h2() { search(); } + pub fn h1() { h2(); } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::cli::helpers::h1; + pub fn cmd_depth3() { h1(); } + "#, + ), + ], + 3, + "cmd_depth3", + &["crate::application::session::search"], + ), + ( + // three overriding impls collapse to ONE `::` anchor + "trait dispatch collapses to a single anchor", + &[ + ( + "src/application/handler.rs", + r#" + pub trait Handler { fn handle(&self); } + pub struct LoggingHandler; + impl Handler for LoggingHandler { fn handle(&self) {} } + pub struct MetricsHandler; + impl Handler for MetricsHandler { fn handle(&self) {} } + pub struct AuditHandler; + impl Handler for AuditHandler { fn handle(&self) {} } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::application::handler::Handler; + pub fn cmd_dispatch(h: &dyn Handler) { h.handle(); } + "#, + ), + ], + 3, + "cmd_dispatch", + &["crate::application::handler::Handler::handle"], + ), + ( + // anchor declared in a peer-adapter (mcp) layer must not be a + // target boundary, even with a target-layer overriding impl + "anchor declared in a peer-adapter layer is skipped", + &[ + ( + "src/mcp/handler.rs", + "pub trait Handler { fn handle(&self); }", + ), + ( + "src/application/logging.rs", + r#" + use crate::mcp::handler::Handler; + pub struct LoggingHandler; + impl Handler for LoggingHandler { fn handle(&self) {} } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::mcp::handler::Handler; + pub fn cmd_via_dyn_peer(h: &dyn Handler) { h.handle(); } + "#, + ), + ], + 3, + "cmd_via_dyn_peer", + &[], + ), + ( + // CLI → MCP handler → application: the CLI walk must not inherit + // MCP's touchpoint by traversing a peer adapter + "peer-adapter traversal is blocked", + &[ + ("src/application/session.rs", "pub fn search() {}"), + ( + "src/mcp/handlers.rs", + r#" + use crate::application::session::search; + pub fn mcp_search() { search(); } + "#, + ), + ( + "src/cli/handlers.rs", + r#" + use crate::mcp::handlers::mcp_search; + pub fn cmd_via_mcp() { mcp_search(); } + "#, + ), + ], + 3, + "cmd_via_mcp", + &[], + ), +]; + +#[test] +fn touchpoint_sets() { + for (label, files, depth, handler, expected) in TOUCHPOINT_SET_CASES { + let touchpoints = tp_3l(files, *depth, handler); + let expected_set: HashSet = expected.iter().map(|s| s.to_string()).collect(); + assert_eq!( + touchpoints, expected_set, + "case {label}: actual={touchpoints:?} expected={expected_set:?}" + ); + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/infer_call.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/infer_call.rs index 0716e1a9..293998b3 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/infer_call.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/infer_call.rs @@ -149,17 +149,29 @@ fn test_call_self_without_self_type_is_none() { // ── MethodCall ──────────────────────────────────────────────────── #[test] -fn test_method_call_with_bound_receiver() { - let mut f = TypeInferFixture::new(); - f.bindings - .insert("session", CanonicalType::path(["crate", "app", "Session"])); - f.index.insert_method_return( - "crate::app::Session", - "diff", - CanonicalType::path(["crate", "app", "Response"]), - ); - let t = infer(&f, "session.diff()").expect("method resolved"); - assert_eq!(t, CanonicalType::path(["crate", "app", "Response"])); +fn method_call_resolves_receiver_type_through_references() { + // A method call resolves via the receiver's bound type. A parenthesised + // reference receiver `(&s)` must be stripped first, then resolved the same + // way as a direct receiver. + for (label, var, expr) in [ + ("direct receiver", "session", "session.diff()"), + ("reference receiver is stripped", "s", "(&s).diff()"), + ] { + let mut f = TypeInferFixture::new(); + f.bindings + .insert(var, CanonicalType::path(["crate", "app", "Session"])); + f.index.insert_method_return( + "crate::app::Session", + "diff", + CanonicalType::path(["crate", "app", "Response"]), + ); + let t = infer(&f, expr).unwrap_or_else(|| panic!("case {label}: method resolved")); + assert_eq!( + t, + CanonicalType::path(["crate", "app", "Response"]), + "case {label}" + ); + } } #[test] @@ -217,17 +229,3 @@ fn test_method_call_unknown_method_is_none() { // No entry in method_returns for "bogus" on Session. assert!(infer(&f, "x.bogus()").is_none()); } - -#[test] -fn test_method_call_on_reference_strips_and_resolves() { - let mut f = TypeInferFixture::new(); - f.bindings - .insert("s", CanonicalType::path(["crate", "app", "Session"])); - f.index.insert_method_return( - "crate::app::Session", - "diff", - CanonicalType::path(["crate", "app", "Response"]), - ); - let t = infer(&f, "(&s).diff()").expect("ref receiver resolved"); - assert_eq!(t, CanonicalType::path(["crate", "app", "Response"])); -} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/patterns_destructure.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/patterns_destructure.rs index 550e396b..891c7f92 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/patterns_destructure.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/patterns_destructure.rs @@ -134,34 +134,60 @@ fn test_none_pattern_binds_nothing() { // ── Pat::Struct ────────────────────────────────────────────────── #[test] -fn test_struct_pattern_binds_field_by_name() { - let mut f = TypeInferFixture::new(); - f.index.insert_struct_field( - "crate::app::Ctx", - "session", - CanonicalType::path(["crate", "app", "Session"]), - ); - let matched = CanonicalType::path(["crate", "app", "Ctx"]); - let b = bindings(&f, "Ctx { session }", matched); - assert_eq!(b.len(), 1); - assert_eq!(b[0].0, "session"); - assert_eq!(b[0].1, CanonicalType::path(["crate", "app", "Session"])); -} - -#[test] -fn test_struct_pattern_with_aliased_field() { - let mut f = TypeInferFixture::new(); - f.index.insert_struct_field( - "crate::app::Ctx", - "session", - CanonicalType::path(["crate", "app", "Session"]), +fn struct_pattern_binds_indexed_field_type() { + // A struct pattern binds each named field to its indexed field type; an + // aliased field (`field: alias`) binds the alias name; a `Some(Struct{..})` + // unwraps the Option first. (label, field, field_leaf, matched, pat, bound_name) + type Case = ( + &'static str, + &'static str, + &'static str, + CanonicalType, + &'static str, + &'static str, ); - let matched = CanonicalType::path(["crate", "app", "Ctx"]); - let b = bindings(&f, "Ctx { session: s }", matched); - assert_eq!(b.len(), 1); - // The alias `s` is bound, not `session`. - assert_eq!(b[0].0, "s"); - assert_eq!(b[0].1, CanonicalType::path(["crate", "app", "Session"])); + let cases: Vec = vec![ + ( + "field bound by name", + "session", + "Session", + CanonicalType::path(["crate", "app", "Ctx"]), + "Ctx { session }", + "session", + ), + ( + "aliased field binds the alias, not the field name", + "session", + "Session", + CanonicalType::path(["crate", "app", "Ctx"]), + "Ctx { session: s }", + "s", + ), + ( + "Some(Struct { field }) unwraps the Option first", + "id", + "Id", + CanonicalType::Option(Box::new(CanonicalType::path(["crate", "app", "Ctx"]))), + "Some(Ctx { id })", + "id", + ), + ]; + for (label, field, field_leaf, matched, pat, bound_name) in cases { + let mut f = TypeInferFixture::new(); + f.index.insert_struct_field( + "crate::app::Ctx", + field, + CanonicalType::path(["crate", "app", field_leaf]), + ); + let b = bindings(&f, pat, matched); + assert_eq!(b.len(), 1, "case {label}: one binding"); + assert_eq!(b[0].0, bound_name, "case {label}: bound name"); + assert_eq!( + b[0].1, + CanonicalType::path(["crate", "app", field_leaf]), + "case {label}: bound type" + ); + } } #[test] @@ -250,19 +276,3 @@ fn test_or_pattern_uses_first_branch_bindings() { } // ── Nested patterns ────────────────────────────────────────────── - -#[test] -fn test_nested_some_struct() { - let mut f = TypeInferFixture::new(); - f.index.insert_struct_field( - "crate::app::Ctx", - "id", - CanonicalType::path(["crate", "app", "Id"]), - ); - // matched: Option; pattern unwraps Some to Ctx then binds id. - let opt = CanonicalType::Option(Box::new(CanonicalType::path(["crate", "app", "Ctx"]))); - let b = bindings(&f, "Some(Ctx { id })", opt); - assert_eq!(b.len(), 1); - assert_eq!(b[0].0, "id"); - assert_eq!(b[0].1, CanonicalType::path(["crate", "app", "Id"])); -} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve.rs deleted file mode 100644 index 6572ccd3..00000000 --- a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve.rs +++ /dev/null @@ -1,844 +0,0 @@ -//! Unit tests for `syn::Type` → `CanonicalType` conversion. -//! -//! The `resolve` module is `pub(super)` — these tests live in the same -//! crate and reach it via the in-crate module path. - -use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; -use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::canonical::CanonicalType; -use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::resolve::{ - resolve_type, ResolveContext, -}; -use crate::adapters::shared::use_tree::{AliasTarget, ScopedAliasMap}; -use std::collections::{HashMap, HashSet}; - -fn parse_type(src: &str) -> syn::Type { - syn::parse_str(src).expect("parse type") -} - -fn ctx<'a>(file: &'a FileScope<'a>) -> ResolveContext<'a> { - ResolveContext { - file, - mod_stack: &[], - type_aliases: None, - transparent_wrappers: None, - workspace_files: None, - alias_param_subs: None, - generic_params: None, - reexports: None, - } -} - -#[test] -fn test_bare_path_resolves_via_local_symbols() { - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("Session".to_string()); - let roots = HashSet::new(); - let ty = parse_type("Session"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/app/session.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert_eq!( - resolved, - CanonicalType::path(["crate", "app", "session", "Session"]) - ); -} - -#[test] -fn test_reference_type_strips_and_recurses() { - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("Session".to_string()); - let roots = HashSet::new(); - let ty = parse_type("&Session"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/app/session.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert_eq!( - resolved, - CanonicalType::path(["crate", "app", "session", "Session"]) - ); -} - -#[test] -fn test_result_wraps_inner() { - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("Session".to_string()); - let roots = HashSet::new(); - let ty = parse_type("Result"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/app/session.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - match resolved { - CanonicalType::Result(inner) => { - assert_eq!( - *inner, - CanonicalType::path(["crate", "app", "session", "Session"]) - ); - } - other => panic!("expected Result(_), got {:?}", other), - } -} - -#[test] -fn test_option_wraps_inner() { - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("T".to_string()); - let roots = HashSet::new(); - let ty = parse_type("Option"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/foo.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert!(matches!(resolved, CanonicalType::Option(_))); -} - -#[test] -fn test_arc_is_stripped() { - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("Session".to_string()); - let roots = HashSet::new(); - let ty = parse_type("Arc"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/app/session.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert_eq!( - resolved, - CanonicalType::path(["crate", "app", "session", "Session"]) - ); -} - -#[test] -fn test_nested_smart_pointers_strip_to_inner() { - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("Session".to_string()); - let roots = HashSet::new(); - // Only smart-pointer wrappers (`Arc` / `Box` / `Rc` / `Cow`) are - // Deref-transparent, so nesting them still reaches the inner type. - let ty = parse_type("Arc>"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/app/session.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert_eq!( - resolved, - CanonicalType::path(["crate", "app", "session", "Session"]) - ); -} - -#[test] -fn test_rwlock_is_not_peeled() { - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("Session".to_string()); - let roots = HashSet::new(); - // `RwLock::read()` returns a guard, not the inner value — peeling - // it would synthesize bogus `Session::read` edges. Stays `Opaque`. - let ty = parse_type("Arc>"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/app/session.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert_eq!(resolved, CanonicalType::Opaque); -} - -#[test] -fn test_vec_becomes_slice() { - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("Handler".to_string()); - let roots = HashSet::new(); - let ty = parse_type("Vec"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/foo.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert!(matches!(resolved, CanonicalType::Slice(_))); -} - -#[test] -fn test_hashmap_keeps_value_type() { - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("Handler".to_string()); - let roots = HashSet::new(); - let ty = parse_type("HashMap"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/foo.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - match resolved { - CanonicalType::Map(inner) => { - assert_eq!(*inner, CanonicalType::path(["crate", "foo", "Handler"])); - } - other => panic!("expected Map(_), got {:?}", other), - } -} - -#[test] -fn test_array_becomes_slice() { - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("T".to_string()); - let roots = HashSet::new(); - let ty = parse_type("[T; 4]"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/foo.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert!(matches!(resolved, CanonicalType::Slice(_))); -} - -#[test] -fn test_slice_type_becomes_slice() { - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("T".to_string()); - let roots = HashSet::new(); - let ty = parse_type("&[T]"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/foo.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert!(matches!(resolved, CanonicalType::Slice(_))); -} - -#[test] -fn test_trait_object_unresolved_is_opaque() { - let alias_map = HashMap::new(); - let local = HashSet::new(); - let roots = HashSet::new(); - let ty = parse_type("Box"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/foo.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - // Box → strip Box → dyn T — when T isn't resolvable (not in - // local symbols / alias map / crate roots), stays Opaque. - assert_eq!(resolved, CanonicalType::Opaque); -} - -#[test] -fn test_trait_object_resolves_via_local_symbols() { - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("Handler".to_string()); - let roots = HashSet::new(); - let ty = parse_type("Box"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/app/mod.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert_eq!( - resolved, - CanonicalType::TraitBound(vec![vec![ - "crate".to_string(), - "app".to_string(), - "Handler".to_string(), - ]]) - ); -} - -#[test] -fn test_impl_trait_unresolved_is_opaque() { - let alias_map = HashMap::new(); - let local = HashSet::new(); - let roots = HashSet::new(); - // `Iterator` isn't in local symbols / alias map — stays Opaque. - let ty = parse_type("impl Iterator"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/foo.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert_eq!(resolved, CanonicalType::Opaque); -} - -#[test] -fn test_impl_trait_resolves_to_trait_bound() { - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("Handler".to_string()); - let roots = HashSet::new(); - // `impl Handler` return-type resolves to `TraitBound(Handler)` so - // trait-dispatch over-approximation can fire on the method call. - let ty = parse_type("impl Handler + Send"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/app/mod.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert_eq!( - resolved, - CanonicalType::TraitBound(vec![vec![ - "crate".to_string(), - "app".to_string(), - "Handler".to_string(), - ]]) - ); -} - -#[test] -fn test_unknown_external_path_is_opaque() { - let alias_map = HashMap::new(); - let local = HashSet::new(); - let roots = HashSet::new(); - let ty = parse_type("external_crate::UnknownType"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/foo.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert_eq!(resolved, CanonicalType::Opaque); -} - -#[test] -fn test_aliased_path_resolves_via_alias_map() { - let mut alias_map = HashMap::new(); - alias_map.insert( - "Session".to_string(), - AliasTarget::relative(vec![ - "crate".to_string(), - "app".to_string(), - "session".to_string(), - "Session".to_string(), - ]), - ); - let local = HashSet::new(); - let roots = HashSet::new(); - let ty = parse_type("Session"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/cli/handlers.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert_eq!( - resolved, - CanonicalType::path(["crate", "app", "session", "Session"]) - ); -} - -#[test] -fn test_future_wraps_output() { - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("Response".to_string()); - let roots = HashSet::new(); - let ty = parse_type("Future"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/foo.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert!(matches!(resolved, CanonicalType::Future(_))); -} - -#[test] -fn test_impl_trait_local_send_named_trait_resolves_not_skipped() { - // `use crate::ports::Send;` then `impl Send` (or `dyn Send`) refers - // to a workspace trait that happens to share its name with the std - // marker. The marker-trait skip used to discard it based on the raw - // last segment, dropping the bound and leaving downstream method - // dispatch (`h.handle()`) unresolved. After alias canonicalisation - // the path resolves to `crate::ports::Send`, which is *not* - // stdlib-prefixed and therefore not a marker. - let mut alias_map = HashMap::new(); - alias_map.insert( - "Send".to_string(), - AliasTarget::relative(vec![ - "crate".to_string(), - "ports".to_string(), - "Send".to_string(), - ]), - ); - let local = HashSet::new(); - let roots = HashSet::new(); - let ty = parse_type("impl Send"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/app/mod.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert_eq!( - resolved, - CanonicalType::TraitBound(vec![vec![ - "crate".to_string(), - "ports".to_string(), - "Send".to_string(), - ]]), - "workspace `Send`-named trait must resolve to its canonical path, \ - not be discarded as a std marker; got {resolved:?}", - ); -} - -#[test] -fn test_impl_trait_bare_std_send_marker_still_skipped() { - // Regression guard: the canonicalisation-first refactor must NOT - // start treating bare `Send` / `Sync` / `Debug` as workspace - // traits. With no alias for `Send` in scope, the bound stays - // unresolvable, and the conservative "single-segment marker" - // fallback still skips it. `impl Handler + Send` therefore picks - // up `Handler`, not the marker. - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("Handler".to_string()); - let roots = HashSet::new(); - let ty = parse_type("impl Handler + Send"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/app/mod.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert_eq!( - resolved, - CanonicalType::TraitBound(vec![vec![ - "crate".to_string(), - "app".to_string(), - "Handler".to_string(), - ]]), - "bare std-marker `Send` must still be skipped so dispatch picks \ - up the local `Handler`; got {resolved:?}", - ); -} - -#[test] -fn test_impl_trait_external_aliased_bound_skipped_workspace_bound_wins() { - // `use serde::Serialize;` then `impl Serialize + Handler`. The - // first bound canonicalises to the external path - // `["serde", "Serialize"]`. Trait dispatch only knows the - // workspace, so accepting an external bound would shadow the - // later workspace `Handler` and leave `make().handle()` - // unresolved. External aliased bounds must be skipped just like - // fully-qualified `serde::Serialize` already is (canonicalisation - // returns `None` for the un-aliased external form). - let mut alias_map = HashMap::new(); - alias_map.insert( - "Serialize".to_string(), - AliasTarget::relative(vec!["serde".to_string(), "Serialize".to_string()]), - ); - let mut local = HashSet::new(); - local.insert("Handler".to_string()); - let roots = HashSet::new(); - let ty = parse_type("impl Serialize + Handler"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/app/mod.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - assert_eq!( - resolved, - CanonicalType::TraitBound(vec![vec![ - "crate".to_string(), - "app".to_string(), - "Handler".to_string(), - ]]), - "external aliased bound `serde::Serialize` must be skipped so \ - workspace `Handler` is picked; got {resolved:?}", - ); -} - -#[test] -fn test_impl_aliased_future_resolves_to_future_with_output() { - // `use std::future::Future as Fut;` then `impl Fut`. - // The raw bound leaf is `Fut`, but the canonicalised path is - // `std::future::Future`, so the bound must still shape the - // result as `Future(Session)` — otherwise `.await` on the - // return type doesn't unwrap and downstream method dispatch - // (e.g. `make().await.diff()`) stays unresolved. - let mut alias_map = HashMap::new(); - alias_map.insert( - "Fut".to_string(), - AliasTarget::relative(vec![ - "std".to_string(), - "future".to_string(), - "Future".to_string(), - ]), - ); - let mut local = HashSet::new(); - local.insert("Session".to_string()); - let roots = HashSet::new(); - let ty = parse_type("impl Fut"); - let resolved = resolve_type( - &ty, - &ctx(&FileScope { - path: "src/app/mod.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }), - ); - let expected_output = CanonicalType::path(["crate", "app", "Session"]); - assert_eq!( - resolved, - CanonicalType::Future(Box::new(expected_output)), - "aliased Future bound must canonicalise to Future(Session); got {resolved:?}", - ); -} - -/// Per-file scope inputs the cross-module alias test owns. `FileScope` -/// holds borrows, so the owning storage stays here and `as_scope` -/// produces a fresh borrow at call sites. -struct ScopeInputs { - path: String, - alias_map: crate::adapters::shared::use_tree::AliasMap, - aliases_per_scope: ScopedAliasMap, - local_symbols: HashSet, - local_decl_scopes: HashMap>>, - crate_root_modules: HashSet, -} - -impl ScopeInputs { - fn new(path: &str) -> Self { - Self { - path: path.to_string(), - alias_map: HashMap::new(), - aliases_per_scope: ScopedAliasMap::new(), - local_symbols: HashSet::new(), - local_decl_scopes: HashMap::new(), - crate_root_modules: HashSet::new(), - } - } - - fn as_scope(&self) -> FileScope<'_> { - FileScope { - path: &self.path, - alias_map: &self.alias_map, - aliases_per_scope: &self.aliases_per_scope, - local_symbols: &self.local_symbols, - workspace_module_paths: None, - local_decl_scopes: &self.local_decl_scopes, - crate_root_modules: &self.crate_root_modules, - } - } -} - -#[test] -fn test_alias_generic_arg_resolves_at_use_site() { - // `domain::type Wrap = Arc` consumed from `app` as - // `Wrap`: the use-site arg `Session` must canonicalise - // against `app`'s symbols, not against `domain`'s decl-site - // scope, which doesn't know `Session`. - use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::workspace_index::AliasDef; - - let domain = ScopeInputs::new("src/domain.rs"); - let mut app = ScopeInputs::new("src/app.rs"); - app.alias_map.insert( - "Wrap".to_string(), - AliasTarget::relative(vec![ - "crate".to_string(), - "domain".to_string(), - "Wrap".to_string(), - ]), - ); - app.local_symbols.insert("Session".to_string()); - - let mut workspace_files: HashMap> = HashMap::new(); - workspace_files.insert("src/domain.rs".to_string(), domain.as_scope()); - - let alias_target: syn::Type = syn::parse_str("Arc").expect("parse alias target"); - let mut type_aliases: HashMap = HashMap::new(); - type_aliases.insert( - "crate::domain::Wrap".to_string(), - AliasDef { - params: vec!["T".to_string()], - target: alias_target, - decl_file: "src/domain.rs".to_string(), - decl_mod_stack: Vec::new(), - }, - ); - - let app_scope = app.as_scope(); - let ty = parse_type("Wrap"); - let resolved = resolve_type( - &ty, - &ResolveContext { - file: &app_scope, - mod_stack: &[], - type_aliases: Some(&type_aliases), - transparent_wrappers: None, - workspace_files: Some(&workspace_files), - alias_param_subs: None, - generic_params: None, - reexports: None, - }, - ); - assert_eq!( - resolved, - CanonicalType::path(["crate", "app", "Session"]), - "alias generic args must resolve at the use-site, got {resolved:?}" - ); -} - -#[test] -fn unbounded_generic_param_shadows_same_named_workspace_symbol() { - // `fn f(...)` with NO bound on Q. Inside the body, a path like - // `Q` must resolve to `Opaque` (the fn-scoped param shadows any - // workspace symbol of the same name), not to the workspace - // canonical for a top-level type named `Q`. Without explicit - // shadowing, `resolve_generic_path` would fall through to - // `canonicalise_type_segments_in_scope` and resolve `Q` to - // `crate::Q`, producing wrong method-dispatch edges. - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("Q".to_string()); - let roots = HashSet::new(); - let file_scope = FileScope { - path: "src/app/runner.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }; - use crate::adapters::analyzers::architecture::call_parity_rule::signature_params::ParamInfo; - let mut generics: HashMap = HashMap::new(); - // Unbounded `` — the param exists, but with no usable bounds. - generics.insert( - "Q".to_string(), - ParamInfo { - bounds: vec![], - turbofish_index: Some(0), - }, - ); - let ty = parse_type("Q"); - let resolved = resolve_type( - &ty, - &ResolveContext { - file: &file_scope, - mod_stack: &[], - type_aliases: None, - transparent_wrappers: None, - workspace_files: None, - alias_param_subs: None, - generic_params: Some(&generics), - reexports: None, - }, - ); - assert_eq!( - resolved, - CanonicalType::Opaque, - "unbounded generic param `Q` must shadow same-named workspace \ - symbol — falling through to canonicalisation would resolve \ - to `crate::Q` and produce wrong dispatch edges, got {resolved:?}" - ); -} - -#[test] -fn unbounded_generic_param_shadowing_does_not_affect_unrelated_path() { - // Sanity: the shadowing fix must not affect a workspace symbol - // whose name is NOT in `generic_params`. `Session` still resolves - // to the workspace canonical even when `Q` is in the param map. - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("Session".to_string()); - let roots = HashSet::new(); - let file_scope = FileScope { - path: "src/app/session.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }; - use crate::adapters::analyzers::architecture::call_parity_rule::signature_params::ParamInfo; - let mut generics: HashMap = HashMap::new(); - generics.insert( - "Q".to_string(), - ParamInfo { - bounds: vec![], - turbofish_index: Some(0), - }, - ); - let ty = parse_type("Session"); - let resolved = resolve_type( - &ty, - &ResolveContext { - file: &file_scope, - mod_stack: &[], - type_aliases: None, - transparent_wrappers: None, - workspace_files: None, - alias_param_subs: None, - generic_params: Some(&generics), - reexports: None, - }, - ); - assert_eq!( - resolved, - CanonicalType::path(["crate", "app", "session", "Session"]), - "path NOT in generic_params must still resolve normally, got {resolved:?}" - ); -} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve/mod.rs new file mode 100644 index 00000000..3c00ed2b --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve/mod.rs @@ -0,0 +1,134 @@ +//! Unit tests for `syn::Type` → `CanonicalType` conversion (the `resolve` +//! module). Split into focused sub-files (each ≤ the SRP file-length cap); +//! shared imports + the `parse_type`/`ctx`/`resolve_*` helpers live here and +//! reach the sub-modules via `use super::*`. + +pub(super) use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; +pub(super) use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::canonical::CanonicalType; +pub(super) use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::resolve::{ + resolve_type, ResolveContext, +}; +pub(super) use crate::adapters::shared::use_tree::{AliasTarget, ScopedAliasMap}; +pub(super) use std::collections::{HashMap, HashSet}; + +mod part_a; +mod part_b; + +pub(super) fn parse_type(src: &str) -> syn::Type { + syn::parse_str(src).expect("parse type") +} + +pub(super) fn ctx<'a>(file: &'a FileScope<'a>) -> ResolveContext<'a> { + ResolveContext { + file, + mod_stack: &[], + type_aliases: None, + transparent_wrappers: None, + workspace_files: None, + alias_param_subs: None, + generic_params: None, + reexports: None, + } +} + +/// Resolve `ty_src` in a `FileScope` with the given path, local symbols, and +/// crate-root modules (empty alias / scoped-alias / decl-scope maps, no +/// workspace module paths). Covers the common test shape; tests that need a +/// populated alias map or scoped aliases build the `FileScope` inline. +pub(super) fn resolve_in( + ty_src: &str, + path: &str, + locals: &[&str], + roots: &[&str], +) -> CanonicalType { + let alias_map = HashMap::new(); + let local: HashSet = locals.iter().map(|s| s.to_string()).collect(); + let root_set: HashSet = roots.iter().map(|s| s.to_string()).collect(); + resolve_type( + &parse_type(ty_src), + &ctx(&FileScope { + path, + alias_map: &alias_map, + aliases_per_scope: &ScopedAliasMap::new(), + local_symbols: &local, + local_decl_scopes: &HashMap::new(), + crate_root_modules: &root_set, + workspace_module_paths: None, + }), + ) +} + +/// Resolve a type with a populated `use`-alias map: each `(name, target)` +/// becomes `alias_map[name] = AliasTarget::relative(target)`. +pub(super) fn resolve_aliased( + ty_src: &str, + path: &str, + aliases: &[(&str, &[&str])], + locals: &[&str], +) -> CanonicalType { + let mut alias_map = HashMap::new(); + for (name, target) in aliases { + alias_map.insert( + name.to_string(), + AliasTarget::relative(target.iter().map(|s| s.to_string()).collect()), + ); + } + let local: HashSet = locals.iter().map(|s| s.to_string()).collect(); + let roots = HashSet::new(); + resolve_type( + &parse_type(ty_src), + &ctx(&FileScope { + path, + alias_map: &alias_map, + aliases_per_scope: &ScopedAliasMap::new(), + local_symbols: &local, + local_decl_scopes: &HashMap::new(), + crate_root_modules: &roots, + workspace_module_paths: None, + }), + ) +} + +/// Resolve a type inside a fn body that declares a single unbounded generic +/// param `param` (turbofish index 0) — the param shadows same-named symbols. +pub(super) fn resolve_with_unbounded_param( + ty_src: &str, + path: &str, + locals: &[&str], + param: &str, +) -> CanonicalType { + use crate::adapters::analyzers::architecture::call_parity_rule::signature_params::ParamInfo; + let alias_map = HashMap::new(); + let local: HashSet = locals.iter().map(|s| s.to_string()).collect(); + let roots = HashSet::new(); + let file_scope = FileScope { + path, + alias_map: &alias_map, + aliases_per_scope: &ScopedAliasMap::new(), + local_symbols: &local, + local_decl_scopes: &HashMap::new(), + crate_root_modules: &roots, + workspace_module_paths: None, + }; + let mut generics: HashMap = HashMap::new(); + generics.insert( + param.to_string(), + ParamInfo { + bounds: vec![], + turbofish_index: Some(0), + }, + ); + resolve_type( + &parse_type(ty_src), + &ResolveContext { + file: &file_scope, + mod_stack: &[], + type_aliases: None, + transparent_wrappers: None, + workspace_files: None, + alias_param_subs: None, + generic_params: Some(&generics), + reexports: None, + }, + ) +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve/part_a.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve/part_a.rs new file mode 100644 index 00000000..e4ab2b3f --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve/part_a.rs @@ -0,0 +1,175 @@ +use super::*; + +#[test] +fn test_bare_path_resolves_via_local_symbols() { + let resolved = resolve_in("Session", "src/app/session.rs", &["Session"], &[]); + assert_eq!( + resolved, + CanonicalType::path(["crate", "app", "session", "Session"]) + ); +} + +#[test] +fn test_reference_type_strips_and_recurses() { + let resolved = resolve_in("&Session", "src/app/session.rs", &["Session"], &[]); + assert_eq!( + resolved, + CanonicalType::path(["crate", "app", "session", "Session"]) + ); +} + +#[test] +fn test_result_wraps_inner() { + let resolved = resolve_in( + "Result", + "src/app/session.rs", + &["Session"], + &[], + ); + match resolved { + CanonicalType::Result(inner) => { + assert_eq!( + *inner, + CanonicalType::path(["crate", "app", "session", "Session"]) + ); + } + other => panic!("expected Result(_), got {:?}", other), + } +} + +#[test] +fn test_option_wraps_inner() { + let resolved = resolve_in("Option", "src/foo.rs", &["T"], &[]); + assert!(matches!(resolved, CanonicalType::Option(_))); +} + +#[test] +fn test_arc_is_stripped() { + let resolved = resolve_in("Arc", "src/app/session.rs", &["Session"], &[]); + assert_eq!( + resolved, + CanonicalType::path(["crate", "app", "session", "Session"]) + ); +} + +#[test] +fn test_nested_smart_pointers_strip_to_inner() { + // Only smart-pointer wrappers (Arc/Box/Rc/Cow) are Deref-transparent, so + // nesting them still reaches the inner type. + let resolved = resolve_in("Arc>", "src/app/session.rs", &["Session"], &[]); + assert_eq!( + resolved, + CanonicalType::path(["crate", "app", "session", "Session"]) + ); +} + +#[test] +fn test_rwlock_is_not_peeled() { + // `RwLock::read()` returns a guard, not the inner value — peeling it + // would synthesize bogus `Session::read` edges. Stays `Opaque`. + let resolved = resolve_in( + "Arc>", + "src/app/session.rs", + &["Session"], + &[], + ); + assert_eq!(resolved, CanonicalType::Opaque); +} + +#[test] +fn test_vec_becomes_slice() { + let resolved = resolve_in("Vec", "src/foo.rs", &["Handler"], &[]); + assert!(matches!(resolved, CanonicalType::Slice(_))); +} + +#[test] +fn test_hashmap_keeps_value_type() { + let resolved = resolve_in("HashMap", "src/foo.rs", &["Handler"], &[]); + match resolved { + CanonicalType::Map(inner) => { + assert_eq!(*inner, CanonicalType::path(["crate", "foo", "Handler"])); + } + other => panic!("expected Map(_), got {:?}", other), + } +} + +#[test] +fn test_array_becomes_slice() { + let resolved = resolve_in("[T; 4]", "src/foo.rs", &["T"], &[]); + assert!(matches!(resolved, CanonicalType::Slice(_))); +} + +#[test] +fn test_slice_type_becomes_slice() { + let resolved = resolve_in("&[T]", "src/foo.rs", &["T"], &[]); + assert!(matches!(resolved, CanonicalType::Slice(_))); +} + +#[test] +fn test_trait_object_unresolved_is_opaque() { + // Box → strip Box → dyn T — when T isn't resolvable (not in + // local symbols / alias map / crate roots), stays Opaque. + let resolved = resolve_in("Box", "src/foo.rs", &[], &[]); + assert_eq!(resolved, CanonicalType::Opaque); +} + +#[test] +fn test_trait_object_resolves_via_local_symbols() { + let resolved = resolve_in("Box", "src/app/mod.rs", &["Handler"], &[]); + assert_eq!( + resolved, + CanonicalType::TraitBound(vec![vec![ + "crate".to_string(), + "app".to_string(), + "Handler".to_string(), + ]]) + ); +} + +#[test] +fn test_impl_trait_unresolved_is_opaque() { + // `Iterator` isn't in local symbols / alias map — stays Opaque. + let resolved = resolve_in("impl Iterator", "src/foo.rs", &[], &[]); + assert_eq!(resolved, CanonicalType::Opaque); +} + +#[test] +fn test_impl_trait_resolves_to_trait_bound() { + // `impl Handler` return-type resolves to `TraitBound(Handler)` so + // trait-dispatch over-approximation can fire on the method call. + let resolved = resolve_in("impl Handler + Send", "src/app/mod.rs", &["Handler"], &[]); + assert_eq!( + resolved, + CanonicalType::TraitBound(vec![vec![ + "crate".to_string(), + "app".to_string(), + "Handler".to_string(), + ]]) + ); +} + +#[test] +fn test_unknown_external_path_is_opaque() { + let resolved = resolve_in("external_crate::UnknownType", "src/foo.rs", &[], &[]); + assert_eq!(resolved, CanonicalType::Opaque); +} + +#[test] +fn test_aliased_path_resolves_via_alias_map() { + let resolved = resolve_aliased( + "Session", + "src/cli/handlers.rs", + &[("Session", &["crate", "app", "session", "Session"])], + &[], + ); + assert_eq!( + resolved, + CanonicalType::path(["crate", "app", "session", "Session"]) + ); +} + +#[test] +fn test_future_wraps_output() { + let resolved = resolve_in("Future", "src/foo.rs", &["Response"], &[]); + assert!(matches!(resolved, CanonicalType::Future(_))); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve/part_b.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve/part_b.rs new file mode 100644 index 00000000..7d6c796c --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve/part_b.rs @@ -0,0 +1,229 @@ +use super::*; + +#[test] +fn test_impl_trait_local_send_named_trait_resolves_not_skipped() { + // `use crate::ports::Send;` then `impl Send` (or `dyn Send`) refers + // to a workspace trait that happens to share its name with the std + // marker. The marker-trait skip used to discard it based on the raw + // last segment, dropping the bound and leaving downstream method + // dispatch (`h.handle()`) unresolved. After alias canonicalisation + // the path resolves to `crate::ports::Send`, which is *not* + // stdlib-prefixed and therefore not a marker. + let resolved = resolve_aliased( + "impl Send", + "src/app/mod.rs", + &[("Send", &["crate", "ports", "Send"])], + &[], + ); + assert_eq!( + resolved, + CanonicalType::TraitBound(vec![vec![ + "crate".to_string(), + "ports".to_string(), + "Send".to_string(), + ]]), + "workspace `Send`-named trait must resolve to its canonical path, \ + not be discarded as a std marker; got {resolved:?}", + ); +} + +#[test] +fn test_impl_trait_bare_std_send_marker_still_skipped() { + // Regression guard: the canonicalisation-first refactor must NOT + // start treating bare `Send` / `Sync` / `Debug` as workspace + // traits. With no alias for `Send` in scope, the bound stays + // unresolvable, and the conservative "single-segment marker" + // fallback still skips it. `impl Handler + Send` therefore picks + // up `Handler`, not the marker. + let resolved = resolve_in("impl Handler + Send", "src/app/mod.rs", &["Handler"], &[]); + assert_eq!( + resolved, + CanonicalType::TraitBound(vec![vec![ + "crate".to_string(), + "app".to_string(), + "Handler".to_string(), + ]]), + "bare std-marker `Send` must still be skipped so dispatch picks \ + up the local `Handler`; got {resolved:?}", + ); +} + +#[test] +fn test_impl_trait_external_aliased_bound_skipped_workspace_bound_wins() { + // `use serde::Serialize;` then `impl Serialize + Handler`. The + // first bound canonicalises to the external path + // `["serde", "Serialize"]`. Trait dispatch only knows the + // workspace, so accepting an external bound would shadow the + // later workspace `Handler` and leave `make().handle()` + // unresolved. External aliased bounds must be skipped just like + // fully-qualified `serde::Serialize` already is (canonicalisation + // returns `None` for the un-aliased external form). + let resolved = resolve_aliased( + "impl Serialize + Handler", + "src/app/mod.rs", + &[("Serialize", &["serde", "Serialize"])], + &["Handler"], + ); + assert_eq!( + resolved, + CanonicalType::TraitBound(vec![vec![ + "crate".to_string(), + "app".to_string(), + "Handler".to_string(), + ]]), + "external aliased bound `serde::Serialize` must be skipped so \ + workspace `Handler` is picked; got {resolved:?}", + ); +} + +#[test] +fn test_impl_aliased_future_resolves_to_future_with_output() { + // `use std::future::Future as Fut;` then `impl Fut`. + // The raw bound leaf is `Fut`, but the canonicalised path is + // `std::future::Future`, so the bound must still shape the + // result as `Future(Session)` — otherwise `.await` on the + // return type doesn't unwrap and downstream method dispatch + // (e.g. `make().await.diff()`) stays unresolved. + let resolved = resolve_aliased( + "impl Fut", + "src/app/mod.rs", + &[("Fut", &["std", "future", "Future"])], + &["Session"], + ); + let expected_output = CanonicalType::path(["crate", "app", "Session"]); + assert_eq!( + resolved, + CanonicalType::Future(Box::new(expected_output)), + "aliased Future bound must canonicalise to Future(Session); got {resolved:?}", + ); +} + +/// Per-file scope inputs the cross-module alias test owns. `FileScope` +/// holds borrows, so the owning storage stays here and `as_scope` +/// produces a fresh borrow at call sites. +struct ScopeInputs { + path: String, + alias_map: crate::adapters::shared::use_tree::AliasMap, + aliases_per_scope: ScopedAliasMap, + local_symbols: HashSet, + local_decl_scopes: HashMap>>, + crate_root_modules: HashSet, +} + +impl ScopeInputs { + fn new(path: &str) -> Self { + Self { + path: path.to_string(), + alias_map: HashMap::new(), + aliases_per_scope: ScopedAliasMap::new(), + local_symbols: HashSet::new(), + local_decl_scopes: HashMap::new(), + crate_root_modules: HashSet::new(), + } + } + + fn as_scope(&self) -> FileScope<'_> { + FileScope { + path: &self.path, + alias_map: &self.alias_map, + aliases_per_scope: &self.aliases_per_scope, + local_symbols: &self.local_symbols, + workspace_module_paths: None, + local_decl_scopes: &self.local_decl_scopes, + crate_root_modules: &self.crate_root_modules, + } + } +} + +#[test] +fn test_alias_generic_arg_resolves_at_use_site() { + // `domain::type Wrap = Arc` consumed from `app` as + // `Wrap`: the use-site arg `Session` must canonicalise + // against `app`'s symbols, not against `domain`'s decl-site + // scope, which doesn't know `Session`. + use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::workspace_index::AliasDef; + + let domain = ScopeInputs::new("src/domain.rs"); + let mut app = ScopeInputs::new("src/app.rs"); + app.alias_map.insert( + "Wrap".to_string(), + AliasTarget::relative(vec![ + "crate".to_string(), + "domain".to_string(), + "Wrap".to_string(), + ]), + ); + app.local_symbols.insert("Session".to_string()); + + let mut workspace_files: HashMap> = HashMap::new(); + workspace_files.insert("src/domain.rs".to_string(), domain.as_scope()); + + let alias_target: syn::Type = syn::parse_str("Arc").expect("parse alias target"); + let mut type_aliases: HashMap = HashMap::new(); + type_aliases.insert( + "crate::domain::Wrap".to_string(), + AliasDef { + params: vec!["T".to_string()], + target: alias_target, + decl_file: "src/domain.rs".to_string(), + decl_mod_stack: Vec::new(), + }, + ); + + let app_scope = app.as_scope(); + let ty = parse_type("Wrap"); + let resolved = resolve_type( + &ty, + &ResolveContext { + file: &app_scope, + mod_stack: &[], + type_aliases: Some(&type_aliases), + transparent_wrappers: None, + workspace_files: Some(&workspace_files), + alias_param_subs: None, + generic_params: None, + reexports: None, + }, + ); + assert_eq!( + resolved, + CanonicalType::path(["crate", "app", "Session"]), + "alias generic args must resolve at the use-site, got {resolved:?}" + ); +} + +#[test] +fn unbounded_generic_param_shadows_same_named_workspace_symbol() { + // `fn f(...)` with NO bound on Q. Inside the body, a path like + // `Q` must resolve to `Opaque` (the fn-scoped param shadows any + // workspace symbol of the same name), not to the workspace + // canonical for a top-level type named `Q`. Without explicit + // shadowing, `resolve_generic_path` would fall through to + // `canonicalise_type_segments_in_scope` and resolve `Q` to + // `crate::Q`, producing wrong method-dispatch edges. + // Unbounded `` with `Q` also in local symbols: the param must + // shadow the workspace symbol so `Q` resolves to Opaque, not crate::Q. + let resolved = resolve_with_unbounded_param("Q", "src/app/runner.rs", &["Q"], "Q"); + assert_eq!( + resolved, + CanonicalType::Opaque, + "unbounded generic param `Q` must shadow same-named workspace \ + symbol — falling through to canonicalisation would resolve \ + to `crate::Q` and produce wrong dispatch edges, got {resolved:?}" + ); +} + +#[test] +fn unbounded_generic_param_shadowing_does_not_affect_unrelated_path() { + // Sanity: the shadowing fix must not affect a workspace symbol + // whose name is NOT in `generic_params`. `Session` still resolves + // to the workspace canonical even when `Q` is in the param map. + // `Q` is the generic param, but the resolved path is `Session` — not + // in generic_params — so it must still resolve to the workspace canonical. + let resolved = resolve_with_unbounded_param("Session", "src/app/session.rs", &["Session"], "Q"); + assert_eq!( + resolved, + CanonicalType::path(["crate", "app", "session", "Session"]), + "path NOT in generic_params must still resolve normally, got {resolved:?}" + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index.rs deleted file mode 100644 index e54fe824..00000000 --- a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index.rs +++ /dev/null @@ -1,2919 +0,0 @@ -//! Integration tests for `WorkspaceTypeIndex` building. -//! -//! Covers struct-field, method-return, and free-fn-return collection -//! across single- and multi-file workspaces plus the cfg-test skip -//! behaviour. - -use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::{ - build_workspace_files_map, collect_local_symbols_scoped, LocalSymbols, WorkspaceFilesInputs, -}; -use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::{ - build_workspace_type_index, CanonicalType, WorkspaceIndexInputs, -}; -use crate::adapters::shared::use_tree::{ - gather_alias_map, gather_alias_map_scoped, AliasMap, ScopedAliasMap, -}; -use std::collections::{HashMap, HashSet}; - -fn parse_file(src: &str) -> syn::File { - syn::parse_str(src).expect("parse file") -} - -struct WsFixture { - parsed: Vec<(String, syn::File)>, - aliases: HashMap, - aliases_scoped: HashMap, - local_symbols: HashMap, -} - -fn fixture(entries: &[(&str, &str)]) -> WsFixture { - let mut parsed = Vec::new(); - let mut aliases = HashMap::new(); - let mut aliases_scoped = HashMap::new(); - let mut local_symbols = HashMap::new(); - for (path, src) in entries { - let ast = parse_file(src); - aliases.insert(path.to_string(), gather_alias_map(&ast)); - aliases_scoped.insert(path.to_string(), gather_alias_map_scoped(&ast)); - local_symbols.insert(path.to_string(), collect_local_symbols_scoped(&ast)); - parsed.push((path.to_string(), ast)); - } - WsFixture { - parsed, - aliases, - aliases_scoped, - local_symbols, - } -} - -fn borrowed(f: &WsFixture) -> Vec<(&str, &syn::File)> { - f.parsed.iter().map(|(p, a)| (p.as_str(), a)).collect() -} - -fn crate_roots(paths: &[&str]) -> HashSet { - paths - .iter() - .filter_map(|p| { - let rest = p.strip_prefix("src/")?; - let first = rest.split('/').next()?; - let name = first.strip_suffix(".rs").unwrap_or(first); - if matches!(name, "lib" | "main") { - None - } else { - Some(name.to_string()) - } - }) - .collect() -} - -// ── Empty / trivial ────────────────────────────────────────────── - -#[test] -fn test_empty_workspace_produces_empty_index() { - let fix = fixture(&[]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &HashSet::new(); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - assert!(index.struct_fields.is_empty()); - assert!(index.method_returns.is_empty()); - assert!(index.fn_returns.is_empty()); -} - -// ── struct_fields ──────────────────────────────────────────────── - -#[test] -fn test_struct_with_named_field_is_indexed() { - // Field type must be a workspace-local type — stdlib `String` would - // resolve to `Opaque` (correct — stdlib isn't in our index) and get - // skipped by `record_field`. - let fix = fixture(&[( - "src/app/session.rs", - r#" - pub struct Id; - pub struct Session { pub id: Id } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/session.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - let field = index.struct_field("crate::app::session::Session", "id"); - assert_eq!( - field, - Some(&CanonicalType::path(["crate", "app", "session", "Id"])) - ); -} - -#[test] -fn test_struct_field_with_arc_is_stripped() { - let fix = fixture(&[( - "src/app/context.rs", - r#" - pub struct Inner { pub v: u8 } - pub struct Ctx { pub inner: std::sync::Arc } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/context.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - let field = index.struct_field("crate::app::context::Ctx", "inner"); - assert_eq!( - field, - Some(&CanonicalType::path(["crate", "app", "context", "Inner"])) - ); -} - -#[test] -fn test_tuple_struct_is_not_indexed() { - let fix = fixture(&[("src/app/foo.rs", "pub struct Id(pub String);")]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/foo.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - assert!(index.struct_fields.is_empty()); -} - -#[test] -fn test_struct_field_with_opaque_type_is_skipped() { - let fix = fixture(&[( - "src/app/foo.rs", - r#" - pub struct Ctx { pub x: external_crate::Unknown } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/foo.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - assert!(index.struct_fields.is_empty()); -} - -// ── method_returns ─────────────────────────────────────────────── - -#[test] -fn test_inherent_method_with_concrete_return() { - let fix = fixture(&[( - "src/app/session.rs", - r#" - pub struct Session; - pub struct Response; - impl Session { - pub fn diff(&self) -> Response { Response } - } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/session.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - let ret = index.method_return("crate::app::session::Session", "diff"); - assert_eq!( - ret, - Some(&CanonicalType::path([ - "crate", "app", "session", "Response" - ])) - ); -} - -#[test] -fn test_method_returning_result_wraps() { - let fix = fixture(&[( - "src/app/session.rs", - r#" - pub struct Session; - pub struct Response; - pub struct Error; - impl Session { - pub fn diff(&self) -> Result { unimplemented!() } - } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/session.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - let ret = index - .method_return("crate::app::session::Session", "diff") - .expect("method indexed"); - match ret { - CanonicalType::Result(inner) => assert_eq!( - **inner, - CanonicalType::path(["crate", "app", "session", "Response"]) - ), - other => panic!("expected Result(_), got {:?}", other), - } -} - -#[test] -fn test_method_returning_result_self_substitutes_inner() { - // `Session::open() -> Result` must store - // `Result`, not `Result`. Without nested-Self - // substitution, downstream chains like - // `Session::open().unwrap().diff()` lose the receiver type at - // `.unwrap()` and fall back to `:diff`. - let fix = fixture(&[( - "src/app/session.rs", - r#" - pub struct Session; - pub struct Error; - impl Session { - pub fn open() -> Result { unimplemented!() } - } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/session.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - let ret = index - .method_return("crate::app::session::Session", "open") - .expect("method indexed"); - let session = CanonicalType::path(["crate", "app", "session", "Session"]); - assert_eq!( - ret, - &CanonicalType::Result(Box::new(session)), - "Result must store Result, got {ret:?}" - ); -} - -#[test] -fn test_method_with_unit_return_is_not_indexed() { - let fix = fixture(&[( - "src/app/foo.rs", - r#" - pub struct S; - impl S { pub fn bump(&self) {} } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/foo.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - assert!(index.method_returns.is_empty()); -} - -#[test] -fn test_method_with_impl_trait_return_is_not_indexed() { - let fix = fixture(&[( - "src/app/foo.rs", - r#" - pub struct S; - impl S { pub fn iter(&self) -> impl Iterator { std::iter::empty() } } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/foo.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - assert!(index.method_returns.is_empty()); -} - -#[test] -fn test_trait_impl_method_is_indexed_by_receiver_type() { - let fix = fixture(&[( - "src/app/foo.rs", - r#" - pub struct S; - pub struct T; - pub trait Convert { fn to(&self) -> T; } - impl Convert for S { fn to(&self) -> T { T } } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/foo.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - // Keyed by the concrete receiver type S, NOT by the trait. - let ret = index.method_return("crate::app::foo::S", "to"); - assert_eq!( - ret, - Some(&CanonicalType::path(["crate", "app", "foo", "T"])) - ); -} - -// ── fn_returns ─────────────────────────────────────────────────── - -#[test] -fn test_free_fn_return_is_indexed() { - let fix = fixture(&[( - "src/app/make.rs", - r#" - pub struct Session; - pub fn make_session() -> Session { Session } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/make.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - let ret = index.fn_return("crate::app::make::make_session"); - assert_eq!( - ret, - Some(&CanonicalType::path(["crate", "app", "make", "Session"])) - ); -} - -#[test] -fn test_generic_return_type_is_opaque_and_not_indexed() { - let fix = fixture(&[( - "src/app/make.rs", - r#" - pub fn get() -> T { unimplemented!() } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/make.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - // Generic T has no alias/local-symbol entry → Opaque → skipped. - assert!(index.fn_returns.is_empty()); -} - -#[test] -fn fn_generic_param_return_does_not_collide_with_same_named_workspace_type() { - // `pub struct Q;` plus `pub fn get() -> Q` — the workspace - // type `Q` shares the leading segment with the fn-scoped generic - // param `Q`. Without threading the fn's generics into the - // workspace-index resolve context, `resolve_type(Q)` falls through - // to the canonicaliser and resolves `Q` to `crate::app::make::Q` - // (the struct), making `fn_returns["...::get"] = crate::app::make::Q`. - // Downstream `get::().diff()` inference would then short- - // circuit on the (wrong) concrete return type instead of using the - // turbofish. - // - // Expected: the fn-scoped param shadows the workspace symbol, - // resolution yields `Opaque`, and the entry is not indexed. - let fix = fixture(&[( - "src/app/make.rs", - r#" - pub struct Q; - pub fn get() -> Q { unimplemented!() } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/make.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - assert_eq!( - index.fn_return("crate::app::make::get"), - None, - "fn-scoped generic param `Q` must shadow workspace struct `Q` \ - and yield Opaque (skipped from index). Got: {:?}", - index.fn_returns, - ); -} - -#[test] -fn method_generic_param_return_does_not_collide_with_same_named_workspace_type() { - // Same shadowing concern, method-level: `impl Service { fn get(&self) -> Q }` - // where the workspace also has `pub struct Q;`. Without threading - // the method's generic params into the resolve context, the return - // type resolves to the workspace struct and poisons the - // `method_returns` map. - let fix = fixture(&[( - "src/app/make.rs", - r#" - pub struct Q; - pub struct Service; - impl Service { - pub fn get(&self) -> Q { unimplemented!() } - } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/make.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - assert_eq!( - index.method_return("crate::app::make::Service", "get"), - None, - "method-scoped generic param `Q` must shadow workspace struct \ - `Q` and yield Opaque (skipped from method_returns). Got: {:?}", - index.method_returns, - ); -} - -#[test] -fn bounded_fn_generic_param_return_carries_canonicalised_trait_bound() { - // `pub fn make() -> Q` where `Handler` is in scope via - // `use crate::ports::Handler;`. The fn-return entry must store a - // canonicalised `TraitBound([["crate","ports","Handler"]])`, NOT - // the raw single-segment `[["Handler"]]` — downstream - // `trait_has_method` / anchor lookups key on canonical paths and - // would silently miss the un-canonicalised form, dropping valid - // trait-dispatch edges. - let fix = fixture(&[ - ( - "src/ports/handler.rs", - r#" - pub trait Handler { fn handle(&self); } - "#, - ), - ( - "src/app/make.rs", - r#" - use crate::ports::handler::Handler; - pub fn make() -> Q { unimplemented!() } - "#, - ), - ]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/ports/handler.rs", "src/app/make.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - // Acceptable outcomes: either skipped entirely (Opaque) or stored - // as GenericParamBound with the canonical path. The forbidden - // outcome is a bound carrying a raw single-segment `["Handler"]`. - // (Note: bare generic-param returns now use `GenericParamBound`, - // not `TraitBound` — `TraitBound` is reserved for `impl Trait` / - // `dyn Trait` shapes that don't substitute under turbofish.) - if let Some(ret) = index.fn_return("crate::app::make::make") { - let canonical_bounds: Vec> = vec![vec![ - "crate".to_string(), - "ports".to_string(), - "handler".to_string(), - "Handler".to_string(), - ]]; - match ret { - CanonicalType::GenericParamBound { bounds, .. } => { - assert_eq!( - bounds, &canonical_bounds, - "trait bound for `Q: Handler` must be canonicalised \ - to `crate::ports::handler::Handler`, got {bounds:?}" - ); - } - CanonicalType::Opaque => {} // also acceptable - other => panic!("unexpected return type for `make`: {other:?}"), - } - } -} - -#[test] -fn bounded_fn_generic_param_return_does_not_block_turbofish_inference() { - // `pub fn get() -> Q` indexed as TraitBound(Handler) - // must NOT block turbofish-based concrete-type inference at the - // call site `get::().diff()` where `diff` is an inherent - // method on `Session` not declared on `Handler`. This is the - // turbofish-overrides-bounded-generic-return path. - // - // Surfaced via the full inference pipeline rather than the index - // alone — driven through `collect_canonical_calls`. The behavioural - // assertion lives there; this test exists as a forward-ref guard. - // - // Fixture: 2 files. workspace has both `Session::diff` (inherent) - // and `Handler::handle` (trait method). `get::().diff()` - // must produce edge `Session::diff`, NOT `Handler::diff` (which - // doesn't exist). - use crate::adapters::analyzers::architecture::call_parity_rule::calls::{ - collect_canonical_calls, FnContext, - }; - use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; - use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::{ - collect_crate_root_modules, collect_local_symbols, - }; - use crate::adapters::shared::use_tree::gather_alias_map; - - let fix = fixture(&[ - ( - "src/ports/handler.rs", - r#" - pub trait Handler { fn handle(&self); } - "#, - ), - ( - "src/app/session.rs", - r#" - pub struct Session; - impl Session { pub fn diff(&self) {} } - "#, - ), - ( - "src/app/make.rs", - r#" - use crate::ports::handler::Handler; - pub fn get() -> Q { unimplemented!() } - "#, - ), - ]); - let borrowed_files = borrowed(&fix); - let workspace_index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&[ - "src/ports/handler.rs", - "src/app/session.rs", - "src/app/make.rs", - ]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - - // Build a use-site fn that calls `get::().diff()` and - // assert the canonical-call set contains `Session::diff`. - let use_site = parse_file( - r#" - use crate::app::make::get; - use crate::app::session::Session; - pub fn use_it() { - get::().diff(); - } - "#, - ); - let alias_map = gather_alias_map(&use_site); - let local_symbols = collect_local_symbols(&use_site); - let crate_roots_set = collect_crate_root_modules(&[("src/cli/use_site.rs", &use_site)]); - let file_scope = FileScope { - path: "src/cli/use_site.rs", - alias_map: &alias_map, - aliases_per_scope: &Default::default(), - local_symbols: &local_symbols, - local_decl_scopes: &Default::default(), - crate_root_modules: &crate_roots_set, - workspace_module_paths: None, - }; - // Walk the file's `use_it` body via collect_canonical_calls. - let body = match &use_site.items[2] { - syn::Item::Fn(item_fn) => &item_fn.block, - _ => panic!("expected fn item at index 2 of use_site"), - }; - let ctx = FnContext { - file: &file_scope, - mod_stack: &[], - body, - signature_params: vec![], - generic_params: std::collections::HashMap::new(), - self_type: None, - workspace_index: Some(&workspace_index), - workspace_files: None, - reexports: None, - }; - let calls = collect_canonical_calls(&ctx); - let session_diff = "crate::app::session::Session::diff"; - assert!( - calls.contains(session_diff), - "turbofish `get::().diff()` must resolve via the turbofish \ - type arg (Session), not via the generic param's trait bound \ - (Handler). Calls: {calls:?}" - ); -} - -#[test] -fn method_generic_param_return_canonicalises_where_bound_on_impl_generic() { - // `impl Service { fn current(&self) -> Q where Q: Handler }` — - // the where-clause bound `Q: Handler` lives on the method's `where` - // but references the impl-level generic `Q`. A method-level - // generics extractor that only sees the method's own param list - // misses it; `method_canonical_generics(sig, impl_generics, …)` - // must extend bounds for outer-name predicates so the bound - // survives canonicalisation. - let fix = fixture(&[ - ( - "src/ports/handler.rs", - r#" - pub trait Handler { fn handle(&self); } - "#, - ), - ( - "src/app/service.rs", - r#" - use crate::ports::handler::Handler; - pub struct Service(pub Q); - impl Service { - pub fn current(&self) -> Q where Q: Handler { unimplemented!() } - } - "#, - ), - ]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/ports/handler.rs", "src/app/service.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - // Strict: the method's where-clause bound on the impl-level - // generic MUST be captured by `method_canonical_generics`. If the - // extractor pipeline drops the outer-name predicate, the param - // has empty bounds and the return resolves to Opaque (no info). - // Capturing it surfaces - // `GenericParamBound { bounds: [canonical Handler], turbofish_index: None }` - // so downstream `service.current().handle()` routes through the - // trait anchor. Note `turbofish_index: None` because Q is impl- - // level (substituted via receiver type, not by a method-call - // turbofish on `current`). - let ret = index - .method_return("crate::app::service::Service", "current") - .expect("method-level where-bound must surface as GenericParamBound, not be dropped"); - let canonical_bounds: Vec> = vec![vec![ - "crate".to_string(), - "ports".to_string(), - "handler".to_string(), - "Handler".to_string(), - ]]; - // Impl-level Q: turbofish_index is None (substituted via receiver - // type, not method-call turbofish). - assert_eq!( - ret, - &CanonicalType::GenericParamBound { - bounds: canonical_bounds, - turbofish_index: None, - }, - "method-level `where Q: Handler` on impl-level `Q` must produce \ - a canonicalised GenericParamBound (with no method-turbofish \ - position) on the method's return, got {ret:?}" - ); -} - -#[test] -fn struct_generic_param_field_does_not_collide_with_same_named_workspace_type() { - // Workspace has both `pub struct Q;` and a generic - // `pub struct Container { pub item: Q }`. The field type `Q` - // is the struct's own generic param, NOT a reference to the - // workspace struct. Without threading the struct's generics into - // the field-collector resolve context, the canonicaliser resolves - // `Q` to `crate::app::make::Q` (the workspace struct) and - // `struct_fields["Container"]["item"] = crate::app::make::Q`, - // poisoning later `self.item.method()` resolution. - // - // Expected: struct's generic `Q` shadows the workspace struct, - // the field resolves to `Opaque`, and the entry is dropped. - let fix = fixture(&[( - "src/app/make.rs", - r#" - pub struct Q; - pub struct Container { pub item: Q } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/make.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - assert_eq!( - index.struct_field("crate::app::make::Container", "item"), - None, - "struct-scoped generic param `Q` must shadow workspace struct \ - `Q` and yield Opaque (skipped from struct_fields). Got: {:?}", - index.struct_fields, - ); -} - -#[test] -fn impl_level_generic_param_return_does_not_collide_with_same_named_workspace_type() { - // Impl-level generic: `impl Service { fn first(&self) -> Q }` - // with the workspace also exposing `pub struct Q;`. The impl-level - // `Q` must shadow the workspace struct for every method's return- - // type resolution. - let fix = fixture(&[( - "src/app/make.rs", - r#" - pub struct Q; - pub struct Service(pub Q); - impl Service { - pub fn first(&self) -> Q { unimplemented!() } - } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/make.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - assert_eq!( - index.method_return("crate::app::make::Service", "first"), - None, - "impl-level generic `Q` must shadow workspace struct `Q` for \ - every method's return resolution. Got: {:?}", - index.method_returns, - ); -} - -#[test] -fn test_fn_inside_inline_mod_keys_include_mod_name() { - let fix = fixture(&[( - "src/app/mod.rs", - r#" - pub struct Session; - pub mod inner { - use super::Session; - pub fn make_session() -> Session { Session } - } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/mod.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - // With inline-mod tracking the key is `crate::app::inner::make_session`, - // matching how `inner::make_session()` canonicalises at a call site. - assert!( - index.fn_return("crate::app::inner::make_session").is_some(), - "fn_returns = {:?}", - index.fn_returns.keys().collect::>() - ); - // And the pre-fix key is absent — no duplicate shadow-registration. - assert!(index.fn_return("crate::app::make_session").is_none()); -} - -#[test] -fn test_fn_inside_inline_mod_resolves_inner_return_type() { - let fix = fixture(&[( - "src/app/mod.rs", - r#" - pub mod inner { - pub struct Session; - pub fn make() -> Session { Session } - } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/mod.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - // Pre-fix: `Session` was looked up against the file's top-level - // local symbols (which only contained `inner`), so the return type - // resolved to `Opaque` and `make` was dropped from the index. - // With per-mod-scope resolution `Session` is found at scope `[inner]` - // and the return canonical is `crate::app::inner::Session`. - assert_eq!( - index.fn_return("crate::app::inner::make"), - Some(&CanonicalType::path(["crate", "app", "inner", "Session"])) - ); -} - -#[test] -fn test_struct_field_inside_inline_mod_keys_include_mod_name() { - let fix = fixture(&[( - "src/app/mod.rs", - r#" - pub struct Session; - pub mod inner { - use super::Session; - pub struct Ctx { pub session: Session } - } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/mod.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - assert!( - index - .struct_field("crate::app::inner::Ctx", "session") - .is_some(), - "struct_fields = {:?}", - index.struct_fields.keys().collect::>() - ); -} - -#[test] -fn test_fn_with_unit_return_is_not_indexed() { - let fix = fixture(&[("src/app/foo.rs", "pub fn bump() {}")]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/foo.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - assert!(index.fn_returns.is_empty()); -} - -// ── cfg-test skip ──────────────────────────────────────────────── - -#[test] -fn test_cfg_test_file_is_skipped() { - let fix = fixture(&[( - "src/app/foo.rs", - r#" - pub struct S { pub x: u8 } - impl S { pub fn get(&self) -> u8 { self.x } } - pub fn build() -> S { S { x: 0 } } - "#, - )]); - let mut cfg_test = HashSet::new(); - cfg_test.insert("src/app/foo.rs".to_string()); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &cfg_test; - let roots = &crate_roots(&["src/app/foo.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - assert!(index.struct_fields.is_empty()); - assert!(index.method_returns.is_empty()); - assert!(index.fn_returns.is_empty()); -} - -// ── multi-file ──────────────────────────────────────────────────── - -// ── trait_methods / trait_impls ─────────────────────────────────── - -#[test] -fn test_trait_declaration_methods_are_indexed() { - let fix = fixture(&[( - "src/app/ports.rs", - r#" - pub trait Handler { - fn handle(&self, msg: &str); - fn can_handle(&self, msg: &str) -> bool; - } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/ports.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - assert!(index.trait_has_method("crate::app::ports::Handler", "handle")); - assert!(index.trait_has_method("crate::app::ports::Handler", "can_handle")); - assert!(!index.trait_has_method("crate::app::ports::Handler", "missing")); -} - -#[test] -fn test_trait_impl_is_indexed() { - let fix = fixture(&[( - "src/app/foo.rs", - r#" - pub struct MyImpl; - pub trait Handler { fn handle(&self); } - impl Handler for MyImpl { fn handle(&self) {} } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/foo.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - let impls = index.impls_of_trait("crate::app::foo::Handler"); - assert!(impls.contains(&"crate::app::foo::MyImpl".to_string())); -} - -#[test] -fn test_multiple_impls_of_same_trait_all_indexed() { - let fix = fixture(&[( - "src/app/foo.rs", - r#" - pub trait Handler { fn handle(&self); } - pub struct A; - pub struct B; - pub struct C; - impl Handler for A { fn handle(&self) {} } - impl Handler for B { fn handle(&self) {} } - impl Handler for C { fn handle(&self) {} } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/foo.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - let impls = index.impls_of_trait("crate::app::foo::Handler"); - assert_eq!(impls.len(), 3); -} - -#[test] -fn test_inherent_impl_does_not_populate_trait_impls() { - let fix = fixture(&[( - "src/app/foo.rs", - r#" - pub struct S; - impl S { pub fn method(&self) {} } - "#, - )]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/foo.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - // Inherent impl has no trait reference, so trait_impls stays empty. - assert!(index.trait_impls.is_empty()); -} - -#[test] -fn test_trait_in_one_file_impl_in_another() { - let fix = fixture(&[ - ( - "src/ports/handler.rs", - "pub trait Handler { fn handle(&self); }", - ), - ( - "src/app/session.rs", - r#" - use crate::ports::handler::Handler; - pub struct Session; - impl Handler for Session { fn handle(&self) {} } - "#, - ), - ]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = HashSet::new(); - let roots = crate_roots(&["src/ports/handler.rs", "src/app/session.rs"]); - let wraps = HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: &cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: &roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: &cfg_test, - transparent_wrappers: &wraps, - reexports: None, - }) - }; - // Trait resolved via import alias. - let impls = index.impls_of_trait("crate::ports::handler::Handler"); - assert!(impls.contains(&"crate::app::session::Session".to_string())); -} - -#[test] -fn test_struct_in_one_file_impl_in_another() { - let fix = fixture(&[ - ( - "src/app/session.rs", - r#" - pub struct Id; - pub struct Session { pub id: Id } - "#, - ), - ( - "src/app/impls.rs", - r#" - use crate::app::session::{Session, Id}; - impl Session { - pub fn clone_id(&self) -> Id { Id } - } - "#, - ), - ]); - let borrowed_files = borrowed(&fix); - let index = { - let cfg_test = HashSet::new(); - let roots = crate_roots(&["src/app/session.rs", "src/app/impls.rs"]); - let wraps = HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: &cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: &roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: &cfg_test, - transparent_wrappers: &wraps, - reexports: None, - }) - }; - // Struct indexed from its declaration file. - assert!(index - .struct_field("crate::app::session::Session", "id") - .is_some()); - // Method indexed from its impl file, keyed on the resolved - // self-type (`crate::app::session::Session` via alias map). - assert_eq!( - index.method_return("crate::app::session::Session", "clone_id"), - Some(&CanonicalType::path(["crate", "app", "session", "Id"])) - ); -} - -#[test] -fn record_trait_methods_captures_method_span() { - // The trait method's source location (file + 1-based line) must - // be captured at index-build time so anchor findings can carry a - // real source line. Without this, anchor findings hard-code - // line=0, which breaks suppression-window matching, the orphan - // detector, and SARIF location reporting. - let fix = fixture(&[( - "src/ports/handler.rs", - // Lines: 1=blank, 2=trait, 3=method-decl - "\npub trait Handler {\n fn handle(&self);\n}\n", - )]); - let borrowed_files = borrowed(&fix); - let cfg_test = HashSet::new(); - let roots = HashSet::new(); - let wraps = HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: &cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: &roots, - workspace_module_paths: None, - }); - let index = build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: &cfg_test, - transparent_wrappers: &wraps, - reexports: None, - }); - let loc = index - .trait_method_location("crate::ports::handler::Handler", "handle") - .expect("trait method location must be captured"); - assert_eq!(loc.file, "src/ports/handler.rs"); - assert_eq!(loc.line, 3); -} - -#[test] -fn method_call_turbofish_overrides_bounded_generic_param_return() { - // Symmetric to the free-fn `get::().diff()` case: a method - // call `service.current::().diff()` where `current` - // returns a bounded generic param. The method's index entry stores - // `TraitBound([crate::ports::handler::Handler])` (useful for plain - // `service.current().handle()` dispatch). When the call site adds - // an explicit `::` turbofish on the METHOD, the turbofish - // substitution must win — the trailing `.diff()` then resolves to - // `Session::diff` (inherent), not to a non-existent - // `Handler::diff`. This is the same TraitBound + turbofish override - // rule, applied to method calls instead of free-fn calls. - use crate::adapters::analyzers::architecture::call_parity_rule::calls::{ - collect_canonical_calls, FnContext, - }; - use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; - use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::{ - collect_crate_root_modules, collect_local_symbols, - }; - use crate::adapters::shared::use_tree::gather_alias_map; - - let fix = fixture(&[ - ( - "src/ports/handler.rs", - r#" - pub trait Handler { fn handle(&self); } - "#, - ), - ( - "src/app/session.rs", - r#" - pub struct Session; - impl Session { pub fn diff(&self) {} } - "#, - ), - ( - "src/app/service.rs", - r#" - use crate::ports::handler::Handler; - pub struct Service; - impl Service { - pub fn current(&self) -> Q { unimplemented!() } - } - "#, - ), - ]); - let borrowed_files = borrowed(&fix); - let workspace_index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&[ - "src/ports/handler.rs", - "src/app/session.rs", - "src/app/service.rs", - ]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - // `s: &Service` typed via sig param so the binding installs as - // Path([Service]) — `let s = Service;` would install Opaque - // because the legacy let-binding extractor only handles - // `Expr::Call` initialisers. With Opaque, `s.current()` would - // never reach the GenericParamBound-override path this test is - // designed to exercise. - let use_site = parse_file( - r#" - use crate::app::service::Service; - use crate::app::session::Session; - pub fn use_it(s: &Service) { - s.current::().diff(); - } - "#, - ); - let alias_map = gather_alias_map(&use_site); - let local_symbols = collect_local_symbols(&use_site); - let crate_roots_set = collect_crate_root_modules(&[("src/cli/use_site.rs", &use_site)]); - let file_scope = FileScope { - path: "src/cli/use_site.rs", - alias_map: &alias_map, - aliases_per_scope: &Default::default(), - local_symbols: &local_symbols, - local_decl_scopes: &Default::default(), - crate_root_modules: &crate_roots_set, - workspace_module_paths: None, - }; - use crate::adapters::analyzers::architecture::call_parity_rule::signature_params::extract_signature_params; - let (body, sig) = match &use_site.items[2] { - syn::Item::Fn(item_fn) => (&item_fn.block, &item_fn.sig), - _ => panic!("expected fn item at index 2 of use_site"), - }; - let ctx = FnContext { - file: &file_scope, - mod_stack: &[], - body, - signature_params: extract_signature_params(sig), - generic_params: std::collections::HashMap::new(), - self_type: None, - workspace_index: Some(&workspace_index), - workspace_files: None, - reexports: None, - }; - let calls = collect_canonical_calls(&ctx); - let session_diff = "crate::app::session::Session::diff"; - assert!( - calls.contains(session_diff), - "method-call turbofish `s.current::().diff()` must \ - resolve via the turbofish type arg (Session), not via the \ - method's generic-param trait bound (Handler). Calls: {calls:?}" - ); -} - -#[test] -fn free_fn_impl_trait_return_turbofish_does_not_substitute_return() { - // `fn make() -> impl Handler` — the return type is `impl Handler`, - // an OPAQUE type that doesn't reference `T`. Calling `make::()` - // substitutes T=Session in the BODY, but the return is still - // "some Handler", not Session. Critical contrast to the - // `get() -> Q` case where Q IS the return type and - // turbofish DOES substitute it. - // - // Bug: pre-split, both shapes were stored as `TraitBound(Handler)` - // in the index, indistinguishable. `turbofish_substitute` would - // fire on either and produce a false `Session::diff` edge for the - // impl-Trait case. The split into `TraitBound` (impl/dyn Trait, - // not substitutable) and `GenericParamBound` (bare param return, - // substitutable) fixes this — only the latter triggers the - // override. - // - // Required behaviour: `make::().diff()` must NOT produce - // edge `Session::diff` (Session may not even implement Handler, and - // even if it does, `impl Handler` is opaque from the caller's view). - use crate::adapters::analyzers::architecture::call_parity_rule::calls::{ - collect_canonical_calls, FnContext, - }; - use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; - use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::{ - collect_crate_root_modules, collect_local_symbols, - }; - use crate::adapters::shared::use_tree::gather_alias_map; - - let fix = fixture(&[ - ( - "src/ports/handler.rs", - r#" - pub trait Handler { fn handle(&self); } - "#, - ), - ( - "src/app/session.rs", - r#" - pub struct Session; - impl Session { pub fn diff(&self) {} } - "#, - ), - ( - "src/app/make.rs", - r#" - use crate::ports::handler::Handler; - pub fn make() -> impl Handler { unimplemented!() } - "#, - ), - ]); - let borrowed_files = borrowed(&fix); - let workspace_index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&[ - "src/ports/handler.rs", - "src/app/session.rs", - "src/app/make.rs", - ]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - let use_site = parse_file( - r#" - use crate::app::make::make; - use crate::app::session::Session; - pub fn use_it() { - make::().diff(); - } - "#, - ); - let alias_map = gather_alias_map(&use_site); - let local_symbols = collect_local_symbols(&use_site); - let crate_roots_set = collect_crate_root_modules(&[("src/cli/use_site.rs", &use_site)]); - let file_scope = FileScope { - path: "src/cli/use_site.rs", - alias_map: &alias_map, - aliases_per_scope: &Default::default(), - local_symbols: &local_symbols, - local_decl_scopes: &Default::default(), - crate_root_modules: &crate_roots_set, - workspace_module_paths: None, - }; - let body = match &use_site.items[2] { - syn::Item::Fn(item_fn) => &item_fn.block, - _ => panic!("expected fn item at index 2 of use_site"), - }; - let ctx = FnContext { - file: &file_scope, - mod_stack: &[], - body, - signature_params: vec![], - generic_params: std::collections::HashMap::new(), - self_type: None, - workspace_index: Some(&workspace_index), - workspace_files: None, - reexports: None, - }; - let calls = collect_canonical_calls(&ctx); - let phantom_session_diff = "crate::app::session::Session::diff"; - assert!( - !calls.contains(phantom_session_diff), - "`make::().diff()` where `make() -> impl Handler` \ - must NOT produce edge `{phantom_session_diff}` — the return is \ - opaque `impl Handler`, not Session. Turbofish on T doesn't \ - substitute the return type. Calls: {calls:?}" - ); -} - -#[test] -fn method_call_impl_trait_return_turbofish_does_not_substitute_return() { - // Method-call analogue: `fn make_handler(&self) -> impl Handler`. - // `s.make_handler::().diff()` must NOT produce - // `Session::diff` edge — same reasoning, the return is opaque. - use crate::adapters::analyzers::architecture::call_parity_rule::calls::{ - collect_canonical_calls, FnContext, - }; - use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; - use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::{ - collect_crate_root_modules, collect_local_symbols, - }; - use crate::adapters::shared::use_tree::gather_alias_map; - - let fix = fixture(&[ - ( - "src/ports/handler.rs", - r#" - pub trait Handler { fn handle(&self); } - "#, - ), - ( - "src/app/session.rs", - r#" - pub struct Session; - impl Session { pub fn diff(&self) {} } - "#, - ), - ( - "src/app/service.rs", - r#" - use crate::ports::handler::Handler; - pub struct Service; - impl Service { - pub fn make_handler(&self) -> impl Handler { unimplemented!() } - } - "#, - ), - ]); - let borrowed_files = borrowed(&fix); - let workspace_index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&[ - "src/ports/handler.rs", - "src/app/session.rs", - "src/app/service.rs", - ]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - let use_site = parse_file( - r#" - use crate::app::service::Service; - use crate::app::session::Session; - pub fn use_it() { - let s = Service; - s.make_handler::().diff(); - } - "#, - ); - let alias_map = gather_alias_map(&use_site); - let local_symbols = collect_local_symbols(&use_site); - let crate_roots_set = collect_crate_root_modules(&[("src/cli/use_site.rs", &use_site)]); - let file_scope = FileScope { - path: "src/cli/use_site.rs", - alias_map: &alias_map, - aliases_per_scope: &Default::default(), - local_symbols: &local_symbols, - local_decl_scopes: &Default::default(), - crate_root_modules: &crate_roots_set, - workspace_module_paths: None, - }; - let body = match &use_site.items[2] { - syn::Item::Fn(item_fn) => &item_fn.block, - _ => panic!("expected fn item at index 2 of use_site"), - }; - let ctx = FnContext { - file: &file_scope, - mod_stack: &[], - body, - signature_params: vec![], - generic_params: std::collections::HashMap::new(), - self_type: None, - workspace_index: Some(&workspace_index), - workspace_files: None, - reexports: None, - }; - let calls = collect_canonical_calls(&ctx); - let phantom_session_diff = "crate::app::session::Session::diff"; - assert!( - !calls.contains(phantom_session_diff), - "method-call `s.make_handler::().diff()` where \ - `make_handler(&self) -> impl Handler` must NOT produce edge \ - `{phantom_session_diff}` — return is opaque `impl Handler`. \ - Calls: {calls:?}" - ); -} - -#[test] -fn multi_generic_fn_turbofish_picks_correct_arg_for_returned_param() { - // `fn get() -> Q` — A is the FIRST generic param, - // Q is the SECOND and IS the return. Calling - // `get::()` substitutes A=Audit and Q=Session. - // The return is Q → Session. The bug: pre-fix `turbofish_substitute` - // always picks the FIRST turbofish arg, so it would substitute - // Audit instead of Session, then `.diff()` would route to - // `Audit::diff` (false edge) or miss `Session::diff`. - // - // Required: GenericParamBound must carry the position of the - // returned param in the call-site-substitutable generics list, so - // turbofish substitution picks arg-at-position. - use crate::adapters::analyzers::architecture::call_parity_rule::calls::{ - collect_canonical_calls, FnContext, - }; - use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; - use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::{ - collect_crate_root_modules, collect_local_symbols, - }; - use crate::adapters::shared::use_tree::gather_alias_map; - - let fix = fixture(&[ - ( - "src/ports/handler.rs", - r#" - pub trait Handler { fn handle(&self); } - "#, - ), - ( - "src/app/audit.rs", - r#" - pub struct Audit; - impl Audit { pub fn audit_method(&self) {} } - "#, - ), - ( - "src/app/session.rs", - r#" - pub struct Session; - impl Session { pub fn diff(&self) {} } - "#, - ), - ( - "src/app/make.rs", - r#" - use crate::ports::handler::Handler; - pub fn get() -> Q { unimplemented!() } - "#, - ), - ]); - let borrowed_files = borrowed(&fix); - let workspace_index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&[ - "src/ports/handler.rs", - "src/app/audit.rs", - "src/app/session.rs", - "src/app/make.rs", - ]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - let use_site = parse_file( - r#" - use crate::app::make::get; - use crate::app::audit::Audit; - use crate::app::session::Session; - pub fn use_it() { - get::().diff(); - } - "#, - ); - let alias_map = gather_alias_map(&use_site); - let local_symbols = collect_local_symbols(&use_site); - let crate_roots_set = collect_crate_root_modules(&[("src/cli/use_site.rs", &use_site)]); - let file_scope = FileScope { - path: "src/cli/use_site.rs", - alias_map: &alias_map, - aliases_per_scope: &Default::default(), - local_symbols: &local_symbols, - local_decl_scopes: &Default::default(), - crate_root_modules: &crate_roots_set, - workspace_module_paths: None, - }; - let body = match &use_site.items[3] { - syn::Item::Fn(item_fn) => &item_fn.block, - _ => panic!("expected fn item at index 3 of use_site"), - }; - let ctx = FnContext { - file: &file_scope, - mod_stack: &[], - body, - signature_params: vec![], - generic_params: std::collections::HashMap::new(), - self_type: None, - workspace_index: Some(&workspace_index), - workspace_files: None, - reexports: None, - }; - let calls = collect_canonical_calls(&ctx); - let session_diff = "crate::app::session::Session::diff"; - let phantom_audit_diff = "crate::app::audit::Audit::diff"; - assert!( - calls.contains(session_diff), - "`get::().diff()` where `get() -> Q` \ - must substitute Q=Session (the SECOND turbofish arg, matching Q's \ - position). Got calls: {calls:?}" - ); - assert!( - !calls.contains(phantom_audit_diff), - "must NOT substitute Q=Audit (the FIRST turbofish arg, matching A's \ - position — but A is not the return). Got calls: {calls:?}" - ); -} - -#[test] -fn wrapper_around_generic_param_return_substitutes_inner_via_turbofish() { - // `fn get() -> Result` — return type is a Result - // wrapping the generic-param Q. Calling `get::()` substitutes - // Q=Session inside the wrapper, so `.unwrap()` produces a Session. - // Then `.diff()` resolves to `Session::diff`. Bug: pre-fix - // `turbofish_substitute` only fired when the whole inferred type - // was GenericParamBound — it didn't recurse into Result/Option/ - // Future wrappers, so the Q inside `Result` was left - // un-substituted. After `.unwrap()` peeled the Result, the turbofish - // context was gone and `.diff()` couldn't resolve to Session::diff. - use crate::adapters::analyzers::architecture::call_parity_rule::calls::{ - collect_canonical_calls, FnContext, - }; - use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; - use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::{ - collect_crate_root_modules, collect_local_symbols, - }; - use crate::adapters::shared::use_tree::gather_alias_map; - - let fix = fixture(&[ - ( - "src/ports/handler.rs", - r#" - pub trait Handler { fn handle(&self); } - "#, - ), - ( - "src/app/session.rs", - r#" - pub struct Session; - impl Session { pub fn diff(&self) {} } - "#, - ), - ( - "src/app/make.rs", - r#" - use crate::ports::handler::Handler; - pub struct MyErr; - pub fn get() -> Result { unimplemented!() } - "#, - ), - ]); - let borrowed_files = borrowed(&fix); - let workspace_index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&[ - "src/ports/handler.rs", - "src/app/session.rs", - "src/app/make.rs", - ]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - let use_site = parse_file( - r#" - use crate::app::make::get; - use crate::app::session::Session; - pub fn use_it() { - get::().unwrap().diff(); - } - "#, - ); - let alias_map = gather_alias_map(&use_site); - let local_symbols = collect_local_symbols(&use_site); - let crate_roots_set = collect_crate_root_modules(&[("src/cli/use_site.rs", &use_site)]); - let file_scope = FileScope { - path: "src/cli/use_site.rs", - alias_map: &alias_map, - aliases_per_scope: &Default::default(), - local_symbols: &local_symbols, - local_decl_scopes: &Default::default(), - crate_root_modules: &crate_roots_set, - workspace_module_paths: None, - }; - let body = match &use_site.items[2] { - syn::Item::Fn(item_fn) => &item_fn.block, - _ => panic!("expected fn item at index 2 of use_site"), - }; - let ctx = FnContext { - file: &file_scope, - mod_stack: &[], - body, - signature_params: vec![], - generic_params: std::collections::HashMap::new(), - self_type: None, - workspace_index: Some(&workspace_index), - workspace_files: None, - reexports: None, - }; - let calls = collect_canonical_calls(&ctx); - let session_diff = "crate::app::session::Session::diff"; - assert!( - calls.contains(session_diff), - "`get::().unwrap().diff()` where `get() -> \ - Result` must substitute Q=Session INSIDE the Result \ - wrapper so `.unwrap()` yields Session and `.diff()` resolves to \ - {session_diff}. Got calls: {calls:?}" - ); -} - -#[test] -fn method_call_wrapper_around_generic_param_return_substitutes_inner() { - // Method-call variant of the wrapper-recursion case: - // `fn current(&self) -> Result` — - // `s.current::().unwrap().diff()` must produce - // `Session::diff` by recursing into the Result wrapper. - use crate::adapters::analyzers::architecture::call_parity_rule::calls::{ - collect_canonical_calls, FnContext, - }; - use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; - use crate::adapters::analyzers::architecture::call_parity_rule::signature_params::extract_signature_params; - use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::{ - collect_crate_root_modules, collect_local_symbols, - }; - use crate::adapters::shared::use_tree::gather_alias_map; - - let fix = fixture(&[ - ( - "src/ports/handler.rs", - r#" - pub trait Handler { fn handle(&self); } - "#, - ), - ( - "src/app/session.rs", - r#" - pub struct Session; - impl Session { pub fn diff(&self) {} } - "#, - ), - ( - "src/app/service.rs", - r#" - use crate::ports::handler::Handler; - pub struct MyErr; - pub struct Service; - impl Service { - pub fn current(&self) -> Result { unimplemented!() } - } - "#, - ), - ]); - let borrowed_files = borrowed(&fix); - let workspace_index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&[ - "src/ports/handler.rs", - "src/app/session.rs", - "src/app/service.rs", - ]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - let use_site = parse_file( - r#" - use crate::app::service::Service; - use crate::app::session::Session; - pub fn use_it(s: &Service) { - s.current::().unwrap().diff(); - } - "#, - ); - let alias_map = gather_alias_map(&use_site); - let local_symbols = collect_local_symbols(&use_site); - let crate_roots_set = collect_crate_root_modules(&[("src/cli/use_site.rs", &use_site)]); - let file_scope = FileScope { - path: "src/cli/use_site.rs", - alias_map: &alias_map, - aliases_per_scope: &Default::default(), - local_symbols: &local_symbols, - local_decl_scopes: &Default::default(), - crate_root_modules: &crate_roots_set, - workspace_module_paths: None, - }; - let (body, sig) = match &use_site.items[2] { - syn::Item::Fn(item_fn) => (&item_fn.block, &item_fn.sig), - _ => panic!("expected fn item at index 2 of use_site"), - }; - let ctx = FnContext { - file: &file_scope, - mod_stack: &[], - body, - signature_params: extract_signature_params(sig), - generic_params: std::collections::HashMap::new(), - self_type: None, - workspace_index: Some(&workspace_index), - workspace_files: None, - reexports: None, - }; - let calls = collect_canonical_calls(&ctx); - let session_diff = "crate::app::session::Session::diff"; - assert!( - calls.contains(session_diff), - "`s.current::().unwrap().diff()` where \ - `current(&self) -> Result` must substitute \ - Q=Session inside the Result wrapper so `.diff()` resolves to \ - {session_diff}. Got calls: {calls:?}" - ); -} - -#[test] -fn vec_around_generic_param_return_substitutes_inner_via_turbofish() { - // `fn get() -> Vec` — `resolve_type` normalises - // `Vec` to `CanonicalType::Slice(GenericParamBound { ... })`. - // Iteration via `for s in get::()` extracts the Slice's - // inner element, so without recursing turbofish substitution - // through `Slice`, `s`'s type stays `GenericParamBound([Handler])` - // and `s.diff()` routes via Handler-anchor (Handler has no diff) - // instead of producing the concrete `Session::diff` edge. - // - // Required: turbofish_substitute must recurse into Slice (and - // Map, by analogy with `HashMap` → Map(Q)) the same way it - // already recurses into Result / Option / Future. - use crate::adapters::analyzers::architecture::call_parity_rule::calls::{ - collect_canonical_calls, FnContext, - }; - use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; - use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::{ - collect_crate_root_modules, collect_local_symbols, - }; - use crate::adapters::shared::use_tree::gather_alias_map; - - let fix = fixture(&[ - ( - "src/ports/handler.rs", - r#" - pub trait Handler { fn handle(&self); } - "#, - ), - ( - "src/app/session.rs", - r#" - pub struct Session; - impl Session { pub fn diff(&self) {} } - "#, - ), - ( - "src/app/make.rs", - r#" - use crate::ports::handler::Handler; - pub fn get() -> Vec { unimplemented!() } - "#, - ), - ]); - let borrowed_files = borrowed(&fix); - let workspace_index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&[ - "src/ports/handler.rs", - "src/app/session.rs", - "src/app/make.rs", - ]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - let use_site = parse_file( - r#" - use crate::app::make::get; - use crate::app::session::Session; - pub fn use_it() { - for s in get::() { - s.diff(); - } - } - "#, - ); - let alias_map = gather_alias_map(&use_site); - let local_symbols = collect_local_symbols(&use_site); - let crate_roots_set = collect_crate_root_modules(&[("src/cli/use_site.rs", &use_site)]); - let file_scope = FileScope { - path: "src/cli/use_site.rs", - alias_map: &alias_map, - aliases_per_scope: &Default::default(), - local_symbols: &local_symbols, - local_decl_scopes: &Default::default(), - crate_root_modules: &crate_roots_set, - workspace_module_paths: None, - }; - let body = match &use_site.items[2] { - syn::Item::Fn(item_fn) => &item_fn.block, - _ => panic!("expected fn item at index 2 of use_site"), - }; - let ctx = FnContext { - file: &file_scope, - mod_stack: &[], - body, - signature_params: vec![], - generic_params: std::collections::HashMap::new(), - self_type: None, - workspace_index: Some(&workspace_index), - workspace_files: None, - reexports: None, - }; - let calls = collect_canonical_calls(&ctx); - let session_diff = "crate::app::session::Session::diff"; - assert!( - calls.contains(session_diff), - "`for s in get::() {{ s.diff(); }}` where \ - `get() -> Vec` must substitute Q=Session inside \ - the Vec/Slice wrapper so the iterator binding yields Session \ - and `.diff()` resolves to {session_diff}. Got calls: {calls:?}" - ); -} - -#[test] -fn absolute_leading_colon_path_is_not_shadowed_by_in_scope_generic() { - // `::Q::method()` is an explicit absolute path (Rust 2018+: from - // an extern crate root). Even when an in-scope fn-generic param - // is named `Q`, the leading-colon form intentionally disambiguates - // AWAY from the generic. Pre-fix, `generic_param_shadow` matched - // purely on segment text (no leading_colon check), so the absolute - // `::Q` got mis-resolved as the generic's `Q` (GenericParamBound) - // instead of falling through to normal canonicalisation. - use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; - use crate::adapters::analyzers::architecture::call_parity_rule::signature_params::ParamInfo; - use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::resolve::{ - resolve_type, ResolveContext, - }; - use crate::adapters::shared::use_tree::ScopedAliasMap; - - // Sanity check on the fixture: `::Q` must parse with leading_colon set. - let ty: syn::Type = syn::parse_str("::Q").expect("parse `::Q`"); - let leading_colon_set = matches!(&ty, syn::Type::Path(tp) if tp.path.leading_colon.is_some()); - assert!( - leading_colon_set, - "fixture invariant: `::Q` must parse with leading_colon set" - ); - - let alias_map = HashMap::new(); - let mut local = HashSet::new(); - local.insert("Q".to_string()); - let roots = HashSet::new(); - let file_scope = FileScope { - path: "src/app/runner.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &HashMap::new(), - crate_root_modules: &roots, - workspace_module_paths: None, - }; - let mut generics: HashMap = HashMap::new(); - generics.insert( - "Q".to_string(), - ParamInfo { - bounds: vec![vec![ - "crate".to_string(), - "ports".to_string(), - "Handler".to_string(), - ]], - turbofish_index: Some(0), - }, - ); - let resolved = resolve_type( - &ty, - &ResolveContext { - file: &file_scope, - mod_stack: &[], - type_aliases: None, - transparent_wrappers: None, - workspace_files: None, - alias_param_subs: None, - generic_params: Some(&generics), - reexports: None, - }, - ); - assert!( - !matches!(resolved, CanonicalType::GenericParamBound { .. }), - "`::Q` (leading_colon set) must NOT short-circuit through \ - generic_param_shadow — the absolute path is intentionally \ - disambiguated AWAY from the in-scope generic param Q. \ - Got: {resolved:?}" - ); -} - -#[test] -fn absolute_leading_colon_call_path_does_not_shadow_to_trait_anchor() { - // Sister to the resolve-side `::Q` shadowing test, but exercises - // the CALL collector's path handling instead of the type - // resolver. `visit_expr_call` strips `path.segments` to ident - // strings and feeds them to `canonicalise_generic_param_path` — - // pre-fix, that helper matched purely on segment text (no - // leading_colon awareness), so `::Q::handle(x)` inside - // `fn run(...)` got canonicalised to the trait-anchor - // `Handler::handle` even though the explicit leading `::` is - // the caller's disambiguation AWAY from the generic param. - // - // Required: when the call path has `leading_colon.is_some()`, - // skip the generic-param canonicalisation branch — the absolute - // path should fall through to normal path canonicalisation - // (which will likely produce `:Q::handle` since `::Q` is - // an extern-crate reference our analyzer can't resolve). - use crate::adapters::analyzers::architecture::call_parity_rule::calls::{ - collect_canonical_calls, FnContext, - }; - use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; - use crate::adapters::analyzers::architecture::call_parity_rule::signature_params::{ - item_canonical_generics, ParamInfo, - }; - use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::{ - collect_crate_root_modules, collect_local_symbols, - }; - use crate::adapters::shared::use_tree::gather_alias_map; - - let fix = fixture(&[( - "src/ports/handler.rs", - r#" - pub trait Handler { fn handle(&self); } - "#, - )]); - let borrowed_files = borrowed(&fix); - let workspace_index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/ports/handler.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - let use_site = parse_file( - r#" - use crate::ports::handler::Handler; - pub fn run(q: Q) { - // Absolute path — explicitly NOT the generic Q. - ::Q::handle(&q); - } - "#, - ); - let alias_map = gather_alias_map(&use_site); - let local_symbols = collect_local_symbols(&use_site); - let crate_roots_set = collect_crate_root_modules(&[("src/app/runner.rs", &use_site)]); - let file_scope = FileScope { - path: "src/app/runner.rs", - alias_map: &alias_map, - aliases_per_scope: &Default::default(), - local_symbols: &local_symbols, - local_decl_scopes: &Default::default(), - crate_root_modules: &crate_roots_set, - workspace_module_paths: None, - }; - let (body, sig) = match &use_site.items[1] { - syn::Item::Fn(item_fn) => (&item_fn.block, &item_fn.sig), - _ => panic!("expected fn item at index 1 of use_site"), - }; - // Build the canonical generics map so `Q: Handler` is in scope - // exactly the way the body collector sees it in production. - let generics: std::collections::HashMap = - item_canonical_generics(&sig.generics, &file_scope, &[], None); - // Sanity: Q must be in the generics map with Handler bound (else - // the test is vacuous — without an in-scope Q, no shadowing could - // happen even pre-fix). - let q_info = generics - .get("Q") - .expect("fixture invariant: Q must be in generics map"); - assert!( - !q_info.bounds.is_empty(), - "fixture invariant: Q must have a resolved Handler bound" - ); - let ctx = FnContext { - file: &file_scope, - mod_stack: &[], - body, - signature_params: vec![], - generic_params: generics, - self_type: None, - workspace_index: Some(&workspace_index), - workspace_files: None, - reexports: None, - }; - let calls = collect_canonical_calls(&ctx); - let trait_anchor = "crate::ports::handler::Handler::handle"; - assert!( - !calls.contains(trait_anchor), - "`::Q::handle(&q)` (leading_colon set) inside `fn run()` \ - must NOT canonicalise to the trait anchor `{trait_anchor}` — the \ - leading `::` is the caller's explicit disambiguation away from \ - the in-scope generic param Q. Got calls: {calls:?}" - ); -} - -#[test] -fn absolute_leading_colon_type_path_does_not_route_to_same_named_workspace_type() { - // Sister to the generic-param-shadow gate: even when no in-scope - // generic matches `Q`, an absolute path `::Q` must NOT canonicalise - // to a workspace `Q` via the fallback `canonicalise_type_segments_in_scope`. - // Rust 2018+: `::Q` is from an extern crate root, so workspace - // canonicalisation does not apply. Pre-fix, with `pub struct Q;` - // in the workspace, `::Q` in a fn body resolves to - // `crate::...::Q` via local-symbols / crate-roots lookup — - // false-positive workspace edge. - use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; - use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::resolve::{ - resolve_type, ResolveContext, - }; - use crate::adapters::shared::use_tree::ScopedAliasMap; - - let ty: syn::Type = syn::parse_str("::Q").expect("parse `::Q`"); - let alias_map = HashMap::new(); - // Workspace has a local `Q` — exactly the false-positive trigger. - let mut local = HashSet::new(); - local.insert("Q".to_string()); - let local_decl_scopes: HashMap>> = { - let mut m = HashMap::new(); - m.insert("Q".to_string(), vec![vec![]]); - m - }; - let roots = HashSet::new(); - let file_scope = FileScope { - path: "src/app/runner.rs", - alias_map: &alias_map, - aliases_per_scope: &ScopedAliasMap::new(), - local_symbols: &local, - local_decl_scopes: &local_decl_scopes, - crate_root_modules: &roots, - workspace_module_paths: None, - }; - let resolved = resolve_type( - &ty, - &ResolveContext { - file: &file_scope, - mod_stack: &[], - type_aliases: None, - transparent_wrappers: None, - workspace_files: None, - alias_param_subs: None, - generic_params: None, // No generic in scope — purely a workspace-Q test - reexports: None, - }, - ); - // Must NOT be Path(crate::app::runner::Q) — the absolute leading - // colon disambiguates AWAY from workspace symbols too, not just - // generics. - if let CanonicalType::Path(segs) = &resolved { - assert!( - !segs.contains(&"Q".to_string()) || segs.first().map(String::as_str) != Some("crate"), - "`::Q` with `pub struct Q;` in the workspace must NOT canonicalise \ - to a workspace `Q` path. Got: {resolved:?}" - ); - } -} - -#[test] -fn absolute_leading_colon_call_path_does_not_route_to_same_named_workspace_fn() { - // Sister test for the call collector: `::Q::handle()` with a - // workspace `Q` available (local symbol or crate-root module) - // must NOT produce a `crate::...::Q::handle` edge. The leading - // colon disambiguates the call AWAY from workspace symbols too, - // not just generic params. - use crate::adapters::analyzers::architecture::call_parity_rule::calls::{ - collect_canonical_calls, FnContext, - }; - use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; - use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::{ - collect_crate_root_modules, collect_local_symbols, - }; - use crate::adapters::shared::use_tree::gather_alias_map; - - let fix = fixture(&[( - "src/app/q.rs", - r#" - // Workspace-local `Q` — the false-positive trigger. - pub struct Q; - impl Q { pub fn handle(&self) {} } - "#, - )]); - let borrowed_files = borrowed(&fix); - let workspace_index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/app/q.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - // Use site: `Q` is in the crate root via the `q` module (local - // symbol of nothing here — instead we'll check via crate-root - // modules). To trigger the bug, we put a workspace-local Q in - // the file's local_symbols by writing a file where Q is local. - let use_site = parse_file( - r#" - pub struct Q; - impl Q { pub fn handle(&self) {} } - pub fn use_it() { - ::Q::handle(); - } - "#, - ); - let alias_map = gather_alias_map(&use_site); - let local_symbols = collect_local_symbols(&use_site); - let crate_roots_set = collect_crate_root_modules(&[("src/cli/use_site.rs", &use_site)]); - let file_scope = FileScope { - path: "src/cli/use_site.rs", - alias_map: &alias_map, - aliases_per_scope: &Default::default(), - local_symbols: &local_symbols, - local_decl_scopes: &Default::default(), - crate_root_modules: &crate_roots_set, - workspace_module_paths: None, - }; - let body = match &use_site.items[2] { - syn::Item::Fn(item_fn) => &item_fn.block, - _ => panic!("expected fn item at index 2 of use_site"), - }; - let ctx = FnContext { - file: &file_scope, - mod_stack: &[], - body, - signature_params: vec![], - generic_params: std::collections::HashMap::new(), - self_type: None, - workspace_index: Some(&workspace_index), - workspace_files: None, - reexports: None, - }; - let calls = collect_canonical_calls(&ctx); - // Must NOT produce a workspace edge — the leading colon means - // extern. Acceptable canonicals: `:Q::handle` or similar. - // Forbidden: any `crate::...::Q::handle` workspace canonical. - let phantom_workspace_edge = "crate::cli::use_site::Q::handle"; - assert!( - !calls.contains(phantom_workspace_edge), - "`::Q::handle()` with workspace-local `Q` must NOT produce \ - workspace edge `{phantom_workspace_edge}` — the leading colon \ - disambiguates AWAY from workspace symbols. Got calls: {calls:?}" - ); -} - -#[test] -fn generic_param_bound_with_leading_colon_does_not_route_to_workspace_trait() { - // `fn run(q: Q) { Q::handle(&q); }` - // — the trait bound on Q is an explicit absolute path `::ports::...`. - // With a workspace-local `crate::ports::handler::Handler` trait in - // the same crate, the bound's segments `["ports", "handler", - // "Handler"]` would otherwise canonicalise to that workspace trait - // and `Q::handle()` would emit a false `Handler::handle` anchor - // edge. The leading colon must be preserved through bound - // extraction so the workspace canonicalisation gate sees it. - use crate::adapters::analyzers::architecture::call_parity_rule::calls::{ - collect_canonical_calls, FnContext, - }; - use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; - use crate::adapters::analyzers::architecture::call_parity_rule::signature_params::item_canonical_generics; - use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::{ - collect_crate_root_modules, collect_local_symbols, - }; - use crate::adapters::shared::use_tree::gather_alias_map; - - let fix = fixture(&[( - "src/ports/handler.rs", - r#" - pub trait Handler { fn handle(&self); } - "#, - )]); - let borrowed_files = borrowed(&fix); - let workspace_index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/ports/handler.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - let use_site = parse_file( - r#" - pub fn run(q: Q) { - Q::handle(&q); - } - "#, - ); - let alias_map = gather_alias_map(&use_site); - let local_symbols = collect_local_symbols(&use_site); - // Include both files so `ports` is in crate_root_modules — that's - // what makes the bound canonicalisable to the workspace trait - // (the false-positive trigger). - let crate_roots_set = collect_crate_root_modules(&[ - ("src/app/runner.rs", &use_site), - ("src/ports/handler.rs", borrowed_files[0].1), - ]); - let file_scope = FileScope { - path: "src/app/runner.rs", - alias_map: &alias_map, - aliases_per_scope: &Default::default(), - local_symbols: &local_symbols, - local_decl_scopes: &Default::default(), - crate_root_modules: &crate_roots_set, - workspace_module_paths: None, - }; - let (body, sig) = match &use_site.items[0] { - syn::Item::Fn(item_fn) => (&item_fn.block, &item_fn.sig), - _ => panic!("expected fn item at index 0 of use_site"), - }; - let generics = item_canonical_generics(&sig.generics, &file_scope, &[], None); - let ctx = FnContext { - file: &file_scope, - mod_stack: &[], - body, - signature_params: vec![], - generic_params: generics, - self_type: None, - workspace_index: Some(&workspace_index), - workspace_files: None, - reexports: None, - }; - let calls = collect_canonical_calls(&ctx); - let phantom_anchor = "crate::ports::handler::Handler::handle"; - assert!( - !calls.contains(phantom_anchor), - "`Q::handle(&q)` where `Q: ::ports::handler::Handler` (extern \ - leading-colon bound) must NOT emit anchor edge `{phantom_anchor}` \ - — the leading colon disambiguates AWAY from the workspace \ - trait. Got calls: {calls:?}" - ); -} - -#[test] -fn dyn_trait_with_leading_colon_does_not_route_to_workspace_trait_anchor() { - // `fn use_it(x: &dyn ::ports::handler::Handler) { x.handle(); }` - // — the `dyn` trait object's path is explicitly absolute. Without - // propagating leading_colon through `resolve_bound_list`, the - // bound canonicalises to `crate::ports::handler::Handler` and - // `x.handle()` routes through the workspace trait-anchor. - use crate::adapters::analyzers::architecture::call_parity_rule::calls::{ - collect_canonical_calls, FnContext, - }; - use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; - use crate::adapters::analyzers::architecture::call_parity_rule::signature_params::extract_signature_params; - use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::{ - collect_crate_root_modules, collect_local_symbols, - }; - use crate::adapters::shared::use_tree::gather_alias_map; - - let fix = fixture(&[( - "src/ports/handler.rs", - r#" - pub trait Handler { fn handle(&self); } - "#, - )]); - let borrowed_files = borrowed(&fix); - let workspace_index = { - let cfg_test = &HashSet::new(); - let roots = &crate_roots(&["src/ports/handler.rs"]); - let wraps = &HashSet::new(); - let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { - files: &borrowed_files, - cfg_test_files: cfg_test, - aliases_per_file: &fix.aliases, - aliases_scoped_per_file: &fix.aliases_scoped, - local_symbols_per_file: &fix.local_symbols, - crate_root_modules: roots, - workspace_module_paths: None, - }); - build_workspace_type_index(&WorkspaceIndexInputs { - files: &borrowed_files, - workspace_files: &workspace_files, - cfg_test_files: cfg_test, - transparent_wrappers: wraps, - reexports: None, - }) - }; - let use_site = parse_file( - r#" - pub fn use_it(x: &dyn ::ports::handler::Handler) { - x.handle(); - } - "#, - ); - let alias_map = gather_alias_map(&use_site); - let local_symbols = collect_local_symbols(&use_site); - // Include both files so `ports` is in crate_root_modules — the - // false-positive trigger requires the workspace trait to be - // canonicalisable from the use_site's scope. - let crate_roots_set = collect_crate_root_modules(&[ - ("src/app/use_site.rs", &use_site), - ("src/ports/handler.rs", borrowed_files[0].1), - ]); - let file_scope = FileScope { - path: "src/app/use_site.rs", - alias_map: &alias_map, - aliases_per_scope: &Default::default(), - local_symbols: &local_symbols, - local_decl_scopes: &Default::default(), - crate_root_modules: &crate_roots_set, - workspace_module_paths: None, - }; - let (body, sig) = match &use_site.items[0] { - syn::Item::Fn(item_fn) => (&item_fn.block, &item_fn.sig), - _ => panic!("expected fn item at index 0 of use_site"), - }; - let ctx = FnContext { - file: &file_scope, - mod_stack: &[], - body, - signature_params: extract_signature_params(sig), - generic_params: std::collections::HashMap::new(), - self_type: None, - workspace_index: Some(&workspace_index), - workspace_files: None, - reexports: None, - }; - let calls = collect_canonical_calls(&ctx); - let phantom_anchor = "crate::ports::handler::Handler::handle"; - assert!( - !calls.contains(phantom_anchor), - "`x.handle()` where `x: &dyn ::ports::handler::Handler` (extern \ - leading-colon `dyn Trait`) must NOT emit anchor edge \ - `{phantom_anchor}`. Got calls: {calls:?}" - ); -} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/empty_and_struct_fields.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/empty_and_struct_fields.rs new file mode 100644 index 00000000..92612bd7 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/empty_and_struct_fields.rs @@ -0,0 +1,85 @@ +use super::*; + +// ── Empty / trivial ────────────────────────────────────────────── + +#[test] +fn test_empty_workspace_produces_empty_index() { + let index = index_for(&[], &[]); + assert!(index.struct_fields.is_empty()); + assert!(index.method_returns.is_empty()); + assert!(index.fn_returns.is_empty()); +} + +// ── struct_fields ──────────────────────────────────────────────── + +/// A struct-field indexing case: `(label, files, roots, expect)`. +/// `expect = Some((struct, field, type))` means that field resolves to that +/// workspace type; `None` means nothing is indexed at all (tuple structs, +/// opaque/non-workspace field types). A tuple (not a struct) so the data +/// table doesn't read as repeated struct-construction boilerplate. +type FieldCase = ( + &'static str, + &'static [(&'static str, &'static str)], + &'static [&'static str], + Option<(&'static str, &'static str, &'static [&'static str])>, +); + +#[test] +fn struct_field_indexing() { + let cases: [FieldCase; 4] = [ + // Field type must be a workspace-local type — stdlib `String` would + // resolve to `Opaque` and get skipped by `record_field`. + ( + "named field of a workspace type is indexed", + &[( + "src/app/session.rs", + "pub struct Id;\npub struct Session { pub id: Id }", + )], + &["src/app/session.rs"], + Some(( + "crate::app::session::Session", + "id", + &["crate", "app", "session", "Id"], + )), + ), + ( + "Arc field is stripped to T", + &[( + "src/app/context.rs", + "pub struct Inner { pub v: u8 }\npub struct Ctx { pub inner: std::sync::Arc }", + )], + &["src/app/context.rs"], + Some(( + "crate::app::context::Ctx", + "inner", + &["crate", "app", "context", "Inner"], + )), + ), + ( + "tuple struct is not indexed", + &[("src/app/foo.rs", "pub struct Id(pub String);")], + &["src/app/foo.rs"], + None, + ), + ( + "opaque (non-workspace) field type is skipped", + &[( + "src/app/foo.rs", + "pub struct Ctx { pub x: external_crate::Unknown }", + )], + &["src/app/foo.rs"], + None, + ), + ]; + for (label, files, roots, expect) in cases { + let index = index_for(files, roots); + match expect { + Some((struct_canonical, field, ty)) => assert_eq!( + index.struct_field(struct_canonical, field), + Some(&CanonicalType::path(ty.iter().copied())), + "case: {label}" + ), + None => assert!(index.struct_fields.is_empty(), "case: {label}"), + } + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/inline_mod_and_traits.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/inline_mod_and_traits.rs new file mode 100644 index 00000000..153e9d75 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/inline_mod_and_traits.rs @@ -0,0 +1,233 @@ +use super::*; + +#[test] +fn test_fn_inside_inline_mod_keys_include_mod_name() { + // With inline-mod tracking the key is `crate::app::inner::make_session`, + // matching how `inner::make_session()` canonicalises at a call site. + let index = index_for( + &[( + "src/app/mod.rs", + "pub struct Session;\npub mod inner {\nuse super::Session;\npub fn make_session() -> Session { Session }\n}", + )], + &["src/app/mod.rs"], + ); + assert!( + index.fn_return("crate::app::inner::make_session").is_some(), + "fn_returns = {:?}", + index.fn_returns.keys().collect::>() + ); + // And the pre-fix key is absent — no duplicate shadow-registration. + assert!(index.fn_return("crate::app::make_session").is_none()); +} + +#[test] +fn test_fn_inside_inline_mod_resolves_inner_return_type() { + // With per-mod-scope resolution `Session` is found at scope `[inner]` and + // the return canonical is `crate::app::inner::Session` (pre-fix it + // resolved to Opaque against the file's top-level symbols and was dropped). + let index = index_for( + &[( + "src/app/mod.rs", + "pub mod inner {\npub struct Session;\npub fn make() -> Session { Session }\n}", + )], + &["src/app/mod.rs"], + ); + assert_eq!( + index.fn_return("crate::app::inner::make"), + Some(&CanonicalType::path(["crate", "app", "inner", "Session"])) + ); +} + +#[test] +fn test_struct_field_inside_inline_mod_keys_include_mod_name() { + let index = index_for( + &[( + "src/app/mod.rs", + "pub struct Session;\npub mod inner {\nuse super::Session;\npub struct Ctx { pub session: Session }\n}", + )], + &["src/app/mod.rs"], + ); + assert!( + index + .struct_field("crate::app::inner::Ctx", "session") + .is_some(), + "struct_fields = {:?}", + index.struct_fields.keys().collect::>() + ); +} + +#[test] +fn test_fn_with_unit_return_is_not_indexed() { + let index = index_for( + &[("src/app/foo.rs", "pub fn bump() {}")], + &["src/app/foo.rs"], + ); + assert!(index.fn_returns.is_empty()); +} + +// ── cfg-test skip ──────────────────────────────────────────────── + +#[test] +fn test_cfg_test_file_is_skipped() { + let fix = fixture(&[( + "src/app/foo.rs", + r#" + pub struct S { pub x: u8 } + impl S { pub fn get(&self) -> u8 { self.x } } + pub fn build() -> S { S { x: 0 } } + "#, + )]); + let mut cfg_test = HashSet::new(); + cfg_test.insert("src/app/foo.rs".to_string()); + let borrowed_files = borrowed(&fix); + let index = { + let cfg_test = &cfg_test; + let roots = &crate_roots(&["src/app/foo.rs"]); + let wraps = &HashSet::new(); + let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { + files: &borrowed_files, + cfg_test_files: cfg_test, + aliases_per_file: &fix.aliases, + aliases_scoped_per_file: &fix.aliases_scoped, + local_symbols_per_file: &fix.local_symbols, + crate_root_modules: roots, + workspace_module_paths: None, + }); + build_workspace_type_index(&WorkspaceIndexInputs { + files: &borrowed_files, + workspace_files: &workspace_files, + cfg_test_files: cfg_test, + transparent_wrappers: wraps, + reexports: None, + }) + }; + assert!(index.struct_fields.is_empty()); + assert!(index.method_returns.is_empty()); + assert!(index.fn_returns.is_empty()); +} + +// ── multi-file ──────────────────────────────────────────────────── + +// ── trait_methods / trait_impls ─────────────────────────────────── + +#[test] +fn test_trait_declaration_methods_are_indexed() { + let index = index_for( + &[( + "src/app/ports.rs", + "pub trait Handler {\nfn handle(&self, msg: &str);\nfn can_handle(&self, msg: &str) -> bool;\n}", + )], + &["src/app/ports.rs"], + ); + assert!(index.trait_has_method("crate::app::ports::Handler", "handle")); + assert!(index.trait_has_method("crate::app::ports::Handler", "can_handle")); + assert!(!index.trait_has_method("crate::app::ports::Handler", "missing")); +} + +#[test] +fn test_trait_impl_is_indexed() { + let index = index_for( + &[( + "src/app/foo.rs", + "pub struct MyImpl;\npub trait Handler { fn handle(&self); }\nimpl Handler for MyImpl { fn handle(&self) {} }", + )], + &["src/app/foo.rs"], + ); + let impls = index.impls_of_trait("crate::app::foo::Handler"); + assert!(impls.contains(&"crate::app::foo::MyImpl".to_string())); +} + +#[test] +fn test_multiple_impls_of_same_trait_all_indexed() { + let index = index_for( + &[( + "src/app/foo.rs", + "pub trait Handler { fn handle(&self); }\npub struct A;\npub struct B;\npub struct C;\nimpl Handler for A { fn handle(&self) {} }\nimpl Handler for B { fn handle(&self) {} }\nimpl Handler for C { fn handle(&self) {} }", + )], + &["src/app/foo.rs"], + ); + let impls = index.impls_of_trait("crate::app::foo::Handler"); + assert_eq!(impls.len(), 3); +} + +#[test] +fn test_inherent_impl_does_not_populate_trait_impls() { + // Inherent impl has no trait reference, so trait_impls stays empty. + let index = index_for( + &[( + "src/app/foo.rs", + "pub struct S;\nimpl S { pub fn method(&self) {} }", + )], + &["src/app/foo.rs"], + ); + assert!(index.trait_impls.is_empty()); +} + +#[test] +fn test_trait_in_one_file_impl_in_another() { + // Trait resolved via import alias. + let index = index_for( + &[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self); }", + ), + ( + "src/app/session.rs", + "use crate::ports::handler::Handler;\npub struct Session;\nimpl Handler for Session { fn handle(&self) {} }", + ), + ], + &["src/ports/handler.rs", "src/app/session.rs"], + ); + let impls = index.impls_of_trait("crate::ports::handler::Handler"); + assert!(impls.contains(&"crate::app::session::Session".to_string())); +} + +#[test] +fn test_struct_in_one_file_impl_in_another() { + let index = index_for( + &[ + ( + "src/app/session.rs", + "pub struct Id;\npub struct Session { pub id: Id }", + ), + ( + "src/app/impls.rs", + "use crate::app::session::{Session, Id};\nimpl Session {\npub fn clone_id(&self) -> Id { Id }\n}", + ), + ], + &["src/app/session.rs", "src/app/impls.rs"], + ); + // Struct indexed from its declaration file. + assert!(index + .struct_field("crate::app::session::Session", "id") + .is_some()); + // Method indexed from its impl file, keyed on the resolved + // self-type (`crate::app::session::Session` via alias map). + assert_eq!( + index.method_return("crate::app::session::Session", "clone_id"), + Some(&CanonicalType::path(["crate", "app", "session", "Id"])) + ); +} + +#[test] +fn record_trait_methods_captures_method_span() { + // The trait method's source location (file + 1-based line) must + // be captured at index-build time so anchor findings can carry a + // real source line. Without this, anchor findings hard-code + // line=0, which breaks suppression-window matching, the orphan + // detector, and SARIF location reporting. + let index = index_for( + &[( + "src/ports/handler.rs", + // Lines: 1=blank, 2=trait, 3=method-decl + "\npub trait Handler {\n fn handle(&self);\n}\n", + )], + &[], + ); + let loc = index + .trait_method_location("crate::ports::handler::Handler", "handle") + .expect("trait method location must be captured"); + assert_eq!(loc.file, "src/ports/handler.rs"); + assert_eq!(loc.line, 3); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/leading_colon_and_disambiguation.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/leading_colon_and_disambiguation.rs new file mode 100644 index 00000000..a3f041be --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/leading_colon_and_disambiguation.rs @@ -0,0 +1,299 @@ +use super::*; + +/// The 4-file workspace for the multi-generic turbofish test: a `Handler` port, +/// `Audit` + `Session` app types, and `get() -> Q` in `make`. +fn multi_generic_workspace() -> WorkspaceTypeIndex { + index_for( + &[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self); }", + ), + ( + "src/app/audit.rs", + "pub struct Audit;\nimpl Audit { pub fn audit_method(&self) {} }", + ), + ( + "src/app/session.rs", + "pub struct Session;\nimpl Session { pub fn diff(&self) {} }", + ), + ( + "src/app/make.rs", + "use crate::ports::handler::Handler;\npub fn get() -> Q { unimplemented!() }", + ), + ], + &[ + "src/ports/handler.rs", + "src/app/audit.rs", + "src/app/session.rs", + "src/app/make.rs", + ], + ) +} + +#[test] +fn multi_generic_fn_turbofish_picks_correct_arg_for_returned_param() { + // `fn get() -> Q` — A is the FIRST generic param, + // Q is the SECOND and IS the return. Calling + // `get::()` substitutes A=Audit and Q=Session. + // The return is Q → Session. The bug: pre-fix `turbofish_substitute` + // always picks the FIRST turbofish arg, so it would substitute + // Audit instead of Session, then `.diff()` would route to + // `Audit::diff` (false edge) or miss `Session::diff`. + // + // Required: GenericParamBound must carry the position of the + // returned param in the call-site-substitutable generics list, so + // turbofish substitution picks arg-at-position. + let workspace_index = multi_generic_workspace(); + let calls = calls_from( + &workspace_index, + r#" + use crate::app::make::get; + use crate::app::audit::Audit; + use crate::app::session::Session; + pub fn use_it() { + get::().diff(); + } + "#, + 3, + ); + let session_diff = "crate::app::session::Session::diff"; + let phantom_audit_diff = "crate::app::audit::Audit::diff"; + assert!( + calls.contains(session_diff), + "`get::().diff()` where `get() -> Q` \ + must substitute Q=Session (the SECOND turbofish arg, matching Q's \ + position). Got calls: {calls:?}" + ); + assert!( + !calls.contains(phantom_audit_diff), + "must NOT substitute Q=Audit (the FIRST turbofish arg, matching A's \ + position — but A is not the return). Got calls: {calls:?}" + ); +} + +// `::Q::method()` is an explicit absolute path (Rust 2018+: from an extern +// crate root). Even when an in-scope fn-generic param is named `Q`, the +// leading-colon form intentionally disambiguates AWAY from the generic. Pre-fix, +// `generic_param_shadow` matched purely on segment text (no leading_colon +// check), so the absolute `::Q` got mis-resolved as the generic's `Q` +// (GenericParamBound) instead of falling through to normal canonicalisation. +// (The `::Q` parse invariant is its own test, `double_colon_q_parses…`, below.) +#[test] +fn absolute_leading_colon_path_is_not_shadowed_by_in_scope_generic() { + use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; + use crate::adapters::analyzers::architecture::call_parity_rule::signature_params::ParamInfo; + use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::resolve::{ + resolve_type, ResolveContext, + }; + use crate::adapters::shared::use_tree::ScopedAliasMap; + + let ty: syn::Type = syn::parse_str("::Q").expect("parse `::Q`"); + // Fixture invariant: `::Q` must carry leading_colon (else the test is vacuous). + assert!(matches!(&ty, syn::Type::Path(tp) if tp.path.leading_colon.is_some())); + let alias_map = HashMap::new(); + let mut local = HashSet::new(); + local.insert("Q".to_string()); + let roots = HashSet::new(); + let file_scope = FileScope { + path: "src/app/runner.rs", + alias_map: &alias_map, + aliases_per_scope: &ScopedAliasMap::new(), + local_symbols: &local, + local_decl_scopes: &HashMap::new(), + crate_root_modules: &roots, + workspace_module_paths: None, + }; + let mut generics: HashMap = HashMap::new(); + generics.insert( + "Q".to_string(), + ParamInfo { + bounds: vec![vec![ + "crate".to_string(), + "ports".to_string(), + "Handler".to_string(), + ]], + turbofish_index: Some(0), + }, + ); + let resolved = resolve_type( + &ty, + &ResolveContext { + file: &file_scope, + mod_stack: &[], + type_aliases: None, + transparent_wrappers: None, + workspace_files: None, + alias_param_subs: None, + generic_params: Some(&generics), + reexports: None, + }, + ); + assert!( + !matches!(resolved, CanonicalType::GenericParamBound { .. }), + "`::Q` (leading_colon set) must NOT short-circuit through \ + generic_param_shadow — the absolute path is intentionally \ + disambiguated AWAY from the in-scope generic param Q. \ + Got: {resolved:?}" + ); +} + +// (label, index files, use-site src, file path, fn index, extra crate-root +// files, build item-generics?, forbidden edge) +type LeadingColonCase = ( + &'static str, + &'static [(&'static str, &'static str)], + &'static str, + &'static str, + usize, + &'static [(&'static str, &'static str)], + bool, + &'static str, +); + +const HANDLER: &str = "pub trait Handler { fn handle(&self); }"; + +const LEADING_COLON_CASES: &[LeadingColonCase] = &[ + ( + // `::Q::handle(&q)` inside `fn run()` — the leading `::` + // disambiguates away from the in-scope generic param Q, so it must + // not collapse to the Handler trait anchor. + "leading-colon call shadowed by an in-scope generic param", + &[("src/ports/handler.rs", HANDLER)], + "use crate::ports::handler::Handler;\npub fn run(q: Q) { ::Q::handle(&q); }", + "src/app/runner.rs", + 1, + &[], + true, + "crate::ports::handler::Handler::handle", + ), + ( + // `::Q::handle()` with a workspace-local `Q` present — the leading + // colon disambiguates away from the workspace symbol too. + "leading-colon call not routed to a same-named workspace fn", + &[( + "src/app/q.rs", + "pub struct Q;\nimpl Q { pub fn handle(&self) {} }", + )], + "pub struct Q;\nimpl Q { pub fn handle(&self) {} }\npub fn use_it() { ::Q::handle(); }", + "src/cli/use_site.rs", + 2, + &[], + false, + "crate::cli::use_site::Q::handle", + ), + ( + // `Q: ::ports::handler::Handler` — the bound's leading colon must be + // preserved so `Q::handle()` does not emit the workspace anchor. + "leading-colon generic bound not routed to the workspace trait", + &[("src/ports/handler.rs", HANDLER)], + "pub fn run(q: Q) { Q::handle(&q); }", + "src/app/runner.rs", + 0, + &[("src/ports/handler.rs", HANDLER)], + true, + "crate::ports::handler::Handler::handle", + ), + ( + // `&dyn ::ports::handler::Handler` — the dyn trait object's absolute + // path must not route `x.handle()` through the workspace anchor. + "leading-colon dyn-trait bound not routed to the workspace trait", + &[("src/ports/handler.rs", HANDLER)], + "pub fn use_it(x: &dyn ::ports::handler::Handler) { x.handle(); }", + "src/app/use_site.rs", + 0, + &[("src/ports/handler.rs", HANDLER)], + false, + "crate::ports::handler::Handler::handle", + ), +]; + +#[test] +fn leading_colon_paths_do_not_route_to_workspace_anchors() { + // An explicit leading `::` is the caller's disambiguation AWAY from both + // in-scope generic params AND same-named workspace symbols (Rust 2018+: + // `::X` is rooted at an extern crate). The call collector must therefore + // never canonicalise these to a workspace trait-anchor or fn edge. Each + // case drives the FileScope → FnContext → collect_canonical_calls pipeline + // (via `calls_from_scoped`) and asserts the `forbidden` edge is absent. + for (label, index_files, use_site, path, fn_index, extra_roots, with_generics, forbidden) in + LEADING_COLON_CASES + { + let roots: Vec<&str> = index_files.iter().map(|(p, _)| *p).collect(); + let workspace_index = index_for(index_files, &roots); + let calls = calls_from_scoped(ScopedCalls { + workspace_index: &workspace_index, + use_site_src: use_site, + path, + fn_index: *fn_index, + extra_root_files: extra_roots, + with_generics: *with_generics, + }); + assert!( + !calls.contains(*forbidden), + "case {label}: `{forbidden}` must be absent (leading `::` \ + disambiguates away). Got calls: {calls:?}" + ); + } +} + +#[test] +fn absolute_leading_colon_type_path_does_not_route_to_same_named_workspace_type() { + // Sister to the generic-param-shadow gate: even when no in-scope + // generic matches `Q`, an absolute path `::Q` must NOT canonicalise + // to a workspace `Q` via the fallback `canonicalise_type_segments_in_scope`. + // Rust 2018+: `::Q` is from an extern crate root, so workspace + // canonicalisation does not apply. Pre-fix, with `pub struct Q;` + // in the workspace, `::Q` in a fn body resolves to + // `crate::...::Q` via local-symbols / crate-roots lookup — + // false-positive workspace edge. + use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; + use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::resolve::{ + resolve_type, ResolveContext, + }; + use crate::adapters::shared::use_tree::ScopedAliasMap; + + let ty: syn::Type = syn::parse_str("::Q").expect("parse `::Q`"); + let alias_map = HashMap::new(); + // Workspace has a local `Q` — exactly the false-positive trigger. + let mut local = HashSet::new(); + local.insert("Q".to_string()); + let local_decl_scopes: HashMap>> = { + let mut m = HashMap::new(); + m.insert("Q".to_string(), vec![vec![]]); + m + }; + let roots = HashSet::new(); + let file_scope = FileScope { + path: "src/app/runner.rs", + alias_map: &alias_map, + aliases_per_scope: &ScopedAliasMap::new(), + local_symbols: &local, + local_decl_scopes: &local_decl_scopes, + crate_root_modules: &roots, + workspace_module_paths: None, + }; + let resolved = resolve_type( + &ty, + &ResolveContext { + file: &file_scope, + mod_stack: &[], + type_aliases: None, + transparent_wrappers: None, + workspace_files: None, + alias_param_subs: None, + generic_params: None, // No generic in scope — purely a workspace-Q test + reexports: None, + }, + ); + // Must NOT be Path(crate::app::runner::Q) — the absolute leading + // colon disambiguates AWAY from workspace symbols too, not just + // generics. + if let CanonicalType::Path(segs) = &resolved { + assert!( + !segs.contains(&"Q".to_string()) || segs.first().map(String::as_str) != Some("crate"), + "`::Q` with `pub struct Q;` in the workspace must NOT canonicalise \ + to a workspace `Q` path. Got: {resolved:?}" + ); + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/method_and_fn_returns.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/method_and_fn_returns.rs new file mode 100644 index 00000000..e108d1d1 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/method_and_fn_returns.rs @@ -0,0 +1,237 @@ +use super::*; + +// ── method_returns ─────────────────────────────────────────────── + +/// A method-return indexing case: `(label, files, roots, receiver, method, +/// expect)`. `expect = Some(ty)` asserts `method_return(receiver, method)` +/// equals that exact type; `None` asserts the method is not indexed. +/// A tuple (not a struct) keeps the data table clear of struct-construction +/// boilerplate (BP-009). `CanonicalType` is built at runtime, hence `vec!`. +type MethodCase = ( + &'static str, + &'static [(&'static str, &'static str)], + &'static [&'static str], + &'static str, + &'static str, + Option, +); + +/// Concrete-return cases: inherent, `Result`, `Result`, and unit +/// returns. Split from the generic cases so each builder stays a small "arrange" +/// step and the test body reads as plain act+assert (no `qual:allow` needed). +fn method_return_concrete_cases() -> Vec { + vec![ + ( + "inherent method with concrete return", + &[( + "src/app/session.rs", + "pub struct Session;\npub struct Response;\nimpl Session { pub fn diff(&self) -> Response { Response } }", + )], + &["src/app/session.rs"], + "crate::app::session::Session", + "diff", + Some(CanonicalType::path(["crate", "app", "session", "Response"])), + ), + ( + "Result return wraps T", + &[( + "src/app/session.rs", + "pub struct Session;\npub struct Response;\npub struct Error;\nimpl Session { pub fn diff(&self) -> Result { unimplemented!() } }", + )], + &["src/app/session.rs"], + "crate::app::session::Session", + "diff", + Some(CanonicalType::Result(Box::new(CanonicalType::path([ + "crate", "app", "session", "Response", + ])))), + ), + ( + // `Result` must store `Result`, not + // `Result`, or chains like `open().unwrap().diff()` + // lose the receiver type at `.unwrap()`. + "Result substitutes the receiver type", + &[( + "src/app/session.rs", + "pub struct Session;\npub struct Error;\nimpl Session { pub fn open() -> Result { unimplemented!() } }", + )], + &["src/app/session.rs"], + "crate::app::session::Session", + "open", + Some(CanonicalType::Result(Box::new(CanonicalType::path([ + "crate", "app", "session", "Session", + ])))), + ), + ( + "unit return is not indexed", + &[("src/app/foo.rs", "pub struct S;\nimpl S { pub fn bump(&self) {} }")], + &["src/app/foo.rs"], + "crate::app::foo::S", + "bump", + None, + ), + ] +} + +/// Generic / trait-dispatch cases: impl-Trait return, trait-impl method keyed by +/// the receiver type, and a method-scoped generic shadowing a workspace type. +fn method_return_generic_cases() -> Vec { + vec![ + ( + "impl-Trait return is not indexed", + &[( + "src/app/foo.rs", + "pub struct S;\nimpl S { pub fn iter(&self) -> impl Iterator { std::iter::empty() } }", + )], + &["src/app/foo.rs"], + "crate::app::foo::S", + "iter", + None, + ), + ( + // Keyed by the concrete receiver type S, NOT by the trait. + "trait-impl method is keyed by the receiver type", + &[( + "src/app/foo.rs", + "pub struct S;\npub struct T;\npub trait Convert { fn to(&self) -> T; }\nimpl Convert for S { fn to(&self) -> T { T } }", + )], + &["src/app/foo.rs"], + "crate::app::foo::S", + "to", + Some(CanonicalType::path(["crate", "app", "foo", "T"])), + ), + ( + // method-scoped generic `Q` must shadow workspace `struct Q`, + // yield Opaque, and not poison method_returns. + "method-scoped generic param shadows a same-named workspace type", + &[( + "src/app/make.rs", + "pub struct Q;\npub struct Service;\nimpl Service { pub fn get(&self) -> Q { unimplemented!() } }", + )], + &["src/app/make.rs"], + "crate::app::make::Service", + "get", + None, + ), + ] +} + +#[test] +fn method_return_indexing() { + let mut cases = method_return_concrete_cases(); + cases.extend(method_return_generic_cases()); + for (label, files, roots, receiver, method, expect) in cases { + let index = index_for(files, roots); + assert_eq!( + index.method_return(receiver, method), + expect.as_ref(), + "case: {label}" + ); + } +} + +// ── fn_returns ─────────────────────────────────────────────────── + +/// A free-fn return indexing case: `(label, files, roots, fn_canonical, +/// expect)`. `Some(ty)` asserts `fn_return(fn_canonical)` equals that type; +/// `None` asserts the fn is not indexed. Tuple (not struct) to avoid BP-009. +type FnCase = ( + &'static str, + &'static [(&'static str, &'static str)], + &'static [&'static str], + &'static str, + Option, +); + +#[test] +fn fn_return_indexing() { + let cases: Vec = vec![ + ( + "concrete return is indexed", + &[( + "src/app/make.rs", + "pub struct Session;\npub fn make_session() -> Session { Session }", + )], + &["src/app/make.rs"], + "crate::app::make::make_session", + Some(CanonicalType::path(["crate", "app", "make", "Session"])), + ), + ( + // Generic T has no alias/local-symbol entry → Opaque → skipped. + "generic return type is opaque and not indexed", + &[( + "src/app/make.rs", + "pub fn get() -> T { unimplemented!() }", + )], + &["src/app/make.rs"], + "crate::app::make::get", + None, + ), + ( + // fn-scoped generic `Q` must shadow workspace `struct Q`, yield + // Opaque, and not be indexed (else turbofish inference breaks). + "fn-scoped generic param shadows a same-named workspace type", + &[( + "src/app/make.rs", + "pub struct Q;\npub fn get() -> Q { unimplemented!() }", + )], + &["src/app/make.rs"], + "crate::app::make::get", + None, + ), + ]; + for (label, files, roots, fn_canonical, expect) in cases { + let index = index_for(files, roots); + assert_eq!( + index.fn_return(fn_canonical), + expect.as_ref(), + "case: {label}" + ); + } +} + +#[test] +fn bounded_fn_generic_param_return_carries_canonicalised_trait_bound() { + // `pub fn make() -> Q` where `Handler` is in scope via + // `use crate::ports::Handler;`. The fn-return entry must store a + // canonicalised `TraitBound([["crate","ports","Handler"]])`, NOT + // the raw single-segment `[["Handler"]]` — downstream + // `trait_has_method` / anchor lookups key on canonical paths and + // would silently miss the un-canonicalised form, dropping valid + // trait-dispatch edges. + // Acceptable outcomes: skipped entirely (Opaque) or stored as + // GenericParamBound with the canonical path. Forbidden: a bound carrying + // the raw single-segment `["Handler"]`. (Bare generic-param returns use + // `GenericParamBound`, not `TraitBound`.) + let index = index_for( + &[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self); }", + ), + ( + "src/app/make.rs", + "use crate::ports::handler::Handler;\npub fn make() -> Q { unimplemented!() }", + ), + ], + &["src/ports/handler.rs", "src/app/make.rs"], + ); + if let Some(ret) = index.fn_return("crate::app::make::make") { + let canonical_bounds: Vec> = vec![vec![ + "crate".to_string(), + "ports".to_string(), + "handler".to_string(), + "Handler".to_string(), + ]]; + match ret { + CanonicalType::GenericParamBound { bounds, .. } => { + assert_eq!( + bounds, &canonical_bounds, + "trait bound for `Q: Handler` must be canonicalised \ + to `crate::ports::handler::Handler`, got {bounds:?}" + ); + } + CanonicalType::Opaque => {} // also acceptable + other => panic!("unexpected return type for `make`: {other:?}"), + } + } +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/mod.rs new file mode 100644 index 00000000..5b228e85 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/mod.rs @@ -0,0 +1,243 @@ +//! Integration tests for `WorkspaceTypeIndex` building — struct-field, +//! method-return, and free-fn-return collection across single- and multi-file +//! workspaces, turbofish/generic substitution, inline-mod + trait indexing, +//! and leading-colon disambiguation. Split into focused sub-files (each ≤ the +//! SRP file-length cap); shared imports, the `WsFixture`/`ScopedCalls` +//! fixtures, and the build/calls helpers live here and reach the sub-modules +//! via `use super::*`. + +pub(super) use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::{ + build_workspace_files_map, collect_local_symbols_scoped, LocalSymbols, WorkspaceFilesInputs, +}; +pub(super) use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::{ + build_workspace_type_index, CanonicalType, WorkspaceIndexInputs, WorkspaceTypeIndex, +}; +pub(super) use crate::adapters::shared::use_tree::{ + gather_alias_map, gather_alias_map_scoped, AliasMap, ScopedAliasMap, +}; +pub(super) use std::collections::{HashMap, HashSet}; + +// Pipeline-wiring imports for `calls_from` / `calls_from_scoped` (kept at module +// level so the helper bodies stay act-only, not import-laden). +use crate::adapters::analyzers::architecture::call_parity_rule::calls::{ + collect_canonical_calls, FnContext, +}; +use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; +use crate::adapters::analyzers::architecture::call_parity_rule::signature_params::{ + extract_signature_params, item_canonical_generics, +}; +use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::{ + collect_crate_root_modules, collect_local_symbols, +}; + +mod empty_and_struct_fields; +mod inline_mod_and_traits; +mod leading_colon_and_disambiguation; +mod method_and_fn_returns; +mod turbofish_and_generics; + +pub(super) fn parse_file(src: &str) -> syn::File { + syn::parse_str(src).expect("parse file") +} + +pub(super) struct WsFixture { + pub(super) parsed: Vec<(String, syn::File)>, + pub(super) aliases: HashMap, + pub(super) aliases_scoped: HashMap, + pub(super) local_symbols: HashMap, +} + +pub(super) fn fixture(entries: &[(&str, &str)]) -> WsFixture { + let mut parsed = Vec::new(); + let mut aliases = HashMap::new(); + let mut aliases_scoped = HashMap::new(); + let mut local_symbols = HashMap::new(); + for (path, src) in entries { + let ast = parse_file(src); + aliases.insert(path.to_string(), gather_alias_map(&ast)); + aliases_scoped.insert(path.to_string(), gather_alias_map_scoped(&ast)); + local_symbols.insert(path.to_string(), collect_local_symbols_scoped(&ast)); + parsed.push((path.to_string(), ast)); + } + WsFixture { + parsed, + aliases, + aliases_scoped, + local_symbols, + } +} + +pub(super) fn borrowed(f: &WsFixture) -> Vec<(&str, &syn::File)> { + f.parsed.iter().map(|(p, a)| (p.as_str(), a)).collect() +} + +pub(super) fn crate_roots(paths: &[&str]) -> HashSet { + paths + .iter() + .filter_map(|p| { + let rest = p.strip_prefix("src/")?; + let first = rest.split('/').next()?; + let name = first.strip_suffix(".rs").unwrap_or(first); + if matches!(name, "lib" | "main") { + None + } else { + Some(name.to_string()) + } + }) + .collect() +} + +/// Build a `WorkspaceTypeIndex` for the common test case — empty cfg-test +/// and transparent-wrapper sets, no re-exports, given crate roots. Tests +/// that need a non-empty set call the builders directly. +pub(super) fn build_index( + files: &[(&str, &syn::File)], + fix: &WsFixture, + roots: &HashSet, +) -> WorkspaceTypeIndex { + let cfg_test = HashSet::new(); + let wraps = HashSet::new(); + let workspace_files = build_workspace_files_map(WorkspaceFilesInputs { + files, + cfg_test_files: &cfg_test, + aliases_per_file: &fix.aliases, + aliases_scoped_per_file: &fix.aliases_scoped, + local_symbols_per_file: &fix.local_symbols, + crate_root_modules: roots, + workspace_module_paths: None, + }); + build_workspace_type_index(&WorkspaceIndexInputs { + files, + workspace_files: &workspace_files, + cfg_test_files: &cfg_test, + transparent_wrappers: &wraps, + reexports: None, + }) +} + +/// One-shot for the common test shape: parse `entries` into a fixture and +/// build its `WorkspaceTypeIndex` with the given crate-root paths (empty +/// slice = no roots). Use this when the test only needs the index; tests +/// that also reuse the fixture/borrowed files build it step by step. +pub(super) fn index_for(entries: &[(&str, &str)], root_paths: &[&str]) -> WorkspaceTypeIndex { + let fix = fixture(entries); + let borrowed_files = borrowed(&fix); + build_index(&borrowed_files, &fix, &crate_roots(root_paths)) +} + +/// Run the canonical-call inference pipeline over the `fn_index`-th item of a +/// parsed `use_site_src`, against `workspace_index`, and return the resolved +/// call set. Centralises the FileScope/FnContext wiring that the +/// turbofish/inference tests would otherwise each repeat verbatim. +pub(super) fn calls_from( + workspace_index: &WorkspaceTypeIndex, + use_site_src: &str, + fn_index: usize, +) -> std::collections::HashSet { + use crate::adapters::analyzers::architecture::call_parity_rule::calls::{ + collect_canonical_calls, FnContext, + }; + use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; + use crate::adapters::analyzers::architecture::call_parity_rule::signature_params::extract_signature_params; + use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::{ + collect_crate_root_modules, collect_local_symbols, + }; + use crate::adapters::shared::use_tree::gather_alias_map; + + let use_site = parse_file(use_site_src); + let alias_map = gather_alias_map(&use_site); + let local_symbols = collect_local_symbols(&use_site); + let crate_roots_set = collect_crate_root_modules(&[("src/cli/use_site.rs", &use_site)]); + let file_scope = FileScope { + path: "src/cli/use_site.rs", + alias_map: &alias_map, + aliases_per_scope: &Default::default(), + local_symbols: &local_symbols, + local_decl_scopes: &Default::default(), + crate_root_modules: &crate_roots_set, + workspace_module_paths: None, + }; + let (body, sig) = match &use_site.items[fn_index] { + syn::Item::Fn(item_fn) => (&item_fn.block, &item_fn.sig), + _ => panic!("expected fn item at index {fn_index} of use_site"), + }; + let ctx = FnContext { + file: &file_scope, + mod_stack: &[], + body, + signature_params: extract_signature_params(sig), + generic_params: std::collections::HashMap::new(), + self_type: None, + workspace_index: Some(workspace_index), + workspace_files: None, + reexports: None, + }; + collect_canonical_calls(&ctx) +} + +/// Inputs for [`calls_from_scoped`]. The leading-colon / generic-bound / +/// dyn-trait disambiguation tests need a custom file path, extra crate-root +/// files (so a same-named workspace trait/symbol is canonicalisable — the +/// false-positive trigger), and either the fn's item-level generics or its +/// signature params — none of which the plain `calls_from` exposes. +pub(super) struct ScopedCalls<'a> { + pub(super) workspace_index: &'a WorkspaceTypeIndex, + pub(super) use_site_src: &'a str, + pub(super) path: &'a str, + pub(super) fn_index: usize, + pub(super) extra_root_files: &'a [(&'a str, &'a str)], + pub(super) with_generics: bool, +} + +/// Run the FileScope → FnContext → `collect_canonical_calls` pipeline with a +/// caller-controlled scope. Collapses the inline FileScope/FnContext arrange +/// the leading-colon disambiguation tests would otherwise repeat. +pub(super) fn calls_from_scoped(input: ScopedCalls) -> std::collections::HashSet { + let use_site = parse_file(input.use_site_src); + let alias_map = gather_alias_map(&use_site); + let local_symbols = collect_local_symbols(&use_site); + let extra_parsed: Vec<(&str, syn::File)> = input + .extra_root_files + .iter() + .map(|(p, s)| (*p, parse_file(s))) + .collect(); + let mut root_inputs: Vec<(&str, &syn::File)> = vec![(input.path, &use_site)]; + root_inputs.extend(extra_parsed.iter().map(|(p, f)| (*p, f))); + let crate_roots_set = collect_crate_root_modules(&root_inputs); + let file_scope = FileScope { + path: input.path, + alias_map: &alias_map, + aliases_per_scope: &Default::default(), + local_symbols: &local_symbols, + local_decl_scopes: &Default::default(), + crate_root_modules: &crate_roots_set, + workspace_module_paths: None, + }; + let (body, sig) = match &use_site.items[input.fn_index] { + syn::Item::Fn(item_fn) => (&item_fn.block, &item_fn.sig), + _ => panic!("expected fn item at index {} of use_site", input.fn_index), + }; + let (generic_params, signature_params) = if input.with_generics { + ( + item_canonical_generics(&sig.generics, &file_scope, &[], None), + vec![], + ) + } else { + ( + std::collections::HashMap::new(), + extract_signature_params(sig), + ) + }; + let ctx = FnContext { + file: &file_scope, + mod_stack: &[], + body, + signature_params, + generic_params, + self_type: None, + workspace_index: Some(input.workspace_index), + workspace_files: None, + reexports: None, + }; + collect_canonical_calls(&ctx) +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/turbofish_and_generics.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/turbofish_and_generics.rs new file mode 100644 index 00000000..87035191 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/turbofish_and_generics.rs @@ -0,0 +1,227 @@ +use super::*; + +// Shared fixture files for the turbofish-substitution rule table: a Handler +// trait (port) and a Session with an inherent `diff` (app). Each case adds a +// third file declaring the generic-returning fn/method under test. +const TF_HANDLER: (&str, &str) = ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self); }", +); +const TF_SESSION: (&str, &str) = ( + "src/app/session.rs", + "pub struct Session;\nimpl Session { pub fn diff(&self) {} }", +); + +// (label, declarer-file (path, src), use-site fn body, session_diff_expected) +type TurbofishCase = ( + &'static str, + (&'static str, &'static str), + &'static str, + bool, +); + +const TURBOFISH_CASES: &[TurbofishCase] = &[ + ( + // free fn `get() -> Q`: turbofish overrides the + // bounded-generic return; `.diff()` → Session::diff, not Handler. + "free-fn bounded generic param return", + ( + "src/app/make.rs", + "use crate::ports::handler::Handler;\npub fn get() -> Q { unimplemented!() }", + ), + "use crate::app::make::get;\nuse crate::app::session::Session;\npub fn use_it() { get::().diff(); }", + true, + ), + ( + // method `current(&self) -> Q`: same override, method + // call. `s: &Service` typed via the sig param so the receiver + // binds as Path([Service]). + "method-call bounded generic param return", + ( + "src/app/service.rs", + "use crate::ports::handler::Handler;\npub struct Service;\nimpl Service { pub fn current(&self) -> Q { unimplemented!() } }", + ), + "use crate::app::service::Service;\nuse crate::app::session::Session;\npub fn use_it(s: &Service) { s.current::().diff(); }", + true, + ), + ( + // free fn `make() -> impl Handler`: opaque return; T does NOT + // substitute it, so no Session::diff edge (TraitBound, not + // GenericParamBound). + "free-fn impl-Trait return is opaque", + ( + "src/app/make.rs", + "use crate::ports::handler::Handler;\npub fn make() -> impl Handler { unimplemented!() }", + ), + "use crate::app::make::make;\nuse crate::app::session::Session;\npub fn use_it() { make::().diff(); }", + false, + ), + ( + // method `make_handler(&self) -> impl Handler`: opaque, same. + "method-call impl-Trait return is opaque", + ( + "src/app/service.rs", + "use crate::ports::handler::Handler;\npub struct Service;\nimpl Service { pub fn make_handler(&self) -> impl Handler { unimplemented!() } }", + ), + "use crate::app::service::Service;\nuse crate::app::session::Session;\npub fn use_it() { let s = Service; s.make_handler::().diff(); }", + false, + ), + ( + // free fn `get() -> Result`: substitution + // recurses into the Result wrapper; `.unwrap().diff()` → Session. + "free-fn Result-wrapped generic param return", + ( + "src/app/make.rs", + "use crate::ports::handler::Handler;\npub struct MyErr;\npub fn get() -> Result { unimplemented!() }", + ), + "use crate::app::make::get;\nuse crate::app::session::Session;\npub fn use_it() { get::().unwrap().diff(); }", + true, + ), + ( + // method `current(&self) -> Result`: same + // wrapper recursion, method call. + "method-call Result-wrapped generic param return", + ( + "src/app/service.rs", + "use crate::ports::handler::Handler;\npub struct MyErr;\npub struct Service;\nimpl Service { pub fn current(&self) -> Result { unimplemented!() } }", + ), + "use crate::app::service::Service;\nuse crate::app::session::Session;\npub fn use_it(s: &Service) { s.current::().unwrap().diff(); }", + true, + ), + ( + // free fn `get() -> Vec`: substitution recurses into + // the Slice; `for s in get::() { s.diff(); }` → Session. + "free-fn Vec-wrapped generic param return (iterated)", + ( + "src/app/make.rs", + "use crate::ports::handler::Handler;\npub fn get() -> Vec { unimplemented!() }", + ), + "use crate::app::make::get;\nuse crate::app::session::Session;\npub fn use_it() { for s in get::() { s.diff(); } }", + true, + ), +]; + +#[test] +fn turbofish_substitution_through_generic_param_returns() { + // A turbofish `::` substitutes a bare generic-param return + // (`-> Q`, including inside Result/Vec wrappers) so a trailing `.diff()` + // resolves to the concrete `Session::diff` — but an `impl Trait` return is + // opaque and must NOT substitute. Each case drives the full inference + // pipeline via `calls_from`; `expected` says whether the `Session::diff` + // edge must appear. (Behaviour lives in `collect_canonical_calls`; the + // index alone can't surface it.) + const SESSION_DIFF: &str = "crate::app::session::Session::diff"; + for (label, declarer, use_site, expected) in TURBOFISH_CASES { + let files = [TF_HANDLER, TF_SESSION, *declarer]; + let roots: Vec<&str> = files.iter().map(|(p, _)| *p).collect(); + let workspace_index = index_for(&files, &roots); + let calls = calls_from(&workspace_index, use_site, 2); + assert_eq!( + calls.contains(SESSION_DIFF), + *expected, + "case {label}: Session::diff edge presence mismatch. Calls: {calls:?}" + ); + } +} + +#[test] +fn method_generic_param_return_canonicalises_where_bound_on_impl_generic() { + // `impl Service { fn current(&self) -> Q where Q: Handler }` — + // the where-clause bound `Q: Handler` lives on the method's `where` + // but references the impl-level generic `Q`. A method-level + // generics extractor that only sees the method's own param list + // misses it; `method_canonical_generics(sig, impl_generics, …)` + // must extend bounds for outer-name predicates so the bound + // survives canonicalisation. + // Strict: the method's where-clause bound on the impl-level generic must + // be captured by `method_canonical_generics`; if the extractor drops the + // outer-name predicate the param has empty bounds and the return is + // Opaque. Capturing it surfaces a canonical `GenericParamBound` (with + // `turbofish_index: None`, since impl-level Q substitutes via the receiver + // type, not a method-call turbofish on `current`). + let index = index_for( + &[ + ( + "src/ports/handler.rs", + "pub trait Handler { fn handle(&self); }", + ), + ( + "src/app/service.rs", + "use crate::ports::handler::Handler;\npub struct Service(pub Q);\nimpl Service { pub fn current(&self) -> Q where Q: Handler { unimplemented!() } }", + ), + ], + &["src/ports/handler.rs", "src/app/service.rs"], + ); + let ret = index + .method_return("crate::app::service::Service", "current") + .expect("method-level where-bound must surface as GenericParamBound, not be dropped"); + let canonical_bounds: Vec> = vec![vec![ + "crate".to_string(), + "ports".to_string(), + "handler".to_string(), + "Handler".to_string(), + ]]; + // Impl-level Q: turbofish_index is None (substituted via receiver + // type, not method-call turbofish). + assert_eq!( + ret, + &CanonicalType::GenericParamBound { + bounds: canonical_bounds, + turbofish_index: None, + }, + "method-level `where Q: Handler` on impl-level `Q` must produce \ + a canonicalised GenericParamBound (with no method-turbofish \ + position) on the method's return, got {ret:?}" + ); +} + +#[test] +fn struct_generic_param_field_does_not_collide_with_same_named_workspace_type() { + // Workspace has both `pub struct Q;` and a generic + // `pub struct Container { pub item: Q }`. The field type `Q` + // is the struct's own generic param, NOT a reference to the + // workspace struct. Without threading the struct's generics into + // the field-collector resolve context, the canonicaliser resolves + // `Q` to `crate::app::make::Q` (the workspace struct) and + // `struct_fields["Container"]["item"] = crate::app::make::Q`, + // poisoning later `self.item.method()` resolution. + // + // Expected: struct's generic `Q` shadows the workspace struct, + // the field resolves to `Opaque`, and the entry is dropped. + let index = index_for( + &[( + "src/app/make.rs", + "pub struct Q;\npub struct Container { pub item: Q }", + )], + &["src/app/make.rs"], + ); + assert_eq!( + index.struct_field("crate::app::make::Container", "item"), + None, + "struct-scoped generic param `Q` must shadow workspace struct \ + `Q` and yield Opaque (skipped from struct_fields). Got: {:?}", + index.struct_fields, + ); +} + +#[test] +fn impl_level_generic_param_return_does_not_collide_with_same_named_workspace_type() { + // Impl-level generic: `impl Service { fn first(&self) -> Q }` + // with the workspace also exposing `pub struct Q;`. The impl-level + // `Q` must shadow the workspace struct for every method's return- + // type resolution. + let index = index_for( + &[( + "src/app/make.rs", + "pub struct Q;\npub struct Service(pub Q);\nimpl Service { pub fn first(&self) -> Q { unimplemented!() } }", + )], + &["src/app/make.rs"], + ); + assert_eq!( + index.method_return("crate::app::make::Service", "first"), + None, + "impl-level generic `Q` must shadow workspace struct `Q` for \ + every method's return resolution. Got: {:?}", + index.method_returns, + ); +} diff --git a/src/adapters/analyzers/architecture/matcher/tests/macro_call.rs b/src/adapters/analyzers/architecture/matcher/tests/macro_call.rs index cfeb1d9b..374f2794 100644 --- a/src/adapters/analyzers/architecture/matcher/tests/macro_call.rs +++ b/src/adapters/analyzers/architecture/matcher/tests/macro_call.rs @@ -1,5 +1,4 @@ use crate::adapters::analyzers::architecture::matcher::find_macro_calls; -use crate::adapters::analyzers::architecture::ViolationKind; fn parse(src: &str) -> syn::File { syn::parse_str(src).expect("fixture must parse") @@ -21,11 +20,7 @@ fn matches_println_expression_macro() { } "#; let hits = find(src, &["println"]); - assert_eq!(hits.len(), 1, "expected one hit: {hits:?}"); - match &hits[0].kind { - ViolationKind::MacroCall { name } => assert_eq!(name, "println"), - other => panic!("unexpected kind: {other:?}"), - } + super::assert_one_named(&hits, "println"); } #[test] diff --git a/src/adapters/analyzers/architecture/matcher/tests/method_call.rs b/src/adapters/analyzers/architecture/matcher/tests/method_call.rs index 87b6c51f..ce5adc2c 100644 --- a/src/adapters/analyzers/architecture/matcher/tests/method_call.rs +++ b/src/adapters/analyzers/architecture/matcher/tests/method_call.rs @@ -14,18 +14,17 @@ fn find(src: &str, names: &[&str]) -> Vec = Some(1); - x.unwrap(); - } - "#; - let hits = find(src, &["unwrap"]); - assert_eq!(hits.len(), 1, "expected one hit: {hits:?}"); - match &hits[0].kind { - ViolationKind::MethodCall { name, .. } => assert_eq!(name, "unwrap"), - other => panic!("unexpected kind: {other:?}"), +fn matches_unwrap_in_direct_and_ufcs_form() { + // A banned method is caught by its final path segment in both + // dot-notation (`x.unwrap()`) and UFCS form (`Option::unwrap(x)`). + for src in [ + // direct dot-notation + "fn run() { let x: Option = Some(1); x.unwrap(); }", + // UFCS form + "fn run() { let x: Option = Some(1); Option::unwrap(x); }", + ] { + let hits = find(src, &["unwrap"]); + super::assert_one_named(&hits, "unwrap"); } } @@ -69,22 +68,6 @@ fn matches_multiple_occurrences_separately() { // ── UFCS-form calls (Type::method(receiver)) ────────────────────────── -#[test] -fn matches_ufcs_call_option_unwrap() { - let src = r#" - fn run() { - let x: Option = Some(1); - Option::unwrap(x); - } - "#; - let hits = find(src, &["unwrap"]); - assert_eq!(hits.len(), 1, "UFCS form must be caught: {hits:?}"); - match &hits[0].kind { - ViolationKind::MethodCall { name, .. } => assert_eq!(name, "unwrap"), - other => panic!("unexpected kind: {other:?}"), - } -} - #[test] fn matches_ufcs_call_result_expect() { let src = r#" diff --git a/src/adapters/analyzers/architecture/matcher/tests/mod.rs b/src/adapters/analyzers/architecture/matcher/tests/mod.rs index f0aeefaf..66de2137 100644 --- a/src/adapters/analyzers/architecture/matcher/tests/mod.rs +++ b/src/adapters/analyzers/architecture/matcher/tests/mod.rs @@ -5,3 +5,17 @@ mod item_kind; mod macro_call; mod method_call; mod path_prefix; + +use crate::adapters::analyzers::architecture::{MatchLocation, ViolationKind}; + +/// Assert that `hits` holds exactly one match whose method/macro name is +/// `expected`. Shared by the method-call and macro-call matcher tests, whose +/// "one hit, check the name" assertion is otherwise identical. +pub(super) fn assert_one_named(hits: &[MatchLocation], expected: &str) { + assert_eq!(hits.len(), 1, "expected one hit: {hits:?}"); + let name = match &hits[0].kind { + ViolationKind::MethodCall { name, .. } | ViolationKind::MacroCall { name } => name, + other => panic!("unexpected kind: {other:?}"), + }; + assert_eq!(name, expected); +} diff --git a/src/adapters/analyzers/architecture/tests/compiled.rs b/src/adapters/analyzers/architecture/tests/compiled.rs index e0a64e1f..e8909f77 100644 --- a/src/adapters/analyzers/architecture/tests/compiled.rs +++ b/src/adapters/analyzers/architecture/tests/compiled.rs @@ -194,23 +194,20 @@ fn compile_call_parity_rejects_duplicate_adapters() { } #[test] -fn compile_call_parity_rejects_call_depth_zero() { - let mut cfg = call_parity_cfg(); - let mut cp = minimal_call_parity(); - cp.call_depth = 0; - cfg.call_parity = Some(cp); - let err = compile_architecture(&cfg).unwrap_err(); - assert!(err.to_lowercase().contains("call_depth"), "err = {err}"); -} - -#[test] -fn compile_call_parity_rejects_call_depth_too_large() { - let mut cfg = call_parity_cfg(); - let mut cp = minimal_call_parity(); - cp.call_depth = 11; - cfg.call_parity = Some(cp); - let err = compile_architecture(&cfg).unwrap_err(); - assert!(err.to_lowercase().contains("call_depth"), "err = {err}"); +fn compile_call_parity_rejects_out_of_range_call_depth() { + // call_depth must be within [1, 10]: both the lower bound (0) and an + // above-ceiling value (11) are rejected with a `call_depth` error. + for (label, call_depth) in [("zero", 0), ("too large", 11)] { + let mut cfg = call_parity_cfg(); + let mut cp = minimal_call_parity(); + cp.call_depth = call_depth; + cfg.call_parity = Some(cp); + let err = compile_architecture(&cfg).unwrap_err(); + assert!( + err.to_lowercase().contains("call_depth"), + "case {label}: err = {err}" + ); + } } #[test] diff --git a/src/adapters/analyzers/architecture/tests/explain.rs b/src/adapters/analyzers/architecture/tests/explain.rs index 84f3490e..a70aee4d 100644 --- a/src/adapters/analyzers/architecture/tests/explain.rs +++ b/src/adapters/analyzers/architecture/tests/explain.rs @@ -6,7 +6,7 @@ //! asserted to keep the tests resilient to cosmetic tweaks. use crate::adapters::analyzers::architecture::compiled::CompiledArchitecture; -use crate::adapters::analyzers::architecture::explain::{explain_file, ImportKind}; +use crate::adapters::analyzers::architecture::explain::{explain_file, ExplainReport, ImportKind}; use crate::adapters::analyzers::architecture::forbidden_rule::CompiledForbiddenRule; use crate::adapters::analyzers::architecture::layer_rule::{LayerDefinitions, UnmatchedBehavior}; use globset::{Glob, GlobMatcher, GlobSet, GlobSetBuilder}; @@ -54,6 +54,21 @@ fn parse_file(src: &str) -> syn::File { syn::parse_str(src).expect("parse") } +/// `minimal_compiled()` plus one `src/domain/** → src/adapters/**` forbidden +/// rule, then explain a domain file that imports an adapter — the fixture +/// shared by the forbidden-violation tests. +fn explain_domain_importing_adapter() -> ExplainReport { + let mut compiled = minimal_compiled(); + compiled.forbidden.push(CompiledForbiddenRule { + from: matcher("src/domain/**"), + to: matcher("src/adapters/**"), + except: globset(&[]), + reason: "no outward imports".to_string(), + }); + let ast = parse_file("use crate::adapters::X;"); + explain_file("src/domain/bad.rs", &ast, &compiled) +} + // ── file layer classification ────────────────────────────────────────── #[test] @@ -155,15 +170,7 @@ fn layer_violation_surfaced() { #[test] fn forbidden_violation_surfaced() { - let mut compiled = minimal_compiled(); - compiled.forbidden.push(CompiledForbiddenRule { - from: matcher("src/domain/**"), - to: matcher("src/adapters/**"), - except: globset(&[]), - reason: "no outward imports".to_string(), - }); - let ast = parse_file("use crate::adapters::X;"); - let report = explain_file("src/domain/bad.rs", &ast, &compiled); + let report = explain_domain_importing_adapter(); assert_eq!(report.forbidden_violations.len(), 1); } @@ -188,16 +195,7 @@ fn render_marks_reexport_point() { #[test] fn render_includes_violation_sections() { - let mut compiled = minimal_compiled(); - compiled.forbidden.push(CompiledForbiddenRule { - from: matcher("src/domain/**"), - to: matcher("src/adapters/**"), - except: globset(&[]), - reason: "no outward imports".to_string(), - }); - let ast = parse_file("use crate::adapters::X;"); - let report = explain_file("src/domain/bad.rs", &ast, &compiled); - let text = report.render(); + let text = explain_domain_importing_adapter().render(); assert!(text.to_lowercase().contains("layer violation"), "{text}"); assert!(text.to_lowercase().contains("forbidden"), "{text}"); } diff --git a/src/adapters/analyzers/architecture/tests/forbidden_rule.rs b/src/adapters/analyzers/architecture/tests/forbidden_rule.rs index 52fde92c..516f0b65 100644 --- a/src/adapters/analyzers/architecture/tests/forbidden_rule.rs +++ b/src/adapters/analyzers/architecture/tests/forbidden_rule.rs @@ -113,17 +113,7 @@ fn from_matching_file_with_to_matching_import_flagged() { "peers isolated", )]; let hits = run(&fx, &rules); - assert_eq!(hits.len(), 1, "{hits:?}"); - match &hits[0].kind { - ViolationKind::ForbiddenEdge { - reason, - imported_path, - } => { - assert_eq!(reason, "peers isolated"); - assert!(imported_path.starts_with("crate::adapters::analyzers::srp")); - } - other => panic!("unexpected kind: {other:?}"), - } + super::assert_single_forbidden_edge(&hits, "peers isolated", "crate::adapters::analyzers::srp"); assert_eq!(hits[0].file, "src/adapters/analyzers/iosp/mod.rs"); } diff --git a/src/adapters/analyzers/architecture/tests/golden_examples.rs b/src/adapters/analyzers/architecture/tests/golden_examples.rs index d17c9068..c9e1f676 100644 --- a/src/adapters/analyzers/architecture/tests/golden_examples.rs +++ b/src/adapters/analyzers/architecture/tests/golden_examples.rs @@ -331,24 +331,11 @@ fn forbidden_example_produces_exactly_one_violation() { reason: "peer analyzers are isolated".to_string(), }; let hits = check_forbidden_rules(&refs, std::slice::from_ref(&rule)); - assert_eq!( - hits.len(), - 1, - "expected exactly one forbidden hit: {hits:?}" + super::assert_single_forbidden_edge( + &hits, + "peer analyzers are isolated", + "crate::adapters::analyzers::srp", ); - match &hits[0].kind { - ViolationKind::ForbiddenEdge { - reason, - imported_path, - } => { - assert_eq!(reason, "peer analyzers are isolated"); - assert!( - imported_path.starts_with("crate::adapters::analyzers::srp"), - "imported_path = {imported_path:?}" - ); - } - other => panic!("unexpected kind: {other:?}"), - } assert!( hits[0].file.ends_with("iosp/bad.rs"), "file = {}", diff --git a/src/adapters/analyzers/architecture/tests/mod.rs b/src/adapters/analyzers/architecture/tests/mod.rs index 5b80948f..042085d2 100644 --- a/src/adapters/analyzers/architecture/tests/mod.rs +++ b/src/adapters/analyzers/architecture/tests/mod.rs @@ -10,3 +10,30 @@ mod golden_examples; mod layer_rule; mod rendering; mod trait_contract; + +use crate::adapters::analyzers::architecture::{MatchLocation, ViolationKind}; + +/// Assert `hits` holds exactly one `ForbiddenEdge` whose reason equals +/// `expected_reason` and whose imported path starts with `imported_prefix`. +/// Shared by the forbidden-rule unit tests and the golden-example snapshot, +/// whose forbidden-hit verification is otherwise identical. +pub(super) fn assert_single_forbidden_edge( + hits: &[MatchLocation], + expected_reason: &str, + imported_prefix: &str, +) { + assert_eq!(hits.len(), 1, "expected one forbidden hit: {hits:?}"); + match &hits[0].kind { + ViolationKind::ForbiddenEdge { + reason, + imported_path, + } => { + assert_eq!(reason, expected_reason); + assert!( + imported_path.starts_with(imported_prefix), + "imported_path = {imported_path:?}" + ); + } + other => panic!("unexpected kind: {other:?}"), + } +} diff --git a/src/adapters/analyzers/coupling/tests/root.rs b/src/adapters/analyzers/coupling/tests/root.rs index e7c5dbaa..3733769f 100644 --- a/src/adapters/analyzers/coupling/tests/root.rs +++ b/src/adapters/analyzers/coupling/tests/root.rs @@ -20,6 +20,21 @@ fn idx(graph: &ModuleGraph, name: &str) -> usize { .unwrap_or_else(|| panic!("module '{name}' not found in graph")) } +/// Whether the module graph built from `files` has a forward edge `from → to`. +fn has_module_edge(files: &[(&str, &str)], from: &str, to: &str) -> bool { + let parsed = make_parsed(files.to_vec()); + let graph = graph::build_module_graph(&parsed); + graph.forward[idx(&graph, from)].contains(&idx(&graph, to)) +} + +/// `(label, files, from_module, to_module)` for a build-graph edge case. +type EdgeCase = ( + &'static str, + &'static [(&'static str, &'static str)], + &'static str, + &'static str, +); + // `file_to_module` lives in `adapters::shared::file_to_module`; its // tests are in `adapters::shared::tests::file_to_module`. @@ -96,43 +111,49 @@ fn test_build_graph_external_dep_ignored() { } #[test] -fn test_build_graph_multiple_files_same_module() { - let parsed = make_parsed(vec![ +fn build_graph_records_use_edges_across_forms() { + // A `use crate::X::…` records a `from → X` edge whether it's spread across + // files of the same module, a glob import, or a renamed import. + // (label, files, from, to) + let cases: &[EdgeCase] = &[ ( - "config/mod.rs", - "use crate::analyzer::Foo; pub mod sections;", + "multiple files of the same module", + &[ + ( + "config/mod.rs", + "use crate::analyzer::Foo; pub mod sections;", + ), + ("config/sections.rs", "pub struct Defaults;"), + ("analyzer.rs", "pub struct Foo;"), + ], + "config", + "analyzer", ), - ("config/sections.rs", "pub struct Defaults;"), - ("analyzer.rs", "pub struct Foo;"), - ]); - let graph = graph::build_module_graph(&parsed); - let config_idx = idx(&graph, "config"); - let analyzer_idx = idx(&graph, "analyzer"); - assert!(graph.forward[config_idx].contains(&analyzer_idx)); -} - -#[test] -fn test_build_graph_glob_use() { - let parsed = make_parsed(vec![ - ("main.rs", "use crate::analyzer::*; fn main() {}"), - ("analyzer.rs", "pub fn analyze() {}"), - ]); - let graph = graph::build_module_graph(&parsed); - let main_idx = idx(&graph, "main"); - let analyzer_idx = idx(&graph, "analyzer"); - assert!(graph.forward[main_idx].contains(&analyzer_idx)); -} - -#[test] -fn test_build_graph_rename_use() { - let parsed = make_parsed(vec![ - ("main.rs", "use crate::config::Config as Cfg; fn main() {}"), - ("config.rs", "pub struct Config;"), - ]); - let graph = graph::build_module_graph(&parsed); - let main_idx = idx(&graph, "main"); - let config_idx = idx(&graph, "config"); - assert!(graph.forward[main_idx].contains(&config_idx)); + ( + "glob use", + &[ + ("main.rs", "use crate::analyzer::*; fn main() {}"), + ("analyzer.rs", "pub fn analyze() {}"), + ], + "main", + "analyzer", + ), + ( + "renamed use", + &[ + ("main.rs", "use crate::config::Config as Cfg; fn main() {}"), + ("config.rs", "pub struct Config;"), + ], + "main", + "config", + ), + ]; + for (label, files, from, to) in cases { + assert!( + has_module_edge(files, from, to), + "case {label}: expected a {from} → {to} edge" + ); + } } // ── compute_coupling_metrics tests ────────────────────────────── diff --git a/src/adapters/analyzers/coupling/tests/sdp.rs b/src/adapters/analyzers/coupling/tests/sdp.rs index 17035e77..242f7ba9 100644 --- a/src/adapters/analyzers/coupling/tests/sdp.rs +++ b/src/adapters/analyzers/coupling/tests/sdp.rs @@ -1,6 +1,40 @@ use crate::adapters::analyzers::coupling::sdp::*; use crate::adapters::analyzers::coupling::{metrics::compute_coupling_metrics, ModuleGraph}; +/// A 6-module graph with exactly one SDP violation (stable `a`→`b` where `b` +/// depends on the more-unstable `x`/`y`). The single `ModuleGraph` literal in +/// this module (keeping it out of BP-009's struct-update window). +fn sdp_graph() -> ModuleGraph { + ModuleGraph { + modules: vec![ + "a".into(), + "b".into(), + "x".into(), + "y".into(), + "p".into(), + "q".into(), + ], + forward: vec![vec![1], vec![4, 5], vec![0], vec![0], vec![], vec![]], + } +} + +/// Run SDP on `sdp_graph()`, optionally pre-suppressing the metric at +/// `suppress_idx`, and report whether the (single) violation is suppressed. +fn sdp_first_violation_suppressed(suppress_idx: Option) -> bool { + let graph = sdp_graph(); + let mut metrics = compute_coupling_metrics(&graph); + if let Some(i) = suppress_idx { + metrics[i].suppressed = true; + } + let violations = check_sdp(&graph, &metrics); + assert_eq!( + violations.len(), + 1, + "fixture must have exactly one violation" + ); + violations[0].suppressed +} + #[test] fn test_no_violations_all_same_instability() { // A → B, both have same structure → no SDP violation @@ -164,69 +198,20 @@ fn test_violation_details() { } #[test] -fn test_sdp_violation_default_not_suppressed() { - let graph = ModuleGraph { - modules: vec![ - "a".into(), - "b".into(), - "x".into(), - "y".into(), - "p".into(), - "q".into(), - ], - forward: vec![vec![1], vec![4, 5], vec![0], vec![0], vec![], vec![]], - }; - let metrics = compute_coupling_metrics(&graph); - let violations = check_sdp(&graph, &metrics); - assert_eq!(violations.len(), 1); - assert!( - !violations[0].suppressed, - "SDP violations should default to not suppressed" - ); -} - -#[test] -fn test_sdp_violation_suppressed_when_from_module_suppressed() { - let graph = ModuleGraph { - modules: vec![ - "a".into(), - "b".into(), - "x".into(), - "y".into(), - "p".into(), - "q".into(), - ], - forward: vec![vec![1], vec![4, 5], vec![0], vec![0], vec![], vec![]], - }; - let mut metrics = compute_coupling_metrics(&graph); - metrics[0].suppressed = true; // "a" is the from_module - let violations = check_sdp(&graph, &metrics); - assert_eq!(violations.len(), 1); - assert!( - violations[0].suppressed, - "from_module suppressed → violation created suppressed" - ); -} - -#[test] -fn test_sdp_violation_suppressed_when_to_module_suppressed() { - let graph = ModuleGraph { - modules: vec![ - "a".into(), - "b".into(), - "x".into(), - "y".into(), - "p".into(), - "q".into(), - ], - forward: vec![vec![1], vec![4, 5], vec![0], vec![0], vec![], vec![]], - }; - let mut metrics = compute_coupling_metrics(&graph); - metrics[1].suppressed = true; // "b" is the to_module - let violations = check_sdp(&graph, &metrics); - assert_eq!(violations.len(), 1); - assert!( - violations[0].suppressed, - "to_module suppressed → violation created suppressed" - ); +fn sdp_violation_inherits_suppression_from_either_endpoint() { + // A violation defaults to not-suppressed, but is created suppressed when + // EITHER the from-module (`a`, idx 0) or the to-module (`b`, idx 1) is + // suppressed. (label, suppressed_metric_idx, violation_suppressed) + let cases: &[(&str, Option, bool)] = &[ + ("no module suppressed → not suppressed", None, false), + ("from-module (a) suppressed", Some(0), true), + ("to-module (b) suppressed", Some(1), true), + ]; + for (label, suppress_idx, expected) in cases { + assert_eq!( + sdp_first_violation_suppressed(*suppress_idx), + *expected, + "case {label}" + ); + } } diff --git a/src/adapters/analyzers/dry/boilerplate/tests/root.rs b/src/adapters/analyzers/dry/boilerplate/tests/root.rs deleted file mode 100644 index e98469a3..00000000 --- a/src/adapters/analyzers/dry/boilerplate/tests/root.rs +++ /dev/null @@ -1,633 +0,0 @@ -use crate::adapters::analyzers::dry::boilerplate::*; -use crate::config::sections::BoilerplateConfig; - -fn parse(code: &str) -> Vec<(String, String, syn::File)> { - let syntax = syn::parse_file(code).expect("parse failed"); - vec![("test.rs".to_string(), code.to_string(), syntax)] -} - -// ── BP-001 ───────────────────────────────────────────────── - -#[test] -fn test_bp001_trivial_from_tuple_struct() { - let code = r#" - struct Wrapper(String); - impl From for Wrapper { - fn from(s: String) -> Self { Self(s) } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - findings.iter().any(|f| f.pattern_id == "BP-001"), - "Trivial From(tuple) should be detected" - ); -} - -#[test] -fn test_bp001_non_trivial_from_not_flagged() { - let code = r#" - struct Processed { data: Vec, len: usize } - impl From> for Processed { - fn from(data: Vec) -> Self { - let len = data.len(); - Self { data, len } - } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-001"), - "Non-trivial From should not be flagged" - ); -} - -// ── BP-002 ───────────────────────────────────────────────── - -#[test] -fn test_bp002_trivial_display() { - let code = r#" - use std::fmt; - struct Name(String); - impl fmt::Display for Name { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "{}", self.0) - } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - findings.iter().any(|f| f.pattern_id == "BP-002"), - "Trivial Display should be detected" - ); -} - -#[test] -fn test_bp002_complex_display_not_flagged() { - let code = r#" - use std::fmt; - struct Point { x: f64, y: f64 } - impl fmt::Display for Point { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - if self.x == 0.0 { - write!(f, "(origin, {})", self.y) - } else { - write!(f, "({}, {})", self.x, self.y) - } - } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-002"), - "Complex Display should not be flagged" - ); -} - -// ── BP-003 ───────────────────────────────────────────────── - -#[test] -fn test_bp003_getter_setter_detected() { - let code = r#" - struct Config { a: i32, b: String, c: bool } - impl Config { - fn a(&self) -> &i32 { &self.a } - fn b(&self) -> &String { &self.b } - fn c(&self) -> &bool { &self.c } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - findings.iter().any(|f| f.pattern_id == "BP-003"), - "3+ getters should be detected" - ); -} - -#[test] -fn test_bp003_few_getters_not_flagged() { - let code = r#" - struct Pair { a: i32, b: i32 } - impl Pair { - fn a(&self) -> &i32 { &self.a } - fn b(&self) -> &i32 { &self.b } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-003"), - "Only 2 getters should not be flagged" - ); -} - -#[test] -fn test_bp003_reports_per_getter_not_per_struct() { - let code = r#" - struct Config { a: i32, b: String, c: bool } - impl Config { - fn a(&self) -> &i32 { &self.a } - fn b(&self) -> &String { &self.b } - fn c(&self) -> &bool { &self.c } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - let bp003: Vec<_> = findings - .iter() - .filter(|f| f.pattern_id == "BP-003") - .collect(); - assert_eq!( - bp003.len(), - 3, - "BP-003 should report one finding per getter, got {}", - bp003.len() - ); - // Each finding should be on a different line (the getter function line) - let lines: std::collections::HashSet = bp003.iter().map(|f| f.line).collect(); - assert_eq!(lines.len(), 3, "Each BP-003 should be on a different line"); -} - -// ── BP-004 ───────────────────────────────────────────────── - -#[test] -fn test_bp004_builder_detected() { - let code = r#" - struct Builder { a: i32, b: String, c: bool } - impl Builder { - fn with_a(mut self, v: i32) -> Self { self.a = v; self } - fn with_b(mut self, v: String) -> Self { self.b = v; self } - fn with_c(mut self, v: bool) -> Self { self.c = v; self } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - findings.iter().any(|f| f.pattern_id == "BP-004"), - "3+ builder methods should be detected" - ); -} - -#[test] -fn test_bp004_non_builder_not_flagged() { - let code = r#" - struct Thing { a: i32 } - impl Thing { - fn with_a(mut self, v: i32) -> Self { self.a = v; self } - fn compute(self) -> i32 { self.a * 2 } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-004"), - "Single builder method should not be flagged" - ); -} - -// ── BP-005 ───────────────────────────────────────────────── - -#[test] -fn test_bp005_manual_default_detected() { - let code = r#" - struct Config { count: i32, name: String, active: bool } - impl Default for Config { - fn default() -> Self { - Self { count: 0, name: String::new(), active: false } - } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - findings.iter().any(|f| f.pattern_id == "BP-005"), - "Manual Default with all default values should be detected" - ); -} - -#[test] -fn test_bp005_custom_default_not_flagged() { - let code = r#" - struct Config { count: i32, name: String } - impl Default for Config { - fn default() -> Self { - Self { count: 42, name: String::new() } - } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-005"), - "Default with custom value (42) should not be flagged" - ); -} - -// ── BP-006 ───────────────────────────────────────────────── - -#[test] -fn test_bp006_repetitive_match_detected() { - let code = r#" - enum Color { Red, Blue, Green, Yellow } - enum Shade { Red, Blue, Green, Yellow } - fn convert(c: Color) -> Shade { - match c { - Color::Red => Shade::Red, - Color::Blue => Shade::Blue, - Color::Green => Shade::Green, - Color::Yellow => Shade::Yellow, - } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - findings.iter().any(|f| f.pattern_id == "BP-006"), - "Repetitive enum mapping match should be detected" - ); -} - -#[test] -fn test_bp006_complex_match_not_flagged() { - let code = r#" - enum Action { Add(i32), Remove(String), Clear } - fn describe(a: &Action) -> &str { - match a { - Action::Add(_) => "adding", - Action::Remove(_) => "removing", - Action::Clear => "clearing", - } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-006"), - "Match with only 3 arms should not be flagged (below threshold)" - ); -} - -#[test] -fn test_bp006_tuple_scrutinee_not_flagged() { - let code = r#" - fn dispatch(a: bool, b: bool) -> i32 { - match (a, b) { - (true, true) => handle_tt(), - (true, false) => handle_tf(), - (false, true) => handle_ft(), - (false, false) => handle_ff(), - } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-006"), - "Match on tuple scrutinee should not be flagged" - ); -} - -#[test] -fn test_bp006_or_pattern_not_flagged() { - let code = r#" - enum Token { A, B, C, D, E } - fn classify(t: Token) -> &'static str { - match t { - Token::A | Token::B => category_ab(), - Token::C => category_c(), - Token::D => category_d(), - Token::E => category_e(), - } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-006"), - "Match with or-patterns should not be flagged" - ); -} - -#[test] -fn test_bp006_dispatch_bindings_not_flagged() { - let code = r#" - enum Msg { A(i32), B(i32), C(i32), D(i32) } - fn dispatch(m: Msg) { - match m { - Msg::A(x) => handle_a(x), - Msg::B(x) => handle_b(x), - Msg::C(x) => handle_c(x), - Msg::D(x) => handle_d(x), - } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-006"), - "Match with variable bindings (dispatch) should not be flagged" - ); -} - -#[test] -fn test_bp006_wildcard_arm_not_flagged() { - let code = r#" - enum Color { Red, Blue, Green, Yellow, Other } - fn to_shade(c: Color) -> Shade { - match c { - Color::Red => Shade::Red, - Color::Blue => Shade::Blue, - Color::Green => Shade::Green, - _ => Shade::default(), - } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-006"), - "Match with wildcard catch-all arm should not be flagged" - ); -} - -#[test] -fn test_bp006_simple_mapping_still_detected() { - let code = r#" - enum Color { Red, Blue, Green, Yellow } - enum Shade { Red, Blue, Green, Yellow } - fn convert(c: Color) -> Shade { - match c { - Color::Red => Shade::Red, - Color::Blue => Shade::Blue, - Color::Green => Shade::Green, - Color::Yellow => Shade::Yellow, - } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - findings.iter().any(|f| f.pattern_id == "BP-006"), - "Simple unit-variant enum mapping should still be detected" - ); -} - -// ── BP-007 ───────────────────────────────────────────────── - -#[test] -fn test_bp007_error_enum_detected() { - let code = r#" - enum AppError { Io(std::io::Error), Parse(String), Net(String) } - impl From for AppError { - fn from(e: std::io::Error) -> Self { Self::Io(e) } - } - impl From for AppError { - fn from(e: String) -> Self { Self::Parse(e) } - } - impl From for AppError { - fn from(e: u32) -> Self { Self::Net(e.to_string()) } - } - "#; - let _findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - // Note: third From is not trivial (e.to_string()), so only 2 trivial Froms - // which is below the threshold. Let's use a truly trivial third: - let code2 = r#" - enum AppError { Io(std::io::Error), Parse(String), Net(i32) } - impl From for AppError { - fn from(e: std::io::Error) -> Self { Self::Io(e) } - } - impl From for AppError { - fn from(e: String) -> Self { Self::Parse(e) } - } - impl From for AppError { - fn from(e: i32) -> Self { Self::Net(e) } - } - "#; - let findings2 = detect_boilerplate(&parse(code2), &BoilerplateConfig::default()); - assert!( - findings2.iter().any(|f| f.pattern_id == "BP-007"), - "3+ trivial From impls for same type should be detected" - ); -} - -#[test] -fn test_bp007_single_from_not_flagged() { - let code = r#" - struct Wrapper(String); - impl From for Wrapper { - fn from(s: String) -> Self { Self(s) } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-007"), - "Single From impl should not trigger error enum detection" - ); -} - -// ── BP-008 ───────────────────────────────────────────────── - -#[test] -fn test_bp008_clone_heavy_detected() { - let code = r#" - struct A { x: String, y: String, z: String } - struct B { x: String, y: String, z: String } - impl A { - fn to_b(&self) -> B { - B { x: self.x.clone(), y: self.y.clone(), z: self.z.clone() } - } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - findings.iter().any(|f| f.pattern_id == "BP-008"), - "Struct construction with 3+ .clone() calls should be detected" - ); -} - -#[test] -fn test_bp008_no_clones_not_flagged() { - let code = r#" - struct B { x: i32, y: i32, z: i32 } - fn make_b() -> B { - B { x: 1, y: 2, z: 3 } - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-008"), - "Struct construction without clones should not be flagged" - ); -} - -// ── BP-009 ───────────────────────────────────────────────── - -#[test] -fn test_bp009_few_fields_not_flagged() { - let code = r#" - struct A { x: i32 } - fn make_two() -> (A, A) { (A { x: 1 }, A { x: 2 }) } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-009"), - "Structs with <3 fields should not be flagged" - ); -} - -#[test] -fn test_bp009_overlapping_constructions_detected() { - let code = r#" - struct Config { host: String, port: u16, timeout: u64, retries: u32 } - fn make_configs() -> (Config, Config) { - let a = Config { host: "a".to_string(), port: 80, timeout: 30, retries: 3 }; - let b = Config { host: "b".to_string(), port: 80, timeout: 30, retries: 3 }; - (a, b) - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - findings.iter().any(|f| f.pattern_id == "BP-009"), - "Two constructions of same type with overlapping fields should be detected" - ); -} - -#[test] -fn test_bp009_different_types_not_flagged() { - let code = r#" - struct A { x: i32, y: i32, z: i32 } - struct B { x: i32, y: i32, z: i32 } - fn make() -> (A, B) { - let a = A { x: 1, y: 2, z: 3 }; - let b = B { x: 1, y: 2, z: 3 }; - (a, b) - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-009"), - "Different struct types should not be grouped" - ); -} - -#[test] -fn test_bp009_struct_update_syntax_not_flagged() { - let code = r#" - struct Config { host: String, port: u16, timeout: u64, retries: u32 } - fn make_configs(base: Config) -> Config { - let a = Config { host: "a".to_string(), port: 80, timeout: 30, retries: 3 }; - let b = Config { host: "b".to_string(), ..base }; - b - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-009"), - "Only one full construction (other uses ..base) should not be flagged" - ); -} - -// ── BP-010 ───────────────────────────────────────────────── - -#[test] -fn test_bp010_different_formats_not_flagged() { - let code = r#" - fn log_stuff() { - println!("a: {}", 1); - println!("b: {}", 2); - println!("c: {}", 3); - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-010"), - "Different format strings should not be flagged" - ); -} - -#[test] -fn test_bp010_repeated_format_detected() { - let code = r#" - fn log_many() { - println!("value: {}", 1); - println!("value: {}", 2); - println!("value: {}", 3); - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - findings.iter().any(|f| f.pattern_id == "BP-010"), - "3+ identical format strings should be detected" - ); -} - -#[test] -fn test_bp010_two_repetitions_not_flagged() { - let code = r#" - fn log_few() { - println!("same: {}", 1); - println!("same: {}", 2); - } - "#; - let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-010"), - "Only 2 repetitions should not be flagged (threshold is 3)" - ); -} - -// ── Config filtering ─────────────────────────────────────── - -#[test] -fn test_pattern_filtering_only_selected() { - let code = r#" - struct W(String); - impl From for W { - fn from(s: String) -> Self { Self(s) } - } - struct Config { count: i32, name: String, active: bool } - impl Default for Config { - fn default() -> Self { - Self { count: 0, name: String::new(), active: false } - } - } - "#; - let config = BoilerplateConfig { - patterns: vec!["BP-005".to_string()], // Only Default - ..BoilerplateConfig::default() - }; - let findings = detect_boilerplate(&parse(code), &config); - assert!( - findings.iter().any(|f| f.pattern_id == "BP-005"), - "BP-005 should be detected when selected" - ); - assert!( - !findings.iter().any(|f| f.pattern_id == "BP-001"), - "BP-001 should be skipped when not selected" - ); -} - -#[test] -fn test_suggest_crates_flag() { - let code = r#" - struct W(String); - impl From for W { - fn from(s: String) -> Self { Self(s) } - } - "#; - let config = BoilerplateConfig { - suggest_crates: false, - ..BoilerplateConfig::default() - }; - let findings = detect_boilerplate(&parse(code), &config); - let f = findings.iter().find(|f| f.pattern_id == "BP-001"); - assert!(f.is_some()); - assert!( - !f.unwrap().suggestion.contains("derive_more"), - "Should not mention crates when suggest_crates is false" - ); -} - -#[test] -fn test_disabled_boilerplate_returns_empty() { - let code = r#" - struct W(String); - impl From for W { - fn from(s: String) -> Self { Self(s) } - } - "#; - let config = BoilerplateConfig { - patterns: vec!["BP-999".to_string()], // No real patterns - ..BoilerplateConfig::default() - }; - let findings = detect_boilerplate(&parse(code), &config); - assert!( - findings.is_empty(), - "No findings when no patterns are enabled" - ); -} diff --git a/src/adapters/analyzers/dry/boilerplate/tests/root/bp001_to_005.rs b/src/adapters/analyzers/dry/boilerplate/tests/root/bp001_to_005.rs new file mode 100644 index 00000000..78fbc888 --- /dev/null +++ b/src/adapters/analyzers/dry/boilerplate/tests/root/bp001_to_005.rs @@ -0,0 +1,210 @@ +use super::*; + +// ── BP-001 ───────────────────────────────────────────────── + +#[test] +fn test_bp001_trivial_from_tuple_struct() { + let code = r#" + struct Wrapper(String); + impl From for Wrapper { + fn from(s: String) -> Self { Self(s) } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-001"), + "Trivial From(tuple) should be detected" + ); +} + +#[test] +fn test_bp001_non_trivial_from_not_flagged() { + let code = r#" + struct Processed { data: Vec, len: usize } + impl From> for Processed { + fn from(data: Vec) -> Self { + let len = data.len(); + Self { data, len } + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-001"), + "Non-trivial From should not be flagged" + ); +} + +// ── BP-002 ───────────────────────────────────────────────── + +#[test] +fn test_bp002_trivial_display() { + let code = r#" + use std::fmt; + struct Name(String); + impl fmt::Display for Name { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.0) + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-002"), + "Trivial Display should be detected" + ); +} + +#[test] +fn test_bp002_complex_display_not_flagged() { + let code = r#" + use std::fmt; + struct Point { x: f64, y: f64 } + impl fmt::Display for Point { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + if self.x == 0.0 { + write!(f, "(origin, {})", self.y) + } else { + write!(f, "({}, {})", self.x, self.y) + } + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-002"), + "Complex Display should not be flagged" + ); +} + +// ── BP-003 ───────────────────────────────────────────────── + +#[test] +fn test_bp003_getter_setter_detected() { + let code = r#" + struct Config { a: i32, b: String, c: bool } + impl Config { + fn a(&self) -> &i32 { &self.a } + fn b(&self) -> &String { &self.b } + fn c(&self) -> &bool { &self.c } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-003"), + "3+ getters should be detected" + ); +} + +#[test] +fn test_bp003_few_getters_not_flagged() { + let code = r#" + struct Pair { a: i32, b: i32 } + impl Pair { + fn a(&self) -> &i32 { &self.a } + fn b(&self) -> &i32 { &self.b } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-003"), + "Only 2 getters should not be flagged" + ); +} + +#[test] +fn test_bp003_reports_per_getter_not_per_struct() { + let code = r#" + struct Config { a: i32, b: String, c: bool } + impl Config { + fn a(&self) -> &i32 { &self.a } + fn b(&self) -> &String { &self.b } + fn c(&self) -> &bool { &self.c } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + let bp003: Vec<_> = findings + .iter() + .filter(|f| f.pattern_id == "BP-003") + .collect(); + assert_eq!( + bp003.len(), + 3, + "BP-003 should report one finding per getter, got {}", + bp003.len() + ); + // Each finding should be on a different line (the getter function line) + let lines: std::collections::HashSet = bp003.iter().map(|f| f.line).collect(); + assert_eq!(lines.len(), 3, "Each BP-003 should be on a different line"); +} + +// ── BP-004 ───────────────────────────────────────────────── + +#[test] +fn test_bp004_builder_detected() { + let code = r#" + struct Builder { a: i32, b: String, c: bool } + impl Builder { + fn with_a(mut self, v: i32) -> Self { self.a = v; self } + fn with_b(mut self, v: String) -> Self { self.b = v; self } + fn with_c(mut self, v: bool) -> Self { self.c = v; self } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-004"), + "3+ builder methods should be detected" + ); +} + +#[test] +fn test_bp004_non_builder_not_flagged() { + let code = r#" + struct Thing { a: i32 } + impl Thing { + fn with_a(mut self, v: i32) -> Self { self.a = v; self } + fn compute(self) -> i32 { self.a * 2 } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-004"), + "Single builder method should not be flagged" + ); +} + +// ── BP-005 ───────────────────────────────────────────────── + +#[test] +fn test_bp005_manual_default_detected() { + let code = r#" + struct Config { count: i32, name: String, active: bool } + impl Default for Config { + fn default() -> Self { + Self { count: 0, name: String::new(), active: false } + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-005"), + "Manual Default with all default values should be detected" + ); +} + +#[test] +fn test_bp005_custom_default_not_flagged() { + let code = r#" + struct Config { count: i32, name: String } + impl Default for Config { + fn default() -> Self { + Self { count: 42, name: String::new() } + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-005"), + "Default with custom value (42) should not be flagged" + ); +} diff --git a/src/adapters/analyzers/dry/boilerplate/tests/root/bp006_to_008.rs b/src/adapters/analyzers/dry/boilerplate/tests/root/bp006_to_008.rs new file mode 100644 index 00000000..6d0e317d --- /dev/null +++ b/src/adapters/analyzers/dry/boilerplate/tests/root/bp006_to_008.rs @@ -0,0 +1,231 @@ +use super::*; + +// ── BP-006 ───────────────────────────────────────────────── + +#[test] +fn test_bp006_repetitive_match_detected() { + let code = r#" + enum Color { Red, Blue, Green, Yellow } + enum Shade { Red, Blue, Green, Yellow } + fn convert(c: Color) -> Shade { + match c { + Color::Red => Shade::Red, + Color::Blue => Shade::Blue, + Color::Green => Shade::Green, + Color::Yellow => Shade::Yellow, + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-006"), + "Repetitive enum mapping match should be detected" + ); +} + +#[test] +fn test_bp006_complex_match_not_flagged() { + let code = r#" + enum Action { Add(i32), Remove(String), Clear } + fn describe(a: &Action) -> &str { + match a { + Action::Add(_) => "adding", + Action::Remove(_) => "removing", + Action::Clear => "clearing", + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-006"), + "Match with only 3 arms should not be flagged (below threshold)" + ); +} + +#[test] +fn test_bp006_tuple_scrutinee_not_flagged() { + let code = r#" + fn dispatch(a: bool, b: bool) -> i32 { + match (a, b) { + (true, true) => handle_tt(), + (true, false) => handle_tf(), + (false, true) => handle_ft(), + (false, false) => handle_ff(), + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-006"), + "Match on tuple scrutinee should not be flagged" + ); +} + +#[test] +fn test_bp006_or_pattern_not_flagged() { + let code = r#" + enum Token { A, B, C, D, E } + fn classify(t: Token) -> &'static str { + match t { + Token::A | Token::B => category_ab(), + Token::C => category_c(), + Token::D => category_d(), + Token::E => category_e(), + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-006"), + "Match with or-patterns should not be flagged" + ); +} + +#[test] +fn test_bp006_dispatch_bindings_not_flagged() { + let code = r#" + enum Msg { A(i32), B(i32), C(i32), D(i32) } + fn dispatch(m: Msg) { + match m { + Msg::A(x) => handle_a(x), + Msg::B(x) => handle_b(x), + Msg::C(x) => handle_c(x), + Msg::D(x) => handle_d(x), + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-006"), + "Match with variable bindings (dispatch) should not be flagged" + ); +} + +#[test] +fn test_bp006_wildcard_arm_not_flagged() { + let code = r#" + enum Color { Red, Blue, Green, Yellow, Other } + fn to_shade(c: Color) -> Shade { + match c { + Color::Red => Shade::Red, + Color::Blue => Shade::Blue, + Color::Green => Shade::Green, + _ => Shade::default(), + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-006"), + "Match with wildcard catch-all arm should not be flagged" + ); +} + +#[test] +fn test_bp006_simple_mapping_still_detected() { + let code = r#" + enum Color { Red, Blue, Green, Yellow } + enum Shade { Red, Blue, Green, Yellow } + fn convert(c: Color) -> Shade { + match c { + Color::Red => Shade::Red, + Color::Blue => Shade::Blue, + Color::Green => Shade::Green, + Color::Yellow => Shade::Yellow, + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-006"), + "Simple unit-variant enum mapping should still be detected" + ); +} + +// ── BP-007 ───────────────────────────────────────────────── + +#[test] +fn test_bp007_error_enum_detected() { + let code = r#" + enum AppError { Io(std::io::Error), Parse(String), Net(String) } + impl From for AppError { + fn from(e: std::io::Error) -> Self { Self::Io(e) } + } + impl From for AppError { + fn from(e: String) -> Self { Self::Parse(e) } + } + impl From for AppError { + fn from(e: u32) -> Self { Self::Net(e.to_string()) } + } + "#; + let _findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + // Note: third From is not trivial (e.to_string()), so only 2 trivial Froms + // which is below the threshold. Let's use a truly trivial third: + let code2 = r#" + enum AppError { Io(std::io::Error), Parse(String), Net(i32) } + impl From for AppError { + fn from(e: std::io::Error) -> Self { Self::Io(e) } + } + impl From for AppError { + fn from(e: String) -> Self { Self::Parse(e) } + } + impl From for AppError { + fn from(e: i32) -> Self { Self::Net(e) } + } + "#; + let findings2 = detect_boilerplate(&parse(code2), &BoilerplateConfig::default()); + assert!( + findings2.iter().any(|f| f.pattern_id == "BP-007"), + "3+ trivial From impls for same type should be detected" + ); +} + +#[test] +fn test_bp007_single_from_not_flagged() { + let code = r#" + struct Wrapper(String); + impl From for Wrapper { + fn from(s: String) -> Self { Self(s) } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-007"), + "Single From impl should not trigger error enum detection" + ); +} + +// ── BP-008 ───────────────────────────────────────────────── + +#[test] +fn test_bp008_clone_heavy_detected() { + let code = r#" + struct A { x: String, y: String, z: String } + struct B { x: String, y: String, z: String } + impl A { + fn to_b(&self) -> B { + B { x: self.x.clone(), y: self.y.clone(), z: self.z.clone() } + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-008"), + "Struct construction with 3+ .clone() calls should be detected" + ); +} + +#[test] +fn test_bp008_no_clones_not_flagged() { + let code = r#" + struct B { x: i32, y: i32, z: i32 } + fn make_b() -> B { + B { x: 1, y: 2, z: 3 } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-008"), + "Struct construction without clones should not be flagged" + ); +} diff --git a/src/adapters/analyzers/dry/boilerplate/tests/root/bp009_onward.rs b/src/adapters/analyzers/dry/boilerplate/tests/root/bp009_onward.rs new file mode 100644 index 00000000..6a19231b --- /dev/null +++ b/src/adapters/analyzers/dry/boilerplate/tests/root/bp009_onward.rs @@ -0,0 +1,188 @@ +use super::*; + +// ── BP-009 ───────────────────────────────────────────────── + +#[test] +fn test_bp009_few_fields_not_flagged() { + let code = r#" + struct A { x: i32 } + fn make_two() -> (A, A) { (A { x: 1 }, A { x: 2 }) } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-009"), + "Structs with <3 fields should not be flagged" + ); +} + +#[test] +fn test_bp009_overlapping_constructions_detected() { + let code = r#" + struct Config { host: String, port: u16, timeout: u64, retries: u32 } + fn make_configs() -> (Config, Config) { + let a = Config { host: "a".to_string(), port: 80, timeout: 30, retries: 3 }; + let b = Config { host: "b".to_string(), port: 80, timeout: 30, retries: 3 }; + (a, b) + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-009"), + "Two constructions of same type with overlapping fields should be detected" + ); +} + +#[test] +fn test_bp009_different_types_not_flagged() { + let code = r#" + struct A { x: i32, y: i32, z: i32 } + struct B { x: i32, y: i32, z: i32 } + fn make() -> (A, B) { + let a = A { x: 1, y: 2, z: 3 }; + let b = B { x: 1, y: 2, z: 3 }; + (a, b) + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-009"), + "Different struct types should not be grouped" + ); +} + +#[test] +fn test_bp009_struct_update_syntax_not_flagged() { + let code = r#" + struct Config { host: String, port: u16, timeout: u64, retries: u32 } + fn make_configs(base: Config) -> Config { + let a = Config { host: "a".to_string(), port: 80, timeout: 30, retries: 3 }; + let b = Config { host: "b".to_string(), ..base }; + b + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-009"), + "Only one full construction (other uses ..base) should not be flagged" + ); +} + +// ── BP-010 ───────────────────────────────────────────────── + +#[test] +fn test_bp010_different_formats_not_flagged() { + let code = r#" + fn log_stuff() { + println!("a: {}", 1); + println!("b: {}", 2); + println!("c: {}", 3); + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-010"), + "Different format strings should not be flagged" + ); +} + +#[test] +fn test_bp010_repeated_format_detected() { + let code = r#" + fn log_many() { + println!("value: {}", 1); + println!("value: {}", 2); + println!("value: {}", 3); + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-010"), + "3+ identical format strings should be detected" + ); +} + +#[test] +fn test_bp010_two_repetitions_not_flagged() { + let code = r#" + fn log_few() { + println!("same: {}", 1); + println!("same: {}", 2); + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-010"), + "Only 2 repetitions should not be flagged (threshold is 3)" + ); +} + +// ── Config filtering ─────────────────────────────────────── + +#[test] +fn test_pattern_filtering_only_selected() { + let code = r#" + struct W(String); + impl From for W { + fn from(s: String) -> Self { Self(s) } + } + struct Config { count: i32, name: String, active: bool } + impl Default for Config { + fn default() -> Self { + Self { count: 0, name: String::new(), active: false } + } + } + "#; + let config = BoilerplateConfig { + patterns: vec!["BP-005".to_string()], // Only Default + ..BoilerplateConfig::default() + }; + let findings = detect_boilerplate(&parse(code), &config); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-005"), + "BP-005 should be detected when selected" + ); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-001"), + "BP-001 should be skipped when not selected" + ); +} + +#[test] +fn test_suggest_crates_flag() { + let code = r#" + struct W(String); + impl From for W { + fn from(s: String) -> Self { Self(s) } + } + "#; + let config = BoilerplateConfig { + suggest_crates: false, + ..BoilerplateConfig::default() + }; + let findings = detect_boilerplate(&parse(code), &config); + let f = findings.iter().find(|f| f.pattern_id == "BP-001"); + assert!(f.is_some()); + assert!( + !f.unwrap().suggestion.contains("derive_more"), + "Should not mention crates when suggest_crates is false" + ); +} + +#[test] +fn test_disabled_boilerplate_returns_empty() { + let code = r#" + struct W(String); + impl From for W { + fn from(s: String) -> Self { Self(s) } + } + "#; + let config = BoilerplateConfig { + patterns: vec!["BP-999".to_string()], // No real patterns + ..BoilerplateConfig::default() + }; + let findings = detect_boilerplate(&parse(code), &config); + assert!( + findings.is_empty(), + "No findings when no patterns are enabled" + ); +} diff --git a/src/adapters/analyzers/dry/boilerplate/tests/root/mod.rs b/src/adapters/analyzers/dry/boilerplate/tests/root/mod.rs new file mode 100644 index 00000000..1db5862b --- /dev/null +++ b/src/adapters/analyzers/dry/boilerplate/tests/root/mod.rs @@ -0,0 +1,15 @@ +//! Boilerplate-detection (BP-001..BP-010 + config filtering) tests. Split +//! into focused sub-files (each ≤ the SRP file-length cap); the shared +//! `parse` helper + imports live here and reach the sub-modules via `use super::*`. + +pub(super) use crate::adapters::analyzers::dry::boilerplate::*; +pub(super) use crate::config::sections::BoilerplateConfig; + +mod bp001_to_005; +mod bp006_to_008; +mod bp009_onward; + +pub(super) fn parse(code: &str) -> Vec<(String, String, syn::File)> { + let syntax = syn::parse_file(code).expect("parse failed"); + vec![("test.rs".to_string(), code.to_string(), syntax)] +} diff --git a/src/adapters/analyzers/dry/fragments.rs b/src/adapters/analyzers/dry/fragments.rs index 6dd5457a..6679498e 100644 --- a/src/adapters/analyzers/dry/fragments.rs +++ b/src/adapters/analyzers/dry/fragments.rs @@ -1,4 +1,4 @@ -use std::collections::{HashMap, HashSet}; +use std::collections::HashMap; use syn::spanned::Spanned; use syn::visit::Visit; @@ -75,15 +75,11 @@ fn collect_all_windows( parsed: &[(String, String, syn::File)], config: &DuplicatesConfig, ) -> (Vec, Vec) { - let cfg_test_files = - crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(parsed); let mut collector = FragmentCollector { config, - cfg_test_files: &cfg_test_files, file: String::new(), fn_infos: Vec::new(), windows: Vec::new(), - in_test: false, parent_type: None, is_trait_impl: false, }; @@ -224,11 +220,9 @@ pub(crate) fn merge_into_fragments( /// AST visitor that collects statement windows from all function bodies. struct FragmentCollector<'a> { config: &'a DuplicatesConfig, - cfg_test_files: &'a HashSet, file: String, fn_infos: Vec, windows: Vec, - in_test: bool, parent_type: Option, is_trait_impl: bool, } @@ -236,9 +230,6 @@ struct FragmentCollector<'a> { impl super::FileVisitor for FragmentCollector<'_> { fn reset_for_file(&mut self, file_path: &str) { self.file = file_path.to_string(); - // Whole-file test classification from the authoritative cfg-test - // set; inline `#[cfg(test)] mod` is still handled per-item below. - self.in_test = self.cfg_test_files.contains(file_path); self.parent_type = None; self.is_trait_impl = false; } @@ -247,11 +238,7 @@ impl super::FileVisitor for FragmentCollector<'_> { impl FragmentCollector<'_> { /// Process a function body: record fn_info and extract statement windows. /// Operation: window extraction logic; normalize/hash calls hidden in closure. - fn process_body(&mut self, name: &str, body: &syn::Block, is_test_fn: bool) { - let is_test = self.in_test || is_test_fn; - if self.config.ignore_tests && is_test { - return; - } + fn process_body(&mut self, name: &str, body: &syn::Block) { if self.config.ignore_trait_impls && self.is_trait_impl { return; } @@ -306,8 +293,7 @@ impl FragmentCollector<'_> { impl<'ast> Visit<'ast> for FragmentCollector<'_> { fn visit_item_fn(&mut self, node: &'ast syn::ItemFn) { let name = node.sig.ident.to_string(); - let is_test = super::has_test_attr(&node.attrs); - self.process_body(&name, &node.block, is_test); + self.process_body(&name, &node.block); syn::visit::visit_item_fn(self, node); } @@ -330,16 +316,6 @@ impl<'ast> Visit<'ast> for FragmentCollector<'_> { fn visit_impl_item_fn(&mut self, node: &'ast syn::ImplItemFn) { let name = node.sig.ident.to_string(); - let is_test = super::has_test_attr(&node.attrs); - self.process_body(&name, &node.block, is_test); - } - - fn visit_item_mod(&mut self, node: &'ast syn::ItemMod) { - let prev_in_test = self.in_test; - if super::has_cfg_test(&node.attrs) { - self.in_test = true; - } - syn::visit::visit_item_mod(self, node); - self.in_test = prev_in_test; + self.process_body(&name, &node.block); } } diff --git a/src/adapters/analyzers/dry/functions.rs b/src/adapters/analyzers/dry/functions.rs index c56c306b..bf017d0d 100644 --- a/src/adapters/analyzers/dry/functions.rs +++ b/src/adapters/analyzers/dry/functions.rs @@ -1,9 +1,9 @@ -use std::collections::{HashMap, HashSet}; +use std::collections::HashMap; use syn::spanned::Spanned; use syn::visit::Visit; -use super::{has_cfg_test, has_test_attr, qualify_name, FileVisitor, FunctionHashEntry}; +use super::{qualify_name, FileVisitor, FunctionHashEntry}; use crate::config::sections::DuplicatesConfig; // ── FunctionCollector (for DRY hashing) ───────────────────────── @@ -11,22 +11,18 @@ use crate::config::sections::DuplicatesConfig; /// AST visitor that collects function bodies and computes their normalized hashes. pub(crate) struct FunctionCollector<'a> { pub(crate) config: &'a DuplicatesConfig, - pub(crate) cfg_test_files: &'a HashSet, pub(crate) file: String, pub(crate) entries: Vec, - in_test: bool, parent_type: Option, is_trait_impl: bool, } impl<'a> FunctionCollector<'a> { - pub(crate) fn new(config: &'a DuplicatesConfig, cfg_test_files: &'a HashSet) -> Self { + pub(crate) fn new(config: &'a DuplicatesConfig) -> Self { Self { config, - cfg_test_files, file: String::new(), entries: Vec::new(), - in_test: false, parent_type: None, is_trait_impl: false, } @@ -36,11 +32,6 @@ impl<'a> FunctionCollector<'a> { impl FileVisitor for FunctionCollector<'_> { fn reset_for_file(&mut self, file_path: &str) { self.file = file_path.to_string(); - // Whole-file test classification comes from the authoritative - // cfg-test file set (integration-test dirs + `#![cfg(test)]` + - // `#[cfg(test)] mod` chains), not a path heuristic. Inline - // `#[cfg(test)] mod` blocks are still handled per-item below. - self.in_test = self.cfg_test_files.contains(file_path); self.parent_type = None; self.is_trait_impl = false; } @@ -54,13 +45,8 @@ impl FunctionCollector<'_> { name: &str, line: usize, body: &syn::Block, - is_test_fn: bool, is_trait_impl: bool, ) -> Option { - let is_test = self.in_test || is_test_fn; - if self.config.ignore_tests && is_test { - return None; - } if self.config.ignore_trait_impls && is_trait_impl { return None; } @@ -102,8 +88,7 @@ impl<'ast> Visit<'ast> for FunctionCollector<'_> { fn visit_item_fn(&mut self, node: &'ast syn::ItemFn) { let name = node.sig.ident.to_string(); let line = node.sig.ident.span().start().line; - let is_test = has_test_attr(&node.attrs); - if let Some(entry) = self.build_hash_entry(&name, line, &node.block, is_test, false) { + if let Some(entry) = self.build_hash_entry(&name, line, &node.block, false) { self.entries.push(entry); } syn::visit::visit_item_fn(self, node); @@ -112,11 +97,6 @@ impl<'ast> Visit<'ast> for FunctionCollector<'_> { fn visit_item_impl(&mut self, node: &'ast syn::ItemImpl) { let prev_parent = self.parent_type.take(); let prev_is_trait = self.is_trait_impl; - let prev_in_test = self.in_test; - - if has_cfg_test(&node.attrs) { - self.in_test = true; - } self.is_trait_impl = node.trait_.is_some(); if let syn::Type::Path(tp) = &*node.self_ty { @@ -129,16 +109,12 @@ impl<'ast> Visit<'ast> for FunctionCollector<'_> { self.parent_type = prev_parent; self.is_trait_impl = prev_is_trait; - self.in_test = prev_in_test; } fn visit_impl_item_fn(&mut self, node: &'ast syn::ImplItemFn) { let name = node.sig.ident.to_string(); let line = node.sig.ident.span().start().line; - let is_test = has_test_attr(&node.attrs); - if let Some(entry) = - self.build_hash_entry(&name, line, &node.block, is_test, self.is_trait_impl) - { + if let Some(entry) = self.build_hash_entry(&name, line, &node.block, self.is_trait_impl) { self.entries.push(entry); } } @@ -147,20 +123,11 @@ impl<'ast> Visit<'ast> for FunctionCollector<'_> { if let Some(ref block) = node.default { let name = node.sig.ident.to_string(); let line = node.sig.ident.span().start().line; - if let Some(entry) = self.build_hash_entry(&name, line, block, false, true) { + if let Some(entry) = self.build_hash_entry(&name, line, block, true) { self.entries.push(entry); } } } - - fn visit_item_mod(&mut self, node: &'ast syn::ItemMod) { - let prev_in_test = self.in_test; - if has_cfg_test(&node.attrs) { - self.in_test = true; - } - syn::visit::visit_item_mod(self, node); - self.in_test = prev_in_test; - } } /// Near-duplicate bucket size: functions with token counts within this range diff --git a/src/adapters/analyzers/dry/match_patterns.rs b/src/adapters/analyzers/dry/match_patterns.rs index af016e75..6de2bdc0 100644 --- a/src/adapters/analyzers/dry/match_patterns.rs +++ b/src/adapters/analyzers/dry/match_patterns.rs @@ -1,9 +1,8 @@ -use std::collections::{HashMap, HashSet}; +use std::collections::HashMap; use syn::visit::Visit; use crate::adapters::analyzers::dry::FileVisitor; -use crate::adapters::shared::cfg_test::{has_cfg_test, has_test_attr}; /// Minimum number of match arms for a match to be considered. const MIN_MATCH_ARMS: usize = 3; @@ -37,12 +36,9 @@ pub(crate) struct CollectedMatch { } /// AST visitor that collects match expressions for repeated pattern detection. -struct MatchPatternCollector<'a> { - config: &'a crate::config::sections::DuplicatesConfig, - cfg_test_files: &'a HashSet, +struct MatchPatternCollector { file: String, collected: Vec, - in_test: bool, /// Fully-qualified current-function name (e.g. `outer::Type::method`) /// so same-named items in different modules or impls aren't merged /// in grouping. @@ -56,12 +52,8 @@ struct MatchPatternCollector<'a> { module_stack: Vec, } -impl FileVisitor for MatchPatternCollector<'_> { +impl FileVisitor for MatchPatternCollector { fn reset_for_file(&mut self, file_path: &str) { - // Whole-file test classification from the authoritative cfg-test - // set (checked against the raw path, matching its keys). Inline - // `#[cfg(test)] mod` is still handled per-item below. - self.in_test = self.cfg_test_files.contains(file_path); // Normalise separators for deterministic findings across OSes, // matching the other DRY collectors (e.g. wildcards.rs). self.file = file_path.replace('\\', "/"); @@ -81,15 +73,10 @@ fn qualify_with_modules(stack: &[String], tail: &str) -> String { } } -impl<'ast> Visit<'ast> for MatchPatternCollector<'_> { +impl<'ast> Visit<'ast> for MatchPatternCollector { fn visit_item_fn(&mut self, node: &'ast syn::ItemFn) { let qualified = qualify_with_modules(&self.module_stack, &node.sig.ident.to_string()); let prev = std::mem::replace(&mut self.current_fn, qualified); - let is_test = has_test_attr(&node.attrs); - if self.config.ignore_tests && (self.in_test || is_test) { - self.current_fn = prev; - return; - } syn::visit::visit_item_fn(self, node); self.current_fn = prev; } @@ -105,11 +92,6 @@ impl<'ast> Visit<'ast> for MatchPatternCollector<'_> { }; let qualified = qualify_with_modules(&self.module_stack, &type_qualified); let prev = std::mem::replace(&mut self.current_fn, qualified); - let is_test = has_test_attr(&node.attrs); - if self.config.ignore_tests && (self.in_test || is_test) { - self.current_fn = prev; - return; - } syn::visit::visit_impl_item_fn(self, node); self.current_fn = prev; } @@ -131,10 +113,6 @@ impl<'ast> Visit<'ast> for MatchPatternCollector<'_> { } fn visit_item_mod(&mut self, node: &'ast syn::ItemMod) { - let prev_in_test = self.in_test; - if has_cfg_test(&node.attrs) { - self.in_test = true; - } // Push the module name only for inline modules — a bare // `mod name;` declaration has `content == None` and its body // lives in a separate file the outer walk visits separately. @@ -148,7 +126,6 @@ impl<'ast> Visit<'ast> for MatchPatternCollector<'_> { if pushed { self.module_stack.pop(); } - self.in_test = prev_in_test; } fn visit_expr_match(&mut self, node: &'ast syn::ExprMatch) { @@ -177,18 +154,10 @@ impl<'ast> Visit<'ast> for MatchPatternCollector<'_> { /// Detect repeated match patterns across parsed files. /// Integration: creates collector, calls visit_all_files, calls group function. -pub fn detect_repeated_matches( - parsed: &[(String, String, syn::File)], - config: &crate::config::sections::DuplicatesConfig, -) -> Vec { - let cfg_test_files = - crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(parsed); +pub fn detect_repeated_matches(parsed: &[(String, String, syn::File)]) -> Vec { let mut collector = MatchPatternCollector { - config, - cfg_test_files: &cfg_test_files, file: String::new(), collected: Vec::new(), - in_test: false, current_fn: String::new(), current_impl_type: String::new(), module_stack: Vec::new(), diff --git a/src/adapters/analyzers/dry/mod.rs b/src/adapters/analyzers/dry/mod.rs index 6609cdc3..f5d611bd 100644 --- a/src/adapters/analyzers/dry/mod.rs +++ b/src/adapters/analyzers/dry/mod.rs @@ -74,9 +74,7 @@ pub(crate) fn collect_function_hashes( parsed: &[(String, String, syn::File)], config: &crate::config::sections::DuplicatesConfig, ) -> Vec { - let cfg_test_files = - crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(parsed); - let mut collector = functions::FunctionCollector::new(config, &cfg_test_files); + let mut collector = functions::FunctionCollector::new(config); visit_all_files(parsed, &mut collector); collector.entries } diff --git a/src/adapters/analyzers/dry/tests/dead_code.rs b/src/adapters/analyzers/dry/tests/dead_code.rs index 4bf1cc6d..2d07bcfa 100644 --- a/src/adapters/analyzers/dry/tests/dead_code.rs +++ b/src/adapters/analyzers/dry/tests/dead_code.rs @@ -11,6 +11,50 @@ fn parse(code: &str) -> Vec<(String, String, syn::File)> { vec![("test.rs".to_string(), code.to_string(), syntax)] } +/// Parse a two-file workspace (`parent` + `child`) into a `parsed` vec. +fn parse2( + parent_path: &str, + parent_code: &str, + child_path: &str, + child_code: &str, +) -> Vec<(String, String, syn::File)> { + vec![ + ( + parent_path.to_string(), + parent_code.to_string(), + syn::parse_file(parent_code).expect("parse parent"), + ), + ( + child_path.to_string(), + child_code.to_string(), + syn::parse_file(child_code).expect("parse child"), + ), + ] +} + +/// `(production_calls, test_calls)` collected from `code` (single file). +fn collected_calls(code: &str) -> (HashSet, HashSet) { + let parsed = parse(code); + let cfg_test_files = + crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(&parsed); + collect_all_calls(&parsed, &cfg_test_files) +} + +/// Run dead-code detection over `parsed` with the default config and no +/// api/test-helper line markers. +fn dead_code_warnings(parsed: &[(String, String, syn::File)]) -> Vec { + let config = Config::default(); + let cfg_test_files = + crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(parsed); + detect_dead_code( + parsed, + &config, + &std::collections::HashMap::new(), + &std::collections::HashMap::new(), + &cfg_test_files, + ) +} + #[test] fn test_detect_dead_code_empty() { let parsed = parse(""); @@ -523,46 +567,58 @@ fn integration_test_entry_point_in_crate_tests_dir_not_dead_code() { } #[test] -fn test_cfg_test_mod_file_not_flagged() { - // Parent file declares `#[cfg(test)] mod helpers;` (external module) - let parent_code = r#" - fn production_fn() { let x = 1; } - #[cfg(test)] - mod helpers; - "#; - // Child file contains helper functions (no #[cfg(test)] at root) - let child_code = r#" - pub fn test_helper() { let x = 1; } - "#; - let parent_ast = syn::parse_file(parent_code).expect("parse parent"); - let child_ast = syn::parse_file(child_code).expect("parse child"); - let parsed = vec![ +fn cfg_test_mod_child_files_not_flagged() { + // A function in an externally-declared `#[cfg(test)] mod X;` child file + // is test code and must not be flagged as dead, across the three + // module-resolution shapes: flat (`helpers.rs`), dir (`helpers/mod.rs`), + // and non-mod parent (`foo.rs` → `foo/`). (label, parent_path, + // parent_code, child_path, child_code, fn_not_flagged) + let cases: &[(&str, &str, &str, &str, &str, &str)] = &[ ( - "src/mod.rs".to_string(), - parent_code.to_string(), - parent_ast, + "flat helpers.rs child", + "src/mod.rs", + r#" + fn production_fn() { let x = 1; } + #[cfg(test)] + mod helpers; + "#, + "src/helpers.rs", + "pub fn test_helper() { let x = 1; }", + "test_helper", ), ( - "src/helpers.rs".to_string(), - child_code.to_string(), - child_ast, + "dir helpers/mod.rs child", + "src/foo/mod.rs", + r#" + fn prod() { let x = 1; } + #[cfg(test)] + mod helpers; + "#, + "src/foo/helpers/mod.rs", + "pub fn test_util() { let x = 1; }", + "test_util", + ), + ( + "non-mod parent foo.rs → foo/", + "src/foo.rs", + r#" + fn prod() { let x = 1; } + #[cfg(test)] + mod test_utils; + "#, + "src/foo/test_utils.rs", + "pub fn helper() { let x = 1; }", + "helper", ), ]; - let config = Config::default(); - let cfg_test_files = - crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(&parsed); - let warnings = detect_dead_code( - &parsed, - &config, - &std::collections::HashMap::new(), - &std::collections::HashMap::new(), - &cfg_test_files, - ); - // test_helper lives in a cfg(test) module file — should be excluded - assert!( - !warnings.iter().any(|w| w.function_name == "test_helper"), - "Functions in #[cfg(test)] mod file should not be flagged as dead code" - ); + for (label, parent_path, parent_code, child_path, child_code, fn_name) in cases { + let warnings = + dead_code_warnings(&parse2(parent_path, parent_code, child_path, child_code)); + assert!( + !warnings.iter().any(|w| w.function_name == *fn_name), + "case {label}: {fn_name} in a #[cfg(test)] mod child must not be flagged; got {warnings:?}" + ); + } } #[test] @@ -623,88 +679,6 @@ fn test_cfg_test_mod_calls_classified_as_test() { ); } -#[test] -fn test_cfg_test_mod_dir_module() { - // Parent declares #[cfg(test)] mod helpers; where child is helpers/mod.rs - let parent_code = r#" - fn prod() { let x = 1; } - #[cfg(test)] - mod helpers; - "#; - let child_code = r#" - pub fn test_util() { let x = 1; } - "#; - let parent_ast = syn::parse_file(parent_code).expect("parse parent"); - let child_ast = syn::parse_file(child_code).expect("parse child"); - let parsed = vec![ - ( - "src/foo/mod.rs".to_string(), - parent_code.to_string(), - parent_ast, - ), - ( - "src/foo/helpers/mod.rs".to_string(), - child_code.to_string(), - child_ast, - ), - ]; - let config = Config::default(); - let cfg_test_files = - crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(&parsed); - let warnings = detect_dead_code( - &parsed, - &config, - &std::collections::HashMap::new(), - &std::collections::HashMap::new(), - &cfg_test_files, - ); - assert!( - !warnings.iter().any(|w| w.function_name == "test_util"), - "Functions in #[cfg(test)] dir module (mod.rs) should not be flagged" - ); -} - -#[test] -fn test_cfg_test_file_path_from_non_mod_parent() { - // Parent is foo.rs (not mod.rs) → child dir is foo/ - let parent_code = r#" - fn prod() { let x = 1; } - #[cfg(test)] - mod test_utils; - "#; - let child_code = r#" - pub fn helper() { let x = 1; } - "#; - let parent_ast = syn::parse_file(parent_code).expect("parse parent"); - let child_ast = syn::parse_file(child_code).expect("parse child"); - let parsed = vec![ - ( - "src/foo.rs".to_string(), - parent_code.to_string(), - parent_ast, - ), - ( - "src/foo/test_utils.rs".to_string(), - child_code.to_string(), - child_ast, - ), - ]; - let config = Config::default(); - let cfg_test_files = - crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(&parsed); - let warnings = detect_dead_code( - &parsed, - &config, - &std::collections::HashMap::new(), - &std::collections::HashMap::new(), - &cfg_test_files, - ); - assert!( - !warnings.iter().any(|w| w.function_name == "helper"), - "Functions in cfg(test) child of foo.rs → foo/test_utils.rs should be excluded" - ); -} - // ── Serde attribute tests ──────────────────────────────── #[test] @@ -971,48 +945,88 @@ fn test_serde_default_fn_realistic_pattern() { ); } -#[test] -fn test_call_inside_assert_detected_as_test_call() { - let code = r#" - fn helper() -> bool { true } - #[cfg(test)] - mod tests { - use super::*; - #[test] - fn test_it() { - assert!(helper()); +// `collect_all_calls` must see calls in various syntactic forms and route them +// to the production vs test set by scope: calls inside `assert!` / `assert_eq!` +// within a `#[test]` count as TEST calls; a `&fn` passed as an argument and a +// bare fn name in a struct field count as PRODUCTION calls. +// (label, code, in_test_scope, callee) +const CALL_FORM_CASES: &[(&str, &str, bool, &str)] = &[ + ( + "call inside assert!() in a #[test]", + r#" + fn helper() -> bool { true } + #[cfg(test)] + mod tests { + use super::*; + #[test] + fn test_it() { + assert!(helper()); + } } - } - "#; - let parsed = parse(code); - let cfg_test_files = collect_cfg_test_file_paths(&parsed); - let (_prod_calls, test_calls) = collect_all_calls(&parsed, &cfg_test_files); - assert!( - test_calls.contains("helper"), - "Call inside assert!() should be in test_calls" - ); -} + "#, + true, + "helper", + ), + ( + "call inside assert_eq!() in a #[test]", + r#" + fn compute() -> usize { 42 } + #[cfg(test)] + mod tests { + use super::*; + #[test] + fn test_it() { + assert_eq!(compute(), 42); + } + } + "#, + true, + "compute", + ), + ( + "&fn passed as a closure argument", + r#" + fn format_item(s: &str) -> String { s.to_string() } -#[test] -fn test_call_inside_assert_eq_detected() { - let code = r#" - fn compute() -> usize { 42 } - #[cfg(test)] - mod tests { - use super::*; - #[test] - fn test_it() { - assert_eq!(compute(), 42); + fn process(items: &[&str], transform: &dyn Fn(&str) -> String) { + items.iter().for_each(|i| { transform(i); }); } - } - "#; - let parsed = parse(code); - let cfg_test_files = collect_cfg_test_file_paths(&parsed); - let (_prod, test_calls) = collect_all_calls(&parsed, &cfg_test_files); - assert!( - test_calls.contains("compute"), - "Call inside assert_eq!() should be in test_calls" - ); + + fn run() { + process(&["a"], &format_item); + } + "#, + false, + "format_item", + ), + ( + "bare fn name in a struct field", + r#" + struct Config { handler: fn() -> i32 } + fn my_handler() -> i32 { 42 } + fn setup() -> Config { + Config { handler: my_handler } + } + "#, + false, + "my_handler", + ), +]; + +#[test] +fn collect_all_calls_recognizes_call_forms() { + for (label, code, in_test_scope, callee) in CALL_FORM_CASES { + let (prod_calls, test_calls) = collected_calls(code); + let set = if *in_test_scope { + &test_calls + } else { + &prod_calls + }; + assert!( + set.contains(*callee), + "case {label}: callee `{callee}` not found in {set:?}" + ); + } } #[test] @@ -1078,46 +1092,6 @@ fn test_api_does_not_count_as_suppression() { assert!(crate::findings::parse_suppression(1, "// qual:api").is_none()); } -#[test] -fn test_function_pointer_ref_recognized_as_call() { - let code = r#" - fn format_item(s: &str) -> String { s.to_string() } - - fn process(items: &[&str], transform: &dyn Fn(&str) -> String) { - items.iter().for_each(|i| { transform(i); }); - } - - fn run() { - process(&["a"], &format_item); - } - "#; - let parsed = parse(code); - let cfg_test_files = collect_cfg_test_file_paths(&parsed); - let (prod_calls, _test_calls) = collect_all_calls(&parsed, &cfg_test_files); - assert!( - prod_calls.contains("format_item"), - "&format_item passed as argument should be recognized as a call" - ); -} - -#[test] -fn test_struct_field_function_pointer_recognized_as_call() { - let code = r#" - struct Config { handler: fn() -> i32 } - fn my_handler() -> i32 { 42 } - fn setup() -> Config { - Config { handler: my_handler } - } - "#; - let parsed = parse(code); - let cfg_test_files = collect_cfg_test_file_paths(&parsed); - let (prod_calls, _test_calls) = collect_all_calls(&parsed, &cfg_test_files); - assert!( - prod_calls.contains("my_handler"), - "Bare function name in struct field should be recognized as a call" - ); -} - // ── Test-helper marker tests ───────────────────────────────── #[test] @@ -1222,32 +1196,22 @@ fn test_helper_marker_does_not_suppress_uncalled() { // both sides of the chain are captured by name and the helper stays // production-reachable. -#[test] -fn helper_reached_via_trait_blanket_dispatch_is_not_dead_code() { - // Three-file setup mirroring the original v1.2.2 incident: - // ports/reporter.rs → trait definitions + blanket impl - // sarif/rules.rs → the helper that was flagged - // sarif/mod.rs → the concrete ReporterImpl, plus a #[cfg(test)] - // module that calls the helper directly via - // a pub-API wrapper (which is what made it - // look like the helper was *only* test-reachable) - // - // The production path is: - // ::render - // → ::publish - // → sarif_rules() - // - // The test path is: - // #[cfg(test)] tests::it() - // → build_sarif_string() (which also calls publish() indirectly, - // but the analyzer only sees its name) - // - // If the analyzer cannot trace through the trait-blanket-dispatch, - // it concludes "sarif_rules has only a test caller" → TestOnly. - let ports_reporter = ( - "src/ports/reporter.rs".to_string(), - String::new(), - syn::parse_file( +/// Three-file workspace mirroring the v1.2.2 incident: `ports/reporter.rs` +/// (trait defs + blanket `impl Reporter for T`), +/// `sarif/rules.rs` (the helper that was flagged), and `sarif/mod.rs` (the +/// concrete `SarifReporter` + a `#[cfg(test)]` module calling the helper via a +/// pub-API wrapper — the thing that made it look test-only). +fn blanket_dispatch_parsed() -> Vec<(String, String, syn::File)> { + let pf = |path: &str, src: &str| { + ( + path.to_string(), + String::new(), + syn::parse_file(src).expect("parse fixture"), + ) + }; + vec![ + pf( + "src/ports/reporter.rs", r#" pub trait ReporterImpl { type Output; @@ -1262,25 +1226,17 @@ fn helper_reached_via_trait_blanket_dispatch_is_not_dead_code() { fn render(&self) -> Self::Output { self.publish() } } "#, - ) - .unwrap(), - ); - let sarif_rules = ( - "src/adapters/report/sarif/rules.rs".to_string(), - String::new(), - syn::parse_file( + ), + pf( + "src/adapters/report/sarif/rules.rs", r#" pub(super) fn sarif_rules() -> Vec { vec![String::from("rule")] } "#, - ) - .unwrap(), - ); - let sarif_mod = ( - "src/adapters/report/sarif/mod.rs".to_string(), - String::new(), - syn::parse_file( + ), + pf( + "src/adapters/report/sarif/mod.rs", r#" use super::rules::sarif_rules; pub struct SarifReporter; @@ -1302,10 +1258,17 @@ fn helper_reached_via_trait_blanket_dispatch_is_not_dead_code() { fn it() { let _ = build_sarif_string(); } } "#, - ) - .unwrap(), - ); - let parsed = vec![ports_reporter, sarif_rules, sarif_mod]; + ), + ] +} + +// Production path `::render → …ReporterImpl::publish +// → sarif_rules()` reaches the helper through a trait-blanket impl. If the +// analyzer can't trace that, it sees only the `#[cfg(test)]` caller and wrongly +// concludes `sarif_rules` is TestOnly. It must NOT be flagged dead-code. +#[test] +fn helper_reached_via_trait_blanket_dispatch_is_not_dead_code() { + let parsed = blanket_dispatch_parsed(); let config = Config::default(); let warnings = detect_dead_code( &parsed, diff --git a/src/adapters/analyzers/dry/tests/fragments.rs b/src/adapters/analyzers/dry/tests/fragments.rs index 75409190..49d3ad16 100644 --- a/src/adapters/analyzers/dry/tests/fragments.rs +++ b/src/adapters/analyzers/dry/tests/fragments.rs @@ -32,11 +32,10 @@ fn low_threshold_config() -> DuplicatesConfig { } #[test] -fn fragments_in_cfg_test_companion_file_skipped() { - // DRY-004 must skip repeated statement windows in test code. A - // `#![cfg(test)]` companion file (no `tests/` path segment) is test - // code; the fragment collector recognises it via the authoritative - // cfg-test file set, not a path heuristic. +fn fragments_in_cfg_test_companion_file_flagged() { + // Since v1.4.0 DRY-004 runs on test code too. A `#![cfg(test)]` + // companion file (no `tests/` path segment) is test code, and its + // repeated statement windows ARE flagged. let code = r#" #![cfg(test)] fn helper_a() { @@ -55,11 +54,10 @@ fn fragments_in_cfg_test_companion_file_skipped() { code.to_string(), syn::parse_file(code).expect("parse failed"), )]; - let config = low_threshold_config(); // ignore_tests = true - let groups = detect_fragments(&parsed, &config); + let groups = detect_fragments(&parsed, &low_threshold_config()); assert!( - groups.is_empty(), - "fragments in a #![cfg(test)] file must be skipped: {groups:?}" + !groups.is_empty(), + "fragments in a #![cfg(test)] file must be flagged: {groups:?}" ); } @@ -278,43 +276,10 @@ fn test_detect_fragments_below_min_tokens() { } #[test] -fn test_detect_fragments_test_excluded() { - let parsed = parse_multi(&[ - ( - "a.rs", - r#" - fn prod() { - let x = 1; - let y = x + 2; - let z = y * x; - } - "#, - ), - ( - "b.rs", - r#" - #[cfg(test)] - mod tests { - fn test_helper() { - let a = 1; - let b = a + 2; - let c = b * a; - } - } - "#, - ), - ]); - let mut config = low_threshold_config(); - config.ignore_tests = true; - let groups = detect_fragments(&parsed, &config); - assert!( - groups.is_empty(), - "Test functions should be excluded when ignore_tests=true" - ); -} - -#[test] -fn test_detect_fragments_test_included() { +fn test_detect_fragments_includes_test_code() { + // DRY-004 always runs on test code (the `ignore_tests` toggle was removed + // in v1.4.0): a repeated statement window shared between a production fn + // and a `#[cfg(test)]` helper is flagged. let parsed = parse_multi(&[ ( "a.rs", @@ -340,13 +305,8 @@ fn test_detect_fragments_test_included() { "#, ), ]); - let mut config = low_threshold_config(); - config.ignore_tests = false; - let groups = detect_fragments(&parsed, &config); - assert!( - !groups.is_empty(), - "Test functions should be included when ignore_tests=false" - ); + let groups = detect_fragments(&parsed, &low_threshold_config()); + assert!(!groups.is_empty(), "test code must be included"); } #[test] @@ -470,40 +430,8 @@ fn test_detect_fragments_impl_method() { #[test] fn test_detect_fragments_three_way() { - let parsed = parse_multi(&[ - ( - "a.rs", - r#" - fn func_a() { - let x = 1; - let y = x + 2; - let z = y * x; - } - "#, - ), - ( - "b.rs", - r#" - fn func_b() { - let a = 1; - let b = a + 2; - let c = b * a; - } - "#, - ), - ( - "c.rs", - r#" - fn func_c() { - let p = 1; - let q = p + 2; - let r = q * p; - } - "#, - ), - ]); - let config = low_threshold_config(); - let groups = detect_fragments(&parsed, &config); + let parsed = super::three_matching_funcs(); + let groups = detect_fragments(&parsed, &low_threshold_config()); // With 3 matching functions, we get pairs: (a,b), (a,c), (b,c) assert!( groups.len() >= 3, diff --git a/src/adapters/analyzers/dry/tests/functions.rs b/src/adapters/analyzers/dry/tests/functions.rs index f874e927..befbd28e 100644 --- a/src/adapters/analyzers/dry/tests/functions.rs +++ b/src/adapters/analyzers/dry/tests/functions.rs @@ -113,7 +113,10 @@ fn test_detect_duplicates_below_min_tokens_excluded() { } #[test] -fn test_detect_duplicates_test_functions_excluded() { +fn test_detect_duplicates_includes_test_functions() { + // Duplicate detection always runs on test code (the `ignore_tests` + // toggle was removed in v1.4.0) — duplicate `#[cfg(test)]` helpers are + // flagged just like production duplicates. let code = r#" #[cfg(test)] mod tests { @@ -122,41 +125,15 @@ fn test_detect_duplicates_test_functions_excluded() { } "#; let parsed = parse(code); - let mut config = low_threshold_config(); - config.ignore_tests = true; - let groups = detect_duplicates(&parsed, &config); - assert!( - groups.is_empty(), - "Test functions should be excluded when ignore_tests=true" - ); -} - -#[test] -fn test_detect_duplicates_test_functions_included() { - let code = r#" - #[cfg(test)] - mod tests { - fn helper_a() { let x = 1; let y = x + 2; let z = y * x; } - fn helper_b() { let a = 1; let b = a + 2; let c = b * a; } - } - "#; - let parsed = parse(code); - let mut config = low_threshold_config(); - config.ignore_tests = false; - let groups = detect_duplicates(&parsed, &config); - assert_eq!( - groups.len(), - 1, - "Test functions should be included when ignore_tests=false" - ); + let groups = detect_duplicates(&parsed, &low_threshold_config()); + assert_eq!(groups.len(), 1, "test functions must be included"); } #[test] -fn duplicates_in_cfg_test_companion_file_skipped() { +fn duplicates_in_cfg_test_companion_file_flagged() { // A `#![cfg(test)]` companion file is test code even though its path - // has no `tests/` segment. Duplicate detection must skip it by - // consulting the authoritative cfg-test file set, not a `tests/` - // path heuristic. + // has no `tests/` segment. Since v1.4.0 duplicate detection runs on + // tests too, so its duplicate helpers ARE flagged. let code = r#" #![cfg(test)] fn helper_one() { let x = 1; let y = x + 2; let z = y * x; } @@ -167,11 +144,11 @@ fn duplicates_in_cfg_test_companion_file_skipped() { code.to_string(), syn::parse_file(code).expect("parse failed"), )]; - let config = low_threshold_config(); // ignore_tests = true - let groups = detect_duplicates(&parsed, &config); - assert!( - groups.is_empty(), - "duplicates in a #![cfg(test)] file must be skipped: {groups:?}" + let groups = detect_duplicates(&parsed, &low_threshold_config()); + assert_eq!( + groups.len(), + 1, + "duplicates in a #![cfg(test)] file must be flagged: {groups:?}" ); } @@ -202,22 +179,8 @@ fn duplicates_in_production_file_under_nested_tests_dir_still_flagged() { #[test] fn test_detect_duplicates_three_way() { - let parsed = parse_multi(&[ - ( - "a.rs", - "fn func_a() { let x = 1; let y = x + 2; let z = y * x; }", - ), - ( - "b.rs", - "fn func_b() { let a = 1; let b = a + 2; let c = b * a; }", - ), - ( - "c.rs", - "fn func_c() { let p = 1; let q = p + 2; let r = q * p; }", - ), - ]); - let config = low_threshold_config(); - let groups = detect_duplicates(&parsed, &config); + let parsed = super::three_matching_funcs(); + let groups = detect_duplicates(&parsed, &low_threshold_config()); assert_eq!(groups.len(), 1); assert_eq!(groups[0].entries.len(), 3, "Should detect 3-way duplicate"); } diff --git a/src/adapters/analyzers/dry/tests/match_patterns.rs b/src/adapters/analyzers/dry/tests/match_patterns.rs index 188424ff..ed557745 100644 --- a/src/adapters/analyzers/dry/tests/match_patterns.rs +++ b/src/adapters/analyzers/dry/tests/match_patterns.rs @@ -1,9 +1,4 @@ use crate::adapters::analyzers::dry::match_patterns::*; -use crate::adapters::analyzers::dry::FileVisitor; -use crate::adapters::shared::cfg_test::{has_cfg_test, has_test_attr}; -use crate::config::sections::DuplicatesConfig; -use std::collections::HashMap; -use syn::visit::Visit; fn parse(code: &str) -> Vec<(String, String, syn::File)> { let syntax = syn::parse_file(code).expect("parse failed"); @@ -13,17 +8,15 @@ fn parse(code: &str) -> Vec<(String, String, syn::File)> { #[test] fn test_detect_empty() { let parsed = parse(""); - let config = DuplicatesConfig::default(); - let result = detect_repeated_matches(&parsed, &config); + let result = detect_repeated_matches(&parsed); assert!(result.is_empty()); } #[test] -fn repeated_matches_in_cfg_test_companion_file_skipped() { - // DRY-005 must skip repeated match patterns in test code. A - // `#![cfg(test)]` companion file (no `tests/` path segment) is test - // code; the collector recognises it via the authoritative cfg-test - // file set, not a path heuristic. +fn repeated_matches_in_cfg_test_companion_file_flagged() { + // Since v1.4.0 DRY-005 runs on test code too. A `#![cfg(test)]` + // companion file (no `tests/` path segment) is test code, and its + // repeated match patterns ARE flagged. let code = r#" #![cfg(test)] enum E { A, B, C } @@ -36,11 +29,11 @@ fn repeated_matches_in_cfg_test_companion_file_skipped() { code.to_string(), syn::parse_file(code).expect("parse failed"), )]; - let config = DuplicatesConfig::default(); // ignore_tests = true - let result = detect_repeated_matches(&parsed, &config); - assert!( - result.is_empty(), - "repeated matches in a #![cfg(test)] file must be skipped: {} group(s)", + let result = detect_repeated_matches(&parsed); + assert_eq!( + result.len(), + 1, + "repeated matches in a #![cfg(test)] file must be flagged: {} group(s)", result.len() ); } @@ -54,8 +47,7 @@ fn test_detect_single_match_not_flagged() { } "#; let parsed = parse(code); - let config = DuplicatesConfig::default(); - let result = detect_repeated_matches(&parsed, &config); + let result = detect_repeated_matches(&parsed); assert!(result.is_empty(), "single instance should not be flagged"); } @@ -74,8 +66,7 @@ fn test_detect_repeated_match_flagged() { } "#; let parsed = parse(code); - let config = DuplicatesConfig::default(); - let result = detect_repeated_matches(&parsed, &config); + let result = detect_repeated_matches(&parsed); assert_eq!(result.len(), 1); assert_eq!(result[0].entries.len(), 3); assert_eq!(result[0].enum_name, "E"); @@ -96,15 +87,15 @@ fn test_detect_different_matches_not_grouped() { } "#; let parsed = parse(code); - let config = DuplicatesConfig::default(); - let result = detect_repeated_matches(&parsed, &config); + let result = detect_repeated_matches(&parsed); // Normalization erases literal values, so these should hash the same // because the structure is identical (match on enum with 3 literal returns) assert_eq!(result.len(), 1, "same structure matches should be grouped"); } #[test] -fn test_detect_test_code_excluded() { +fn test_detect_test_code_included() { + // Repeated matches inside a `#[cfg(test)] mod` are flagged since v1.4.0. let code = r#" enum E { A, B, C } #[cfg(test)] @@ -116,12 +107,8 @@ fn test_detect_test_code_excluded() { } "#; let parsed = parse(code); - let config = DuplicatesConfig { - ignore_tests: true, - ..DuplicatesConfig::default() - }; - let result = detect_repeated_matches(&parsed, &config); - assert!(result.is_empty(), "test code should be excluded"); + let result = detect_repeated_matches(&parsed); + assert_eq!(result.len(), 1, "test code must be included"); } #[test] @@ -132,8 +119,7 @@ fn test_detect_few_arms_not_flagged() { fn f3(b: bool) -> i32 { match b { true => 1, false => 0 } } "#; let parsed = parse(code); - let config = DuplicatesConfig::default(); - let result = detect_repeated_matches(&parsed, &config); + let result = detect_repeated_matches(&parsed); assert!( result.is_empty(), "matches with <3 arms should not be flagged" diff --git a/src/adapters/analyzers/dry/tests/mod.rs b/src/adapters/analyzers/dry/tests/mod.rs index 366aa960..6670cfbe 100644 --- a/src/adapters/analyzers/dry/tests/mod.rs +++ b/src/adapters/analyzers/dry/tests/mod.rs @@ -4,3 +4,18 @@ mod functions; mod match_patterns; mod root; mod wildcards; + +/// Three free functions (`func_a`/`func_b`/`func_c`) with identical +/// `let x = 1; let y = x + 2; let z = y * x;` bodies in separate files — the +/// shared 3-way-match fixture used by both the duplicate-function and the +/// fragment three-way tests. +pub(super) fn three_matching_funcs() -> Vec<(String, String, syn::File)> { + ["a", "b", "c"] + .iter() + .map(|n| { + let src = format!("fn func_{n}() {{ let x = 1; let y = x + 2; let z = y * x; }}"); + let ast = syn::parse_file(&src).expect("fixture must parse"); + (format!("{n}.rs"), src, ast) + }) + .collect() +} diff --git a/src/adapters/analyzers/dry/tests/root.rs b/src/adapters/analyzers/dry/tests/root.rs index 5695c51e..e8038823 100644 --- a/src/adapters/analyzers/dry/tests/root.rs +++ b/src/adapters/analyzers/dry/tests/root.rs @@ -6,138 +6,140 @@ fn parse(code: &str) -> Vec<(String, String, syn::File)> { vec![("test.rs".to_string(), code.to_string(), syntax)] } -#[test] -fn test_collect_function_hashes_empty() { - let parsed = parse(""); - let config = DuplicatesConfig::default(); - let entries = collect_function_hashes(&parsed, &config); - assert!(entries.is_empty()); -} - -#[test] -fn test_collect_function_hashes_small_function_excluded() { - // A tiny function should be excluded by min_tokens - let parsed = parse("fn tiny() { let x = 1; }"); - let config = DuplicatesConfig::default(); // min_tokens = 30 - let entries = collect_function_hashes(&parsed, &config); - assert!(entries.is_empty(), "Small function should be filtered out"); -} - -#[test] -fn test_collect_function_hashes_large_function_included() { - // A larger function with many tokens - let code = r#" - fn big_fn() { - let a = 1; - let b = 2; - let c = a + b; - let d = c * a; - let e = d - b; - let f = e + c; - let g = f * d; - let h = g - e; - let i = h + f; - let j = i * g; - } - "#; - let parsed = parse(code); +/// Collect function hashes for `code` under a config with the given +/// thresholds and trait-impl flag. (DRY always runs on test code.) +fn hashes_of( + code: &str, + min_tokens: usize, + min_lines: usize, + ignore_trait_impls: bool, +) -> Vec { let config = DuplicatesConfig { - min_tokens: 5, // Lower threshold for test - min_lines: 1, + min_tokens, + min_lines, + ignore_trait_impls, ..DuplicatesConfig::default() }; - let entries = collect_function_hashes(&parsed, &config); - assert_eq!(entries.len(), 1); - assert_eq!(entries[0].name, "big_fn"); + collect_function_hashes(&parse(code), &config) } -#[test] -fn test_collect_function_hashes_test_excluded() { - let code = r#" - #[cfg(test)] - mod tests { - fn helper() { - let a = 1; let b = 2; let c = a + b; - let d = c * a; let e = d - b; let f = e + c; - } - } - "#; - let parsed = parse(code); - let config = DuplicatesConfig { - min_tokens: 5, - min_lines: 1, - ignore_tests: true, - ..DuplicatesConfig::default() - }; - let entries = collect_function_hashes(&parsed, &config); - assert!(entries.is_empty(), "Test functions should be excluded"); -} +// (label, code, min_tokens, min_lines, ignore_trait_impls, expected_len, +// expected_qualified) +type HashCase = ( + &'static str, + &'static str, + usize, + usize, + bool, + usize, + Option<&'static str>, +); -#[test] -fn test_collect_function_hashes_test_included_when_not_ignored() { - let code = r#" - #[cfg(test)] - mod tests { - fn helper() { - let a = 1; let b = 2; let c = a + b; - let d = c * a; let e = d - b; let f = e + c; +const HASH_CASES: &[HashCase] = &[ + ("empty source", "", 30, 5, true, 0, None), + ( + "tiny fn filtered by default min_tokens", + "fn tiny() { let x = 1; }", + 30, + 5, + true, + 0, + None, + ), + ( + "large free fn included", + r#" + fn big_fn() { + let a = 1; + let b = 2; + let c = a + b; + let d = c * a; + let e = d - b; + let f = e + c; + let g = f * d; + let h = g - e; + let i = h + f; + let j = i * g; } - } - "#; - let parsed = parse(code); - let config = DuplicatesConfig { - min_tokens: 5, - min_lines: 1, - ignore_tests: false, - ..DuplicatesConfig::default() - }; - let entries = collect_function_hashes(&parsed, &config); - assert_eq!(entries.len(), 1, "Test functions should be included"); -} - -#[test] -fn test_collect_function_hashes_impl_method() { - let code = r#" - struct Foo; - impl Foo { - fn method(&self) { - let a = 1; let b = 2; let c = a + b; - let d = c * a; let e = d - b; let f = e + c; + "#, + 5, + 1, + true, + 1, + Some("big_fn"), + ), + ( + "cfg(test) fn included (DRY runs on test code)", + r#" + #[cfg(test)] + mod tests { + fn helper() { + let a = 1; let b = 2; let c = a + b; + let d = c * a; let e = d - b; let f = e + c; + } } - } - "#; - let parsed = parse(code); - let config = DuplicatesConfig { - min_tokens: 5, - min_lines: 1, - ..DuplicatesConfig::default() - }; - let entries = collect_function_hashes(&parsed, &config); - assert_eq!(entries.len(), 1); - assert_eq!(entries[0].qualified_name, "Foo::method"); -} + "#, + 5, + 1, + true, + 1, + None, + ), + ( + "impl method included with qualified name", + r#" + struct Foo; + impl Foo { + fn method(&self) { + let a = 1; let b = 2; let c = a + b; + let d = c * a; let e = d - b; let f = e + c; + } + } + "#, + 5, + 1, + true, + 1, + Some("Foo::method"), + ), + ( + "trait-impl method excluded when ignore_trait_impls", + r#" + trait Bar { fn do_thing(&self); } + struct Foo; + impl Bar for Foo { + fn do_thing(&self) { + let a = 1; let b = 2; let c = a + b; + let d = c * a; let e = d - b; let f = e + c; + } + } + "#, + 5, + 1, + true, + 0, + None, + ), +]; #[test] -fn test_collect_function_hashes_trait_impl_excluded() { - let code = r#" - trait Bar { fn do_thing(&self); } - struct Foo; - impl Bar for Foo { - fn do_thing(&self) { - let a = 1; let b = 2; let c = a + b; - let d = c * a; let e = d - b; let f = e + c; - } +fn collect_function_hashes_inclusion() { + // `collect_function_hashes` includes a fn only when it clears the token + // threshold and isn't filtered out: tiny fns drop (default min_tokens=30); + // trait-impl methods drop iff `ignore_trait_impls`. Test code is always + // included (the `ignore_tests` toggle was removed in v1.4.0). + for (label, code, min_tokens, min_lines, ignore_trait_impls, expected_len, qualified) in + HASH_CASES + { + let entries = hashes_of(code, *min_tokens, *min_lines, *ignore_trait_impls); + assert_eq!(entries.len(), *expected_len, "case {label}: len"); + if let Some(q) = qualified { + assert_eq!( + &entries[0].qualified_name, q, + "case {label}: qualified_name" + ); } - "#; - let parsed = parse(code); - let config = DuplicatesConfig { - min_tokens: 5, - min_lines: 1, - ignore_trait_impls: true, - ..DuplicatesConfig::default() - }; - let entries = collect_function_hashes(&parsed, &config); - assert!(entries.is_empty(), "Trait impl methods should be excluded"); + } } #[test] @@ -177,9 +179,21 @@ fn test_collect_declared_functions_basic() { assert!(declared.iter().any(|d| d.name == "foo" && !d.is_main)); } +/// Whether `fn_name` in `code` is a declared test function (`is_test`). +fn declared_is_test(code: &str, fn_name: &str) -> bool { + collect_declared_functions(&parse(code)) + .into_iter() + .find(|d| d.name == fn_name) + .unwrap_or_else(|| panic!("fn {fn_name} not found")) + .is_test +} + #[test] -fn test_collect_declared_functions_test_context() { - let code = r#" +fn declared_function_is_test_classification() { + // `collect_declared_functions` marks fns inside `#[cfg(test)] mod` / + // `#[cfg(test)] impl` as tests (false for production fns alongside them). + // (label, code, fn_name, expected_is_test) + const CFG_TEST_MOD: &str = r#" fn production() {} #[cfg(test)] mod tests { @@ -188,17 +202,50 @@ fn test_collect_declared_functions_test_context() { fn test_something() {} } "#; - let parsed = parse(code); - let declared = collect_declared_functions(&parsed); - let prod = declared.iter().find(|d| d.name == "production").unwrap(); - assert!(!prod.is_test); - let helper = declared.iter().find(|d| d.name == "helper").unwrap(); - assert!(helper.is_test); - let test_fn = declared - .iter() - .find(|d| d.name == "test_something") - .unwrap(); - assert!(test_fn.is_test); + const CFG_TEST_IMPL: &str = r#" + pub struct Foo; + + #[cfg(test)] + impl Foo { + fn test_helper(&self) -> bool { true } + pub fn another_helper() -> i32 { 42 } + } + "#; + let cases: &[(&str, &str, &str, bool)] = &[ + ( + "production fn outside cfg(test)", + CFG_TEST_MOD, + "production", + false, + ), + ( + "plain helper in cfg(test) mod", + CFG_TEST_MOD, + "helper", + true, + ), + ( + "#[test] fn in cfg(test) mod", + CFG_TEST_MOD, + "test_something", + true, + ), + ( + "method in cfg(test) impl", + CFG_TEST_IMPL, + "test_helper", + true, + ), + ( + "pub method in cfg(test) impl", + CFG_TEST_IMPL, + "another_helper", + true, + ), + ]; + for (label, code, fn_name, expected) in cases { + assert_eq!(declared_is_test(code, fn_name), *expected, "case {label}"); + } } #[test] @@ -249,33 +296,3 @@ fn test_collect_declared_functions_allow_list_without_dead_code() { assert_eq!(declared.len(), 1); assert!(!declared[0].has_allow_dead_code); } - -#[test] -fn test_cfg_test_impl_methods_are_test() { - let code = r#" - pub struct Foo; - - #[cfg(test)] - impl Foo { - fn test_helper(&self) -> bool { true } - pub fn another_helper() -> i32 { 42 } - } - "#; - let parsed = parse(code); - let declared = collect_declared_functions(&parsed); - - let helper = declared.iter().find(|d| d.name == "test_helper").unwrap(); - assert!( - helper.is_test, - "Method inside #[cfg(test)] impl should have is_test=true" - ); - - let another = declared - .iter() - .find(|d| d.name == "another_helper") - .unwrap(); - assert!( - another.is_test, - "Pub method inside #[cfg(test)] impl should have is_test=true" - ); -} diff --git a/src/adapters/analyzers/iosp/tests/classify.rs b/src/adapters/analyzers/iosp/tests/classify.rs index 39dd36d2..e369a51a 100644 --- a/src/adapters/analyzers/iosp/tests/classify.rs +++ b/src/adapters/analyzers/iosp/tests/classify.rs @@ -6,6 +6,26 @@ use crate::adapters::analyzers::iosp::types::{ use crate::config::Config; use syn::ItemImpl; +/// Parse `code`, locate the free fn named `fn_name`, and classify it against a +/// default config + a scope built from the same file. Collapses the +/// find-the-fn + classify arrange shared by the control-flow classification +/// tests. +fn classify_named_fn(code: &str, fn_name: &str) -> Classification { + let syntax = syn::parse_file(code).unwrap(); + let scope = ProjectScope::from_files(&[("test.rs", &syntax)]); + let config = Config::default(); + let f_fn = syntax + .items + .iter() + .find_map(|item| match item { + syn::Item::Fn(f) if f.sig.ident == fn_name => Some(f), + _ => None, + }) + .unwrap_or_else(|| panic!("fn `{fn_name}` not found")); + let (class, _, _) = classify_function(&f_fn.block, &config, &scope, fn_name, (None, &f_fn.sig)); + class +} + #[test] fn test_is_trivial_body_empty() { let block: syn::Block = syn::parse_quote!({}); @@ -243,41 +263,28 @@ fn test_extract_type_name_no_path() { #[test] fn test_for_loop_delegation_is_integration() { - let code = r#" + let class = classify_named_fn( + r#" fn process(_x: i32) {} fn f(items: Vec) { for x in items { process(x); } } - "#; - let syntax = syn::parse_file(code).unwrap(); - let scope = ProjectScope::from_files(&[("test.rs", &syntax)]); - let config = Config::default(); - let f_fn = syntax - .items - .iter() - .find_map(|item| { - if let syn::Item::Fn(f) = item { - if f.sig.ident == "f" { - return Some(f); - } - } - None - }) - .unwrap(); - let (class, _, _) = classify_function(&f_fn.block, &config, &scope, "f", (None, &f_fn.sig)); + "#, + "f", + ); assert_eq!( class, Classification::Integration, - "For-loop with delegation-only body should be Integration, got {:?}", - class + "For-loop with delegation-only body should be Integration, got {class:?}" ); } #[test] fn test_for_loop_with_logic_is_violation() { - let code = r#" + let class = classify_named_fn( + r#" fn process(_x: i32) {} fn f(items: Vec) { for x in items { @@ -286,26 +293,11 @@ fn test_for_loop_with_logic_is_violation() { } } } - "#; - let syntax = syn::parse_file(code).unwrap(); - let scope = ProjectScope::from_files(&[("test.rs", &syntax)]); - let config = Config::default(); - let f_fn = syntax - .items - .iter() - .find_map(|item| { - if let syn::Item::Fn(f) = item { - if f.sig.ident == "f" { - return Some(f); - } - } - None - }) - .unwrap(); - let (class, _, _) = classify_function(&f_fn.block, &config, &scope, "f", (None, &f_fn.sig)); + "#, + "f", + ); assert!( matches!(class, Classification::Violation { .. }), - "For-loop with logic should be Violation, got {:?}", - class + "For-loop with logic should be Violation, got {class:?}" ); } diff --git a/src/adapters/analyzers/iosp/tests/root.rs b/src/adapters/analyzers/iosp/tests/root.rs deleted file mode 100644 index 0e72b7e8..00000000 --- a/src/adapters/analyzers/iosp/tests/root.rs +++ /dev/null @@ -1,1330 +0,0 @@ -use crate::adapters::analyzers::iosp::scope::ProjectScope; -use crate::adapters::analyzers::iosp::*; -use crate::config::Config; - -/// Helper: parse code, build scope from it, analyze with default config. -fn parse_and_analyze(code: &str) -> Vec { - let syntax = syn::parse_file(code).expect("Failed to parse test code"); - let scope_files = vec![("test.rs", &syntax)]; - let scope = ProjectScope::from_files(&scope_files); - let config = Config::default(); - let analyzer = Analyzer::new(&config, &scope); - let mut results = analyzer.analyze_file(&syntax, "test.rs"); - let parsed = vec![("test.rs".to_string(), code.to_string(), syntax)]; - let recursive_lines = crate::adapters::source::filesystem::collect_recursive_lines(&parsed); - crate::app::warnings::apply_recursive_annotations(&mut results, &recursive_lines); - crate::app::warnings::apply_leaf_reclassification(&mut results); - results -} - -/// Helper: parse code with a custom config. -fn parse_and_analyze_with_config(code: &str, config: &Config) -> Vec { - let syntax = syn::parse_file(code).expect("Failed to parse test code"); - let scope_files = vec![("test.rs", &syntax)]; - let scope = ProjectScope::from_files(&scope_files); - let analyzer = Analyzer::new(config, &scope); - analyzer.analyze_file(&syntax, "test.rs") -} - -// --------------------------------------------------------------- -// Classification Tests -// --------------------------------------------------------------- - -#[test] -fn test_pure_integration() { - let code = r#" - fn helper_a() {} - fn helper_b() {} - fn integrator() { - helper_a(); - helper_b(); - } - "#; - let results = parse_and_analyze(code); - let integrator = results.iter().find(|r| r.name == "integrator").unwrap(); - assert_eq!(integrator.classification, Classification::Integration); -} - -#[test] -fn test_pure_operation() { - let code = r#" - fn operation(x: i32) -> &'static str { - let _y = x; - if _y > 0 { - "positive" - } else { - "non-positive" - } - } - "#; - let results = parse_and_analyze(code); - let op = results.iter().find(|r| r.name == "operation").unwrap(); - assert_eq!(op.classification, Classification::Operation); -} - -#[test] -fn test_violation_mixed() { - let code = r#" - fn helper(x: i32) { if x > 0 { violator(x); } } - fn violator(x: i32) { - let _y = x; - if _y > 0 { - helper(_y); - } - } - "#; - let results = parse_and_analyze(code); - let v = results.iter().find(|r| r.name == "violator").unwrap(); - assert!( - matches!(v.classification, Classification::Violation { .. }), - "Expected Violation, got {:?}", - v.classification - ); -} - -#[test] -fn test_violation_locations() { - let code = r#"fn helper(x: i32) { if x > 0 { violator(x); } } -fn violator(x: i32) { -let _y = x; -if _y > 0 { - helper(_y); -} -} -"#; - let results = parse_and_analyze(code); - let v = results.iter().find(|r| r.name == "violator").unwrap(); - if let Classification::Violation { - logic_locations, - call_locations, - .. - } = &v.classification - { - assert!( - logic_locations - .iter() - .any(|l| l.kind == "if" && l.line == 4), - "Expected 'if' on line 4, got: {:?}", - logic_locations - ); - assert!( - call_locations - .iter() - .any(|c| c.name == "helper" && c.line == 5), - "Expected 'helper' call on line 5, got: {:?}", - call_locations - ); - } else { - panic!("Expected Violation, got {:?}", v.classification); - } -} - -#[test] -fn test_trivial_empty_body() { - let code = r#" - fn f() {} - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert_eq!(f.classification, Classification::Trivial); -} - -#[test] -fn test_trivial_single_return() { - let code = r#" - fn f() -> i32 { 42 } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert_eq!(f.classification, Classification::Trivial); -} - -#[test] -fn test_trivial_getter() { - let code = r#" - struct Foo { x: i32 } - impl Foo { - fn get_x(&self) -> i32 { self.x } - } - "#; - let results = parse_and_analyze(code); - let getter = results.iter().find(|r| r.name == "get_x").unwrap(); - assert_eq!(getter.classification, Classification::Trivial); -} - -#[test] -fn test_single_stmt_with_own_call() { - let code = r#" - fn helper() {} - fn f() { helper() } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert_eq!( - f.classification, - Classification::Integration, - "Single-statement body with own call should be Integration, got {:?}", - f.classification - ); -} - -#[test] -fn test_single_stmt_with_logic() { - let code = r#" - fn f(x: i32) -> i32 { if x > 0 { 1 } else { 0 } } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert_eq!( - f.classification, - Classification::Operation, - "Single-statement body with logic should be Operation, got {:?}", - f.classification - ); -} - -// --------------------------------------------------------------- -// Closure Tests -// --------------------------------------------------------------- - -#[test] -fn test_closure_lenient_ignores_logic() { - let code = r#" - fn f() { - let v = vec![1, 2, 3]; - let _: Vec<_> = v.into_iter().collect(); - let _ = (|| { if true { 1 } else { 2 } })(); - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert!( - !matches!(f.classification, Classification::Violation { .. }), - "Logic inside a closure should not cause a violation in lenient mode, got {:?}", - f.classification - ); -} - -#[test] -fn test_closure_strict_counts_logic() { - let mut config = Config::default(); - config.strict_closures = true; - let code = r#" - fn f() { - let v = vec![1, 2, 3]; - let _ = (|| { if true { 1 } else { 2 } })(); - let _ = v.len(); - } - "#; - let results = parse_and_analyze_with_config(code, &config); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert!( - matches!( - f.classification, - Classification::Operation | Classification::Violation { .. } - ), - "Expected logic to be counted in strict closure mode, got {:?}", - f.classification - ); -} - -#[test] -fn test_closure_lenient_ignores_calls() { - let code = r#" - fn helper() {} - fn f() { - let c = || { helper(); }; - c(); - let _ = 1; - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert!( - !matches!(f.classification, Classification::Violation { .. }), - "Own call inside closure should be ignored in lenient mode, got {:?}", - f.classification - ); -} - -#[test] -fn test_closure_strict_counts_calls() { - let mut config = Config::default(); - config.strict_closures = true; - let code = r#" - fn helper() {} - fn f() { - let c = || { helper(); }; - c(); - let _ = 1; - } - "#; - let results = parse_and_analyze_with_config(code, &config); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert!( - matches!( - f.classification, - Classification::Integration | Classification::Violation { .. } - ), - "Own call inside closure should be counted in strict mode, got {:?}", - f.classification - ); -} - -// --------------------------------------------------------------- -// Iterator Tests -// --------------------------------------------------------------- - -#[test] -fn test_iterator_lenient_not_own_call() { - let code = r#" - fn f() -> Vec { - let v = vec![1, 2, 3]; - v.iter().map(|x| x + 1).collect() - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert!( - !matches!(f.classification, Classification::Violation { .. }), - "Iterator methods should not be own calls in lenient mode, got {:?}", - f.classification - ); -} - -#[test] -fn test_iterator_strict_counts_as_logic() { - let mut config = Config::default(); - config.strict_iterator_chains = true; - let code = r#" - struct Foo; - impl Foo { - fn map(&self) {} - } - fn f() -> Vec { - let v = vec![1, 2, 3]; - let x = v.iter().map(|x| x + 1).collect::>(); - x - } - "#; - let results = parse_and_analyze_with_config(code, &config); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert!( - matches!( - f.classification, - Classification::Integration | Classification::Violation { .. } - ), - "Iterator methods should be counted in strict mode when in scope, got {:?}", - f.classification - ); -} - -// --------------------------------------------------------------- -// ProjectScope Tests -// --------------------------------------------------------------- - -#[test] -fn test_method_call_own_type() { - let code = r#" - struct MyStruct; - impl MyStruct { - fn do_work(&self) {} - fn orchestrate(&self) { - self.do_work(); - self.do_work(); - } - } - "#; - let results = parse_and_analyze(code); - let orch = results.iter().find(|r| r.name == "orchestrate").unwrap(); - assert_eq!(orch.classification, Classification::Integration); -} - -#[test] -fn test_method_call_external() { - let code = r#" - fn operation_fn() { - let mut v = Vec::new(); - if v.is_empty() { - v.push(1); - } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "operation_fn").unwrap(); - assert_eq!(f.classification, Classification::Operation); -} - -#[test] -fn test_function_call_own() { - let code = r#" - fn step_a() {} - fn step_b() {} - fn orchestrate() { - step_a(); - step_b(); - } - "#; - let results = parse_and_analyze(code); - let orch = results.iter().find(|r| r.name == "orchestrate").unwrap(); - assert_eq!(orch.classification, Classification::Integration); -} - -#[test] -fn test_path_call_own_type() { - let code = r#" - struct MyType; - impl MyType { - fn create() -> Self { MyType } - } - fn f() { - let _a = MyType::create(); - let _b = MyType::create(); - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert_eq!(f.classification, Classification::Integration); -} - -#[test] -fn test_path_call_external_type() { - let code = r#" - fn f() { - let _a = String::new(); - let _b = String::new(); - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert!( - !matches!(f.classification, Classification::Integration), - "String::new() should not be counted as own call, got {:?}", - f.classification - ); -} - -// --------------------------------------------------------------- -// Structure Tests -// --------------------------------------------------------------- - -#[test] -fn test_impl_block_parent_type() { - let code = r#" - struct Foo; - impl Foo { - fn bar(&self) {} - } - "#; - let results = parse_and_analyze(code); - let bar = results.iter().find(|r| r.name == "bar").unwrap(); - assert_eq!(bar.parent_type, Some("Foo".to_string())); -} - -#[test] -fn test_trait_default_impl() { - let code = r#" - fn step() {} - trait MyTrait { - fn default_method(&self) { - step(); - step(); - } - } - "#; - let results = parse_and_analyze(code); - let dm = results.iter().find(|r| r.name == "default_method").unwrap(); - assert_eq!(dm.classification, Classification::Integration); - assert_eq!(dm.parent_type, Some("MyTrait".to_string())); -} - -#[test] -fn test_ignored_function_skipped() { - let mut config = Config::default(); - config.ignore_functions.push("test_*".to_string()); - let code = r#" - fn test_something() { - if true { } - } - fn real_function() -> i32 { 42 } - "#; - let results = parse_and_analyze_with_config(code, &config); - assert!( - results.iter().all(|r| r.name != "test_something"), - "Ignored function should not appear in results" - ); - assert!( - results.iter().any(|r| r.name == "real_function"), - "Non-ignored function should appear in results" - ); -} - -#[test] -fn test_nested_module() { - let code = r#" - mod inner { - fn nested_fn() -> i32 { 42 } - } - "#; - let results = parse_and_analyze(code); - let nested = results.iter().find(|r| r.name == "nested_fn").unwrap(); - assert_eq!(nested.classification, Classification::Trivial); -} - -// --------------------------------------------------------------- -// A2: Recursion Tests -// --------------------------------------------------------------- - -#[test] -fn test_recursion_default_is_violation() { - let code = r#" - fn fib(n: u32) -> u32 { - let _x = n; - if n <= 1 { n } else { fib(n - 1) + fib(n - 2) } - } - "#; - let results = parse_and_analyze(code); - let fib = results.iter().find(|r| r.name == "fib").unwrap(); - assert!( - matches!(fib.classification, Classification::Violation { .. }), - "Recursive function should be Violation by default, got {:?}", - fib.classification - ); -} - -#[test] -fn test_recursion_allowed_becomes_operation() { - let mut config = Config::default(); - config.allow_recursion = true; - let code = r#" - fn fib(n: u32) -> u32 { - let _x = n; - if n <= 1 { n } else { fib(n - 1) + fib(n - 2) } - } - "#; - let results = parse_and_analyze_with_config(code, &config); - let fib = results.iter().find(|r| r.name == "fib").unwrap(); - assert_eq!( - fib.classification, - Classification::Operation, - "Recursive function with allow_recursion should be Operation, got {:?}", - fib.classification - ); -} - -// --------------------------------------------------------------- -// A3: Error Propagation Tests -// --------------------------------------------------------------- - -#[test] -fn test_question_mark_default_not_logic() { - let code = r#" - fn f() -> Result<(), String> { - let _x = 1; - let _y: Result = Ok(1); - Ok(()) - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert!( - !matches!(f.classification, Classification::Violation { .. }), - "? operator should not count as logic by default" - ); -} - -#[test] -fn test_question_mark_strict_counts_as_logic() { - let mut config = Config::default(); - config.strict_error_propagation = true; - let code = r#" - fn helper() -> Result { Ok(42) } - fn f() -> Result<(), String> { - let _x = helper()?; - let _ = 1; - Ok(()) - } - "#; - let results = parse_and_analyze_with_config(code, &config); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert!( - matches!(f.classification, Classification::Violation { .. }), - "? operator should count as logic with strict_error_propagation, got {:?}", - f.classification - ); -} - -// --------------------------------------------------------------- -// A4: Async/Await Tests -// --------------------------------------------------------------- - -#[test] -fn test_async_block_lenient_ignores_logic() { - let code = r#" - fn f() { - let _ = async { if true { 1 } else { 2 } }; - let _ = 1; - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert!( - !matches!(f.classification, Classification::Violation { .. }), - "Logic inside async block should be ignored in lenient mode, got {:?}", - f.classification - ); -} - -// --------------------------------------------------------------- -// G1: Complexity Metrics Tests -// --------------------------------------------------------------- - -#[test] -fn test_complexity_metrics_present() { - let code = r#" - fn f(x: i32) { - let _y = x; - if x > 0 { - if x > 10 { - let _ = x + 1; - } - } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "f").unwrap(); - let metrics = f - .complexity - .as_ref() - .expect("Should have complexity metrics"); - assert!(metrics.logic_count > 0, "Should have logic count"); - assert!(metrics.max_nesting > 0, "Should have nesting depth"); -} - -#[test] -fn test_complexity_nesting_depth() { - let code = r#" - fn f(x: i32) { - let _y = x; - if x > 0 { - if x > 10 { - while x > 100 { - break; - } - } - } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "f").unwrap(); - let metrics = f.complexity.as_ref().unwrap(); - assert_eq!( - metrics.max_nesting, 3, - "Expected nesting depth 3 (if > if > while)" - ); -} - -// --------------------------------------------------------------- -// C2: Severity Tests -// --------------------------------------------------------------- - -#[test] -fn test_severity_low() { - let code = r#" - fn helper(x: bool) { if x { f(false); } } - fn f(x: bool) { - let _y = x; - if x { helper(true); } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert_eq!(f.severity, Some(Severity::Low)); -} - -#[test] -fn test_severity_none_for_non_violation() { - let code = r#" - fn f(x: i32) { - let _y = x; - if x > 0 { } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert_eq!(f.severity, None); -} - -// --------------------------------------------------------------- -// Suppression Tests -// --------------------------------------------------------------- - -#[test] -fn test_suppressed_flag_default_false() { - let code = r#" - fn f() {} - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert!(!f.suppressed); -} - -// --------------------------------------------------------------- -// D1/D7: qualified_name + severity fields -// --------------------------------------------------------------- - -#[test] -fn test_qualified_name_free_fn() { - let code = r#" - fn my_function() {} - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "my_function").unwrap(); - assert_eq!(f.qualified_name, "my_function"); -} - -#[test] -fn test_qualified_name_impl_method() { - let code = r#" - struct Foo; - impl Foo { - fn bar(&self) {} - } - "#; - let results = parse_and_analyze(code); - let bar = results.iter().find(|r| r.name == "bar").unwrap(); - assert_eq!(bar.qualified_name, "Foo::bar"); -} - -// --------------------------------------------------------------- -// Bug Fix: Trivial Self-Getter Not Violation -// --------------------------------------------------------------- - -#[test] -fn test_trivial_self_getter_not_violation() { - let code = r#" - struct Counter { count: usize } - impl Counter { - fn symbol_count(&self) -> usize { self.count } - fn next_symbol(&self) -> usize { - if self.symbol_count() > 0 { - self.symbol_count() + 1 - } else { - 0 - } - } - } - "#; - let results = parse_and_analyze(code); - let next = results.iter().find(|r| r.name == "next_symbol").unwrap(); - assert_eq!( - next.classification, - Classification::Operation, - "Trivial getter should not make next_symbol a Violation, got {:?}", - next.classification - ); -} - -// --------------------------------------------------------------- -// Bug Fix: Type::new() Not Own Call -// --------------------------------------------------------------- - -#[test] -fn test_leaf_constructor_call_is_operation() { - // Adx::new() is Trivial (leaf). Calling a leaf + logic = Operation. - let code = r#" - struct Adx { period: usize } - impl Adx { - fn new(period: usize) -> Self { Adx { period } } - } - fn compute(data: &[f64]) -> f64 { - let indicator = Adx::new(14); - if data.is_empty() { 0.0 } else { data[0] } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "compute").unwrap(); - assert!( - matches!(f.classification, Classification::Operation), - "Adx::new() is leaf → calling it + logic = Operation, got {:?}", - f.classification - ); -} - -// --------------------------------------------------------------- -// Bug Fix: Trivial .get() Getter Not Violation -// --------------------------------------------------------------- - -#[test] -fn test_trivial_getter_get_not_violation() { - let code = r#" - struct Browser { results: Vec, selected: usize } - impl Browser { - fn current(&self) -> Option<&String> { self.results.get(self.selected) } - fn process(&self) -> String { - if let Some(item) = self.current() { - item.clone() - } else { - String::new() - } - } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "process").unwrap(); - assert_eq!( - f.classification, - Classification::Operation, - "Trivial .get() getter should not make process a Violation, got {:?}", - f.classification - ); -} - -// --------------------------------------------------------------- -// Bug Fix: For-Loop Delegation Not Violation -// --------------------------------------------------------------- - -#[test] -fn test_for_loop_delegation_not_violation() { - let code = r#" - fn process(_x: i32) {} - fn f(items: Vec) { - for x in items { - process(x); - } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "f").unwrap(); - assert_eq!( - f.classification, - Classification::Integration, - "For-loop delegation should be Integration, got {:?}", - f.classification - ); -} - -// --------------------------------------------------------------- -// Bug Fix: Match-Dispatch Delegation Not Violation -// --------------------------------------------------------------- - -#[test] -fn test_match_dispatch_is_integration() { - let code = r#" - fn call_a() {} - fn call_b() {} - fn dispatch(x: i32) { - match x { - 0 => call_a(), - _ => call_b(), - } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "dispatch").unwrap(); - assert_eq!( - f.classification, - Classification::Integration, - "Match dispatch should be Integration, got {:?}", - f.classification - ); -} - -#[test] -fn test_match_dispatch_method_is_integration() { - let code = r#" - struct S; - impl S { - fn run_a(&self) {} - fn run_b(&self) {} - fn dispatch(&self, x: i32) { - match x { - 0 => self.run_a(), - _ => self.run_b(), - } - } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "dispatch").unwrap(); - assert_eq!( - f.classification, - Classification::Integration, - "Match method dispatch should be Integration, got {:?}", - f.classification - ); -} - -#[test] -fn test_match_with_logic_in_arm_is_violation() { - let code = r#" - fn call_a(_x: i32) { if _x > 0 { dispatch(_x - 1); } } - fn call_b() { dispatch(0); } - fn dispatch(x: i32) { - match x { - 0 => call_a(x + 1), - _ => call_b(), - } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "dispatch").unwrap(); - assert!( - matches!(f.classification, Classification::Violation { .. }), - "Match with logic in arm should be Violation, got {:?}", - f.classification - ); -} - -#[test] -fn test_match_with_guard_is_violation() { - let code = r#" - fn call_a() { if true { dispatch(0); } } - fn call_b() { dispatch(1); } - fn dispatch(x: i32) { - match x { - n if n > 0 => call_a(), - _ => call_b(), - } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "dispatch").unwrap(); - assert!( - matches!(f.classification, Classification::Violation { .. }), - "Match with guard should be Violation, got {:?}", - f.classification - ); -} - -#[test] -fn test_match_dispatch_complexity_still_tracked() { - let code = r#" - fn call_a() {} - fn call_b() {} - fn dispatch(x: i32) { - match x { - 0 => call_a(), - _ => call_b(), - } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|r| r.name == "dispatch").unwrap(); - assert_eq!( - f.classification, - Classification::Integration, - "Match dispatch should be Integration, got {:?}", - f.classification - ); - assert!( - f.complexity.as_ref().unwrap().cognitive_complexity >= 1, - "Complexity should still be tracked for dispatch match" - ); -} - -// --------------------------------------------------------------- -// is_test detection tests -// --------------------------------------------------------------- - -#[test] -fn test_fn_with_test_attr_is_test() { - let code = r#" - fn helper() {} - #[test] - fn my_test() { - helper(); - if true {} - } - "#; - let results = parse_and_analyze(code); - let test_fn = results.iter().find(|f| f.name == "my_test").unwrap(); - assert!( - test_fn.is_test, - "Function with #[test] should have is_test=true" - ); -} - -#[test] -fn test_fn_inside_cfg_test_mod_is_test() { - let code = r#" - fn production_fn() {} - #[cfg(test)] - mod tests { - fn test_helper() {} - } - "#; - let results = parse_and_analyze(code); - let prod = results.iter().find(|f| f.name == "production_fn").unwrap(); - assert!( - !prod.is_test, - "Production function should have is_test=false" - ); - let helper = results.iter().find(|f| f.name == "test_helper").unwrap(); - assert!( - helper.is_test, - "Function inside #[cfg(test)] mod should have is_test=true" - ); -} - -#[test] -fn test_regular_fn_not_test() { - let code = r#" - fn regular() { if true {} } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|f| f.name == "regular").unwrap(); - assert!(!f.is_test, "Regular function should have is_test=false"); -} - -#[test] -fn test_cfg_test_impl_methods_are_test() { - let code = r#" - pub struct Config { pub name: String } - - impl Config { - pub fn new(name: String) -> Self { Self { name } } - } - - #[cfg(test)] - impl Config { - fn test_helper(&self) -> bool { true } - pub fn another_helper() -> i32 { if true { 1 } else { 2 } } - } - "#; - let results = parse_and_analyze(code); - let helper = results.iter().find(|f| f.name == "test_helper").unwrap(); - assert!( - helper.is_test, - "Method inside #[cfg(test)] impl should have is_test=true" - ); - let another = results.iter().find(|f| f.name == "another_helper").unwrap(); - assert!( - another.is_test, - "Pub method inside #[cfg(test)] impl should have is_test=true" - ); - // Regular impl method should NOT be test - let new_fn = results.iter().find(|f| f.name == "new").unwrap(); - assert!( - !new_fn.is_test, - "Method in regular impl should have is_test=false" - ); -} - -// --------------------------------------------------------------- -// Bug 2: Method-call type resolution tests -// --------------------------------------------------------------- - -#[test] -fn test_method_on_non_project_type_not_own_call() { - // Cache defines .clear(), but reset_name calls .clear() on a String parameter. - // String::clear is NOT an own call — different type. - let code = r#" - struct Cache { data: Vec } - impl Cache { - fn clear(&mut self) { - self.data = Vec::new(); - } - } - fn reset_name(name: &mut String) { - if name.is_empty() { return; } - name.clear(); - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|f| f.name == "reset_name").unwrap(); - assert!( - matches!(f.classification, Classification::Operation), - "name.clear() is String::clear, not Cache::clear — should be Operation, got {:?}", - f.classification - ); -} - -#[test] -fn test_self_method_call_is_own_call() { - // self.process() IS an own call — it's on the same type - let code = r#" - struct Engine; - impl Engine { - fn process(&self) -> i32 { 42 } - fn run(&self) { - self.process(); - } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|f| f.name == "run").unwrap(); - assert!( - matches!(f.classification, Classification::Integration), - "self.process() is own call — should be Integration, got {:?}", - f.classification - ); -} - -#[test] -fn test_method_on_param_project_type_is_own_call() { - // db.query() where db is a project type parameter — IS an own call - let code = r#" - struct Database; - impl Database { - fn query(&self) -> Vec { vec![] } - } - fn fetch(db: &Database) { - db.query(); - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|f| f.name == "fetch").unwrap(); - assert!( - matches!(f.classification, Classification::Integration), - "db.query() on project type param — should be Integration, got {:?}", - f.classification - ); -} - -#[test] -fn test_method_name_collision_resolved_by_type() { - // Both Formatter and Vec have "push". Formatter::push is own, - // but v.push() on a Vec parameter should NOT be an own call. - let code = r#" - struct Formatter { parts: Vec } - impl Formatter { - fn push(&mut self, s: String) { - self.parts.push(s); - } - } - fn collect_items(v: &mut Vec) { - if v.is_empty() { return; } - v.push("done".to_string()); - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|f| f.name == "collect_items").unwrap(); - assert!( - matches!(f.classification, Classification::Operation), - "v.push() on Vec param — not an own call, should be Operation, got {:?}", - f.classification - ); -} - -// --------------------------------------------------------------- -// Automatic leaf detection tests -// --------------------------------------------------------------- - -#[test] -fn test_leaf_call_not_counted_as_own_call() { - // get_config is a leaf (C=0, Operation). - // cmd_quality calls get_config + has logic → should be Operation (leaf calls don't count). - let code = r#" - fn get_config() -> i32 { - if true { 1 } else { 2 } - } - fn cmd_quality(clear: bool) -> i32 { - let config = get_config(); - if clear { config + 1 } else { config } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|f| f.name == "cmd_quality").unwrap(); - assert!( - matches!(f.classification, Classification::Operation), - "Calling a leaf (get_config) + logic should be Operation, got {:?}", - f.classification - ); -} - -#[test] -fn test_non_leaf_call_still_violation() { - // bad_a and bad_b form a cycle — both are Violations that can't be reclassified. - // caller has logic + calls bad_a → stays Violation. - let code = r#" - fn bad_a(x: bool) -> i32 { - if x { bad_b(false) } else { 0 } - } - fn bad_b(x: bool) -> i32 { - if x { bad_a(true) } else { 1 } - } - fn caller(x: bool) -> i32 { - if x { bad_a(true) } else { 0 } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|f| f.name == "caller").unwrap(); - assert!( - matches!(f.classification, Classification::Violation { .. }), - "Calling a non-leaf (orchestrator) + logic should be Violation, got {:?}", - f.classification - ); -} - -#[test] -fn test_multiple_leaf_calls_still_operation() { - // Both helpers are leaves (C=0). Calling multiple leaves + logic → Operation. - let code = r#" - fn validate(s: &str) -> bool { s.len() > 3 } - fn normalize(s: &str) -> String { s.to_lowercase() } - fn process(input: &str) -> Option { - if validate(input) { - Some(normalize(input)) - } else { - None - } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|f| f.name == "process").unwrap(); - assert!( - matches!(f.classification, Classification::Operation), - "Calling only leaves + logic should be Operation, got {:?}", - f.classification - ); -} - -#[test] -fn test_pure_integration_unchanged() { - // Integration (only calls, no logic) stays Integration — unaffected by leaf detection. - let code = r#" - fn step_a() {} - fn step_b() {} - fn pipeline() { - step_a(); - step_b(); - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|f| f.name == "pipeline").unwrap(); - assert!( - matches!(f.classification, Classification::Integration), - "Pure Integration should stay Integration, got {:?}", - f.classification - ); -} - -#[test] -fn test_cascading_leaf_detection() { - // step_a and step_b are leaves (C=0). - // middle calls only leaves → after leaf detection, middle is Operation → also a leaf. - // top calls middle + has logic → should be Operation (middle is transitively a leaf). - let code = r#" - fn step_a() -> i32 { if true { 1 } else { 0 } } - fn step_b() -> i32 { 42 } - fn middle() -> i32 { - if step_a() > 0 { step_b() } else { 0 } - } - fn top(x: bool) -> i32 { - if x { middle() } else { -1 } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|f| f.name == "top").unwrap(); - assert!( - matches!(f.classification, Classification::Operation), - "Cascading leaf: top calls middle (which calls only leaves) should be Operation, got {:?}", - f.classification - ); -} - -// --------------------------------------------------------------- -// qual:recursive annotation tests -// --------------------------------------------------------------- - -#[test] -fn test_recursive_annotation_makes_self_call_safe() { - let code = r#" - // qual:recursive - fn traverse(node: &str) -> i32 { - if node.is_empty() { return 0; } - traverse(node) - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|f| f.name == "traverse").unwrap(); - assert!( - matches!(f.classification, Classification::Operation), - "qual:recursive should make self-call safe → Operation, got {:?}", - f.classification - ); -} - -#[test] -fn test_recursive_without_annotation_is_violation() { - let code = r#" - fn inner() {} - fn traverse(node: &str) -> i32 { - if node.is_empty() { return 0; } - inner(); - traverse(node) - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|f| f.name == "traverse").unwrap(); - assert!( - matches!(f.classification, Classification::Violation { .. }), - "Without annotation, recursive + non-leaf call + logic = Violation, got {:?}", - f.classification - ); -} - -// --------------------------------------------------------------- -// Integration-as-safe-target tests -// --------------------------------------------------------------- - -#[test] -fn test_call_to_integration_is_safe() { - let code = r#" - fn log_action() {} - fn db_save() { log_action(); } - fn handler(x: bool) -> i32 { - if x { db_save(); 1 } else { 0 } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|f| f.name == "handler").unwrap(); - assert!( - matches!(f.classification, Classification::Operation), - "Call to Integration (L=0, C>0) + logic should be Operation, got {:?}", - f.classification - ); -} - -#[test] -fn test_call_to_violation_stays_violation() { - let code = r#" - fn bad_a(x: bool) -> i32 { - if x { bad_b(false) } else { 0 } - } - fn bad_b(x: bool) -> i32 { - if x { bad_a(true) } else { 1 } - } - fn caller(y: bool) -> i32 { - if y { bad_a(true) } else { -1 } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|f| f.name == "caller").unwrap(); - assert!( - matches!(f.classification, Classification::Violation { .. }), - "Call to mutually-recursive Violation + logic should stay Violation, got {:?}", - f.classification - ); -} - -#[test] -fn test_mixed_leaf_and_integration_calls_safe() { - let code = r#" - fn log_it() {} - fn get_config() -> i32 { if true { 1 } else { 2 } } - fn db_fetch() -> i32 { log_it(); 42 } - fn process(x: bool) -> i32 { - let cfg = get_config(); - if x { db_fetch() + cfg } else { cfg } - } - "#; - let results = parse_and_analyze(code); - let f = results.iter().find(|f| f.name == "process").unwrap(); - assert!( - matches!(f.classification, Classification::Operation), - "Calls to leaf + integration + logic should be Operation, got {:?}", - f.classification - ); -} diff --git a/src/adapters/analyzers/iosp/tests/root/classification_exact.rs b/src/adapters/analyzers/iosp/tests/root/classification_exact.rs new file mode 100644 index 00000000..fa633615 --- /dev/null +++ b/src/adapters/analyzers/iosp/tests/root/classification_exact.rs @@ -0,0 +1,133 @@ +use super::*; + +const CLASSIFICATION_EXACT_CASES: &[(&str, &str, &str, Classification)] = &[ + ( + "pure integration (two own free-fn calls)", + r#" + fn helper_a() {} + fn helper_b() {} + fn integrator() { + helper_a(); + helper_b(); + } + "#, + "integrator", + Classification::Integration, + ), + ( + "pure operation (branching logic, no own calls)", + r#" + fn operation(x: i32) -> &'static str { + let _y = x; + if _y > 0 { + "positive" + } else { + "non-positive" + } + } + "#, + "operation", + Classification::Operation, + ), + ( + "trivial empty body", + "fn f() {}", + "f", + Classification::Trivial, + ), + ( + "trivial single return", + "fn f() -> i32 { 42 }", + "f", + Classification::Trivial, + ), + ( + "trivial getter", + r#" + struct Foo { x: i32 } + impl Foo { + fn get_x(&self) -> i32 { self.x } + } + "#, + "get_x", + Classification::Trivial, + ), + ( + "single statement with own call → integration", + r#" + fn helper() {} + fn f() { helper() } + "#, + "f", + Classification::Integration, + ), + ( + "single statement with logic → operation", + "fn f(x: i32) -> i32 { if x > 0 { 1 } else { 0 } }", + "f", + Classification::Operation, + ), + ( + "self-method calls → integration", + r#" + struct MyStruct; + impl MyStruct { + fn do_work(&self) {} + fn orchestrate(&self) { + self.do_work(); + self.do_work(); + } + } + "#, + "orchestrate", + Classification::Integration, + ), + ( + "external method calls → operation", + r#" + fn operation_fn() { + let mut v = Vec::new(); + if v.is_empty() { + v.push(1); + } + } + "#, + "operation_fn", + Classification::Operation, + ), + ( + "own free-fn calls → integration", + r#" + fn step_a() {} + fn step_b() {} + fn orchestrate() { + step_a(); + step_b(); + } + "#, + "orchestrate", + Classification::Integration, + ), + ( + "same-type path ctor calls → integration", + r#" + struct MyType; + impl MyType { + fn create() -> Self { MyType } + } + fn f() { + let _a = MyType::create(); + let _b = MyType::create(); + } + "#, + "f", + Classification::Integration, + ), +]; + +#[test] +fn classification_exact() { + for (label, code, fn_name, expected) in CLASSIFICATION_EXACT_CASES { + assert_eq!(&classify(code, fn_name), expected, "case {label}"); + } +} diff --git a/src/adapters/analyzers/iosp/tests/root/classification_predicate.rs b/src/adapters/analyzers/iosp/tests/root/classification_predicate.rs new file mode 100644 index 00000000..51468f20 --- /dev/null +++ b/src/adapters/analyzers/iosp/tests/root/classification_predicate.rs @@ -0,0 +1,160 @@ +use super::*; + +type Pred = fn(&Classification) -> bool; +const NOT_VIOLATION: Pred = |c| !matches!(c, Classification::Violation { .. }); + +// Closures and iterator chains don't count as logic/own-calls in lenient +// (default) mode, so a fn whose only logic/calls live inside them is not a +// Violation; `strict_closures` / `strict_iterator_chains` flip that. A genuine +// logic+own-call mix is always a Violation; stdlib path ctors (String::new) +// never make an integration. +// (label, code, fn_name, strict_closures, strict_iterators, predicate) +const PREDICATE_CASES: &[(&str, &str, &str, bool, bool, Pred)] = &[ + ( + "logic+own-call mix is a violation", + r#" + fn helper(x: i32) { if x > 0 { violator(x); } } + fn violator(x: i32) { + let _y = x; + if _y > 0 { + helper(_y); + } + } + "#, + "violator", + false, + false, + |c| matches!(c, Classification::Violation { .. }), + ), + ( + "lenient: logic inside a closure is ignored", + r#" + fn f() { + let v = vec![1, 2, 3]; + let _: Vec<_> = v.into_iter().collect(); + let _ = (|| { if true { 1 } else { 2 } })(); + } + "#, + "f", + false, + false, + NOT_VIOLATION, + ), + ( + "strict closures: logic inside a closure counts", + r#" + fn f() { + let v = vec![1, 2, 3]; + let _ = (|| { if true { 1 } else { 2 } })(); + let _ = v.len(); + } + "#, + "f", + true, + false, + |c| { + matches!( + c, + Classification::Operation | Classification::Violation { .. } + ) + }, + ), + ( + "lenient: own call inside a closure is ignored", + r#" + fn helper() {} + fn f() { + let c = || { helper(); }; + c(); + let _ = 1; + } + "#, + "f", + false, + false, + NOT_VIOLATION, + ), + ( + "strict closures: own call inside a closure counts", + r#" + fn helper() {} + fn f() { + let c = || { helper(); }; + c(); + let _ = 1; + } + "#, + "f", + true, + false, + |c| { + matches!( + c, + Classification::Integration | Classification::Violation { .. } + ) + }, + ), + ( + "lenient: iterator methods are not own calls", + r#" + fn f() -> Vec { + let v = vec![1, 2, 3]; + v.iter().map(|x| x + 1).collect() + } + "#, + "f", + false, + false, + NOT_VIOLATION, + ), + ( + "strict iterators: in-scope iterator methods count", + r#" + struct Foo; + impl Foo { + fn map(&self) {} + } + fn f() -> Vec { + let v = vec![1, 2, 3]; + let x = v.iter().map(|x| x + 1).collect::>(); + x + } + "#, + "f", + false, + true, + |c| { + matches!( + c, + Classification::Integration | Classification::Violation { .. } + ) + }, + ), + ( + "stdlib path ctor is not an own call", + r#" + fn f() { + let _a = String::new(); + let _b = String::new(); + } + "#, + "f", + false, + false, + |c| !matches!(c, Classification::Integration), + ), +]; + +#[test] +fn classification_predicate_lenient_vs_strict() { + for (label, code, fn_name, strict_closures, strict_iterators, predicate) in PREDICATE_CASES { + let mut config = Config::default(); + config.strict_closures = *strict_closures; + config.strict_iterator_chains = *strict_iterators; + let classification = classify_cfg(code, fn_name, &config); + assert!( + predicate(&classification), + "case {label}: unexpected {classification:?}" + ); + } +} diff --git a/src/adapters/analyzers/iosp/tests/root/classify_basics.rs b/src/adapters/analyzers/iosp/tests/root/classify_basics.rs new file mode 100644 index 00000000..f0b5ddcf --- /dev/null +++ b/src/adapters/analyzers/iosp/tests/root/classify_basics.rs @@ -0,0 +1,213 @@ +use super::*; + +#[test] +fn test_violation_locations() { + let code = r#"fn helper(x: i32) { if x > 0 { violator(x); } } +fn violator(x: i32) { +let _y = x; +if _y > 0 { + helper(_y); +} +} +"#; + let results = parse_and_analyze(code); + let v = results.iter().find(|r| r.name == "violator").unwrap(); + if let Classification::Violation { + logic_locations, + call_locations, + .. + } = &v.classification + { + assert!( + logic_locations + .iter() + .any(|l| l.kind == "if" && l.line == 4), + "Expected 'if' on line 4, got: {:?}", + logic_locations + ); + assert!( + call_locations + .iter() + .any(|c| c.name == "helper" && c.line == 5), + "Expected 'helper' call on line 5, got: {:?}", + call_locations + ); + } else { + panic!("Expected Violation, got {:?}", v.classification); + } +} + +// --------------------------------------------------------------- +// Structure Tests +// --------------------------------------------------------------- + +#[test] +fn test_impl_block_parent_type() { + let code = r#" + struct Foo; + impl Foo { + fn bar(&self) {} + } + "#; + let results = parse_and_analyze(code); + let bar = results.iter().find(|r| r.name == "bar").unwrap(); + assert_eq!(bar.parent_type, Some("Foo".to_string())); +} + +#[test] +fn test_trait_default_impl() { + let code = r#" + fn step() {} + trait MyTrait { + fn default_method(&self) { + step(); + step(); + } + } + "#; + let results = parse_and_analyze(code); + let dm = results.iter().find(|r| r.name == "default_method").unwrap(); + assert_eq!(dm.classification, Classification::Integration); + assert_eq!(dm.parent_type, Some("MyTrait".to_string())); +} + +#[test] +fn test_ignored_function_skipped() { + let mut config = Config::default(); + config.ignore_functions.push("test_*".to_string()); + let code = r#" + fn test_something() { + if true { } + } + fn real_function() -> i32 { 42 } + "#; + let results = parse_and_analyze_with_config(code, &config); + assert!( + results.iter().all(|r| r.name != "test_something"), + "Ignored function should not appear in results" + ); + assert!( + results.iter().any(|r| r.name == "real_function"), + "Non-ignored function should appear in results" + ); +} + +#[test] +fn test_nested_module() { + let code = r#" + mod inner { + fn nested_fn() -> i32 { 42 } + } + "#; + let results = parse_and_analyze(code); + let nested = results.iter().find(|r| r.name == "nested_fn").unwrap(); + assert_eq!(nested.classification, Classification::Trivial); +} + +// --------------------------------------------------------------- +// A2: Recursion Tests +// --------------------------------------------------------------- + +#[test] +fn test_recursion_default_is_violation() { + let code = r#" + fn fib(n: u32) -> u32 { + let _x = n; + if n <= 1 { n } else { fib(n - 1) + fib(n - 2) } + } + "#; + let results = parse_and_analyze(code); + let fib = results.iter().find(|r| r.name == "fib").unwrap(); + assert!( + matches!(fib.classification, Classification::Violation { .. }), + "Recursive function should be Violation by default, got {:?}", + fib.classification + ); +} + +#[test] +fn test_recursion_allowed_becomes_operation() { + let mut config = Config::default(); + config.allow_recursion = true; + let code = r#" + fn fib(n: u32) -> u32 { + let _x = n; + if n <= 1 { n } else { fib(n - 1) + fib(n - 2) } + } + "#; + let results = parse_and_analyze_with_config(code, &config); + let fib = results.iter().find(|r| r.name == "fib").unwrap(); + assert_eq!( + fib.classification, + Classification::Operation, + "Recursive function with allow_recursion should be Operation, got {:?}", + fib.classification + ); +} + +// --------------------------------------------------------------- +// A3: Error Propagation Tests +// --------------------------------------------------------------- + +#[test] +fn test_question_mark_default_not_logic() { + let code = r#" + fn f() -> Result<(), String> { + let _x = 1; + let _y: Result = Ok(1); + Ok(()) + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|r| r.name == "f").unwrap(); + assert!( + !matches!(f.classification, Classification::Violation { .. }), + "? operator should not count as logic by default" + ); +} + +#[test] +fn test_question_mark_strict_counts_as_logic() { + let mut config = Config::default(); + config.strict_error_propagation = true; + let code = r#" + fn helper() -> Result { Ok(42) } + fn f() -> Result<(), String> { + let _x = helper()?; + let _ = 1; + Ok(()) + } + "#; + let results = parse_and_analyze_with_config(code, &config); + let f = results.iter().find(|r| r.name == "f").unwrap(); + assert!( + matches!(f.classification, Classification::Violation { .. }), + "? operator should count as logic with strict_error_propagation, got {:?}", + f.classification + ); +} + +// --------------------------------------------------------------- +// A4: Async/Await Tests +// --------------------------------------------------------------- + +#[test] +fn test_async_block_lenient_ignores_logic() { + let code = r#" + fn f() { + let _ = async { if true { 1 } else { 2 } }; + let _ = 1; + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|r| r.name == "f").unwrap(); + assert!( + !matches!(f.classification, Classification::Violation { .. }), + "Logic inside async block should be ignored in lenient mode, got {:?}", + f.classification + ); +} + +// --------------------------------------------------------------- +// G1: Complexity Metrics Tests +// --------------------------------------------------------------- diff --git a/src/adapters/analyzers/iosp/tests/root/complexity_and_metadata.rs b/src/adapters/analyzers/iosp/tests/root/complexity_and_metadata.rs new file mode 100644 index 00000000..e2fa9d44 --- /dev/null +++ b/src/adapters/analyzers/iosp/tests/root/complexity_and_metadata.rs @@ -0,0 +1,122 @@ +use super::*; + +#[test] +fn test_complexity_metrics_present() { + let code = r#" + fn f(x: i32) { + let _y = x; + if x > 0 { + if x > 10 { + let _ = x + 1; + } + } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|r| r.name == "f").unwrap(); + let metrics = f + .complexity + .as_ref() + .expect("Should have complexity metrics"); + assert!(metrics.logic_count > 0, "Should have logic count"); + assert!(metrics.max_nesting > 0, "Should have nesting depth"); +} + +#[test] +fn test_complexity_nesting_depth() { + let code = r#" + fn f(x: i32) { + let _y = x; + if x > 0 { + if x > 10 { + while x > 100 { + break; + } + } + } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|r| r.name == "f").unwrap(); + let metrics = f.complexity.as_ref().unwrap(); + assert_eq!( + metrics.max_nesting, 3, + "Expected nesting depth 3 (if > if > while)" + ); +} + +// --------------------------------------------------------------- +// C2: Severity Tests +// --------------------------------------------------------------- + +#[test] +fn test_severity_low() { + let code = r#" + fn helper(x: bool) { if x { f(false); } } + fn f(x: bool) { + let _y = x; + if x { helper(true); } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|r| r.name == "f").unwrap(); + assert_eq!(f.severity, Some(Severity::Low)); +} + +#[test] +fn test_severity_none_for_non_violation() { + let code = r#" + fn f(x: i32) { + let _y = x; + if x > 0 { } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|r| r.name == "f").unwrap(); + assert_eq!(f.severity, None); +} + +// --------------------------------------------------------------- +// Suppression Tests +// --------------------------------------------------------------- + +#[test] +fn test_suppressed_flag_default_false() { + let code = r#" + fn f() {} + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|r| r.name == "f").unwrap(); + assert!(!f.suppressed); +} + +// --------------------------------------------------------------- +// D1/D7: qualified_name + severity fields +// --------------------------------------------------------------- + +#[test] +fn test_qualified_name_free_fn() { + let code = r#" + fn my_function() {} + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|r| r.name == "my_function").unwrap(); + assert_eq!(f.qualified_name, "my_function"); +} + +#[test] +fn test_qualified_name_impl_method() { + let code = r#" + struct Foo; + impl Foo { + fn bar(&self) {} + } + "#; + let results = parse_and_analyze(code); + let bar = results.iter().find(|r| r.name == "bar").unwrap(); + assert_eq!(bar.qualified_name, "Foo::bar"); +} + +// --------------------------------------------------------------- +// Bug Fix: Trivial Self-Getter Not Violation +// --------------------------------------------------------------- diff --git a/src/adapters/analyzers/iosp/tests/root/dispatch_and_getters.rs b/src/adapters/analyzers/iosp/tests/root/dispatch_and_getters.rs new file mode 100644 index 00000000..6e89eae9 --- /dev/null +++ b/src/adapters/analyzers/iosp/tests/root/dispatch_and_getters.rs @@ -0,0 +1,228 @@ +use super::*; + +#[test] +fn test_trivial_self_getter_not_violation() { + let code = r#" + struct Counter { count: usize } + impl Counter { + fn symbol_count(&self) -> usize { self.count } + fn next_symbol(&self) -> usize { + if self.symbol_count() > 0 { + self.symbol_count() + 1 + } else { + 0 + } + } + } + "#; + let results = parse_and_analyze(code); + let next = results.iter().find(|r| r.name == "next_symbol").unwrap(); + assert_eq!( + next.classification, + Classification::Operation, + "Trivial getter should not make next_symbol a Violation, got {:?}", + next.classification + ); +} + +// --------------------------------------------------------------- +// Bug Fix: Type::new() Not Own Call +// --------------------------------------------------------------- + +#[test] +fn test_leaf_constructor_call_is_operation() { + // Adx::new() is Trivial (leaf). Calling a leaf + logic = Operation. + let code = r#" + struct Adx { period: usize } + impl Adx { + fn new(period: usize) -> Self { Adx { period } } + } + fn compute(data: &[f64]) -> f64 { + let indicator = Adx::new(14); + if data.is_empty() { 0.0 } else { data[0] } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|r| r.name == "compute").unwrap(); + assert!( + matches!(f.classification, Classification::Operation), + "Adx::new() is leaf → calling it + logic = Operation, got {:?}", + f.classification + ); +} + +// --------------------------------------------------------------- +// Bug Fix: Trivial .get() Getter Not Violation +// --------------------------------------------------------------- + +#[test] +fn test_trivial_getter_get_not_violation() { + let code = r#" + struct Browser { results: Vec, selected: usize } + impl Browser { + fn current(&self) -> Option<&String> { self.results.get(self.selected) } + fn process(&self) -> String { + if let Some(item) = self.current() { + item.clone() + } else { + String::new() + } + } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|r| r.name == "process").unwrap(); + assert_eq!( + f.classification, + Classification::Operation, + "Trivial .get() getter should not make process a Violation, got {:?}", + f.classification + ); +} + +// --------------------------------------------------------------- +// Bug Fix: For-Loop Delegation Not Violation +// --------------------------------------------------------------- + +#[test] +fn test_for_loop_delegation_not_violation() { + let code = r#" + fn process(_x: i32) {} + fn f(items: Vec) { + for x in items { + process(x); + } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|r| r.name == "f").unwrap(); + assert_eq!( + f.classification, + Classification::Integration, + "For-loop delegation should be Integration, got {:?}", + f.classification + ); +} + +// --------------------------------------------------------------- +// Bug Fix: Match-Dispatch Delegation Not Violation +// --------------------------------------------------------------- + +#[test] +fn test_match_dispatch_is_integration() { + let code = r#" + fn call_a() {} + fn call_b() {} + fn dispatch(x: i32) { + match x { + 0 => call_a(), + _ => call_b(), + } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|r| r.name == "dispatch").unwrap(); + assert_eq!( + f.classification, + Classification::Integration, + "Match dispatch should be Integration, got {:?}", + f.classification + ); +} + +#[test] +fn test_match_dispatch_method_is_integration() { + let code = r#" + struct S; + impl S { + fn run_a(&self) {} + fn run_b(&self) {} + fn dispatch(&self, x: i32) { + match x { + 0 => self.run_a(), + _ => self.run_b(), + } + } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|r| r.name == "dispatch").unwrap(); + assert_eq!( + f.classification, + Classification::Integration, + "Match method dispatch should be Integration, got {:?}", + f.classification + ); +} + +#[test] +fn test_match_with_logic_in_arm_is_violation() { + let code = r#" + fn call_a(_x: i32) { if _x > 0 { dispatch(_x - 1); } } + fn call_b() { dispatch(0); } + fn dispatch(x: i32) { + match x { + 0 => call_a(x + 1), + _ => call_b(), + } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|r| r.name == "dispatch").unwrap(); + assert!( + matches!(f.classification, Classification::Violation { .. }), + "Match with logic in arm should be Violation, got {:?}", + f.classification + ); +} + +#[test] +fn test_match_with_guard_is_violation() { + let code = r#" + fn call_a() { if true { dispatch(0); } } + fn call_b() { dispatch(1); } + fn dispatch(x: i32) { + match x { + n if n > 0 => call_a(), + _ => call_b(), + } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|r| r.name == "dispatch").unwrap(); + assert!( + matches!(f.classification, Classification::Violation { .. }), + "Match with guard should be Violation, got {:?}", + f.classification + ); +} + +#[test] +fn test_match_dispatch_complexity_still_tracked() { + let code = r#" + fn call_a() {} + fn call_b() {} + fn dispatch(x: i32) { + match x { + 0 => call_a(), + _ => call_b(), + } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|r| r.name == "dispatch").unwrap(); + assert_eq!( + f.classification, + Classification::Integration, + "Match dispatch should be Integration, got {:?}", + f.classification + ); + assert!( + f.complexity.as_ref().unwrap().cognitive_complexity >= 1, + "Complexity should still be tracked for dispatch match" + ); +} + +// --------------------------------------------------------------- +// is_test detection tests +// --------------------------------------------------------------- diff --git a/src/adapters/analyzers/iosp/tests/root/is_test.rs b/src/adapters/analyzers/iosp/tests/root/is_test.rs new file mode 100644 index 00000000..6aa83064 --- /dev/null +++ b/src/adapters/analyzers/iosp/tests/root/is_test.rs @@ -0,0 +1,93 @@ +use super::*; + +#[test] +fn test_fn_with_test_attr_is_test() { + let code = r#" + fn helper() {} + #[test] + fn my_test() { + helper(); + if true {} + } + "#; + let results = parse_and_analyze(code); + let test_fn = results.iter().find(|f| f.name == "my_test").unwrap(); + assert!( + test_fn.is_test, + "Function with #[test] should have is_test=true" + ); +} + +// `is_test` marks fns inside `#[cfg(test)] mod` / `#[cfg(test)] impl` (and is +// false for production fns and regular impl methods alongside them). +// (label, code, fn_name, expected_is_test) +const CFG_TEST_MOD: &str = r#" + fn production_fn() {} + #[cfg(test)] + mod tests { + fn test_helper() {} + } + "#; +const CFG_TEST_IMPL: &str = r#" + pub struct Config { pub name: String } + + impl Config { + pub fn new(name: String) -> Self { Self { name } } + } + + #[cfg(test)] + impl Config { + fn test_helper(&self) -> bool { true } + pub fn another_helper() -> i32 { if true { 1 } else { 2 } } + } + "#; + +const IS_TEST_CASES: &[(&str, &str, &str, bool)] = &[ + ( + "production fn outside cfg(test)", + CFG_TEST_MOD, + "production_fn", + false, + ), + ( + "fn inside #[cfg(test)] mod", + CFG_TEST_MOD, + "test_helper", + true, + ), + ( + "plain regular fn", + "fn regular() { if true {} }", + "regular", + false, + ), + ( + "method inside #[cfg(test)] impl", + CFG_TEST_IMPL, + "test_helper", + true, + ), + ( + "pub method inside #[cfg(test)] impl", + CFG_TEST_IMPL, + "another_helper", + true, + ), + ( + "method in a regular impl alongside it", + CFG_TEST_IMPL, + "new", + false, + ), +]; + +#[test] +fn is_test_classification() { + for (label, code, fn_name, expected) in IS_TEST_CASES { + assert_eq!(is_test_of(code, fn_name), *expected, "case {label}"); + } +} + +// --------------------------------------------------------------- +// Bug 2: Method-call type resolution tests +// --------------------------------------------------------------- diff --git a/src/adapters/analyzers/iosp/tests/root/mod.rs b/src/adapters/analyzers/iosp/tests/root/mod.rs new file mode 100644 index 00000000..554206ee --- /dev/null +++ b/src/adapters/analyzers/iosp/tests/root/mod.rs @@ -0,0 +1,77 @@ +//! IOSP classification + own-call analysis tests, split into focused +//! sub-files (each ≤ the SRP file-length cap). Shared imports and the +//! parse/analyze/classify helpers live here and reach the sub-modules via +//! `use super::*`; per-test case tables live with their tests. + +pub(super) use crate::adapters::analyzers::iosp::scope::ProjectScope; +pub(super) use crate::adapters::analyzers::iosp::*; +pub(super) use crate::config::Config; + +mod classification_exact; +mod classification_predicate; +mod classify_basics; +mod complexity_and_metadata; +mod dispatch_and_getters; +mod is_test; +mod own_calls_a; +mod own_calls_b; + +/// Helper: parse code, build scope from it, analyze with default config. +pub(super) fn parse_and_analyze(code: &str) -> Vec { + let syntax = syn::parse_file(code).expect("Failed to parse test code"); + let scope_files = vec![("test.rs", &syntax)]; + let scope = ProjectScope::from_files(&scope_files); + let config = Config::default(); + let analyzer = Analyzer::new(&config, &scope); + let mut results = analyzer.analyze_file(&syntax, "test.rs"); + let parsed = vec![("test.rs".to_string(), code.to_string(), syntax)]; + let recursive_lines = crate::adapters::source::filesystem::collect_recursive_lines(&parsed); + crate::app::warnings::apply_recursive_annotations(&mut results, &recursive_lines); + crate::app::warnings::apply_leaf_reclassification(&mut results); + results +} + +/// Helper: parse code with a custom config. +pub(super) fn parse_and_analyze_with_config(code: &str, config: &Config) -> Vec { + let syntax = syn::parse_file(code).expect("Failed to parse test code"); + let scope_files = vec![("test.rs", &syntax)]; + let scope = ProjectScope::from_files(&scope_files); + let analyzer = Analyzer::new(config, &scope); + analyzer.analyze_file(&syntax, "test.rs") +} + +// --------------------------------------------------------------- +// Classification Tests +// --------------------------------------------------------------- + +/// Classify `fn_name` in `code` under the default config. +pub(super) fn classify(code: &str, fn_name: &str) -> Classification { + parse_and_analyze(code) + .into_iter() + .find(|r| r.name == fn_name) + .unwrap_or_else(|| panic!("fn {fn_name} not found")) + .classification +} + +/// Classify `fn_name` in `code` under a custom config. +pub(super) fn classify_cfg(code: &str, fn_name: &str, config: &Config) -> Classification { + parse_and_analyze_with_config(code, config) + .into_iter() + .find(|r| r.name == fn_name) + .unwrap_or_else(|| panic!("fn {fn_name} not found")) + .classification +} + +/// Whether `fn_name` in `code` is classified as test code (`is_test`). +pub(super) fn is_test_of(code: &str, fn_name: &str) -> bool { + parse_and_analyze(code) + .into_iter() + .find(|f| f.name == fn_name) + .unwrap_or_else(|| panic!("fn {fn_name} not found")) + .is_test +} + +// (label, code, fn_name, expected) — Integration = orchestrates own calls only; +// Operation = contains logic and no own calls; Trivial = empty / single-return / +// getter. Own calls include self-methods, free fns, and same-type path-ctors; +// stdlib method/path calls (Vec::is_empty, String::new) are NOT own calls. diff --git a/src/adapters/analyzers/iosp/tests/root/own_calls_a.rs b/src/adapters/analyzers/iosp/tests/root/own_calls_a.rs new file mode 100644 index 00000000..b2f03886 --- /dev/null +++ b/src/adapters/analyzers/iosp/tests/root/own_calls_a.rs @@ -0,0 +1,166 @@ +use super::*; + +#[test] +fn test_method_on_non_project_type_not_own_call() { + // Cache defines .clear(), but reset_name calls .clear() on a String parameter. + // String::clear is NOT an own call — different type. + let code = r#" + struct Cache { data: Vec } + impl Cache { + fn clear(&mut self) { + self.data = Vec::new(); + } + } + fn reset_name(name: &mut String) { + if name.is_empty() { return; } + name.clear(); + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|f| f.name == "reset_name").unwrap(); + assert!( + matches!(f.classification, Classification::Operation), + "name.clear() is String::clear, not Cache::clear — should be Operation, got {:?}", + f.classification + ); +} + +#[test] +fn test_self_method_call_is_own_call() { + // self.process() IS an own call — it's on the same type + let code = r#" + struct Engine; + impl Engine { + fn process(&self) -> i32 { 42 } + fn run(&self) { + self.process(); + } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|f| f.name == "run").unwrap(); + assert!( + matches!(f.classification, Classification::Integration), + "self.process() is own call — should be Integration, got {:?}", + f.classification + ); +} + +#[test] +fn test_method_on_param_project_type_is_own_call() { + // db.query() where db is a project type parameter — IS an own call + let code = r#" + struct Database; + impl Database { + fn query(&self) -> Vec { vec![] } + } + fn fetch(db: &Database) { + db.query(); + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|f| f.name == "fetch").unwrap(); + assert!( + matches!(f.classification, Classification::Integration), + "db.query() on project type param — should be Integration, got {:?}", + f.classification + ); +} + +#[test] +fn test_method_name_collision_resolved_by_type() { + // Both Formatter and Vec have "push". Formatter::push is own, + // but v.push() on a Vec parameter should NOT be an own call. + let code = r#" + struct Formatter { parts: Vec } + impl Formatter { + fn push(&mut self, s: String) { + self.parts.push(s); + } + } + fn collect_items(v: &mut Vec) { + if v.is_empty() { return; } + v.push("done".to_string()); + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|f| f.name == "collect_items").unwrap(); + assert!( + matches!(f.classification, Classification::Operation), + "v.push() on Vec param — not an own call, should be Operation, got {:?}", + f.classification + ); +} + +// --------------------------------------------------------------- +// Automatic leaf detection tests +// --------------------------------------------------------------- + +#[test] +fn test_leaf_call_not_counted_as_own_call() { + // get_config is a leaf (C=0, Operation). + // cmd_quality calls get_config + has logic → should be Operation (leaf calls don't count). + let code = r#" + fn get_config() -> i32 { + if true { 1 } else { 2 } + } + fn cmd_quality(clear: bool) -> i32 { + let config = get_config(); + if clear { config + 1 } else { config } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|f| f.name == "cmd_quality").unwrap(); + assert!( + matches!(f.classification, Classification::Operation), + "Calling a leaf (get_config) + logic should be Operation, got {:?}", + f.classification + ); +} + +#[test] +fn test_non_leaf_call_still_violation() { + // bad_a and bad_b form a cycle — both are Violations that can't be reclassified. + // caller has logic + calls bad_a → stays Violation. + let code = r#" + fn bad_a(x: bool) -> i32 { + if x { bad_b(false) } else { 0 } + } + fn bad_b(x: bool) -> i32 { + if x { bad_a(true) } else { 1 } + } + fn caller(x: bool) -> i32 { + if x { bad_a(true) } else { 0 } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|f| f.name == "caller").unwrap(); + assert!( + matches!(f.classification, Classification::Violation { .. }), + "Calling a non-leaf (orchestrator) + logic should be Violation, got {:?}", + f.classification + ); +} + +#[test] +fn test_multiple_leaf_calls_still_operation() { + // Both helpers are leaves (C=0). Calling multiple leaves + logic → Operation. + let code = r#" + fn validate(s: &str) -> bool { s.len() > 3 } + fn normalize(s: &str) -> String { s.to_lowercase() } + fn process(input: &str) -> Option { + if validate(input) { + Some(normalize(input)) + } else { + None + } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|f| f.name == "process").unwrap(); + assert!( + matches!(f.classification, Classification::Operation), + "Calling only leaves + logic should be Operation, got {:?}", + f.classification + ); +} diff --git a/src/adapters/analyzers/iosp/tests/root/own_calls_b.rs b/src/adapters/analyzers/iosp/tests/root/own_calls_b.rs new file mode 100644 index 00000000..7054fff6 --- /dev/null +++ b/src/adapters/analyzers/iosp/tests/root/own_calls_b.rs @@ -0,0 +1,150 @@ +use super::*; + +#[test] +fn test_pure_integration_unchanged() { + // Integration (only calls, no logic) stays Integration — unaffected by leaf detection. + let code = r#" + fn step_a() {} + fn step_b() {} + fn pipeline() { + step_a(); + step_b(); + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|f| f.name == "pipeline").unwrap(); + assert!( + matches!(f.classification, Classification::Integration), + "Pure Integration should stay Integration, got {:?}", + f.classification + ); +} + +#[test] +fn test_cascading_leaf_detection() { + // step_a and step_b are leaves (C=0). + // middle calls only leaves → after leaf detection, middle is Operation → also a leaf. + // top calls middle + has logic → should be Operation (middle is transitively a leaf). + let code = r#" + fn step_a() -> i32 { if true { 1 } else { 0 } } + fn step_b() -> i32 { 42 } + fn middle() -> i32 { + if step_a() > 0 { step_b() } else { 0 } + } + fn top(x: bool) -> i32 { + if x { middle() } else { -1 } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|f| f.name == "top").unwrap(); + assert!( + matches!(f.classification, Classification::Operation), + "Cascading leaf: top calls middle (which calls only leaves) should be Operation, got {:?}", + f.classification + ); +} + +// --------------------------------------------------------------- +// qual:recursive annotation tests +// --------------------------------------------------------------- + +#[test] +fn test_recursive_annotation_makes_self_call_safe() { + let code = r#" + // qual:recursive + fn traverse(node: &str) -> i32 { + if node.is_empty() { return 0; } + traverse(node) + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|f| f.name == "traverse").unwrap(); + assert!( + matches!(f.classification, Classification::Operation), + "qual:recursive should make self-call safe → Operation, got {:?}", + f.classification + ); +} + +#[test] +fn test_recursive_without_annotation_is_violation() { + let code = r#" + fn inner() {} + fn traverse(node: &str) -> i32 { + if node.is_empty() { return 0; } + inner(); + traverse(node) + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|f| f.name == "traverse").unwrap(); + assert!( + matches!(f.classification, Classification::Violation { .. }), + "Without annotation, recursive + non-leaf call + logic = Violation, got {:?}", + f.classification + ); +} + +// --------------------------------------------------------------- +// Integration-as-safe-target tests +// --------------------------------------------------------------- + +#[test] +fn test_call_to_integration_is_safe() { + let code = r#" + fn log_action() {} + fn db_save() { log_action(); } + fn handler(x: bool) -> i32 { + if x { db_save(); 1 } else { 0 } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|f| f.name == "handler").unwrap(); + assert!( + matches!(f.classification, Classification::Operation), + "Call to Integration (L=0, C>0) + logic should be Operation, got {:?}", + f.classification + ); +} + +#[test] +fn test_call_to_violation_stays_violation() { + let code = r#" + fn bad_a(x: bool) -> i32 { + if x { bad_b(false) } else { 0 } + } + fn bad_b(x: bool) -> i32 { + if x { bad_a(true) } else { 1 } + } + fn caller(y: bool) -> i32 { + if y { bad_a(true) } else { -1 } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|f| f.name == "caller").unwrap(); + assert!( + matches!(f.classification, Classification::Violation { .. }), + "Call to mutually-recursive Violation + logic should stay Violation, got {:?}", + f.classification + ); +} + +#[test] +fn test_mixed_leaf_and_integration_calls_safe() { + let code = r#" + fn log_it() {} + fn get_config() -> i32 { if true { 1 } else { 2 } } + fn db_fetch() -> i32 { log_it(); 42 } + fn process(x: bool) -> i32 { + let cfg = get_config(); + if x { db_fetch() + cfg } else { cfg } + } + "#; + let results = parse_and_analyze(code); + let f = results.iter().find(|f| f.name == "process").unwrap(); + assert!( + matches!(f.classification, Classification::Operation), + "Calls to leaf + integration + logic should be Operation, got {:?}", + f.classification + ); +} diff --git a/src/adapters/analyzers/iosp/tests/scope/collection_and_ownership.rs b/src/adapters/analyzers/iosp/tests/scope/collection_and_ownership.rs new file mode 100644 index 00000000..51883ba8 --- /dev/null +++ b/src/adapters/analyzers/iosp/tests/scope/collection_and_ownership.rs @@ -0,0 +1,108 @@ +use super::*; + +// ── ScopeCollector Tests ────────────────────────────────────────── + +#[test] +fn test_collect_free_functions() { + let scope = build_scope("fn foo() {} fn bar() {}"); + assert!(scope.functions.contains("foo")); + assert!(scope.functions.contains("bar")); +} + +#[test] +fn test_collect_impl_methods() { + let scope = build_scope("struct Foo; impl Foo { fn bar(&self) {} }"); + assert!(scope.methods.contains("bar")); + assert!(scope.types.contains("Foo")); +} + +#[test] +fn test_collect_trait_methods() { + let scope = build_scope("trait T { fn baz(&self); }"); + assert!(scope.methods.contains("baz")); + assert!(scope.types.contains("T")); +} + +#[test] +fn test_collect_struct_names() { + let scope = build_scope("struct S;"); + assert!(scope.types.contains("S")); +} + +#[test] +fn test_collect_enum_names() { + let scope = build_scope("enum E { A }"); + assert!(scope.types.contains("E")); +} + +#[test] +fn test_collect_nested_module() { + let scope = build_scope("mod inner { fn f() {} }"); + assert!(scope.functions.contains("f")); +} + +// ── is_own_function Tests ───────────────────────────────────────── + +#[test] +fn test_own_function_single_segment() { + let scope = build_scope("fn foo() {}"); + assert!(scope.is_own_function("foo")); +} + +#[test] +fn test_own_function_not_in_scope() { + let scope = build_scope("fn foo() {}"); + assert!(!scope.is_own_function("unknown")); +} + +#[test] +fn test_own_function_type_prefix() { + let scope = build_scope("struct Config; impl Config { fn load() {} }"); + assert!(scope.is_own_function("Config::load")); +} + +#[test] +fn test_own_function_external_type() { + let scope = build_scope("fn foo() {}"); + assert!(!scope.is_own_function("String::new")); +} + +#[test] +fn test_own_function_self_inherent_is_own() { + // Inherent impl method IS an own call (no longer blocked by UNIVERSAL_METHODS) + let scope = build_scope("struct X; impl X { fn default(&self) {} }"); + assert!(scope.is_own_function("Self::default")); +} + +#[test] +fn test_own_function_self_own_method() { + let scope = build_scope("struct X; impl X { fn analyze(&self) {} }"); + assert!(scope.is_own_function("Self::analyze")); +} + +// ── is_own_method Tests ─────────────────────────────────────────── + +#[test] +fn test_own_method_in_scope() { + let scope = build_scope("struct A; impl A { fn analyze_file(&self) {} }"); + assert!(scope.is_own_method("analyze_file")); +} + +#[test] +fn test_own_method_not_in_scope() { + let scope = build_scope("struct A; impl A { fn analyze_file(&self) {} }"); + assert!(!scope.is_own_method("push")); +} + +#[test] +fn test_own_method_inherent_is_own() { + // Inherent impl constructor IS an own method (type-resolution handles disambiguation) + let scope = build_scope("struct A; impl A { fn new() -> Self { A } }"); + assert!(scope.is_own_method("new")); +} + +#[test] +fn test_own_method_not_universal() { + let scope = build_scope("struct A; impl A { fn record_logic(&mut self) {} }"); + assert!(scope.is_own_method("record_logic")); +} diff --git a/src/adapters/analyzers/iosp/tests/scope/mod.rs b/src/adapters/analyzers/iosp/tests/scope/mod.rs new file mode 100644 index 00000000..4b28b7f2 --- /dev/null +++ b/src/adapters/analyzers/iosp/tests/scope/mod.rs @@ -0,0 +1,17 @@ +//! `ProjectScope` / own-call recognition tests. Split into focused sub-files +//! (each ≤ the SRP file-length cap); shared imports + the `build_scope` helper +//! live here and reach the sub-modules via `use super::*`. + +pub(super) use crate::adapters::analyzers::iosp::scope::*; +pub(super) use std::collections::{HashMap, HashSet}; +pub(super) use syn::visit::Visit; +pub(super) use syn::{File, ImplItem, TraitItem}; + +mod collection_and_ownership; +mod trivial_and_edge_cases; + +pub(super) fn build_scope(code: &str) -> ProjectScope { + let syntax = syn::parse_file(code).expect("Failed to parse test code"); + let files = vec![("test.rs", &syntax)]; + ProjectScope::from_files(&files) +} diff --git a/src/adapters/analyzers/iosp/tests/scope.rs b/src/adapters/analyzers/iosp/tests/scope/trivial_and_edge_cases.rs similarity index 72% rename from src/adapters/analyzers/iosp/tests/scope.rs rename to src/adapters/analyzers/iosp/tests/scope/trivial_and_edge_cases.rs index 60051283..630688e2 100644 --- a/src/adapters/analyzers/iosp/tests/scope.rs +++ b/src/adapters/analyzers/iosp/tests/scope/trivial_and_edge_cases.rs @@ -1,120 +1,4 @@ -use crate::adapters::analyzers::iosp::scope::*; -use std::collections::{HashMap, HashSet}; -use syn::visit::Visit; -use syn::{File, ImplItem, TraitItem}; - -fn build_scope(code: &str) -> ProjectScope { - let syntax = syn::parse_file(code).expect("Failed to parse test code"); - let files = vec![("test.rs", &syntax)]; - ProjectScope::from_files(&files) -} - -// ── ScopeCollector Tests ────────────────────────────────────────── - -#[test] -fn test_collect_free_functions() { - let scope = build_scope("fn foo() {} fn bar() {}"); - assert!(scope.functions.contains("foo")); - assert!(scope.functions.contains("bar")); -} - -#[test] -fn test_collect_impl_methods() { - let scope = build_scope("struct Foo; impl Foo { fn bar(&self) {} }"); - assert!(scope.methods.contains("bar")); - assert!(scope.types.contains("Foo")); -} - -#[test] -fn test_collect_trait_methods() { - let scope = build_scope("trait T { fn baz(&self); }"); - assert!(scope.methods.contains("baz")); - assert!(scope.types.contains("T")); -} - -#[test] -fn test_collect_struct_names() { - let scope = build_scope("struct S;"); - assert!(scope.types.contains("S")); -} - -#[test] -fn test_collect_enum_names() { - let scope = build_scope("enum E { A }"); - assert!(scope.types.contains("E")); -} - -#[test] -fn test_collect_nested_module() { - let scope = build_scope("mod inner { fn f() {} }"); - assert!(scope.functions.contains("f")); -} - -// ── is_own_function Tests ───────────────────────────────────────── - -#[test] -fn test_own_function_single_segment() { - let scope = build_scope("fn foo() {}"); - assert!(scope.is_own_function("foo")); -} - -#[test] -fn test_own_function_not_in_scope() { - let scope = build_scope("fn foo() {}"); - assert!(!scope.is_own_function("unknown")); -} - -#[test] -fn test_own_function_type_prefix() { - let scope = build_scope("struct Config; impl Config { fn load() {} }"); - assert!(scope.is_own_function("Config::load")); -} - -#[test] -fn test_own_function_external_type() { - let scope = build_scope("fn foo() {}"); - assert!(!scope.is_own_function("String::new")); -} - -#[test] -fn test_own_function_self_inherent_is_own() { - // Inherent impl method IS an own call (no longer blocked by UNIVERSAL_METHODS) - let scope = build_scope("struct X; impl X { fn default(&self) {} }"); - assert!(scope.is_own_function("Self::default")); -} - -#[test] -fn test_own_function_self_own_method() { - let scope = build_scope("struct X; impl X { fn analyze(&self) {} }"); - assert!(scope.is_own_function("Self::analyze")); -} - -// ── is_own_method Tests ─────────────────────────────────────────── - -#[test] -fn test_own_method_in_scope() { - let scope = build_scope("struct A; impl A { fn analyze_file(&self) {} }"); - assert!(scope.is_own_method("analyze_file")); -} - -#[test] -fn test_own_method_not_in_scope() { - let scope = build_scope("struct A; impl A { fn analyze_file(&self) {} }"); - assert!(!scope.is_own_method("push")); -} - -#[test] -fn test_own_method_inherent_is_own() { - // Inherent impl constructor IS an own method (type-resolution handles disambiguation) - let scope = build_scope("struct A; impl A { fn new() -> Self { A } }"); - assert!(scope.is_own_method("new")); -} - -#[test] -fn test_own_method_not_universal() { - let scope = build_scope("struct A; impl A { fn record_logic(&mut self) {} }"); - assert!(scope.is_own_method("record_logic")); -} +use super::*; // ── Trivial Accessor Tests ─────────────────────────────────────── diff --git a/src/adapters/analyzers/iosp/visitor/tests/root.rs b/src/adapters/analyzers/iosp/visitor/tests/root.rs deleted file mode 100644 index 49ddc0a9..00000000 --- a/src/adapters/analyzers/iosp/visitor/tests/root.rs +++ /dev/null @@ -1,547 +0,0 @@ -use crate::adapters::analyzers::iosp::scope::ProjectScope; -use crate::adapters::analyzers::iosp::visitor::*; -use crate::config::Config; -use std::collections::HashMap; -use syn::visit::Visit; - -fn empty_scope() -> ProjectScope { - ProjectScope::default() -} - -#[test] -fn test_new_defaults() { - let config = Config::default(); - let scope = empty_scope(); - let visitor = BodyVisitor::new(&config, &scope, Some("test_fn"), None, HashMap::new()); - assert!(visitor.logic.is_empty()); - assert!(visitor.own_calls.is_empty()); - assert_eq!(visitor.max_nesting, 0); - assert_eq!(visitor.closure_depth, 0); - assert_eq!(visitor.async_block_depth, 0); - assert_eq!(visitor.nesting_depth, 0); - assert_eq!(visitor.current_fn_name, Some("test_fn".to_string())); - assert_eq!(visitor.cognitive_complexity, 0); - assert_eq!(visitor.cyclomatic_complexity, 1); // base path - assert!(visitor.complexity_hotspots.is_empty()); - assert!(visitor.magic_numbers.is_empty()); - assert!(visitor.last_boolean_op.is_none()); - assert_eq!(visitor.in_const_context, 0); -} - -#[test] -fn test_new_without_fn_name() { - let config = Config::default(); - let scope = empty_scope(); - let visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); - assert!(visitor.current_fn_name.is_none()); -} - -#[test] -fn test_in_lenient_nested_context_closure() { - let config = Config::default(); - let scope = empty_scope(); - let mut visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); - assert!(!visitor.in_lenient_nested_context()); - visitor.closure_depth = 1; - assert!(visitor.in_lenient_nested_context()); -} - -#[test] -fn test_in_lenient_nested_context_strict_mode() { - let mut config = Config::default(); - config.strict_closures = true; - let scope = empty_scope(); - let mut visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); - visitor.closure_depth = 1; - assert!(!visitor.in_lenient_nested_context()); -} - -#[test] -fn test_in_lenient_nested_context_async_block() { - let config = Config::default(); - let scope = empty_scope(); - let mut visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); - visitor.async_block_depth = 1; - assert!(visitor.in_lenient_nested_context()); -} - -#[test] -fn test_is_iterator_method_known() { - assert!(BodyVisitor::is_iterator_method("map")); - assert!(BodyVisitor::is_iterator_method("filter")); - assert!(BodyVisitor::is_iterator_method("collect")); - assert!(BodyVisitor::is_iterator_method("fold")); - assert!(BodyVisitor::is_iterator_method("iter")); - assert!(BodyVisitor::is_iterator_method("into_iter")); -} - -#[test] -fn test_is_iterator_method_unknown() { - assert!(!BodyVisitor::is_iterator_method("foo")); - assert!(!BodyVisitor::is_iterator_method("bar")); - assert!(!BodyVisitor::is_iterator_method("push")); - assert!(!BodyVisitor::is_iterator_method("analyze")); -} - -#[test] -fn test_is_recursive_call_match() { - let config = Config::default(); - let scope = empty_scope(); - let visitor = BodyVisitor::new(&config, &scope, Some("my_func"), None, HashMap::new()); - assert!(visitor.is_recursive_call("my_func")); -} - -#[test] -fn test_is_recursive_call_qualified() { - let config = Config::default(); - let scope = empty_scope(); - let visitor = BodyVisitor::new(&config, &scope, Some("bar"), None, HashMap::new()); - assert!(visitor.is_recursive_call("Foo::bar")); -} - -#[test] -fn test_is_recursive_call_no_fn_name() { - let config = Config::default(); - let scope = empty_scope(); - let visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); - assert!(!visitor.is_recursive_call("anything")); -} - -#[test] -fn test_enter_exit_nesting() { - let config = Config::default(); - let scope = empty_scope(); - let mut visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); - assert_eq!(visitor.nesting_depth, 0); - assert_eq!(visitor.max_nesting, 0); - - visitor.enter_nesting(); - assert_eq!(visitor.nesting_depth, 1); - assert_eq!(visitor.max_nesting, 1); - - visitor.enter_nesting(); - assert_eq!(visitor.nesting_depth, 2); - assert_eq!(visitor.max_nesting, 2); - - visitor.exit_nesting(); - assert_eq!(visitor.nesting_depth, 1); - assert_eq!(visitor.max_nesting, 2); - - visitor.exit_nesting(); - assert_eq!(visitor.nesting_depth, 0); - assert_eq!(visitor.max_nesting, 2); -} - -#[test] -fn test_extract_call_name_path() { - let expr: syn::Expr = syn::parse_quote!(foo::bar); - assert_eq!( - BodyVisitor::extract_call_name(&expr), - Some("foo::bar".to_string()) - ); -} - -#[test] -fn test_extract_call_name_simple() { - let expr: syn::Expr = syn::parse_quote!(my_func); - assert_eq!( - BodyVisitor::extract_call_name(&expr), - Some("my_func".to_string()) - ); -} - -#[test] -fn test_extract_call_name_non_path() { - let expr: syn::Expr = syn::parse_quote!(42); - assert_eq!(BodyVisitor::extract_call_name(&expr), None); -} - -#[test] -fn test_record_logic_normal() { - let config = Config::default(); - let scope = empty_scope(); - let mut visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); - visitor.record_logic("if", proc_macro2::Span::call_site()); - assert_eq!(visitor.logic.len(), 1); - assert_eq!(visitor.logic[0].kind, "if"); -} - -#[test] -fn test_record_logic_skipped_in_closure() { - let config = Config::default(); - let scope = empty_scope(); - let mut visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); - visitor.closure_depth = 1; - visitor.record_logic("if", proc_macro2::Span::call_site()); - assert!(visitor.logic.is_empty()); -} - -#[test] -fn test_record_logic_in_for_iter() { - let config = Config::default(); - let scope = empty_scope(); - let mut visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); - visitor.in_for_iter = true; - visitor.record_logic("comparison", proc_macro2::Span::call_site()); - assert!(visitor.logic.is_empty()); -} - -#[test] -fn test_record_logic_in_async_block_lenient() { - let config = Config::default(); - let scope = empty_scope(); - let mut visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); - visitor.async_block_depth = 1; - visitor.record_logic("if", proc_macro2::Span::call_site()); - assert!(visitor.logic.is_empty()); -} - -// ── Complexity tracking tests ───────────────────────────────────── - -fn visit_code(code: &str) -> BodyVisitor<'static> { - // Leak config and scope to satisfy lifetime requirements - let config: &'static Config = Box::leak(Box::default()); - let scope: &'static ProjectScope = Box::leak(Box::default()); - let mut visitor = BodyVisitor::new(config, scope, Some("test_fn"), None, HashMap::new()); - let block: syn::Block = syn::parse_str(&format!("{{ {code} }}")).unwrap(); - block.stmts.iter().for_each(|stmt| visitor.visit_stmt(stmt)); - visitor -} - -#[test] -fn test_cognitive_simple_if() { - let v = visit_code("if true { let _ = 1; }"); - // if at nesting 0: 1 + 0 = 1 - assert_eq!(v.cognitive_complexity, 1); -} - -#[test] -fn test_cognitive_nested_if() { - let v = visit_code("if true { if false { let _ = 1; } }"); - // outer if at nesting 0: 1+0=1, inner if at nesting 1: 1+1=2, total=3 - assert_eq!(v.cognitive_complexity, 3); -} - -#[test] -fn test_cognitive_deep_nesting() { - let v = visit_code("if true { if false { if true { let _ = 1; } } }"); - // nesting 0: 1, nesting 1: 2, nesting 2: 3, total=6 - assert_eq!(v.cognitive_complexity, 6); -} - -#[test] -fn test_cognitive_match() { - let v = visit_code("match 1 { 1 => {}, 2 => {}, _ => {} }"); - // match at nesting 0: 1+0=1 - assert_eq!(v.cognitive_complexity, 1); -} - -#[test] -fn test_cognitive_for_while_loop() { - let v = visit_code("for _ in 0..10 { while true { loop { break; } } }"); - // for at 0: 1, while at 1: 2, loop at 2: 3, total=6 - assert_eq!(v.cognitive_complexity, 6); -} - -#[test] -fn test_cognitive_boolean_alternation() { - // a && b || c should have 1 alternation - let v = visit_code("let _ = true && false || true;"); - // The alternation adds 1 to cognitive - assert!( - v.cognitive_complexity >= 1, - "Expected alternation to add to cognitive, got {}", - v.cognitive_complexity - ); -} - -#[test] -fn test_cognitive_no_alternation() { - let v = visit_code("let _ = true && false && true;"); - // No alternation — same operator throughout - // cognitive stays 0 for boolean ops (no alternation) - assert_eq!(v.cognitive_complexity, 0); -} - -#[test] -fn test_cyclomatic_basic() { - let v = visit_code("if true {} if false {}"); - // base=1, +1 per if = 3 - assert_eq!(v.cyclomatic_complexity, 3); -} - -#[test] -fn test_cyclomatic_match_arms_all_trivial() { - // All arms return literals → all trivial → cyclomatic = base only - let v = visit_code("match x { 1 => \"a\", 2 => \"b\", 3 => \"c\", _ => \"d\" }"); - // base=1, all 4 arms are trivial (Lit bodies) → +0 - assert_eq!(v.cyclomatic_complexity, 1); -} - -#[test] -fn test_cyclomatic_match_arms_with_control_flow() { - // Arms with if/match bodies are non-trivial - let v = visit_code("match x { 1 => if y { 1 } else { 2 }, 2 => 0, _ => 0 }"); - // base=1, 1 non-trivial arm (if body) → +(1-1)=0, plus inner if: +1 - assert_eq!(v.cyclomatic_complexity, 2); -} - -#[test] -fn test_cyclomatic_match_all_nontrivial() { - // All arms have blocks with multiple stmts → non-trivial - let v = visit_code( - "match x { 1 => { let a = 1; a }, 2 => { let b = 2; b }, _ => { let c = 3; c } }", - ); - // base=1, 3 non-trivial arms → +(3-1)=2 - assert_eq!(v.cyclomatic_complexity, 3); -} - -#[test] -fn test_cyclomatic_lookup_table_match() { - // Large lookup table like bin_op_str — all literal returns - let v = visit_code( - r#"match op { - 0 => "+", 1 => "-", 2 => "*", 3 => "/", - 4 => "%", 5 => "&&", 6 => "||", 7 => "^", - 8 => "&", 9 => "|", _ => "?" - }"#, - ); - // base=1, all 11 arms trivial (Lit) → +0 - assert_eq!(v.cyclomatic_complexity, 1); -} - -#[test] -fn test_cyclomatic_match_mixed_trivial_nontrivial() { - // Mix of trivial and non-trivial arms - let v = visit_code( - "match x { 1 => true, 2 => if y { true } else { false }, 3 => false, _ => false }", - ); - // base=1, 1 non-trivial arm (if body) → +(1-1)=0, plus inner if: +1 - assert_eq!(v.cyclomatic_complexity, 2); -} - -#[test] -fn test_cyclomatic_boolean_ops() { - let v = visit_code("let _ = true && false || true;"); - // base=1, +1 for &&, +1 for || = 3 - assert_eq!(v.cyclomatic_complexity, 3); -} - -#[test] -fn test_complexity_hotspot_at_deep_nesting() { - let v = visit_code("if true { if false { if true { if false { let _ = 1; } } } }"); - // nesting reaches 3 at the 4th if → hotspot recorded - assert!( - !v.complexity_hotspots.is_empty(), - "Expected hotspot at nesting >= 3" - ); - assert_eq!(v.complexity_hotspots[0].nesting_depth, 3); - assert_eq!(v.complexity_hotspots[0].construct, "if"); -} - -#[test] -fn test_no_hotspot_at_shallow_nesting() { - let v = visit_code("if true { if false { let _ = 1; } }"); - // max nesting is 2, below threshold of 3 - assert!(v.complexity_hotspots.is_empty()); -} - -// ── Magic number detection tests ────────────────────────────────── - -#[test] -fn test_magic_number_detected() { - let v = visit_code("let x = 42;"); - assert_eq!(v.magic_numbers.len(), 1); - assert_eq!(v.magic_numbers[0].value, "42"); -} - -#[test] -fn test_magic_number_allowed_not_flagged() { - let v = visit_code("let x = 0; let y = 1; let z = 2;"); - // 0, 1, 2 are in the default allowed list - assert!(v.magic_numbers.is_empty()); -} - -#[test] -fn test_magic_number_negative_detected() { - let v = visit_code("let x = -42;"); - assert_eq!(v.magic_numbers.len(), 1); - assert_eq!(v.magic_numbers[0].value, "-42"); -} - -#[test] -fn test_magic_number_negative_one_allowed() { - let v = visit_code("let x = -1;"); - // -1 is in the default allowed list - assert!(v.magic_numbers.is_empty()); -} - -#[test] -fn test_magic_number_float_detected() { - let v = visit_code("let x = 3.14;"); - assert_eq!(v.magic_numbers.len(), 1); - assert_eq!(v.magic_numbers[0].value, "3.14"); -} - -#[test] -fn test_magic_number_in_const_not_flagged() { - let v = visit_code("const LIMIT: i32 = 42;"); - assert!( - v.magic_numbers.is_empty(), - "Const context should suppress magic numbers, got {:?}", - v.magic_numbers - ); -} - -#[test] -fn test_magic_number_detection_disabled() { - let mut config = Config::default(); - config.complexity.detect_magic_numbers = false; - let scope = empty_scope(); - let mut visitor = BodyVisitor::new(&config, &scope, Some("test_fn"), None, HashMap::new()); - let block: syn::Block = syn::parse_str("{ let x = 42; }").unwrap(); - block.stmts.iter().for_each(|stmt| visitor.visit_stmt(stmt)); - assert!(visitor.magic_numbers.is_empty()); -} - -// ── Delegation detection tests ─────────────────────────────────── - -#[test] -fn test_delegation_single_call() { - let block: syn::Block = syn::parse_str("{ call(x); }").unwrap(); - assert!(is_delegation_only_body(&block.stmts)); -} - -#[test] -fn test_delegation_method_call_with_try() { - let block: syn::Block = syn::parse_str("{ wtr.write_record(f(t))?; }").unwrap(); - assert!(is_delegation_only_body(&block.stmts)); -} - -#[test] -fn test_delegation_await() { - let block: syn::Block = syn::parse_str("{ sync(s).await; }").unwrap(); - assert!(is_delegation_only_body(&block.stmts)); -} - -#[test] -fn test_delegation_if_let_push() { - let block: syn::Block = syn::parse_str("{ if let Some(r) = call()? { v.push(r); } }").unwrap(); - assert!(is_delegation_only_body(&block.stmts)); -} - -#[test] -fn test_delegation_let_binding() { - let block: syn::Block = syn::parse_str("{ let r = call(x); store(r); }").unwrap(); - assert!(is_delegation_only_body(&block.stmts)); -} - -#[test] -fn test_delegation_multiple_calls() { - let block: syn::Block = syn::parse_str("{ a(x); b(y); }").unwrap(); - assert!(is_delegation_only_body(&block.stmts)); -} - -#[test] -fn test_not_delegation_comparison() { - let block: syn::Block = syn::parse_str("{ if x > 0 { call(x); } }").unwrap(); - assert!(!is_delegation_only_body(&block.stmts)); -} - -#[test] -fn test_not_delegation_arithmetic() { - let block: syn::Block = syn::parse_str("{ let y = x + 1; call(y); }").unwrap(); - assert!(!is_delegation_only_body(&block.stmts)); -} - -#[test] -fn test_not_delegation_match() { - let block: syn::Block = syn::parse_str("{ match x { 0 => call_a(), _ => call_b() } }").unwrap(); - assert!(!is_delegation_only_body(&block.stmts)); -} - -// --------------------------------------------------------------- -// Match-Dispatch Detection -// --------------------------------------------------------------- - -fn parse_match_arms(code: &str) -> Vec { - let expr: syn::ExprMatch = syn::parse_str(code).unwrap(); - expr.arms -} - -#[test] -fn test_match_dispatch_all_calls() { - let arms = parse_match_arms("match x { 0 => call_a(), _ => call_b() }"); - assert!(is_match_dispatch(&arms)); -} - -#[test] -fn test_match_dispatch_method_calls() { - let arms = parse_match_arms("match x { A => self.run_a(d), B => self.run_b(d) }"); - assert!(is_match_dispatch(&arms)); -} - -#[test] -fn test_match_dispatch_with_try() { - let arms = parse_match_arms("match x { 0 => call_a()?, _ => call_b()? }"); - assert!(is_match_dispatch(&arms)); -} - -#[test] -fn test_match_dispatch_block_with_call() { - let arms = parse_match_arms("match x { 0 => { call_a() }, _ => { call_b() } }"); - assert!(is_match_dispatch(&arms)); -} - -#[test] -fn test_match_not_dispatch_logic_in_arm() { - let arms = parse_match_arms("match x { 0 => { let d = call(); d + 1 }, _ => call_b() }"); - assert!(!is_match_dispatch(&arms)); -} - -#[test] -fn test_match_not_dispatch_with_guard() { - let arms = parse_match_arms("match x { n if n > 0 => call_a(), _ => call_b() }"); - assert!(!is_match_dispatch(&arms)); -} - -#[test] -fn test_match_not_dispatch_arithmetic() { - let arms = parse_match_arms("match x { 0 => a + b, _ => call_b() }"); - assert!(!is_match_dispatch(&arms)); -} - -#[test] -fn test_match_dispatch_tuple_pattern() { - let arms = parse_match_arms("match (a, b) { (Some(_), Some(p)) => call_a(p), _ => call_b() }"); - assert!(is_match_dispatch(&arms)); -} - -// ── Array index magic number exclusion ─────────────────────────── - -#[test] -fn test_magic_number_in_array_index_not_flagged() { - let v = visit_code("let x = arr[3];"); - assert!( - v.magic_numbers.is_empty(), - "Array index 3 should not be flagged" - ); -} - -#[test] -fn test_magic_number_outside_index_still_flagged() { - let v = visit_code("let x = arr[3]; let y = 42;"); - assert_eq!(v.magic_numbers.len(), 1); - assert_eq!(v.magic_numbers[0].value, "42"); -} - -#[test] -fn test_magic_number_nested_index_not_flagged() { - let v = visit_code("let x = matrix[3][4];"); - // Only the index expressions (3, 4) should be suppressed; no other magic numbers - let flagged: Vec<&str> = v.magic_numbers.iter().map(|m| m.value.as_str()).collect(); - assert!( - flagged.is_empty(), - "Nested array indices should not be flagged, got: {flagged:?}" - ); -} diff --git a/src/adapters/analyzers/iosp/visitor/tests/root/complexity.rs b/src/adapters/analyzers/iosp/visitor/tests/root/complexity.rs new file mode 100644 index 00000000..3045ae80 --- /dev/null +++ b/src/adapters/analyzers/iosp/visitor/tests/root/complexity.rs @@ -0,0 +1,141 @@ +use super::*; + +// ── Complexity tracking tests ───────────────────────────────────── + +#[test] +fn test_cognitive_simple_if() { + let v = visit_code("if true { let _ = 1; }"); + // if at nesting 0: 1 + 0 = 1 + assert_eq!(v.cognitive_complexity, 1); +} + +#[test] +fn test_cognitive_nested_if() { + let v = visit_code("if true { if false { let _ = 1; } }"); + // outer if at nesting 0: 1+0=1, inner if at nesting 1: 1+1=2, total=3 + assert_eq!(v.cognitive_complexity, 3); +} + +#[test] +fn test_cognitive_deep_nesting() { + let v = visit_code("if true { if false { if true { let _ = 1; } } }"); + // nesting 0: 1, nesting 1: 2, nesting 2: 3, total=6 + assert_eq!(v.cognitive_complexity, 6); +} + +#[test] +fn test_cognitive_match() { + let v = visit_code("match 1 { 1 => {}, 2 => {}, _ => {} }"); + // match at nesting 0: 1+0=1 + assert_eq!(v.cognitive_complexity, 1); +} + +#[test] +fn test_cognitive_for_while_loop() { + let v = visit_code("for _ in 0..10 { while true { loop { break; } } }"); + // for at 0: 1, while at 1: 2, loop at 2: 3, total=6 + assert_eq!(v.cognitive_complexity, 6); +} + +#[test] +fn test_cognitive_boolean_alternation() { + // a && b || c should have 1 alternation + let v = visit_code("let _ = true && false || true;"); + // The alternation adds 1 to cognitive + assert!( + v.cognitive_complexity >= 1, + "Expected alternation to add to cognitive, got {}", + v.cognitive_complexity + ); +} + +#[test] +fn test_cognitive_no_alternation() { + let v = visit_code("let _ = true && false && true;"); + // No alternation — same operator throughout + // cognitive stays 0 for boolean ops (no alternation) + assert_eq!(v.cognitive_complexity, 0); +} + +#[test] +fn test_cyclomatic_basic() { + let v = visit_code("if true {} if false {}"); + // base=1, +1 per if = 3 + assert_eq!(v.cyclomatic_complexity, 3); +} + +#[test] +fn test_cyclomatic_match_arms_all_trivial() { + // All arms return literals → all trivial → cyclomatic = base only + let v = visit_code("match x { 1 => \"a\", 2 => \"b\", 3 => \"c\", _ => \"d\" }"); + // base=1, all 4 arms are trivial (Lit bodies) → +0 + assert_eq!(v.cyclomatic_complexity, 1); +} + +#[test] +fn test_cyclomatic_match_arms_with_control_flow() { + // Arms with if/match bodies are non-trivial + let v = visit_code("match x { 1 => if y { 1 } else { 2 }, 2 => 0, _ => 0 }"); + // base=1, 1 non-trivial arm (if body) → +(1-1)=0, plus inner if: +1 + assert_eq!(v.cyclomatic_complexity, 2); +} + +#[test] +fn test_cyclomatic_match_all_nontrivial() { + // All arms have blocks with multiple stmts → non-trivial + let v = visit_code( + "match x { 1 => { let a = 1; a }, 2 => { let b = 2; b }, _ => { let c = 3; c } }", + ); + // base=1, 3 non-trivial arms → +(3-1)=2 + assert_eq!(v.cyclomatic_complexity, 3); +} + +#[test] +fn test_cyclomatic_lookup_table_match() { + // Large lookup table like bin_op_str — all literal returns + let v = visit_code( + r#"match op { + 0 => "+", 1 => "-", 2 => "*", 3 => "/", + 4 => "%", 5 => "&&", 6 => "||", 7 => "^", + 8 => "&", 9 => "|", _ => "?" + }"#, + ); + // base=1, all 11 arms trivial (Lit) → +0 + assert_eq!(v.cyclomatic_complexity, 1); +} + +#[test] +fn test_cyclomatic_match_mixed_trivial_nontrivial() { + // Mix of trivial and non-trivial arms + let v = visit_code( + "match x { 1 => true, 2 => if y { true } else { false }, 3 => false, _ => false }", + ); + // base=1, 1 non-trivial arm (if body) → +(1-1)=0, plus inner if: +1 + assert_eq!(v.cyclomatic_complexity, 2); +} + +#[test] +fn test_cyclomatic_boolean_ops() { + let v = visit_code("let _ = true && false || true;"); + // base=1, +1 for &&, +1 for || = 3 + assert_eq!(v.cyclomatic_complexity, 3); +} + +#[test] +fn test_complexity_hotspot_at_deep_nesting() { + let v = visit_code("if true { if false { if true { if false { let _ = 1; } } } }"); + // nesting reaches 3 at the 4th if → hotspot recorded + assert!( + !v.complexity_hotspots.is_empty(), + "Expected hotspot at nesting >= 3" + ); + assert_eq!(v.complexity_hotspots[0].nesting_depth, 3); + assert_eq!(v.complexity_hotspots[0].construct, "if"); +} + +#[test] +fn test_no_hotspot_at_shallow_nesting() { + let v = visit_code("if true { if false { let _ = 1; } }"); + // max nesting is 2, below threshold of 3 + assert!(v.complexity_hotspots.is_empty()); +} diff --git a/src/adapters/analyzers/iosp/visitor/tests/root/construction.rs b/src/adapters/analyzers/iosp/visitor/tests/root/construction.rs new file mode 100644 index 00000000..edc3bfa4 --- /dev/null +++ b/src/adapters/analyzers/iosp/visitor/tests/root/construction.rs @@ -0,0 +1,189 @@ +use super::*; + +#[test] +fn test_new_defaults() { + let config = Config::default(); + let scope = empty_scope(); + let visitor = BodyVisitor::new(&config, &scope, Some("test_fn"), None, HashMap::new()); + assert!(visitor.logic.is_empty()); + assert!(visitor.own_calls.is_empty()); + assert_eq!(visitor.max_nesting, 0); + assert_eq!(visitor.closure_depth, 0); + assert_eq!(visitor.async_block_depth, 0); + assert_eq!(visitor.nesting_depth, 0); + assert_eq!(visitor.current_fn_name, Some("test_fn".to_string())); + assert_eq!(visitor.cognitive_complexity, 0); + assert_eq!(visitor.cyclomatic_complexity, 1); // base path + assert!(visitor.complexity_hotspots.is_empty()); + assert!(visitor.magic_numbers.is_empty()); + assert!(visitor.last_boolean_op.is_none()); + assert_eq!(visitor.in_const_context, 0); +} + +#[test] +fn test_new_without_fn_name() { + let config = Config::default(); + let scope = empty_scope(); + let visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); + assert!(visitor.current_fn_name.is_none()); +} + +#[test] +fn test_in_lenient_nested_context_closure() { + let config = Config::default(); + let scope = empty_scope(); + let mut visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); + assert!(!visitor.in_lenient_nested_context()); + visitor.closure_depth = 1; + assert!(visitor.in_lenient_nested_context()); +} + +#[test] +fn test_in_lenient_nested_context_strict_mode() { + let mut config = Config::default(); + config.strict_closures = true; + let scope = empty_scope(); + let mut visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); + visitor.closure_depth = 1; + assert!(!visitor.in_lenient_nested_context()); +} + +#[test] +fn test_in_lenient_nested_context_async_block() { + let config = Config::default(); + let scope = empty_scope(); + let mut visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); + visitor.async_block_depth = 1; + assert!(visitor.in_lenient_nested_context()); +} + +#[test] +fn test_is_iterator_method_known() { + assert!(BodyVisitor::is_iterator_method("map")); + assert!(BodyVisitor::is_iterator_method("filter")); + assert!(BodyVisitor::is_iterator_method("collect")); + assert!(BodyVisitor::is_iterator_method("fold")); + assert!(BodyVisitor::is_iterator_method("iter")); + assert!(BodyVisitor::is_iterator_method("into_iter")); +} + +#[test] +fn test_is_iterator_method_unknown() { + assert!(!BodyVisitor::is_iterator_method("foo")); + assert!(!BodyVisitor::is_iterator_method("bar")); + assert!(!BodyVisitor::is_iterator_method("push")); + assert!(!BodyVisitor::is_iterator_method("analyze")); +} + +#[test] +fn test_is_recursive_call_match() { + let config = Config::default(); + let scope = empty_scope(); + let visitor = BodyVisitor::new(&config, &scope, Some("my_func"), None, HashMap::new()); + assert!(visitor.is_recursive_call("my_func")); +} + +#[test] +fn test_is_recursive_call_qualified() { + let config = Config::default(); + let scope = empty_scope(); + let visitor = BodyVisitor::new(&config, &scope, Some("bar"), None, HashMap::new()); + assert!(visitor.is_recursive_call("Foo::bar")); +} + +#[test] +fn test_is_recursive_call_no_fn_name() { + let config = Config::default(); + let scope = empty_scope(); + let visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); + assert!(!visitor.is_recursive_call("anything")); +} + +#[test] +fn test_enter_exit_nesting() { + let config = Config::default(); + let scope = empty_scope(); + let mut visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); + assert_eq!(visitor.nesting_depth, 0); + assert_eq!(visitor.max_nesting, 0); + + visitor.enter_nesting(); + assert_eq!(visitor.nesting_depth, 1); + assert_eq!(visitor.max_nesting, 1); + + visitor.enter_nesting(); + assert_eq!(visitor.nesting_depth, 2); + assert_eq!(visitor.max_nesting, 2); + + visitor.exit_nesting(); + assert_eq!(visitor.nesting_depth, 1); + assert_eq!(visitor.max_nesting, 2); + + visitor.exit_nesting(); + assert_eq!(visitor.nesting_depth, 0); + assert_eq!(visitor.max_nesting, 2); +} + +#[test] +fn test_extract_call_name_path() { + let expr: syn::Expr = syn::parse_quote!(foo::bar); + assert_eq!( + BodyVisitor::extract_call_name(&expr), + Some("foo::bar".to_string()) + ); +} + +#[test] +fn test_extract_call_name_simple() { + let expr: syn::Expr = syn::parse_quote!(my_func); + assert_eq!( + BodyVisitor::extract_call_name(&expr), + Some("my_func".to_string()) + ); +} + +#[test] +fn test_extract_call_name_non_path() { + let expr: syn::Expr = syn::parse_quote!(42); + assert_eq!(BodyVisitor::extract_call_name(&expr), None); +} + +#[test] +fn test_record_logic_normal() { + let config = Config::default(); + let scope = empty_scope(); + let mut visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); + visitor.record_logic("if", proc_macro2::Span::call_site()); + assert_eq!(visitor.logic.len(), 1); + assert_eq!(visitor.logic[0].kind, "if"); +} + +#[test] +fn test_record_logic_skipped_in_closure() { + let config = Config::default(); + let scope = empty_scope(); + let mut visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); + visitor.closure_depth = 1; + visitor.record_logic("if", proc_macro2::Span::call_site()); + assert!(visitor.logic.is_empty()); +} + +#[test] +fn test_record_logic_in_for_iter() { + let config = Config::default(); + let scope = empty_scope(); + let mut visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); + visitor.in_for_iter = true; + visitor.record_logic("comparison", proc_macro2::Span::call_site()); + assert!(visitor.logic.is_empty()); +} + +#[test] +fn test_record_logic_in_async_block_lenient() { + let config = Config::default(); + let scope = empty_scope(); + let mut visitor = BodyVisitor::new(&config, &scope, None, None, HashMap::new()); + visitor.async_block_depth = 1; + visitor.record_logic("if", proc_macro2::Span::call_site()); + assert!(visitor.logic.is_empty()); +} diff --git a/src/adapters/analyzers/iosp/visitor/tests/root/magic_and_delegation.rs b/src/adapters/analyzers/iosp/visitor/tests/root/magic_and_delegation.rs new file mode 100644 index 00000000..da2a931b --- /dev/null +++ b/src/adapters/analyzers/iosp/visitor/tests/root/magic_and_delegation.rs @@ -0,0 +1,194 @@ +use super::*; + +// ── Magic number detection tests ────────────────────────────────── + +#[test] +fn test_magic_number_detected() { + let v = visit_code("let x = 42;"); + assert_eq!(v.magic_numbers.len(), 1); + assert_eq!(v.magic_numbers[0].value, "42"); +} + +#[test] +fn test_magic_number_allowed_not_flagged() { + let v = visit_code("let x = 0; let y = 1; let z = 2;"); + // 0, 1, 2 are in the default allowed list + assert!(v.magic_numbers.is_empty()); +} + +#[test] +fn test_magic_number_negative_detected() { + let v = visit_code("let x = -42;"); + assert_eq!(v.magic_numbers.len(), 1); + assert_eq!(v.magic_numbers[0].value, "-42"); +} + +#[test] +fn test_magic_number_negative_one_allowed() { + let v = visit_code("let x = -1;"); + // -1 is in the default allowed list + assert!(v.magic_numbers.is_empty()); +} + +#[test] +fn test_magic_number_float_detected() { + let v = visit_code("let x = 3.14;"); + assert_eq!(v.magic_numbers.len(), 1); + assert_eq!(v.magic_numbers[0].value, "3.14"); +} + +#[test] +fn test_magic_number_in_const_not_flagged() { + let v = visit_code("const LIMIT: i32 = 42;"); + assert!( + v.magic_numbers.is_empty(), + "Const context should suppress magic numbers, got {:?}", + v.magic_numbers + ); +} + +#[test] +fn test_magic_number_detection_disabled() { + let mut config = Config::default(); + config.complexity.detect_magic_numbers = false; + let scope = empty_scope(); + let mut visitor = BodyVisitor::new(&config, &scope, Some("test_fn"), None, HashMap::new()); + let block: syn::Block = syn::parse_str("{ let x = 42; }").unwrap(); + block.stmts.iter().for_each(|stmt| visitor.visit_stmt(stmt)); + assert!(visitor.magic_numbers.is_empty()); +} + +// ── Delegation detection tests ─────────────────────────────────── + +#[test] +fn test_delegation_single_call() { + let block: syn::Block = syn::parse_str("{ call(x); }").unwrap(); + assert!(is_delegation_only_body(&block.stmts)); +} + +#[test] +fn test_delegation_method_call_with_try() { + let block: syn::Block = syn::parse_str("{ wtr.write_record(f(t))?; }").unwrap(); + assert!(is_delegation_only_body(&block.stmts)); +} + +#[test] +fn test_delegation_await() { + let block: syn::Block = syn::parse_str("{ sync(s).await; }").unwrap(); + assert!(is_delegation_only_body(&block.stmts)); +} + +#[test] +fn test_delegation_if_let_push() { + let block: syn::Block = syn::parse_str("{ if let Some(r) = call()? { v.push(r); } }").unwrap(); + assert!(is_delegation_only_body(&block.stmts)); +} + +#[test] +fn test_delegation_let_binding() { + let block: syn::Block = syn::parse_str("{ let r = call(x); store(r); }").unwrap(); + assert!(is_delegation_only_body(&block.stmts)); +} + +#[test] +fn test_delegation_multiple_calls() { + let block: syn::Block = syn::parse_str("{ a(x); b(y); }").unwrap(); + assert!(is_delegation_only_body(&block.stmts)); +} + +#[test] +fn test_not_delegation_comparison() { + let block: syn::Block = syn::parse_str("{ if x > 0 { call(x); } }").unwrap(); + assert!(!is_delegation_only_body(&block.stmts)); +} + +#[test] +fn test_not_delegation_arithmetic() { + let block: syn::Block = syn::parse_str("{ let y = x + 1; call(y); }").unwrap(); + assert!(!is_delegation_only_body(&block.stmts)); +} + +#[test] +fn test_not_delegation_match() { + let block: syn::Block = syn::parse_str("{ match x { 0 => call_a(), _ => call_b() } }").unwrap(); + assert!(!is_delegation_only_body(&block.stmts)); +} + +// --------------------------------------------------------------- +// Match-Dispatch Detection +#[test] +fn test_match_dispatch_all_calls() { + let arms = parse_match_arms("match x { 0 => call_a(), _ => call_b() }"); + assert!(is_match_dispatch(&arms)); +} + +#[test] +fn test_match_dispatch_method_calls() { + let arms = parse_match_arms("match x { A => self.run_a(d), B => self.run_b(d) }"); + assert!(is_match_dispatch(&arms)); +} + +#[test] +fn test_match_dispatch_with_try() { + let arms = parse_match_arms("match x { 0 => call_a()?, _ => call_b()? }"); + assert!(is_match_dispatch(&arms)); +} + +#[test] +fn test_match_dispatch_block_with_call() { + let arms = parse_match_arms("match x { 0 => { call_a() }, _ => { call_b() } }"); + assert!(is_match_dispatch(&arms)); +} + +#[test] +fn test_match_not_dispatch_logic_in_arm() { + let arms = parse_match_arms("match x { 0 => { let d = call(); d + 1 }, _ => call_b() }"); + assert!(!is_match_dispatch(&arms)); +} + +#[test] +fn test_match_not_dispatch_with_guard() { + let arms = parse_match_arms("match x { n if n > 0 => call_a(), _ => call_b() }"); + assert!(!is_match_dispatch(&arms)); +} + +#[test] +fn test_match_not_dispatch_arithmetic() { + let arms = parse_match_arms("match x { 0 => a + b, _ => call_b() }"); + assert!(!is_match_dispatch(&arms)); +} + +#[test] +fn test_match_dispatch_tuple_pattern() { + let arms = parse_match_arms("match (a, b) { (Some(_), Some(p)) => call_a(p), _ => call_b() }"); + assert!(is_match_dispatch(&arms)); +} + +// ── Array index magic number exclusion ─────────────────────────── + +#[test] +fn test_magic_number_in_array_index_not_flagged() { + let v = visit_code("let x = arr[3];"); + assert!( + v.magic_numbers.is_empty(), + "Array index 3 should not be flagged" + ); +} + +#[test] +fn test_magic_number_outside_index_still_flagged() { + let v = visit_code("let x = arr[3]; let y = 42;"); + assert_eq!(v.magic_numbers.len(), 1); + assert_eq!(v.magic_numbers[0].value, "42"); +} + +#[test] +fn test_magic_number_nested_index_not_flagged() { + let v = visit_code("let x = matrix[3][4];"); + // Only the index expressions (3, 4) should be suppressed; no other magic numbers + let flagged: Vec<&str> = v.magic_numbers.iter().map(|m| m.value.as_str()).collect(); + assert!( + flagged.is_empty(), + "Nested array indices should not be flagged, got: {flagged:?}" + ); +} diff --git a/src/adapters/analyzers/iosp/visitor/tests/root/mod.rs b/src/adapters/analyzers/iosp/visitor/tests/root/mod.rs new file mode 100644 index 00000000..73ca7a4f --- /dev/null +++ b/src/adapters/analyzers/iosp/visitor/tests/root/mod.rs @@ -0,0 +1,34 @@ +//! `BodyVisitor` tests: construction/context, complexity tracking +//! (cognitive/cyclomatic/hotspots), magic-number + delegation detection. +//! Split into focused sub-files (each ≤ the SRP file-length cap); shared +//! imports + the `empty_scope`/`visit_code`/`parse_match_arms` helpers live +//! here and reach the sub-modules via `use super::*`. + +pub(super) use crate::adapters::analyzers::iosp::scope::ProjectScope; +pub(super) use crate::adapters::analyzers::iosp::visitor::*; +pub(super) use crate::config::Config; +pub(super) use std::collections::HashMap; +pub(super) use syn::visit::Visit; + +mod complexity; +mod construction; +mod magic_and_delegation; + +pub(super) fn empty_scope() -> ProjectScope { + ProjectScope::default() +} + +pub(super) fn visit_code(code: &str) -> BodyVisitor<'static> { + // Leak config and scope to satisfy lifetime requirements + let config: &'static Config = Box::leak(Box::default()); + let scope: &'static ProjectScope = Box::leak(Box::default()); + let mut visitor = BodyVisitor::new(config, scope, Some("test_fn"), None, HashMap::new()); + let block: syn::Block = syn::parse_str(&format!("{{ {code} }}")).unwrap(); + block.stmts.iter().for_each(|stmt| visitor.visit_stmt(stmt)); + visitor +} + +pub(super) fn parse_match_arms(code: &str) -> Vec { + let expr: syn::ExprMatch = syn::parse_str(code).unwrap(); + expr.arms +} diff --git a/src/adapters/analyzers/srp/mod.rs b/src/adapters/analyzers/srp/mod.rs index 45d9b08e..2ac493d7 100644 --- a/src/adapters/analyzers/srp/mod.rs +++ b/src/adapters/analyzers/srp/mod.rs @@ -88,6 +88,7 @@ pub fn analyze_srp( parsed: &[(String, String, syn::File)], config: &SrpConfig, file_call_graph: &std::collections::HashMap)>>, + test_length_thresholds: (usize, usize), ) -> SrpAnalysis { let mut structs = Vec::new(); let mut struct_collector = StructCollector { @@ -106,8 +107,13 @@ pub fn analyze_srp( let struct_warnings = cohesion::build_struct_warnings(&structs, &methods, config); let cfg_test_files = crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(parsed); - let module_warnings = - module::analyze_module_srp(parsed, config, file_call_graph, &cfg_test_files); + let module_warnings = module::analyze_module_srp( + parsed, + config, + file_call_graph, + &cfg_test_files, + test_length_thresholds, + ); let param_warnings = Vec::new(); SrpAnalysis { struct_warnings, diff --git a/src/adapters/analyzers/srp/module.rs b/src/adapters/analyzers/srp/module.rs index ce142376..435a3ead 100644 --- a/src/adapters/analyzers/srp/module.rs +++ b/src/adapters/analyzers/srp/module.rs @@ -102,32 +102,46 @@ pub(crate) fn count_independent_clusters( /// Analyze module-level SRP: flag files with excessive production line counts /// or too many independent function clusters. +/// +/// Test files (per `cfg_test_files`) are length-scored against the +/// `[tests]`-resolved baseline/ceiling instead of the production ones; the +/// cohesion (independent-cluster) check is **production-only** because a test +/// file's independent `#[test]` fns are its purpose, not a low-cohesion smell. /// Operation: iterates files, computes production lines, length score, -/// and independent clusters via closures. +/// and (production-only) independent clusters via closures. pub fn analyze_module_srp( parsed: &[(String, String, syn::File)], config: &SrpConfig, file_call_graph: &HashMap)>>, cfg_test_files: &std::collections::HashSet, + test_length_thresholds: (usize, usize), ) -> Vec { parsed .iter() - .filter(|(path, _, _)| !cfg_test_files.contains(path)) .filter_map(|(path, source, syntax)| { + let is_test = cfg_test_files.contains(path); + // `test_length_thresholds` = `(baseline, ceiling)` resolved from + // `[tests]` (defaults to production). Applied to test files only. + let (baseline, ceiling) = if is_test { + test_length_thresholds + } else { + (config.file_length_baseline, config.file_length_ceiling) + }; let production_lines = count_production_lines(source); - let score = compute_file_length_score( - production_lines, - config.file_length_baseline, - config.file_length_ceiling, - ); + let score = compute_file_length_score(production_lines, baseline, ceiling); - let free_fns = collect_free_functions(syntax); - let call_graph = file_call_graph - .get(path) - .map(|v| v.as_slice()) - .unwrap_or(&[]); - let (cluster_count, cluster_names) = - count_independent_clusters(&free_fns, call_graph, config.min_cluster_statements); + // Cohesion is production-only: independent test fns are expected, so + // a test file contributes no clusters (and the walk is skipped). + let (cluster_count, cluster_names) = if is_test { + (0, Vec::new()) + } else { + let free_fns = collect_free_functions(syntax); + let call_graph = file_call_graph + .get(path) + .map(|v| v.as_slice()) + .unwrap_or(&[]); + count_independent_clusters(&free_fns, call_graph, config.min_cluster_statements) + }; let has_length_warning = score > 0.0; // Use strict `>` for consistency with the other `max_*` diff --git a/src/adapters/analyzers/srp/tests/cohesion.rs b/src/adapters/analyzers/srp/tests/cohesion.rs deleted file mode 100644 index c3e22c1d..00000000 --- a/src/adapters/analyzers/srp/tests/cohesion.rs +++ /dev/null @@ -1,545 +0,0 @@ -use crate::adapters::analyzers::srp::cohesion::*; -use crate::adapters::analyzers::srp::{MethodFieldData, StructInfo}; -use crate::config::sections::SrpConfig; -use std::collections::{HashMap, HashSet}; - -fn make_method(name: &str, parent: &str, fields: &[&str], calls: &[&str]) -> MethodFieldData { - MethodFieldData { - method_name: name.to_string(), - parent_type: parent.to_string(), - field_accesses: fields.iter().map(|s| s.to_string()).collect(), - call_targets: calls.iter().map(|s| s.to_string()).collect(), - self_method_calls: HashSet::new(), - is_constructor: false, - } -} - -fn make_method_with_self_calls( - name: &str, - parent: &str, - fields: &[&str], - self_calls: &[&str], -) -> MethodFieldData { - MethodFieldData { - method_name: name.to_string(), - parent_type: parent.to_string(), - field_accesses: fields.iter().map(|s| s.to_string()).collect(), - call_targets: HashSet::new(), - self_method_calls: self_calls.iter().map(|s| s.to_string()).collect(), - is_constructor: false, - } -} - -fn make_constructor(name: &str, parent: &str, calls: &[&str]) -> MethodFieldData { - MethodFieldData { - method_name: name.to_string(), - parent_type: parent.to_string(), - field_accesses: HashSet::new(), - call_targets: calls.iter().map(|s| s.to_string()).collect(), - self_method_calls: HashSet::new(), - is_constructor: true, - } -} - -fn make_struct(name: &str, fields: &[&str]) -> StructInfo { - StructInfo { - name: name.to_string(), - file: "test.rs".to_string(), - line: 1, - fields: fields.iter().map(|s| s.to_string()).collect(), - } -} - -#[test] -fn test_lcom4_fully_cohesive() { - // All methods access the same field → LCOM4 = 1 - let m1 = make_method("a", "Foo", &["x"], &[]); - let m2 = make_method("b", "Foo", &["x"], &[]); - let m3 = make_method("c", "Foo", &["x"], &[]); - let methods: Vec<&MethodFieldData> = vec![&m1, &m2, &m3]; - let fields = vec!["x".to_string(), "y".to_string()]; - let (lcom4, clusters) = compute_lcom4( - &methods, - &fields, - &build_field_method_index(&methods, &fields), - ); - assert_eq!(lcom4, 1); - assert_eq!(clusters.len(), 1); -} - -#[test] -fn test_lcom4_two_clusters() { - // Two disjoint groups of methods - let m1 = make_method("a", "Foo", &["x"], &[]); - let m2 = make_method("b", "Foo", &["x"], &[]); - let m3 = make_method("c", "Foo", &["y"], &[]); - let m4 = make_method("d", "Foo", &["y"], &[]); - let methods: Vec<&MethodFieldData> = vec![&m1, &m2, &m3, &m4]; - let fields = vec!["x".to_string(), "y".to_string()]; - let (lcom4, clusters) = compute_lcom4( - &methods, - &fields, - &build_field_method_index(&methods, &fields), - ); - assert_eq!(lcom4, 2); - assert_eq!(clusters.len(), 2); -} - -#[test] -fn test_lcom4_no_shared_fields() { - // Each method accesses a unique field → N components - let m1 = make_method("a", "Foo", &["x"], &[]); - let m2 = make_method("b", "Foo", &["y"], &[]); - let m3 = make_method("c", "Foo", &["z"], &[]); - let methods: Vec<&MethodFieldData> = vec![&m1, &m2, &m3]; - let fields = vec!["x".to_string(), "y".to_string(), "z".to_string()]; - let (lcom4, _) = compute_lcom4( - &methods, - &fields, - &build_field_method_index(&methods, &fields), - ); - assert_eq!(lcom4, 3); -} - -#[test] -fn test_lcom4_empty_methods() { - let methods: Vec<&MethodFieldData> = vec![]; - let fields = vec!["x".to_string()]; - let (lcom4, clusters) = compute_lcom4( - &methods, - &fields, - &build_field_method_index(&methods, &fields), - ); - assert_eq!(lcom4, 0); - assert!(clusters.is_empty()); -} - -#[test] -fn test_lcom4_method_with_no_field_access() { - // Method that doesn't access any struct fields → isolated component - let m1 = make_method("a", "Foo", &["x"], &[]); - let m2 = make_method("b", "Foo", &[], &["helper"]); - let methods: Vec<&MethodFieldData> = vec![&m1, &m2]; - let fields = vec!["x".to_string()]; - let (lcom4, _) = compute_lcom4( - &methods, - &fields, - &build_field_method_index(&methods, &fields), - ); - assert_eq!(lcom4, 2); -} - -#[test] -fn test_fan_out_distinct_targets() { - let m1 = make_method("a", "Foo", &[], &["helper", "process"]); - let m2 = make_method("b", "Foo", &[], &["helper", "format"]); - let methods: Vec<&MethodFieldData> = vec![&m1, &m2]; - let fan_out = compute_fan_out(&methods); - assert_eq!(fan_out, 3); // helper, process, format -} - -#[test] -fn test_fan_out_empty() { - let m1 = make_method("a", "Foo", &["x"], &[]); - let methods: Vec<&MethodFieldData> = vec![&m1]; - let fan_out = compute_fan_out(&methods); - assert_eq!(fan_out, 0); -} - -#[test] -fn test_composite_score_fully_cohesive() { - let config = SrpConfig::default(); - // LCOM4=1, small struct → low score - let score = compute_composite_score(1, 3, 3, 0, &config); - assert!( - score < config.smell_threshold, - "Cohesive struct should score below threshold, got {score}" - ); -} - -#[test] -fn test_composite_score_high_lcom4() { - let config = SrpConfig::default(); - // LCOM4=4, many fields, many methods, high fan-out - let score = compute_composite_score(4, 15, 20, 12, &config); - assert!( - score >= config.smell_threshold, - "Incohesive struct should exceed threshold, got {score}" - ); -} - -#[test] -fn test_composite_score_lcom4_one_is_zero() { - let config = SrpConfig::default(); - let score_cohesive = compute_composite_score(1, 5, 5, 2, &config); - let score_incohesive = compute_composite_score(3, 5, 5, 2, &config); - assert!(score_incohesive > score_cohesive); -} - -#[test] -fn test_build_struct_warnings_no_warning_for_small_struct() { - let structs = vec![make_struct("Counter", &["count"])]; - let m1 = make_method("increment", "Counter", &["count"], &[]); - let m2 = make_method("get", "Counter", &["count"], &[]); - let methods = vec![m1, m2]; - let config = SrpConfig::default(); - let warnings = build_struct_warnings(&structs, &methods, &config); - assert!(warnings.is_empty(), "Small cohesive struct should not warn"); -} - -#[test] -fn test_build_struct_warnings_single_method_skipped() { - // Structs with <2 methods are skipped (LCOM4 is undefined) - let structs = vec![make_struct("Solo", &["x", "y", "z"])]; - let m1 = make_method("do_it", "Solo", &["x"], &[]); - let methods = vec![m1]; - let config = SrpConfig::default(); - let warnings = build_struct_warnings(&structs, &methods, &config); - assert!(warnings.is_empty()); -} - -#[test] -fn test_build_struct_warnings_no_methods_skipped() { - let structs = vec![make_struct("Data", &["x", "y"])]; - let methods = vec![]; - let config = SrpConfig::default(); - let warnings = build_struct_warnings(&structs, &methods, &config); - assert!(warnings.is_empty()); -} - -#[test] -fn test_build_struct_warnings_triggers_for_incohesive() { - // Create a struct with clearly disjoint method groups + high fan-out - let structs = vec![make_struct( - "GodObject", - &[ - "db", "cache", "logger", "metrics", "config", "state", "buffer", "queue", "pool", - "handler", "router", "auth", - ], - )]; - let methods = vec![ - make_method( - "read_db", - "GodObject", - &["db"], - &["query", "parse", "validate"], - ), - make_method("write_db", "GodObject", &["db"], &["insert", "commit"]), - make_method( - "read_cache", - "GodObject", - &["cache"], - &["get_key", "deserialize"], - ), - make_method( - "write_cache", - "GodObject", - &["cache"], - &["set_key", "serialize"], - ), - make_method("log_info", "GodObject", &["logger"], &["format_log"]), - make_method( - "log_error", - "GodObject", - &["logger", "metrics"], - &["format_log", "increment"], - ), - make_method( - "route_request", - "GodObject", - &["router", "handler"], - &["match_path", "dispatch"], - ), - make_method( - "authenticate", - "GodObject", - &["auth", "config"], - &["verify_token", "check_role"], - ), - make_method( - "flush_buffer", - "GodObject", - &["buffer", "queue"], - &["drain", "send"], - ), - make_method( - "manage_pool", - "GodObject", - &["pool", "state"], - &["allocate", "release"], - ), - ]; - let config = SrpConfig::default(); - let warnings = build_struct_warnings(&structs, &methods, &config); - assert!( - !warnings.is_empty(), - "Incohesive god object should trigger SRP warning" - ); - assert_eq!(warnings[0].struct_name, "GodObject"); -} - -#[test] -fn test_lcom4_transitive_connection() { - // a→{x}, b→{x,y}, c→{y} → all connected through b - let m1 = make_method("a", "Foo", &["x"], &[]); - let m2 = make_method("b", "Foo", &["x", "y"], &[]); - let m3 = make_method("c", "Foo", &["y"], &[]); - let methods: Vec<&MethodFieldData> = vec![&m1, &m2, &m3]; - let fields = vec!["x".to_string(), "y".to_string()]; - let (lcom4, _) = compute_lcom4( - &methods, - &fields, - &build_field_method_index(&methods, &fields), - ); - assert_eq!( - lcom4, 1, - "Transitively connected methods should form one component" - ); -} - -#[test] -fn test_cluster_contains_correct_fields() { - let m1 = make_method("a", "Foo", &["x"], &[]); - let m2 = make_method("b", "Foo", &["y"], &[]); - let methods: Vec<&MethodFieldData> = vec![&m1, &m2]; - let fields = vec!["x".to_string(), "y".to_string()]; - let (_, clusters) = compute_lcom4( - &methods, - &fields, - &build_field_method_index(&methods, &fields), - ); - assert_eq!(clusters.len(), 2); - // Each cluster should have exactly one method and one field - for c in &clusters { - assert_eq!(c.methods.len(), 1); - assert_eq!(c.fields.len(), 1); - } -} - -#[test] -fn test_lcom4_constructor_connects_all_fields() { - // Constructor (returns Self) should connect all methods via shared fields - let m1 = make_method("get_x", "Foo", &["x"], &[]); - let m2 = make_method("get_y", "Foo", &["y"], &[]); - let m3 = make_constructor("new", "Foo", &[]); - let methods: Vec<&MethodFieldData> = vec![&m1, &m2, &m3]; - let fields = vec!["x".to_string(), "y".to_string()]; - let (lcom4, _) = compute_lcom4( - &methods, - &fields, - &build_field_method_index(&methods, &fields), - ); - // Constructor touches all fields → connects get_x and get_y → LCOM4 = 1 - assert_eq!( - lcom4, 1, - "Constructor should connect disjoint method groups" - ); -} - -#[test] -fn test_lcom4_without_constructor_stays_disjoint() { - // Without constructor, disjoint getters stay separate - let m1 = make_method("get_x", "Foo", &["x"], &[]); - let m2 = make_method("get_y", "Foo", &["y"], &[]); - let methods: Vec<&MethodFieldData> = vec![&m1, &m2]; - let fields = vec!["x".to_string(), "y".to_string()]; - let (lcom4, _) = compute_lcom4( - &methods, - &fields, - &build_field_method_index(&methods, &fields), - ); - assert_eq!(lcom4, 2, "Without constructor, disjoint groups remain"); -} - -#[test] -fn test_lcom4_constructor_default_pattern() { - // fn default() -> Self is also a constructor - let m1 = make_method("get_a", "Config", &["a"], &[]); - let m2 = make_method("get_b", "Config", &["b"], &[]); - let m3 = make_method("get_c", "Config", &["c"], &[]); - let m4 = make_constructor("default", "Config", &[]); - let methods: Vec<&MethodFieldData> = vec![&m1, &m2, &m3, &m4]; - let fields = vec!["a".to_string(), "b".to_string(), "c".to_string()]; - let (lcom4, _) = compute_lcom4( - &methods, - &fields, - &build_field_method_index(&methods, &fields), - ); - assert_eq!(lcom4, 1, "Default constructor should unify all clusters"); -} - -#[test] -fn test_lcom4_ignores_non_struct_fields() { - // Method accesses a field that's not part of the struct → should be ignored - let m1 = make_method("a", "Foo", &["x", "foreign_field"], &[]); - let m2 = make_method("b", "Foo", &["x"], &[]); - let methods: Vec<&MethodFieldData> = vec![&m1, &m2]; - let fields = vec!["x".to_string()]; // foreign_field is not a struct field - let (lcom4, _) = compute_lcom4( - &methods, - &fields, - &build_field_method_index(&methods, &fields), - ); - assert_eq!(lcom4, 1, "Both methods share 'x', foreign field ignored"); -} - -#[test] -fn test_lcom4_self_method_call_resolves_field_access() { - // conn() accesses self.conn directly - // query() calls self.conn() — should transitively share 'conn' field - // insert() calls self.conn() — should also share 'conn' field - // Without resolution: query and insert have no direct field access → LCOM4=3 - // With resolution: all three share 'conn' → LCOM4=1 - let conn = make_method("conn", "Database", &["conn"], &[]); - let query = make_method_with_self_calls("query", "Database", &[], &["conn"]); - let insert = make_method_with_self_calls("insert", "Database", &[], &["conn"]); - let methods: Vec<&MethodFieldData> = vec![&conn, &query, &insert]; - let fields = vec!["conn".to_string()]; - let (lcom4, _) = compute_lcom4( - &methods, - &fields, - &build_field_method_index(&methods, &fields), - ); - assert_eq!( - lcom4, 1, - "Methods sharing field via self.conn() call should be one component" - ); -} - -// ── End-to-end collector tests exercising MethodBodyVisitor ────── - -/// Run the full SRP method collection path and return method data for a -/// single struct, so assertions can see exactly what `MethodBodyVisitor` -/// produces from real source. Bug 2 root cause was that `MethodBodyVisitor` -/// didn't descend into macro token streams, so `self.validate()` inside -/// `debug_assert!(...)` was invisible to LCOM4. -fn collect_methods_for(code: &str) -> Vec { - let syntax = syn::parse_file(code).expect("parse test fixture"); - let parsed = vec![("test.rs".to_string(), code.to_string(), syntax)]; - let mut result = Vec::new(); - let mut collector = crate::adapters::analyzers::srp::ImplMethodCollector { - file: String::new(), - methods: &mut result, - }; - crate::adapters::analyzers::dry::visit_all_files(&parsed, &mut collector); - result -} - -#[test] -fn method_body_visitor_sees_self_calls_inside_debug_assert_macro() { - let code = r#" - struct Storage { buf: usize, active: bool } - impl Storage { - fn seq_len(&self) -> usize { self.buf } - fn validate(&self) -> bool { self.active && self.buf > 0 } - fn append(&mut self, n: usize) { - self.buf = n; - self.active = true; - debug_assert!(self.validate()); - } - } - "#; - let methods = collect_methods_for(code); - let append = methods - .iter() - .find(|m| m.method_name == "append") - .expect("append collected"); - assert!( - append.self_method_calls.contains("validate"), - "append should see self.validate() inside debug_assert!, got: {:?}", - append.self_method_calls - ); -} - -#[test] -fn lcom4_unites_methods_linked_via_debug_assert_macro() { - // Bug 2 reproducer. `append` only writes `extra`, which no other - // method touches — so field-sharing alone cannot unite the clusters. - // The sole link is `debug_assert!(self.validate())`, which lives in - // a macro token stream. Without visit_macro on MethodBodyVisitor, - // LCOM4 reports 2 clusters ({readers+validate}, {append}). - let code = r#" - struct Store { - a: usize, - b: usize, - extra: bool, - } - impl Store { - fn read_a(&self) -> usize { self.a } - fn read_b(&self) -> usize { self.b } - fn validate(&self) -> bool { self.a > 0 && self.b > 0 } - fn append(&mut self, flag: bool) { - self.extra = flag; - debug_assert!(self.validate()); - } - } - "#; - let syntax = syn::parse_file(code).expect("parse fixture"); - let parsed = vec![("test.rs".to_string(), code.to_string(), syntax)]; - let analysis = crate::adapters::analyzers::srp::analyze_srp( - &parsed, - &SrpConfig { - smell_threshold: 0.0, - ..SrpConfig::default() - }, - &HashMap::new(), - ); - let w = analysis - .struct_warnings - .iter() - .find(|w| w.struct_name == "Store") - .expect("Store warning collected (smell_threshold=0)"); - assert_eq!( - w.lcom4, 1, - "Macro-linked methods should form one cluster, got {}", - w.lcom4 - ); -} - -#[test] -fn lcom4_unites_methods_via_assert_eq_macro() { - let code = r#" - struct Pair { a: i32, b: i32 } - impl Pair { - fn a(&self) -> i32 { self.a } - fn b(&self) -> i32 { self.b } - fn check(&self) { - assert_eq!(self.a(), self.b()); - } - } - "#; - let methods = collect_methods_for(code); - let check = methods - .iter() - .find(|m| m.method_name == "check") - .expect("check collected"); - assert!( - check.self_method_calls.contains("a") && check.self_method_calls.contains("b"), - "check should see both self.a() and self.b() inside assert_eq!, got: {:?}", - check.self_method_calls - ); -} - -#[test] -fn lcom4_unites_methods_via_format_macro_call_edge() { - let code = r#" - struct View { title: String, body: String } - impl View { - fn title(&self) -> &str { &self.title } - fn body(&self) -> &str { &self.body } - fn render(&self) -> String { - format!("{} — {}", self.title(), self.body()) - } - } - "#; - let methods = collect_methods_for(code); - let render = methods - .iter() - .find(|m| m.method_name == "render") - .expect("render collected"); - assert!( - render.self_method_calls.contains("title") && render.self_method_calls.contains("body"), - "render should see self.title()/self.body() inside format!, got: {:?}", - render.self_method_calls - ); -} diff --git a/src/adapters/analyzers/srp/tests/cohesion/lcom4_and_collector.rs b/src/adapters/analyzers/srp/tests/cohesion/lcom4_and_collector.rs new file mode 100644 index 00000000..2737339b --- /dev/null +++ b/src/adapters/analyzers/srp/tests/cohesion/lcom4_and_collector.rs @@ -0,0 +1,224 @@ +use super::*; + +#[test] +fn lcom4_constructor_and_transitive_connections() { + // LCOM4 = number of connected components: methods sharing a field (directly + // or transitively) merge; a constructor (returns Self) touches all fields + // and unifies everything; fields not on the struct are ignored. + let cases: &[Lcom4CtorCase] = &[ + ( + "transitive: a{x}, b{x,y}, c{y} connect through b", + &[("a", &["x"]), ("b", &["x", "y"]), ("c", &["y"])], + &[], + &["x", "y"], + 1, + ), + ( + "disjoint getters without a constructor stay separate", + &[("get_x", &["x"]), ("get_y", &["y"])], + &[], + &["x", "y"], + 2, + ), + ( + "constructor connects otherwise-disjoint getters", + &[("get_x", &["x"]), ("get_y", &["y"])], + &["new"], + &["x", "y"], + 1, + ), + ( + "default() constructor also unifies all clusters", + &[("get_a", &["a"]), ("get_b", &["b"]), ("get_c", &["c"])], + &["default"], + &["a", "b", "c"], + 1, + ), + ( + "field not on the struct is ignored", + &[("a", &["x", "foreign_field"]), ("b", &["x"])], + &[], + &["x"], + 1, + ), + ]; + for (label, methods, constructors, struct_fields, expected) in cases { + let mut owned: Vec = methods + .iter() + .map(|(name, fields)| make_method(name, "T", fields, &[])) + .collect(); + owned.extend( + constructors + .iter() + .map(|name| make_constructor(name, "T", &[])), + ); + let refs: Vec<&MethodFieldData> = owned.iter().collect(); + let fields: Vec = struct_fields.iter().map(|s| s.to_string()).collect(); + let (lcom4, _) = compute_lcom4(&refs, &fields, &build_field_method_index(&refs, &fields)); + assert_eq!(lcom4, *expected, "case {label}"); + } +} + +#[test] +fn test_cluster_contains_correct_fields() { + let m1 = make_method("a", "Foo", &["x"], &[]); + let m2 = make_method("b", "Foo", &["y"], &[]); + let methods: Vec<&MethodFieldData> = vec![&m1, &m2]; + let fields = vec!["x".to_string(), "y".to_string()]; + let (_, clusters) = compute_lcom4( + &methods, + &fields, + &build_field_method_index(&methods, &fields), + ); + assert_eq!(clusters.len(), 2); + // Each cluster should have exactly one method and one field + for c in &clusters { + assert_eq!(c.methods.len(), 1); + assert_eq!(c.fields.len(), 1); + } +} + +#[test] +fn test_lcom4_self_method_call_resolves_field_access() { + // conn() accesses self.conn directly + // query() calls self.conn() — should transitively share 'conn' field + // insert() calls self.conn() — should also share 'conn' field + // Without resolution: query and insert have no direct field access → LCOM4=3 + // With resolution: all three share 'conn' → LCOM4=1 + let conn = make_method("conn", "Database", &["conn"], &[]); + let query = make_method_with_self_calls("query", "Database", &[], &["conn"]); + let insert = make_method_with_self_calls("insert", "Database", &[], &["conn"]); + let methods: Vec<&MethodFieldData> = vec![&conn, &query, &insert]; + let fields = vec!["conn".to_string()]; + let (lcom4, _) = compute_lcom4( + &methods, + &fields, + &build_field_method_index(&methods, &fields), + ); + assert_eq!( + lcom4, 1, + "Methods sharing field via self.conn() call should be one component" + ); +} + +// ── End-to-end collector tests exercising MethodBodyVisitor ────── + +#[test] +fn method_body_visitor_sees_self_calls_inside_debug_assert_macro() { + let code = r#" + struct Storage { buf: usize, active: bool } + impl Storage { + fn seq_len(&self) -> usize { self.buf } + fn validate(&self) -> bool { self.active && self.buf > 0 } + fn append(&mut self, n: usize) { + self.buf = n; + self.active = true; + debug_assert!(self.validate()); + } + } + "#; + let methods = collect_methods_for(code); + let append = methods + .iter() + .find(|m| m.method_name == "append") + .expect("append collected"); + assert!( + append.self_method_calls.contains("validate"), + "append should see self.validate() inside debug_assert!, got: {:?}", + append.self_method_calls + ); +} + +#[test] +fn lcom4_unites_methods_linked_via_debug_assert_macro() { + // Bug 2 reproducer. `append` only writes `extra`, which no other + // method touches — so field-sharing alone cannot unite the clusters. + // The sole link is `debug_assert!(self.validate())`, which lives in + // a macro token stream. Without visit_macro on MethodBodyVisitor, + // LCOM4 reports 2 clusters ({readers+validate}, {append}). + let code = r#" + struct Store { + a: usize, + b: usize, + extra: bool, + } + impl Store { + fn read_a(&self) -> usize { self.a } + fn read_b(&self) -> usize { self.b } + fn validate(&self) -> bool { self.a > 0 && self.b > 0 } + fn append(&mut self, flag: bool) { + self.extra = flag; + debug_assert!(self.validate()); + } + } + "#; + let syntax = syn::parse_file(code).expect("parse fixture"); + let parsed = vec![("test.rs".to_string(), code.to_string(), syntax)]; + let analysis = crate::adapters::analyzers::srp::analyze_srp( + &parsed, + &SrpConfig { + smell_threshold: 0.0, + ..SrpConfig::default() + }, + &HashMap::new(), + (300, 800), + ); + let w = analysis + .struct_warnings + .iter() + .find(|w| w.struct_name == "Store") + .expect("Store warning collected (smell_threshold=0)"); + assert_eq!( + w.lcom4, 1, + "Macro-linked methods should form one cluster, got {}", + w.lcom4 + ); +} + +#[test] +fn lcom4_unites_methods_via_assert_eq_macro() { + let code = r#" + struct Pair { a: i32, b: i32 } + impl Pair { + fn a(&self) -> i32 { self.a } + fn b(&self) -> i32 { self.b } + fn check(&self) { + assert_eq!(self.a(), self.b()); + } + } + "#; + let methods = collect_methods_for(code); + let check = methods + .iter() + .find(|m| m.method_name == "check") + .expect("check collected"); + assert!( + check.self_method_calls.contains("a") && check.self_method_calls.contains("b"), + "check should see both self.a() and self.b() inside assert_eq!, got: {:?}", + check.self_method_calls + ); +} + +#[test] +fn lcom4_unites_methods_via_format_macro_call_edge() { + let code = r#" + struct View { title: String, body: String } + impl View { + fn title(&self) -> &str { &self.title } + fn body(&self) -> &str { &self.body } + fn render(&self) -> String { + format!("{} — {}", self.title(), self.body()) + } + } + "#; + let methods = collect_methods_for(code); + let render = methods + .iter() + .find(|m| m.method_name == "render") + .expect("render collected"); + assert!( + render.self_method_calls.contains("title") && render.self_method_calls.contains("body"), + "render should see self.title()/self.body() inside format!, got: {:?}", + render.self_method_calls + ); +} diff --git a/src/adapters/analyzers/srp/tests/cohesion/mod.rs b/src/adapters/analyzers/srp/tests/cohesion/mod.rs new file mode 100644 index 00000000..12eb9bc8 --- /dev/null +++ b/src/adapters/analyzers/srp/tests/cohesion/mod.rs @@ -0,0 +1,109 @@ +//! Cohesion / LCOM4 + struct-SRP-warning tests. Split into focused +//! sub-files (each ≤ the SRP file-length cap); shared imports, the +//! `make_*`/`collect_methods_for` helpers, and the case-type aliases live +//! here and reach the sub-modules via `use super::*`. + +pub(super) use crate::adapters::analyzers::srp::cohesion::*; +pub(super) use crate::adapters::analyzers::srp::{MethodFieldData, StructInfo}; +pub(super) use crate::config::sections::SrpConfig; +pub(super) use std::collections::{HashMap, HashSet}; + +mod lcom4_and_collector; +mod scoring; +mod warnings; + +/// An LCOM4 scenario: `(label, methods, fields, expected_lcom4, +/// expected_clusters)`. Each method is `(name, field_accesses, call_targets)` +/// on parent `Foo`. `expected_clusters = None` skips the cluster-count check. +/// A tuple (not a struct) keeps the data table clear of BP-009. +pub(super) type Lcom4Case = ( + &'static str, + &'static [( + &'static str, + &'static [&'static str], + &'static [&'static str], + )], + &'static [&'static str], + usize, + Option, +); + +/// lcom4 constructor-connection case: `(label, field-accessing methods as +/// (name, fields), constructor names (return Self, connect every field), +/// struct fields, expected lcom4)`. +pub(super) type Lcom4CtorCase = ( + &'static str, + &'static [(&'static str, &'static [&'static str])], + &'static [&'static str], + &'static [&'static str], + usize, +); + +pub(super) fn make_method( + name: &str, + parent: &str, + fields: &[&str], + calls: &[&str], +) -> MethodFieldData { + MethodFieldData { + method_name: name.to_string(), + parent_type: parent.to_string(), + field_accesses: fields.iter().map(|s| s.to_string()).collect(), + call_targets: calls.iter().map(|s| s.to_string()).collect(), + self_method_calls: HashSet::new(), + is_constructor: false, + } +} + +pub(super) fn make_method_with_self_calls( + name: &str, + parent: &str, + fields: &[&str], + self_calls: &[&str], +) -> MethodFieldData { + MethodFieldData { + method_name: name.to_string(), + parent_type: parent.to_string(), + field_accesses: fields.iter().map(|s| s.to_string()).collect(), + call_targets: HashSet::new(), + self_method_calls: self_calls.iter().map(|s| s.to_string()).collect(), + is_constructor: false, + } +} + +pub(super) fn make_constructor(name: &str, parent: &str, calls: &[&str]) -> MethodFieldData { + MethodFieldData { + method_name: name.to_string(), + parent_type: parent.to_string(), + field_accesses: HashSet::new(), + call_targets: calls.iter().map(|s| s.to_string()).collect(), + self_method_calls: HashSet::new(), + is_constructor: true, + } +} + +pub(super) fn make_struct(name: &str, fields: &[&str]) -> StructInfo { + StructInfo { + name: name.to_string(), + file: "test.rs".to_string(), + line: 1, + fields: fields.iter().map(|s| s.to_string()).collect(), + } +} + +/// Run the full SRP method collection path and return method data for a +/// single struct, so assertions can see exactly what `MethodBodyVisitor` +/// produces from real source. Bug 2 root cause was that `MethodBodyVisitor` +/// didn't descend into macro token streams, so `self.validate()` inside +/// `debug_assert!(...)` was invisible to LCOM4. +pub(super) fn collect_methods_for(code: &str) -> Vec { + let syntax = syn::parse_file(code).expect("parse test fixture"); + let parsed = vec![("test.rs".to_string(), code.to_string(), syntax)]; + let mut result = Vec::new(); + let mut collector = crate::adapters::analyzers::srp::ImplMethodCollector { + file: String::new(), + methods: &mut result, + }; + crate::adapters::analyzers::dry::visit_all_files(&parsed, &mut collector); + result +} diff --git a/src/adapters/analyzers/srp/tests/cohesion/scoring.rs b/src/adapters/analyzers/srp/tests/cohesion/scoring.rs new file mode 100644 index 00000000..a08a40ef --- /dev/null +++ b/src/adapters/analyzers/srp/tests/cohesion/scoring.rs @@ -0,0 +1,102 @@ +use super::*; + +#[test] +fn lcom4_scenarios() { + let cases: &[Lcom4Case] = &[ + ( + "all methods share one field → fully cohesive", + &[("a", &["x"], &[]), ("b", &["x"], &[]), ("c", &["x"], &[])], + &["x", "y"], + 1, + Some(1), + ), + ( + "two disjoint method groups → two clusters", + &[ + ("a", &["x"], &[]), + ("b", &["x"], &[]), + ("c", &["y"], &[]), + ("d", &["y"], &[]), + ], + &["x", "y"], + 2, + Some(2), + ), + ( + "each method a unique field → N components", + &[("a", &["x"], &[]), ("b", &["y"], &[]), ("c", &["z"], &[])], + &["x", "y", "z"], + 3, + None, + ), + ("no methods → LCOM4 0, no clusters", &[], &["x"], 0, Some(0)), + ( + "method with no field access → isolated component", + &[("a", &["x"], &[]), ("b", &[], &["helper"])], + &["x"], + 2, + None, + ), + ]; + for (label, method_specs, field_names, exp_lcom4, exp_clusters) in cases { + let methods: Vec = method_specs + .iter() + .map(|(n, f, c)| make_method(n, "Foo", f, c)) + .collect(); + let refs: Vec<&MethodFieldData> = methods.iter().collect(); + let fields: Vec = field_names.iter().map(|s| s.to_string()).collect(); + let (lcom4, clusters) = + compute_lcom4(&refs, &fields, &build_field_method_index(&refs, &fields)); + assert_eq!(lcom4, *exp_lcom4, "case: {label}"); + if let Some(c) = exp_clusters { + assert_eq!(clusters.len(), *c, "case: {label}"); + } + } +} + +#[test] +fn test_fan_out_distinct_targets() { + let m1 = make_method("a", "Foo", &[], &["helper", "process"]); + let m2 = make_method("b", "Foo", &[], &["helper", "format"]); + let methods: Vec<&MethodFieldData> = vec![&m1, &m2]; + let fan_out = compute_fan_out(&methods); + assert_eq!(fan_out, 3); // helper, process, format +} + +#[test] +fn test_fan_out_empty() { + let m1 = make_method("a", "Foo", &["x"], &[]); + let methods: Vec<&MethodFieldData> = vec![&m1]; + let fan_out = compute_fan_out(&methods); + assert_eq!(fan_out, 0); +} + +#[test] +fn test_composite_score_fully_cohesive() { + let config = SrpConfig::default(); + // LCOM4=1, small struct → low score + let score = compute_composite_score(1, 3, 3, 0, &config); + assert!( + score < config.smell_threshold, + "Cohesive struct should score below threshold, got {score}" + ); +} + +#[test] +fn test_composite_score_high_lcom4() { + let config = SrpConfig::default(); + // LCOM4=4, many fields, many methods, high fan-out + let score = compute_composite_score(4, 15, 20, 12, &config); + assert!( + score >= config.smell_threshold, + "Incohesive struct should exceed threshold, got {score}" + ); +} + +#[test] +fn test_composite_score_lcom4_one_is_zero() { + let config = SrpConfig::default(); + let score_cohesive = compute_composite_score(1, 5, 5, 2, &config); + let score_incohesive = compute_composite_score(3, 5, 5, 2, &config); + assert!(score_incohesive > score_cohesive); +} diff --git a/src/adapters/analyzers/srp/tests/cohesion/warnings.rs b/src/adapters/analyzers/srp/tests/cohesion/warnings.rs new file mode 100644 index 00000000..20bc7bd0 --- /dev/null +++ b/src/adapters/analyzers/srp/tests/cohesion/warnings.rs @@ -0,0 +1,115 @@ +use super::*; + +#[test] +fn test_build_struct_warnings_no_warning_for_small_struct() { + let structs = vec![make_struct("Counter", &["count"])]; + let m1 = make_method("increment", "Counter", &["count"], &[]); + let m2 = make_method("get", "Counter", &["count"], &[]); + let methods = vec![m1, m2]; + let config = SrpConfig::default(); + let warnings = build_struct_warnings(&structs, &methods, &config); + assert!(warnings.is_empty(), "Small cohesive struct should not warn"); +} + +#[test] +fn test_build_struct_warnings_single_method_skipped() { + // Structs with <2 methods are skipped (LCOM4 is undefined) + let structs = vec![make_struct("Solo", &["x", "y", "z"])]; + let m1 = make_method("do_it", "Solo", &["x"], &[]); + let methods = vec![m1]; + let config = SrpConfig::default(); + let warnings = build_struct_warnings(&structs, &methods, &config); + assert!(warnings.is_empty()); +} + +#[test] +fn test_build_struct_warnings_no_methods_skipped() { + let structs = vec![make_struct("Data", &["x", "y"])]; + let methods = vec![]; + let config = SrpConfig::default(); + let warnings = build_struct_warnings(&structs, &methods, &config); + assert!(warnings.is_empty()); +} + +/// A 12-field "god object" with disjoint field groups and high fan-out — the +/// incohesive struct fixture that must trip the struct-SRP warning. +fn god_object_struct() -> Vec { + vec![make_struct( + "GodObject", + &[ + "db", "cache", "logger", "metrics", "config", "state", "buffer", "queue", "pool", + "handler", "router", "auth", + ], + )] +} + +/// Ten methods in clearly disjoint responsibility clusters (db / cache / +/// logging / routing / auth / buffering / pooling) — the incohesive arrange. +fn god_object_methods() -> Vec { + vec![ + make_method( + "read_db", + "GodObject", + &["db"], + &["query", "parse", "validate"], + ), + make_method("write_db", "GodObject", &["db"], &["insert", "commit"]), + make_method( + "read_cache", + "GodObject", + &["cache"], + &["get_key", "deserialize"], + ), + make_method( + "write_cache", + "GodObject", + &["cache"], + &["set_key", "serialize"], + ), + make_method("log_info", "GodObject", &["logger"], &["format_log"]), + make_method( + "log_error", + "GodObject", + &["logger", "metrics"], + &["format_log", "increment"], + ), + make_method( + "route_request", + "GodObject", + &["router", "handler"], + &["match_path", "dispatch"], + ), + make_method( + "authenticate", + "GodObject", + &["auth", "config"], + &["verify_token", "check_role"], + ), + make_method( + "flush_buffer", + "GodObject", + &["buffer", "queue"], + &["drain", "send"], + ), + make_method( + "manage_pool", + "GodObject", + &["pool", "state"], + &["allocate", "release"], + ), + ] +} + +#[test] +fn test_build_struct_warnings_triggers_for_incohesive() { + let warnings = build_struct_warnings( + &god_object_struct(), + &god_object_methods(), + &SrpConfig::default(), + ); + assert!( + !warnings.is_empty(), + "Incohesive god object should trigger SRP warning" + ); + assert_eq!(warnings[0].struct_name, "GodObject"); +} diff --git a/src/adapters/analyzers/srp/tests/module.rs b/src/adapters/analyzers/srp/tests/module.rs deleted file mode 100644 index e898f86e..00000000 --- a/src/adapters/analyzers/srp/tests/module.rs +++ /dev/null @@ -1,564 +0,0 @@ -use crate::adapters::analyzers::srp::module::*; -use crate::config::sections::SrpConfig; -use std::collections::HashMap; -use syn::visit::Visit; - -#[test] -fn test_count_production_lines_simple() { - let source = "fn main() {\n println!(\"hello\");\n}\n"; - assert_eq!(count_production_lines(source), 3); -} - -#[test] -fn test_count_production_lines_with_test_module() { - let source = "fn main() {}\n\n#[cfg(test)]\nmod tests {\n #[test]\n fn test_it() {}\n}\n"; - // Only "fn main() {}" is production code (1 line of code, blank lines skipped) - assert_eq!(count_production_lines(source), 1); -} - -#[test] -fn test_count_production_lines_skips_comments() { - let source = "// This is a comment\nfn foo() {}\n// Another comment\nfn bar() {}\n"; - assert_eq!(count_production_lines(source), 2); -} - -#[test] -fn test_count_production_lines_skips_blanks() { - let source = "\n\nfn foo() {}\n\n\nfn bar() {}\n\n"; - assert_eq!(count_production_lines(source), 2); -} - -#[test] -fn test_count_production_lines_stops_on_single_line_cfg_test() { - // Single-line form: `#[cfg(test)] mod tests { ... }` on one line. - // Previously this would not match `trimmed == "#[cfg(test)]"` and - // the test body would be counted as production. - let source = "fn main() {}\n#[cfg(test)] mod tests { fn t() {} fn u() {} }\n"; - assert_eq!( - count_production_lines(source), - 1, - "single-line `#[cfg(test)] mod tests` must terminate counting" - ); -} - -#[test] -fn test_count_production_lines_stops_on_cfg_test_with_trailing_whitespace() { - // `#[cfg(test)] ` (trailing whitespace) — exact-equality check - // used to skip past this line. - let source = "fn main() {}\n#[cfg(test)] \nmod tests { fn t() {} }\n"; - assert_eq!(count_production_lines(source), 1); -} - -#[test] -fn test_count_production_lines_skips_block_comment() { - // Multi-line `/* … */` block: opening line, body lines, and - // closing line are all non-production. - let source = "\ -/* - * A multi-line block comment. - * Spans several lines. - */ -fn foo() {} -"; - assert_eq!( - count_production_lines(source), - 1, - "only `fn foo() {{}}` is production" - ); -} - -#[test] -fn test_count_production_lines_skips_single_line_block_comment() { - let source = "/* header */\nfn foo() {}\nfn bar() {}\n"; - assert_eq!(count_production_lines(source), 2); -} - -#[test] -fn test_count_production_lines_counts_deref_starting_lines() { - // Lines starting with `*` outside a block comment are valid code - // (deref / assign-through pointer) and must count as production. - let source = "\ -fn write(p: &mut i32) { - *p = 42; - *p += 1; -} -"; - // Body lines: `fn` signature, 2 deref assignments, closing `}` — 4. - assert_eq!(count_production_lines(source), 4); -} - -#[test] -fn test_count_production_lines_counts_code_before_block_comment() { - // `let x = 1; /* note */` has code before the comment and must count. - let source = "fn foo() {\n let x = 1; /* note */\n}\n"; - assert_eq!(count_production_lines(source), 3); -} - -#[test] -fn test_count_production_lines_counts_code_after_inline_block_comment() { - // `/* note */ let x = 1;` has code AFTER the inline comment. - // A leading-only heuristic would wrongly skip this. - let source = "fn foo() {\n /* note */ let x = 1;\n}\n"; - assert_eq!(count_production_lines(source), 3); -} - -#[test] -fn test_count_production_lines_skips_pure_inline_block_comment() { - let source = "fn foo() {\n /* note */\n}\n"; - assert_eq!(count_production_lines(source), 2); -} - -#[test] -fn test_count_production_lines_handles_nested_block_comments() { - // Rust supports nested block comments: the inner `*/` must NOT - // close the outer, so "still outer" stays inside the comment. - let source = "\ -/* outer - /* inner */ - still outer */ -fn foo() {} -"; - assert_eq!( - count_production_lines(source), - 1, - "nested block comments must track depth, not a boolean flag" - ); -} - -#[test] -fn test_count_production_lines_nested_block_closes_properly() { - // Confirm depth unwinds correctly: after both `*/` the scanner - // is back at depth 0 and recognises `fn bar() {}` on the same - // line as real code. - let source = "/* a /* b */ c */ fn bar() {}\n"; - assert_eq!(count_production_lines(source), 1); -} - -#[test] -fn test_count_production_lines_empty() { - assert_eq!(count_production_lines(""), 0); -} - -#[test] -fn test_file_length_score_below_baseline() { - let score = compute_file_length_score(100, 300, 800); - assert!((score - 0.0).abs() < f64::EPSILON); -} - -#[test] -fn test_file_length_score_at_baseline() { - let score = compute_file_length_score(300, 300, 800); - assert!((score - 0.0).abs() < f64::EPSILON); -} - -#[test] -fn test_file_length_score_above_ceiling() { - let score = compute_file_length_score(1000, 300, 800); - assert!((score - 1.0).abs() < f64::EPSILON); -} - -#[test] -fn test_file_length_score_midpoint() { - let score = compute_file_length_score(550, 300, 800); - assert!((score - 0.5).abs() < f64::EPSILON); -} - -#[test] -fn test_file_length_score_at_ceiling() { - let score = compute_file_length_score(800, 300, 800); - assert!((score - 1.0).abs() < f64::EPSILON); -} - -#[test] -fn test_analyze_module_srp_below_baseline() { - let source = "fn foo() {}\nfn bar() {}\n"; - let syntax = syn::parse_file(source).unwrap(); - let parsed = vec![("test.rs".to_string(), source.to_string(), syntax)]; - let config = SrpConfig::default(); // baseline=300 - let call_graph = HashMap::new(); - let cfg_test_files = std::collections::HashSet::new(); - let warnings = analyze_module_srp(&parsed, &config, &call_graph, &cfg_test_files); - assert!(warnings.is_empty()); -} - -#[test] -fn test_analyze_module_srp_above_baseline() { - // Generate source with many lines - let mut source = String::new(); - for i in 0..400 { - source.push_str(&format!("fn func_{i}() {{ let x = 1; }}\n")); - } - let syntax = syn::parse_file(&source).unwrap(); - let parsed = vec![("big.rs".to_string(), source.to_string(), syntax)]; - let config = SrpConfig::default(); - let call_graph = HashMap::new(); - let cfg_test_files = std::collections::HashSet::new(); - let warnings = analyze_module_srp(&parsed, &config, &call_graph, &cfg_test_files); - assert!(!warnings.is_empty()); - assert_eq!(warnings[0].module, "big.rs"); - assert!(warnings[0].length_score > 0.0); -} - -#[test] -fn test_analyze_module_srp_skips_cfg_test_files() { - // A file reachable only under `#[cfg(test)]` is exempt from the - // module-SRP check. Without this, test-helper files with many - // independent #[test] fns get falsely flagged as "too many - // independent clusters" or "too many production lines". - let mut source = String::new(); - for i in 0..10 { - source.push_str(&format!( - "#[test]\nfn test_scenario_{i}() {{ assert!(true); }}\n" - )); - } - let syntax = syn::parse_file(&source).unwrap(); - let parsed = vec![( - "src/some/tests/helpers.rs".to_string(), - source.to_string(), - syntax, - )]; - let config = SrpConfig::default(); - let call_graph = HashMap::new(); - let mut cfg_test_files = std::collections::HashSet::new(); - cfg_test_files.insert("src/some/tests/helpers.rs".to_string()); - let warnings = analyze_module_srp(&parsed, &config, &call_graph, &cfg_test_files); - assert!( - warnings.is_empty(), - "cfg-test file must be skipped: {warnings:?}" - ); -} - -#[test] -fn test_analyze_module_srp_still_flags_non_cfg_test_files() { - // Negative control: without cfg-test tag, a big production file with - // many isolated substantive functions is flagged as "too many clusters". - let mut source = String::new(); - for i in 0..10 { - source.push_str(&format!( - "fn helper_{i}() {{ let a = 1; let b = 2; let c = 3; let d = 4; let e = 5; }}\n" - )); - } - let syntax = syn::parse_file(&source).unwrap(); - let parsed = vec![("src/prod/module.rs".to_string(), source.to_string(), syntax)]; - let config = SrpConfig::default(); - let call_graph = HashMap::new(); - let cfg_test_files = std::collections::HashSet::new(); // empty - let warnings = analyze_module_srp(&parsed, &config, &call_graph, &cfg_test_files); - assert!( - !warnings.is_empty(), - "production file with many unconnected substantive fns must be flagged" - ); -} - -#[test] -fn test_analyze_module_srp_test_lines_excluded() { - // Production lines below baseline, but with large test module - let mut source = String::from("fn foo() {}\nfn bar() {}\n\n#[cfg(test)]\nmod tests {\n"); - for i in 0..500 { - source.push_str(&format!(" fn test_{i}() {{ assert!(true); }}\n")); - } - source.push_str("}\n"); - let syntax = syn::parse_file(&source).unwrap(); - let parsed = vec![("test.rs".to_string(), source.to_string(), syntax)]; - let config = SrpConfig::default(); - let call_graph = HashMap::new(); - let cfg_test_files = std::collections::HashSet::new(); - let warnings = analyze_module_srp(&parsed, &config, &call_graph, &cfg_test_files); - assert!( - warnings.is_empty(), - "Test code should not count towards production lines" - ); -} - -// ── Free function collector tests ───────────────────────────── - -#[test] -fn test_collect_free_functions_basic() { - let code = "fn foo() {} pub fn bar() {} fn baz(x: i32) { let a = 1; let b = 2; }"; - let syntax = syn::parse_file(code).unwrap(); - let fns = collect_free_functions(&syntax); - assert_eq!(fns.len(), 3); - assert!(fns[0].is_private); - assert!(!fns[1].is_private); - assert!(fns[2].is_private); - assert_eq!(fns[2].statement_count, 2); -} - -#[test] -fn test_collect_free_functions_skips_impl_methods() { - let code = "struct S; impl S { fn method(&self) {} } fn free() {}"; - let syntax = syn::parse_file(code).unwrap(); - let fns = collect_free_functions(&syntax); - assert_eq!(fns.len(), 1); - assert_eq!(fns[0].name, "free"); -} - -// ── Independent cluster tests ───────────────────────────────── - -#[test] -fn test_clusters_no_functions() { - let (count, names) = count_independent_clusters(&[], &[], 5); - assert_eq!(count, 0); - assert!(names.is_empty()); -} - -#[test] -fn test_clusters_single_private_function() { - let fns = vec![FreeFunctionInfo { - name: "alpha".to_string(), - is_private: true, - statement_count: 10, - }]; - let (count, _) = count_independent_clusters(&fns, &[], 5); - assert_eq!(count, 1); -} - -#[test] -fn test_clusters_connected_functions() { - let fns = vec![ - FreeFunctionInfo { - name: "a".to_string(), - is_private: true, - statement_count: 10, - }, - FreeFunctionInfo { - name: "b".to_string(), - is_private: true, - statement_count: 10, - }, - FreeFunctionInfo { - name: "c".to_string(), - is_private: true, - statement_count: 10, - }, - ]; - // a calls b, b calls c → all connected - let calls = vec![ - ("a".to_string(), vec!["b".to_string()]), - ("b".to_string(), vec!["c".to_string()]), - ]; - let (count, names) = count_independent_clusters(&fns, &calls, 5); - assert_eq!(count, 1); - assert_eq!(names[0].len(), 3); -} - -#[test] -fn test_clusters_disconnected_functions() { - let fns = vec![ - FreeFunctionInfo { - name: "a".to_string(), - is_private: true, - statement_count: 10, - }, - FreeFunctionInfo { - name: "b".to_string(), - is_private: true, - statement_count: 10, - }, - FreeFunctionInfo { - name: "c".to_string(), - is_private: true, - statement_count: 10, - }, - FreeFunctionInfo { - name: "d".to_string(), - is_private: true, - statement_count: 10, - }, - ]; - // a calls b, c calls d → 2 clusters - let calls = vec![ - ("a".to_string(), vec!["b".to_string()]), - ("c".to_string(), vec!["d".to_string()]), - ]; - let (count, names) = count_independent_clusters(&fns, &calls, 5); - assert_eq!(count, 2); - assert_eq!(names.len(), 2); -} - -#[test] -fn test_clusters_public_functions_excluded() { - let fns = vec![ - FreeFunctionInfo { - name: "pub_fn".to_string(), - is_private: false, - statement_count: 10, - }, - FreeFunctionInfo { - name: "priv_fn".to_string(), - is_private: true, - statement_count: 10, - }, - ]; - let (count, _) = count_independent_clusters(&fns, &[], 5); - assert_eq!(count, 1); // only priv_fn counted -} - -#[test] -fn test_clusters_small_functions_excluded() { - let fns = vec![ - FreeFunctionInfo { - name: "small".to_string(), - is_private: true, - statement_count: 2, - }, - FreeFunctionInfo { - name: "big".to_string(), - is_private: true, - statement_count: 10, - }, - ]; - let (count, _) = count_independent_clusters(&fns, &[], 5); - assert_eq!(count, 1); // only big counted -} - -#[test] -fn test_clusters_three_independent_triggers_warning() { - let fns = vec![ - FreeFunctionInfo { - name: "algo1".to_string(), - is_private: true, - statement_count: 10, - }, - FreeFunctionInfo { - name: "algo2".to_string(), - is_private: true, - statement_count: 10, - }, - FreeFunctionInfo { - name: "algo3".to_string(), - is_private: true, - statement_count: 10, - }, - ]; - // No calls between them → 3 independent clusters - let (count, names) = count_independent_clusters(&fns, &[], 5); - assert_eq!(count, 3); - assert_eq!(names.len(), 3); -} - -#[test] -fn test_clusters_shared_caller_unites_callees() { - // Private functions a, b, c are all called by public entry_point - // → they serve the same responsibility and should be 1 cluster - let fns = vec![ - FreeFunctionInfo { - name: "a".to_string(), - is_private: true, - statement_count: 10, - }, - FreeFunctionInfo { - name: "b".to_string(), - is_private: true, - statement_count: 10, - }, - FreeFunctionInfo { - name: "c".to_string(), - is_private: true, - statement_count: 10, - }, - ]; - // entry_point (not in private set) calls a, b, c → unites them - let calls = vec![( - "entry_point".to_string(), - vec!["a".to_string(), "b".to_string(), "c".to_string()], - )]; - let (count, names) = count_independent_clusters(&fns, &calls, 5); - assert_eq!(count, 1); - assert_eq!(names[0].len(), 3); -} - -#[test] -fn test_clusters_two_callers_two_groups() { - // Two public entry points each calling different private functions - // → 2 clusters, not 4 - let fns = vec![ - FreeFunctionInfo { - name: "a".to_string(), - is_private: true, - statement_count: 10, - }, - FreeFunctionInfo { - name: "b".to_string(), - is_private: true, - statement_count: 10, - }, - FreeFunctionInfo { - name: "c".to_string(), - is_private: true, - statement_count: 10, - }, - FreeFunctionInfo { - name: "d".to_string(), - is_private: true, - statement_count: 10, - }, - ]; - let calls = vec![ - ("pub1".to_string(), vec!["a".to_string(), "b".to_string()]), - ("pub2".to_string(), vec!["c".to_string(), "d".to_string()]), - ]; - let (count, names) = count_independent_clusters(&fns, &calls, 5); - assert_eq!(count, 2); - assert_eq!(names.len(), 2); -} - -#[test] -fn test_cohesion_warning_without_length_warning() { - // File is short (below baseline) but has 3+ independent private algorithms - let code = r#" -fn algo_sort(data: &mut [i32]) { -let n = data.len(); -let mut swapped = true; -while swapped { - swapped = false; - for i in 1..n { - if data[i - 1] > data[i] { - data.swap(i - 1, i); - swapped = true; - } - } -} -} -fn algo_search(data: &[i32], target: i32) -> Option { -let mut lo = 0; -let mut hi = data.len(); -while lo < hi { - let mid = (lo + hi) / 2; - if data[mid] == target { - return Some(mid); - } else if data[mid] < target { - lo = mid + 1; - } else { - hi = mid; - } -} -None -} -fn algo_hash(data: &[u8]) -> u64 { -let mut h: u64 = 0; -for &b in data { - h = h.wrapping_mul(31).wrapping_add(b as u64); -} -let extra = data.len() as u64; -let final_val = h ^ extra; -final_val -} -"#; - let syntax = syn::parse_file(code).unwrap(); - let parsed = vec![("algos.rs".to_string(), code.to_string(), syntax)]; - // `max_*` thresholds are exclusive ("highest value that still - // passes"); with 3 independent clusters in the fixture, setting - // the max to 2 is what triggers the warning. - let config = SrpConfig { - max_independent_clusters: 2, - min_cluster_statements: 3, - ..SrpConfig::default() - }; - let call_graph = HashMap::new(); - let cfg_test_files = std::collections::HashSet::new(); - let warnings = analyze_module_srp(&parsed, &config, &call_graph, &cfg_test_files); - assert_eq!(warnings.len(), 1); - assert_eq!(warnings[0].independent_clusters, 3); - assert!((warnings[0].length_score - 0.0).abs() < f64::EPSILON); -} diff --git a/src/adapters/analyzers/srp/tests/module/clusters.rs b/src/adapters/analyzers/srp/tests/module/clusters.rs new file mode 100644 index 00000000..45445831 --- /dev/null +++ b/src/adapters/analyzers/srp/tests/module/clusters.rs @@ -0,0 +1,271 @@ +use super::*; + +// ── Independent cluster tests ───────────────────────────────── + +#[test] +fn test_clusters_no_functions() { + let (count, names) = count_independent_clusters(&[], &[], 5); + assert_eq!(count, 0); + assert!(names.is_empty()); +} + +#[test] +fn test_clusters_single_private_function() { + let fns = vec![FreeFunctionInfo { + name: "alpha".to_string(), + is_private: true, + statement_count: 10, + }]; + let (count, _) = count_independent_clusters(&fns, &[], 5); + assert_eq!(count, 1); +} + +#[test] +fn test_clusters_connected_functions() { + let fns = vec![ + FreeFunctionInfo { + name: "a".to_string(), + is_private: true, + statement_count: 10, + }, + FreeFunctionInfo { + name: "b".to_string(), + is_private: true, + statement_count: 10, + }, + FreeFunctionInfo { + name: "c".to_string(), + is_private: true, + statement_count: 10, + }, + ]; + // a calls b, b calls c → all connected + let calls = vec![ + ("a".to_string(), vec!["b".to_string()]), + ("b".to_string(), vec!["c".to_string()]), + ]; + let (count, names) = count_independent_clusters(&fns, &calls, 5); + assert_eq!(count, 1); + assert_eq!(names[0].len(), 3); +} + +#[test] +fn test_clusters_disconnected_functions() { + let fns = vec![ + FreeFunctionInfo { + name: "a".to_string(), + is_private: true, + statement_count: 10, + }, + FreeFunctionInfo { + name: "b".to_string(), + is_private: true, + statement_count: 10, + }, + FreeFunctionInfo { + name: "c".to_string(), + is_private: true, + statement_count: 10, + }, + FreeFunctionInfo { + name: "d".to_string(), + is_private: true, + statement_count: 10, + }, + ]; + // a calls b, c calls d → 2 clusters + let calls = vec![ + ("a".to_string(), vec!["b".to_string()]), + ("c".to_string(), vec!["d".to_string()]), + ]; + let (count, names) = count_independent_clusters(&fns, &calls, 5); + assert_eq!(count, 2); + assert_eq!(names.len(), 2); +} + +#[test] +fn test_clusters_public_functions_excluded() { + let fns = vec![ + FreeFunctionInfo { + name: "pub_fn".to_string(), + is_private: false, + statement_count: 10, + }, + FreeFunctionInfo { + name: "priv_fn".to_string(), + is_private: true, + statement_count: 10, + }, + ]; + let (count, _) = count_independent_clusters(&fns, &[], 5); + assert_eq!(count, 1); // only priv_fn counted +} + +#[test] +fn test_clusters_small_functions_excluded() { + let fns = vec![ + FreeFunctionInfo { + name: "small".to_string(), + is_private: true, + statement_count: 2, + }, + FreeFunctionInfo { + name: "big".to_string(), + is_private: true, + statement_count: 10, + }, + ]; + let (count, _) = count_independent_clusters(&fns, &[], 5); + assert_eq!(count, 1); // only big counted +} + +#[test] +fn test_clusters_three_independent_triggers_warning() { + let fns = vec![ + FreeFunctionInfo { + name: "algo1".to_string(), + is_private: true, + statement_count: 10, + }, + FreeFunctionInfo { + name: "algo2".to_string(), + is_private: true, + statement_count: 10, + }, + FreeFunctionInfo { + name: "algo3".to_string(), + is_private: true, + statement_count: 10, + }, + ]; + // No calls between them → 3 independent clusters + let (count, names) = count_independent_clusters(&fns, &[], 5); + assert_eq!(count, 3); + assert_eq!(names.len(), 3); +} + +#[test] +fn test_clusters_shared_caller_unites_callees() { + // Private functions a, b, c are all called by public entry_point + // → they serve the same responsibility and should be 1 cluster + let fns = vec![ + FreeFunctionInfo { + name: "a".to_string(), + is_private: true, + statement_count: 10, + }, + FreeFunctionInfo { + name: "b".to_string(), + is_private: true, + statement_count: 10, + }, + FreeFunctionInfo { + name: "c".to_string(), + is_private: true, + statement_count: 10, + }, + ]; + // entry_point (not in private set) calls a, b, c → unites them + let calls = vec![( + "entry_point".to_string(), + vec!["a".to_string(), "b".to_string(), "c".to_string()], + )]; + let (count, names) = count_independent_clusters(&fns, &calls, 5); + assert_eq!(count, 1); + assert_eq!(names[0].len(), 3); +} + +#[test] +fn test_clusters_two_callers_two_groups() { + // Two public entry points each calling different private functions + // → 2 clusters, not 4 + let fns = vec![ + FreeFunctionInfo { + name: "a".to_string(), + is_private: true, + statement_count: 10, + }, + FreeFunctionInfo { + name: "b".to_string(), + is_private: true, + statement_count: 10, + }, + FreeFunctionInfo { + name: "c".to_string(), + is_private: true, + statement_count: 10, + }, + FreeFunctionInfo { + name: "d".to_string(), + is_private: true, + statement_count: 10, + }, + ]; + let calls = vec![ + ("pub1".to_string(), vec!["a".to_string(), "b".to_string()]), + ("pub2".to_string(), vec!["c".to_string(), "d".to_string()]), + ]; + let (count, names) = count_independent_clusters(&fns, &calls, 5); + assert_eq!(count, 2); + assert_eq!(names.len(), 2); +} + +#[test] +fn test_cohesion_warning_without_length_warning() { + // File is short (below baseline) but has 3+ independent private algorithms + let code = r#" +fn algo_sort(data: &mut [i32]) { +let n = data.len(); +let mut swapped = true; +while swapped { + swapped = false; + for i in 1..n { + if data[i - 1] > data[i] { + data.swap(i - 1, i); + swapped = true; + } + } +} +} +fn algo_search(data: &[i32], target: i32) -> Option { +let mut lo = 0; +let mut hi = data.len(); +while lo < hi { + let mid = (lo + hi) / 2; + if data[mid] == target { + return Some(mid); + } else if data[mid] < target { + lo = mid + 1; + } else { + hi = mid; + } +} +None +} +fn algo_hash(data: &[u8]) -> u64 { +let mut h: u64 = 0; +for &b in data { + h = h.wrapping_mul(31).wrapping_add(b as u64); +} +let extra = data.len() as u64; +let final_val = h ^ extra; +final_val +} +"#; + let syntax = syn::parse_file(code).unwrap(); + let parsed = vec![("algos.rs".to_string(), code.to_string(), syntax)]; + // `max_*` thresholds are exclusive ("highest value that still + // passes"); with 3 independent clusters in the fixture, setting + // the max to 2 is what triggers the warning. + let config = SrpConfig { + max_independent_clusters: 2, + min_cluster_statements: 3, + ..SrpConfig::default() + }; + let call_graph = HashMap::new(); + let cfg_test_files = std::collections::HashSet::new(); + let warnings = analyze_module_srp(&parsed, &config, &call_graph, &cfg_test_files, (300, 800)); + assert_eq!(warnings.len(), 1); + assert_eq!(warnings[0].independent_clusters, 3); + assert!((warnings[0].length_score - 0.0).abs() < f64::EPSILON); +} diff --git a/src/adapters/analyzers/srp/tests/module/mod.rs b/src/adapters/analyzers/srp/tests/module/mod.rs new file mode 100644 index 00000000..c800955c --- /dev/null +++ b/src/adapters/analyzers/srp/tests/module/mod.rs @@ -0,0 +1,13 @@ +//! Module-level SRP tests: production-line counting, file-length scoring, +//! `analyze_module_srp`, free-function collection, and independent-cluster +//! detection. Split into focused sub-files (each ≤ the SRP file-length cap); +//! shared imports live here and reach the sub-modules via `use super::*`. + +pub(super) use crate::adapters::analyzers::srp::module::*; +pub(super) use crate::config::sections::SrpConfig; +pub(super) use std::collections::HashMap; +pub(super) use syn::visit::Visit; + +mod clusters; +mod production_lines; +mod scoring_and_analysis; diff --git a/src/adapters/analyzers/srp/tests/module/production_lines.rs b/src/adapters/analyzers/srp/tests/module/production_lines.rs new file mode 100644 index 00000000..fc3010bc --- /dev/null +++ b/src/adapters/analyzers/srp/tests/module/production_lines.rs @@ -0,0 +1,137 @@ +use super::*; + +#[test] +fn test_count_production_lines_simple() { + let source = "fn main() {\n println!(\"hello\");\n}\n"; + assert_eq!(count_production_lines(source), 3); +} + +#[test] +fn test_count_production_lines_with_test_module() { + let source = "fn main() {}\n\n#[cfg(test)]\nmod tests {\n #[test]\n fn test_it() {}\n}\n"; + // Only "fn main() {}" is production code (1 line of code, blank lines skipped) + assert_eq!(count_production_lines(source), 1); +} + +#[test] +fn test_count_production_lines_skips_comments() { + let source = "// This is a comment\nfn foo() {}\n// Another comment\nfn bar() {}\n"; + assert_eq!(count_production_lines(source), 2); +} + +#[test] +fn test_count_production_lines_skips_blanks() { + let source = "\n\nfn foo() {}\n\n\nfn bar() {}\n\n"; + assert_eq!(count_production_lines(source), 2); +} + +#[test] +fn test_count_production_lines_stops_on_single_line_cfg_test() { + // Single-line form: `#[cfg(test)] mod tests { ... }` on one line. + // Previously this would not match `trimmed == "#[cfg(test)]"` and + // the test body would be counted as production. + let source = "fn main() {}\n#[cfg(test)] mod tests { fn t() {} fn u() {} }\n"; + assert_eq!( + count_production_lines(source), + 1, + "single-line `#[cfg(test)] mod tests` must terminate counting" + ); +} + +#[test] +fn test_count_production_lines_stops_on_cfg_test_with_trailing_whitespace() { + // `#[cfg(test)] ` (trailing whitespace) — exact-equality check + // used to skip past this line. + let source = "fn main() {}\n#[cfg(test)] \nmod tests { fn t() {} }\n"; + assert_eq!(count_production_lines(source), 1); +} + +#[test] +fn test_count_production_lines_skips_block_comment() { + // Multi-line `/* … */` block: opening line, body lines, and + // closing line are all non-production. + let source = "\ +/* + * A multi-line block comment. + * Spans several lines. + */ +fn foo() {} +"; + assert_eq!( + count_production_lines(source), + 1, + "only `fn foo() {{}}` is production" + ); +} + +#[test] +fn test_count_production_lines_skips_single_line_block_comment() { + let source = "/* header */\nfn foo() {}\nfn bar() {}\n"; + assert_eq!(count_production_lines(source), 2); +} + +#[test] +fn test_count_production_lines_counts_deref_starting_lines() { + // Lines starting with `*` outside a block comment are valid code + // (deref / assign-through pointer) and must count as production. + let source = "\ +fn write(p: &mut i32) { + *p = 42; + *p += 1; +} +"; + // Body lines: `fn` signature, 2 deref assignments, closing `}` — 4. + assert_eq!(count_production_lines(source), 4); +} + +#[test] +fn test_count_production_lines_counts_code_before_block_comment() { + // `let x = 1; /* note */` has code before the comment and must count. + let source = "fn foo() {\n let x = 1; /* note */\n}\n"; + assert_eq!(count_production_lines(source), 3); +} + +#[test] +fn test_count_production_lines_counts_code_after_inline_block_comment() { + // `/* note */ let x = 1;` has code AFTER the inline comment. + // A leading-only heuristic would wrongly skip this. + let source = "fn foo() {\n /* note */ let x = 1;\n}\n"; + assert_eq!(count_production_lines(source), 3); +} + +#[test] +fn test_count_production_lines_skips_pure_inline_block_comment() { + let source = "fn foo() {\n /* note */\n}\n"; + assert_eq!(count_production_lines(source), 2); +} + +#[test] +fn test_count_production_lines_handles_nested_block_comments() { + // Rust supports nested block comments: the inner `*/` must NOT + // close the outer, so "still outer" stays inside the comment. + let source = "\ +/* outer + /* inner */ + still outer */ +fn foo() {} +"; + assert_eq!( + count_production_lines(source), + 1, + "nested block comments must track depth, not a boolean flag" + ); +} + +#[test] +fn test_count_production_lines_nested_block_closes_properly() { + // Confirm depth unwinds correctly: after both `*/` the scanner + // is back at depth 0 and recognises `fn bar() {}` on the same + // line as real code. + let source = "/* a /* b */ c */ fn bar() {}\n"; + assert_eq!(count_production_lines(source), 1); +} + +#[test] +fn test_count_production_lines_empty() { + assert_eq!(count_production_lines(""), 0); +} diff --git a/src/adapters/analyzers/srp/tests/module/scoring_and_analysis.rs b/src/adapters/analyzers/srp/tests/module/scoring_and_analysis.rs new file mode 100644 index 00000000..8b8021c2 --- /dev/null +++ b/src/adapters/analyzers/srp/tests/module/scoring_and_analysis.rs @@ -0,0 +1,155 @@ +use super::*; + +#[test] +fn test_file_length_score_below_baseline() { + let score = compute_file_length_score(100, 300, 800); + assert!((score - 0.0).abs() < f64::EPSILON); +} + +#[test] +fn test_file_length_score_at_baseline() { + let score = compute_file_length_score(300, 300, 800); + assert!((score - 0.0).abs() < f64::EPSILON); +} + +#[test] +fn test_file_length_score_above_ceiling() { + let score = compute_file_length_score(1000, 300, 800); + assert!((score - 1.0).abs() < f64::EPSILON); +} + +#[test] +fn test_file_length_score_midpoint() { + let score = compute_file_length_score(550, 300, 800); + assert!((score - 0.5).abs() < f64::EPSILON); +} + +#[test] +fn test_file_length_score_at_ceiling() { + let score = compute_file_length_score(800, 300, 800); + assert!((score - 1.0).abs() < f64::EPSILON); +} + +#[test] +fn test_analyze_module_srp_below_baseline() { + let source = "fn foo() {}\nfn bar() {}\n"; + let syntax = syn::parse_file(source).unwrap(); + let parsed = vec![("test.rs".to_string(), source.to_string(), syntax)]; + let config = SrpConfig::default(); // baseline=300 + let call_graph = HashMap::new(); + let cfg_test_files = std::collections::HashSet::new(); + let warnings = analyze_module_srp(&parsed, &config, &call_graph, &cfg_test_files, (300, 800)); + assert!(warnings.is_empty()); +} + +// Module-SRP file-kind matrix: `(label, fn-template (IDX → index), count, path, +// is_cfg_test, expect_flagged)`. Locks in the test-aware behaviour — file-length +// applies to test files (at the resolved test baseline), but cohesion +// (independent clusters) is production-only: independent `#[test]` fns are a +// test file's purpose, not a low-cohesion smell. +type FileKindCase = (&'static str, &'static str, usize, &'static str, bool, bool); +const FILE_KIND_CASES: &[FileKindCase] = &[ + ( + "prod over baseline → length-flagged", + "fn func_IDX() { let x = 1; }\n", + 400, + "big.rs", + false, + true, + ), + ( + "cfg-test over baseline → length still applies", + "#[test]\nfn test_case_IDX() { assert!(true); }\n", + 400, + "src/some/tests/big.rs", + true, + true, + ), + ( + "prod independent substantive fns → cohesion-flagged", + "fn helper_IDX() { let a = 1; let b = 2; let c = 3; let d = 4; let e = 5; }\n", + 10, + "src/prod/module.rs", + false, + true, + ), + ( + "cfg-test independent substantive fns → cohesion exempt", + "fn helper_IDX() { let a = 1; let b = 2; let c = 3; let d = 4; let e = 5; }\n", + 10, + "src/some/tests/helpers.rs", + true, + false, + ), +]; + +#[test] +fn test_analyze_module_srp_length_and_cohesion_by_file_kind() { + for (label, template, count, path, is_cfg_test, expect_flagged) in FILE_KIND_CASES { + let mut source = String::new(); + for i in 0..*count { + source.push_str(&template.replace("IDX", &i.to_string())); + } + let syntax = syn::parse_file(&source).unwrap(); + let parsed = vec![(path.to_string(), source.clone(), syntax)]; + let mut cfg_test_files = std::collections::HashSet::new(); + if *is_cfg_test { + cfg_test_files.insert(path.to_string()); + } + let warnings = analyze_module_srp( + &parsed, + &SrpConfig::default(), + &HashMap::new(), + &cfg_test_files, + (300, 800), + ); + assert_eq!( + !warnings.is_empty(), + *expect_flagged, + "case {label}: {warnings:?}" + ); + } +} + +#[test] +fn test_analyze_module_srp_test_lines_excluded() { + // Production lines below baseline, but with large test module + let mut source = String::from("fn foo() {}\nfn bar() {}\n\n#[cfg(test)]\nmod tests {\n"); + for i in 0..500 { + source.push_str(&format!(" fn test_{i}() {{ assert!(true); }}\n")); + } + source.push_str("}\n"); + let syntax = syn::parse_file(&source).unwrap(); + let parsed = vec![("test.rs".to_string(), source.to_string(), syntax)]; + let config = SrpConfig::default(); + let call_graph = HashMap::new(); + let cfg_test_files = std::collections::HashSet::new(); + let warnings = analyze_module_srp(&parsed, &config, &call_graph, &cfg_test_files, (300, 800)); + assert!( + warnings.is_empty(), + "Test code should not count towards production lines" + ); +} + +// ── Free function collector tests ───────────────────────────── + +#[test] +fn test_collect_free_functions_basic() { + let code = "fn foo() {} pub fn bar() {} fn baz(x: i32) { let a = 1; let b = 2; }"; + let syntax = syn::parse_file(code).unwrap(); + let fns = collect_free_functions(&syntax); + assert_eq!(fns.len(), 3); + assert!(fns[0].is_private); + assert!(!fns[1].is_private); + assert!(fns[2].is_private); + assert_eq!(fns[2].statement_count, 2); +} + +#[test] +fn test_collect_free_functions_skips_impl_methods() { + let code = "struct S; impl S { fn method(&self) {} } fn free() {}"; + let syntax = syn::parse_file(code).unwrap(); + let fns = collect_free_functions(&syntax); + assert_eq!(fns.len(), 1); + assert_eq!(fns[0].name, "free"); +} diff --git a/src/adapters/analyzers/srp/tests/root.rs b/src/adapters/analyzers/srp/tests/root.rs index eb91d203..ba13daaa 100644 --- a/src/adapters/analyzers/srp/tests/root.rs +++ b/src/adapters/analyzers/srp/tests/root.rs @@ -195,7 +195,7 @@ fn test_analyze_srp_empty() { let parsed: Vec<(String, String, syn::File)> = vec![]; let config = SrpConfig::default(); let call_graph = std::collections::HashMap::new(); - let analysis = analyze_srp(&parsed, &config, &call_graph); + let analysis = analyze_srp(&parsed, &config, &call_graph, (300, 800)); assert!(analysis.struct_warnings.is_empty()); assert!(analysis.module_warnings.is_empty()); } @@ -214,7 +214,7 @@ fn test_analyze_srp_cohesive_struct() { let parsed = vec![("test.rs".to_string(), code.to_string(), syntax)]; let config = SrpConfig::default(); let call_graph = std::collections::HashMap::new(); - let analysis = analyze_srp(&parsed, &config, &call_graph); + let analysis = analyze_srp(&parsed, &config, &call_graph, (300, 800)); // Fully cohesive struct → no warning assert!( analysis.struct_warnings.is_empty(), @@ -234,7 +234,7 @@ fn test_analyze_srp_multiple_files() { ]; let config = SrpConfig::default(); let call_graph = std::collections::HashMap::new(); - let analysis = analyze_srp(&parsed, &config, &call_graph); + let analysis = analyze_srp(&parsed, &config, &call_graph, (300, 800)); // Both structs are simple → no warnings assert!(analysis.struct_warnings.is_empty()); } @@ -245,6 +245,6 @@ fn test_analyze_srp_returns_empty_param_warnings() { let parsed: Vec<(String, String, syn::File)> = vec![]; let config = SrpConfig::default(); let call_graph = std::collections::HashMap::new(); - let analysis = analyze_srp(&parsed, &config, &call_graph); + let analysis = analyze_srp(&parsed, &config, &call_graph, (300, 800)); assert!(analysis.param_warnings.is_empty()); } diff --git a/src/adapters/analyzers/structural/tests/btc.rs b/src/adapters/analyzers/structural/tests/btc.rs index f2fd6f7f..fa08c44c 100644 --- a/src/adapters/analyzers/structural/tests/btc.rs +++ b/src/adapters/analyzers/structural/tests/btc.rs @@ -3,13 +3,7 @@ use crate::adapters::analyzers::structural::{StructuralWarning, StructuralWarnin use crate::config::StructuralConfig; fn detect_in(source: &str) -> Vec { - let parsed = super::parse_single(source); - let config = StructuralConfig::default(); - let cfg_test_files = - crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(&parsed); - let mut warnings = Vec::new(); - detect_btc(&mut warnings, &parsed, &config, &cfg_test_files); - warnings + super::detect_single(source, detect_btc) } #[test] diff --git a/src/adapters/analyzers/structural/tests/deh.rs b/src/adapters/analyzers/structural/tests/deh.rs index 6c50b373..9de3e482 100644 --- a/src/adapters/analyzers/structural/tests/deh.rs +++ b/src/adapters/analyzers/structural/tests/deh.rs @@ -3,13 +3,7 @@ use crate::adapters::analyzers::structural::{StructuralWarning, StructuralWarnin use crate::config::StructuralConfig; fn detect_in(source: &str) -> Vec { - let parsed = super::parse_single(source); - let config = StructuralConfig::default(); - let cfg_test_files = - crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(&parsed); - let mut warnings = Vec::new(); - detect_deh(&mut warnings, &parsed, &config, &cfg_test_files); - warnings + super::detect_single(source, detect_deh) } #[test] diff --git a/src/adapters/analyzers/structural/tests/iet.rs b/src/adapters/analyzers/structural/tests/iet.rs index f3e2affd..a13af827 100644 --- a/src/adapters/analyzers/structural/tests/iet.rs +++ b/src/adapters/analyzers/structural/tests/iet.rs @@ -3,13 +3,7 @@ use crate::adapters::analyzers::structural::{StructuralWarning, StructuralWarnin use crate::config::StructuralConfig; fn detect_in(source: &str) -> Vec { - let parsed = super::parse_single(source); - let config = StructuralConfig::default(); - let cfg_test_files = - crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(&parsed); - let mut warnings = Vec::new(); - detect_iet(&mut warnings, &parsed, &config, &cfg_test_files); - warnings + super::detect_single(source, detect_iet) } #[test] diff --git a/src/adapters/analyzers/structural/tests/mod.rs b/src/adapters/analyzers/structural/tests/mod.rs index b423eeff..8625d7d8 100644 --- a/src/adapters/analyzers/structural/tests/mod.rs +++ b/src/adapters/analyzers/structural/tests/mod.rs @@ -25,3 +25,44 @@ pub(super) fn parse_multi(sources: &[(&str, &str)]) -> Vec<(String, String, syn: }) .collect() } + +use super::{StructuralMetadata, StructuralWarning}; +use crate::config::StructuralConfig; +use std::collections::HashSet; + +/// Run a parsed-tree structural detector (deh/iet/slm/nms/btc shape) over a +/// single-file fixture, returning its warnings. Centralises the +/// `parse_single → config → cfg_test_files → detect → warnings` boilerplate. +pub(super) fn detect_single( + source: &str, + detect: impl Fn( + &mut Vec, + &[(String, String, syn::File)], + &StructuralConfig, + &HashSet, + ), +) -> Vec { + let parsed = parse_single(source); + let config = StructuralConfig::default(); + let cfg_test_files = + crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(&parsed); + let mut warnings = Vec::new(); + detect(&mut warnings, &parsed, &config, &cfg_test_files); + warnings +} + +/// Run a metadata-based structural detector (sit/oi shape) over an +/// already-parsed fixture, returning its warnings. Shared by the single-file +/// (sit) and multi-file (oi) callers via the appropriate `parse_*` helper. +pub(super) fn detect_meta( + parsed: &[(String, String, syn::File)], + detect: impl Fn(&mut Vec, &StructuralMetadata, &StructuralConfig), +) -> Vec { + let cfg_test_files = + crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(parsed); + let meta = super::collect_metadata(parsed, &cfg_test_files); + let config = StructuralConfig::default(); + let mut warnings = Vec::new(); + detect(&mut warnings, &meta, &config); + warnings +} diff --git a/src/adapters/analyzers/structural/tests/nms.rs b/src/adapters/analyzers/structural/tests/nms.rs index 4c13b943..8e0ca104 100644 --- a/src/adapters/analyzers/structural/tests/nms.rs +++ b/src/adapters/analyzers/structural/tests/nms.rs @@ -1,15 +1,8 @@ use crate::adapters::analyzers::structural::nms::*; use crate::adapters::analyzers::structural::{StructuralWarning, StructuralWarningKind}; -use crate::config::StructuralConfig; fn detect_in(source: &str) -> Vec { - let parsed = super::parse_single(source); - let config = StructuralConfig::default(); - let cfg_test_files = - crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(&parsed); - let mut warnings = Vec::new(); - detect_nms(&mut warnings, &parsed, &config, &cfg_test_files); - warnings + super::detect_single(source, detect_nms) } #[test] diff --git a/src/adapters/analyzers/structural/tests/oi.rs b/src/adapters/analyzers/structural/tests/oi.rs index 03e16406..5f400672 100644 --- a/src/adapters/analyzers/structural/tests/oi.rs +++ b/src/adapters/analyzers/structural/tests/oi.rs @@ -4,14 +4,7 @@ use crate::adapters::analyzers::structural::{StructuralWarning, StructuralWarnin use crate::config::StructuralConfig; fn detect_multi(sources: &[(&str, &str)]) -> Vec { - let parsed = super::parse_multi(sources); - let cfg_test_files = - crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(&parsed); - let meta = collect_metadata(&parsed, &cfg_test_files); - let config = StructuralConfig::default(); - let mut warnings = Vec::new(); - detect_oi(&mut warnings, &meta, &config); - warnings + super::detect_meta(&super::parse_multi(sources), detect_oi) } #[test] diff --git a/src/adapters/analyzers/structural/tests/sit.rs b/src/adapters/analyzers/structural/tests/sit.rs index 71c7c925..2c474e28 100644 --- a/src/adapters/analyzers/structural/tests/sit.rs +++ b/src/adapters/analyzers/structural/tests/sit.rs @@ -4,14 +4,7 @@ use crate::adapters::analyzers::structural::{StructuralWarning, StructuralWarnin use crate::config::StructuralConfig; fn detect_from(source: &str) -> Vec { - let parsed = super::parse_single(source); - let cfg_test_files = - crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(&parsed); - let meta = collect_metadata(&parsed, &cfg_test_files); - let config = StructuralConfig::default(); - let mut warnings = Vec::new(); - detect_sit(&mut warnings, &meta, &config); - warnings + super::detect_meta(&super::parse_single(source), detect_sit) } #[test] diff --git a/src/adapters/analyzers/structural/tests/slm.rs b/src/adapters/analyzers/structural/tests/slm.rs index 15e20b23..d31e4e9d 100644 --- a/src/adapters/analyzers/structural/tests/slm.rs +++ b/src/adapters/analyzers/structural/tests/slm.rs @@ -1,15 +1,8 @@ use crate::adapters::analyzers::structural::slm::*; use crate::adapters::analyzers::structural::{StructuralWarning, StructuralWarningKind}; -use crate::config::StructuralConfig; fn detect_in(source: &str) -> Vec { - let parsed = super::parse_single(source); - let config = StructuralConfig::default(); - let cfg_test_files = - crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths(&parsed); - let mut warnings = Vec::new(); - detect_slm(&mut warnings, &parsed, &config, &cfg_test_files); - warnings + super::detect_single(source, detect_slm) } #[test] diff --git a/src/adapters/analyzers/tq/tests/coverage.rs b/src/adapters/analyzers/tq/tests/coverage.rs index 657fff72..43a9f209 100644 --- a/src/adapters/analyzers/tq/tests/coverage.rs +++ b/src/adapters/analyzers/tq/tests/coverage.rs @@ -43,16 +43,25 @@ fn make_lcov_data(fn_hits: &[(&str, u64)], line_hits: &[(usize, u64)]) -> LcovFi // ── TQ-004 tests ──────────────────────────────────────── #[test] -fn test_uncovered_function_detected() { - let results = vec![make_func("process", "src/lib.rs", 10)]; - let mut lcov = HashMap::new(); - lcov.insert( - "src/lib.rs".to_string(), - make_lcov_data(&[("process", 0)], &[]), - ); - let warnings = detect_uncovered_functions(&results, &lcov); - assert_eq!(warnings.len(), 1); - assert_eq!(warnings[0].kind, TqWarningKind::Uncovered); +fn uncovered_function_is_flagged_regardless_of_name() { + // A function with zero hits is flagged Uncovered. The second case guards a + // real regression: a production function merely *named* `test_*` (no test + // attribute, is_test = false) is real production code and must still be + // coverage-checked — the old name-prefix heuristic wrongly skipped it. + for (label, fn_name) in [ + ("ordinary production fn", "process"), + ("production fn named like a test", "test_connection"), + ] { + let results = vec![make_func(fn_name, "src/lib.rs", 10)]; + let mut lcov = HashMap::new(); + lcov.insert( + "src/lib.rs".to_string(), + make_lcov_data(&[(fn_name, 0)], &[]), + ); + let warnings = detect_uncovered_functions(&results, &lcov); + assert_eq!(warnings.len(), 1, "case {label}"); + assert_eq!(warnings[0].kind, TqWarningKind::Uncovered, "case {label}"); + } } #[test] @@ -92,22 +101,6 @@ fn test_function_excluded_by_is_test_flag() { assert!(warnings.is_empty()); } -#[test] -fn production_function_named_like_test_is_still_checked() { - // A production function merely *named* `test_*` (no test attribute, - // is_test = false) is real production code and must still be - // coverage-checked — the old name-prefix heuristic wrongly skipped it. - let results = vec![make_func("test_connection", "src/lib.rs", 10)]; - let mut lcov = HashMap::new(); - lcov.insert( - "src/lib.rs".to_string(), - make_lcov_data(&[("test_connection", 0)], &[]), - ); - let warnings = detect_uncovered_functions(&results, &lcov); - assert_eq!(warnings.len(), 1); - assert_eq!(warnings[0].kind, TqWarningKind::Uncovered); -} - #[test] fn test_suppressed_function_excluded() { let mut func = make_func("process", "src/lib.rs", 10); diff --git a/src/adapters/analyzers/tq/tests/sut.rs b/src/adapters/analyzers/tq/tests/sut.rs index c2bd0613..0cacb7d1 100644 --- a/src/adapters/analyzers/tq/tests/sut.rs +++ b/src/adapters/analyzers/tq/tests/sut.rs @@ -107,14 +107,15 @@ fn test_empty_test_emits_warning() { } #[test] -fn test_type_constructor_recognized_as_sut() { +fn test_associated_function_call_recognized_as_sut() { + // Any associated-function call on an in-scope type (`Type::assoc()`) counts + // as a SUT call — there's no `new`-specific path, so a constructor and a + // plain static method exercise the same recognition. let declared = vec![make_declared("new", false)]; - // Build a scope that includes a type named "MyType" let scope_source = "struct MyType {} impl MyType { fn new() -> Self { MyType {} } }"; let scope_syntax = syn::parse_file(scope_source).expect("scope source"); let scope_refs = vec![("lib.rs", &scope_syntax)]; let scope = ProjectScope::from_files(&scope_refs); - // Test: calling MyType::new() should count as SUT let source = r#" #[test] fn test_constructor() { @@ -131,29 +132,6 @@ fn test_type_constructor_recognized_as_sut() { ); } -#[test] -fn test_static_method_recognized_as_sut() { - let declared = vec![make_declared("load", false)]; - let scope_source = "struct Config {} impl Config { fn load() -> Self { Config {} } }"; - let scope_syntax = syn::parse_file(scope_source).expect("scope source"); - let scope_refs = vec![("lib.rs", &scope_syntax)]; - let scope = ProjectScope::from_files(&scope_refs); - let source = r#" - #[test] - fn test_load() { - let c = Config::load(); - } - "#; - let syntax = syn::parse_file(source).expect("test source"); - let parsed = vec![("test.rs".to_string(), source.to_string(), syntax)]; - let reaches_prod = HashSet::new(); - let warnings = detect_no_sut_tests(&parsed, &scope, &declared, &reaches_prod); - assert!( - warnings.is_empty(), - "Config::load() should be recognized as SUT call" - ); -} - #[test] fn test_transitive_sut_via_helper() { let declared = vec![make_declared("prod_fn", false)]; diff --git a/src/adapters/analyzers/tq/tests/untested.rs b/src/adapters/analyzers/tq/tests/untested.rs index 35cf8c67..68f7f75a 100644 --- a/src/adapters/analyzers/tq/tests/untested.rs +++ b/src/adapters/analyzers/tq/tests/untested.rs @@ -3,7 +3,7 @@ use crate::adapters::analyzers::dry::DeclaredFunction; use crate::adapters::analyzers::tq::untested::*; use crate::adapters::analyzers::tq::{TqWarning, TqWarningKind}; use crate::config::Config; -use std::collections::{HashMap, HashSet, VecDeque}; +use std::collections::{HashMap, HashSet}; fn make_declared(name: &str, is_test: bool) -> DeclaredFunction { DeclaredFunction { @@ -20,6 +20,28 @@ fn make_declared(name: &str, is_test: bool) -> DeclaredFunction { } } +/// Build the declared / prod-call / test-call / call-graph inputs, derive the +/// transitive tested set, and run TQ-untested detection. Collapses the shared +/// arrange across the transitive-coverage tests (each `edges` entry is one +/// `from → to` call; each `from` is unique in these fixtures). +fn untested_via_graph( + declared: &[&str], + prod: &[&str], + test: &[&str], + edges: &[(&str, &str)], +) -> Vec { + let declared: Vec = + declared.iter().map(|n| make_declared(n, false)).collect(); + let prod_calls: HashSet = prod.iter().map(|s| s.to_string()).collect(); + let test_calls: HashSet = test.iter().map(|s| s.to_string()).collect(); + let call_graph: HashMap> = edges + .iter() + .map(|(f, t)| (f.to_string(), vec![t.to_string()])) + .collect(); + let tested = build_transitive_tested_set(&test_calls, &call_graph); + detect_untested_functions(&declared, &prod_calls, &tested, &[], &Config::default()) +} + #[test] fn test_untested_prod_fn_emits_warning() { let declared = vec![make_declared("process", false)]; @@ -149,55 +171,26 @@ fn test_dead_code_excluded() { #[test] fn test_transitive_tested_not_flagged() { // Test calls A, A calls B → B should not be flagged - let declared = vec![make_declared("a", false), make_declared("b", false)]; - let prod_calls: HashSet = ["a", "b"].iter().map(|s| s.to_string()).collect(); - let test_calls: HashSet = ["a".to_string()].into(); - let call_graph: HashMap> = - [("a".to_string(), vec!["b".to_string()])].into(); - let tested = build_transitive_tested_set(&test_calls, &call_graph); - let config = Config::default(); - - let warnings = detect_untested_functions(&declared, &prod_calls, &tested, &[], &config); + let warnings = untested_via_graph(&["a", "b"], &["a", "b"], &["a"], &[("a", "b")]); assert!(warnings.is_empty(), "b is transitively tested via a"); } #[test] fn test_deep_transitive_not_flagged() { // Test calls A, A→B→C → C should not be flagged - let declared = vec![ - make_declared("a", false), - make_declared("b", false), - make_declared("c", false), - ]; - let prod_calls: HashSet = ["a", "b", "c"].iter().map(|s| s.to_string()).collect(); - let test_calls: HashSet = ["a".to_string()].into(); - let call_graph: HashMap> = [ - ("a".to_string(), vec!["b".to_string()]), - ("b".to_string(), vec!["c".to_string()]), - ] - .into(); - let tested = build_transitive_tested_set(&test_calls, &call_graph); - let config = Config::default(); - - let warnings = detect_untested_functions(&declared, &prod_calls, &tested, &[], &config); + let warnings = untested_via_graph( + &["a", "b", "c"], + &["a", "b", "c"], + &["a"], + &[("a", "b"), ("b", "c")], + ); assert!(warnings.is_empty(), "c is transitively tested via a→b→c"); } #[test] fn test_circular_calls_no_infinite_loop() { // A→B→A (cycle), test calls A → terminates without infinite loop - let declared = vec![make_declared("a", false), make_declared("b", false)]; - let prod_calls: HashSet = ["a", "b"].iter().map(|s| s.to_string()).collect(); - let test_calls: HashSet = ["a".to_string()].into(); - let call_graph: HashMap> = [ - ("a".to_string(), vec!["b".to_string()]), - ("b".to_string(), vec!["a".to_string()]), - ] - .into(); - let tested = build_transitive_tested_set(&test_calls, &call_graph); - let config = Config::default(); - - let warnings = detect_untested_functions(&declared, &prod_calls, &tested, &[], &config); + let warnings = untested_via_graph(&["a", "b"], &["a", "b"], &["a"], &[("a", "b"), ("b", "a")]); assert!( warnings.is_empty(), "cycle terminates; both a and b are tested" @@ -207,19 +200,7 @@ fn test_circular_calls_no_infinite_loop() { #[test] fn test_untested_leaf_still_flagged() { // Test calls A, A calls B, but D is never called transitively → D flagged - let declared = vec![ - make_declared("a", false), - make_declared("b", false), - make_declared("d", false), - ]; - let prod_calls: HashSet = ["a", "b", "d"].iter().map(|s| s.to_string()).collect(); - let test_calls: HashSet = ["a".to_string()].into(); - let call_graph: HashMap> = - [("a".to_string(), vec!["b".to_string()])].into(); - let tested = build_transitive_tested_set(&test_calls, &call_graph); - let config = Config::default(); - - let warnings = detect_untested_functions(&declared, &prod_calls, &tested, &[], &config); + let warnings = untested_via_graph(&["a", "b", "d"], &["a", "b", "d"], &["a"], &[("a", "b")]); assert_eq!(warnings.len(), 1); assert_eq!(warnings[0].function_name, "d"); } diff --git a/src/adapters/config/init.rs b/src/adapters/config/init.rs index c6597a06..d40a45af 100644 --- a/src/adapters/config/init.rs +++ b/src/adapters/config/init.rs @@ -143,7 +143,6 @@ similarity_threshold = 0.85 min_tokens = 30 min_lines = 5 min_statements = 3 -ignore_tests = true ignore_trait_impls = true detect_dead_code = true detect_wildcard_imports = true @@ -267,7 +266,6 @@ similarity_threshold = 0.85 min_tokens = 30 min_lines = 5 min_statements = 3 -ignore_tests = true ignore_trait_impls = true detect_dead_code = true detect_wildcard_imports = true diff --git a/src/adapters/config/sections.rs b/src/adapters/config/sections.rs index 6061c1a8..506d0430 100644 --- a/src/adapters/config/sections.rs +++ b/src/adapters/config/sections.rs @@ -118,7 +118,6 @@ pub struct DuplicatesConfig { pub min_tokens: usize, pub min_lines: usize, pub min_statements: usize, - pub ignore_tests: bool, pub ignore_trait_impls: bool, pub detect_dead_code: bool, pub detect_wildcard_imports: bool, @@ -133,7 +132,6 @@ impl Default for DuplicatesConfig { min_tokens: DEFAULT_MIN_TOKENS, min_lines: DEFAULT_MIN_LINES, min_statements: DEFAULT_MIN_STATEMENTS, - ignore_tests: true, ignore_trait_impls: true, detect_dead_code: DEFAULT_DETECT_DEAD_CODE, detect_wildcard_imports: DEFAULT_DETECT_WILDCARD_IMPORTS, diff --git a/src/adapters/config/tests/init.rs b/src/adapters/config/tests/init.rs index c99aad9f..e76389e7 100644 --- a/src/adapters/config/tests/init.rs +++ b/src/adapters/config/tests/init.rs @@ -1,6 +1,30 @@ use crate::adapters::config::init::*; use crate::config::Config; +/// Build a `ProjectMetrics` carrying just the complexity maxima (file/function +/// counts fixed at 1 — they only affect the generated comment text, not the +/// thresholds). Keeps repeated constructions out of `BP-009`'s window. +fn complexity_metrics( + max_cognitive: usize, + max_cyclomatic: usize, + max_nesting_depth: usize, + max_function_lines: usize, +) -> ProjectMetrics { + ProjectMetrics { + file_count: 1, + function_count: 1, + max_cognitive, + max_cyclomatic, + max_nesting_depth, + max_function_lines, + } +} + +/// Generate a tailored config for `metrics` and parse it back into a `Config`. +fn tailored_config(metrics: &ProjectMetrics) -> Config { + toml::from_str(&generate_tailored_config(metrics)).expect("tailored config must be valid TOML") +} + #[test] fn test_generate_default_config_is_valid_toml() { let content = generate_default_config(); @@ -34,15 +58,7 @@ fn test_generate_default_config_contents() { #[test] fn test_generate_tailored_config_is_valid_toml() { - let metrics = ProjectMetrics { - file_count: 10, - function_count: 50, - max_cognitive: 12, - max_cyclomatic: 8, - max_nesting_depth: 3, - max_function_lines: 45, - }; - let content = generate_tailored_config(&metrics); + let content = generate_tailored_config(&complexity_metrics(12, 8, 3, 45)); let result: Result = toml::from_str(&content); assert!( result.is_ok(), @@ -52,51 +68,41 @@ fn test_generate_tailored_config_is_valid_toml() { } #[test] -fn test_generate_tailored_config_uses_headroom() { - let metrics = ProjectMetrics { - file_count: 5, - function_count: 20, - max_cognitive: 20, - max_cyclomatic: 15, - max_nesting_depth: 5, - max_function_lines: 80, +fn tailored_config_complexity_thresholds() { + // Thresholds are set to 1.2× the observed maxima, but never below the + // built-in defaults (so a tiny project clamps to the defaults). + // (label, metrics, expected [cognitive, cyclomatic, nesting, function_lines]) + use crate::adapters::config::sections::{ + DEFAULT_MAX_COGNITIVE, DEFAULT_MAX_CYCLOMATIC, DEFAULT_MAX_FUNCTION_LINES, + DEFAULT_MAX_NESTING_DEPTH, }; - let content = generate_tailored_config(&metrics); - let cfg: Config = toml::from_str(&content).unwrap(); - assert_eq!(cfg.complexity.max_cognitive, 24); - assert_eq!(cfg.complexity.max_cyclomatic, 18); - assert_eq!(cfg.complexity.max_nesting_depth, 6); - assert_eq!(cfg.complexity.max_function_lines, 96); -} - -#[test] -fn test_generate_tailored_config_respects_minimums() { - let metrics = ProjectMetrics { - file_count: 1, - function_count: 2, - max_cognitive: 3, - max_cyclomatic: 2, - max_nesting_depth: 1, - max_function_lines: 10, - }; - let content = generate_tailored_config(&metrics); - let cfg: Config = toml::from_str(&content).unwrap(); - assert_eq!( - cfg.complexity.max_cognitive, - crate::adapters::config::sections::DEFAULT_MAX_COGNITIVE - ); - assert_eq!( - cfg.complexity.max_cyclomatic, - crate::adapters::config::sections::DEFAULT_MAX_CYCLOMATIC - ); - assert_eq!( - cfg.complexity.max_nesting_depth, - crate::adapters::config::sections::DEFAULT_MAX_NESTING_DEPTH - ); - assert_eq!( - cfg.complexity.max_function_lines, - crate::adapters::config::sections::DEFAULT_MAX_FUNCTION_LINES - ); + let cases: &[(&str, ProjectMetrics, [usize; 4])] = &[ + ( + "1.2× headroom above observed maxima", + complexity_metrics(20, 15, 5, 80), + [24, 18, 6, 96], + ), + ( + "tiny project clamps to the built-in defaults", + complexity_metrics(3, 2, 1, 10), + [ + DEFAULT_MAX_COGNITIVE, + DEFAULT_MAX_CYCLOMATIC, + DEFAULT_MAX_NESTING_DEPTH, + DEFAULT_MAX_FUNCTION_LINES, + ], + ), + ]; + for (label, metrics, [cognitive, cyclomatic, nesting, function_lines]) in cases { + let c = tailored_config(metrics).complexity; + assert_eq!(c.max_cognitive, *cognitive, "case {label}: cognitive"); + assert_eq!(c.max_cyclomatic, *cyclomatic, "case {label}: cyclomatic"); + assert_eq!(c.max_nesting_depth, *nesting, "case {label}: nesting"); + assert_eq!( + c.max_function_lines, *function_lines, + "case {label}: function_lines" + ); + } } #[test] diff --git a/src/adapters/report/html/tests/root.rs b/src/adapters/report/html/tests/root.rs index 9afc4284..62dd764c 100644 --- a/src/adapters/report/html/tests/root.rs +++ b/src/adapters/report/html/tests/root.rs @@ -1,7 +1,8 @@ use crate::adapters::analyzers::iosp::{ - compute_severity, CallOccurrence, Classification, ComplexityMetrics, FunctionAnalysis, - LogicOccurrence, MagicNumberOccurrence, + CallOccurrence, Classification, ComplexityMetrics, FunctionAnalysis, LogicOccurrence, + MagicNumberOccurrence, }; +use crate::adapters::report::test_support::make_result; use crate::ports::Reporter; use crate::report::html::*; use crate::report::Summary; @@ -16,33 +17,6 @@ fn build_html_string(analysis: &AnalysisResult) -> String { .render(&analysis.findings, &analysis.data) } -fn make_result(name: &str, classification: Classification) -> FunctionAnalysis { - let severity = compute_severity(&classification); - FunctionAnalysis { - name: name.to_string(), - file: "test.rs".to_string(), - line: 1, - classification, - parent_type: None, - suppressed: false, - complexity: None, - qualified_name: name.to_string(), - severity, - cognitive_warning: false, - cyclomatic_warning: false, - nesting_depth_warning: false, - function_length_warning: false, - unsafe_warning: false, - error_handling_warning: false, - complexity_suppressed: false, - own_calls: vec![], - parameter_count: 0, - is_trait_impl: false, - is_test: false, - effort_score: None, - } -} - fn make_analysis(results: Vec) -> AnalysisResult { let mut summary = Summary::from_results(&results); summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); diff --git a/src/adapters/report/mod.rs b/src/adapters/report/mod.rs index 130c9842..6cc20ecc 100644 --- a/src/adapters/report/mod.rs +++ b/src/adapters/report/mod.rs @@ -246,5 +246,7 @@ impl Summary { } } +#[cfg(test)] +mod test_support; #[cfg(test)] mod tests; diff --git a/src/adapters/report/sarif/tests/root.rs b/src/adapters/report/sarif/tests/root.rs deleted file mode 100644 index d181d70c..00000000 --- a/src/adapters/report/sarif/tests/root.rs +++ /dev/null @@ -1,373 +0,0 @@ -use crate::adapters::analyzers::iosp::{ - compute_severity, CallOccurrence, Classification, FunctionAnalysis, LogicOccurrence, -}; -use crate::report::sarif::*; -use crate::report::Summary; - -fn make_result(name: &str, classification: Classification) -> FunctionAnalysis { - let severity = compute_severity(&classification); - FunctionAnalysis { - name: name.to_string(), - file: "test.rs".to_string(), - line: 1, - classification, - parent_type: None, - suppressed: false, - complexity: None, - qualified_name: name.to_string(), - severity, - cognitive_warning: false, - cyclomatic_warning: false, - nesting_depth_warning: false, - function_length_warning: false, - unsafe_warning: false, - error_handling_warning: false, - complexity_suppressed: false, - own_calls: vec![], - parameter_count: 0, - is_trait_impl: false, - is_test: false, - effort_score: None, - } -} - -fn make_analysis(results: Vec) -> AnalysisResult { - let summary = Summary::from_results(&results); - let data = crate::app::projection::project_data(&results, None); - let findings = crate::domain::AnalysisFindings { - iosp: crate::app::projection::project_iosp(&results), - ..Default::default() - }; - AnalysisResult { - results, - summary, - findings, - data, - } -} - -#[test] -fn test_print_sarif_emits_no_results_when_clean() { - let analysis = make_analysis(vec![make_result("good_fn", Classification::Integration)]); - let s = build_sarif_string(&analysis); - let v: serde_json::Value = serde_json::from_str(&s).expect("valid SARIF JSON"); - let results = &v["runs"][0]["results"]; - assert_eq!( - results.as_array().map(Vec::len), - Some(0), - "Integration function should produce no SARIF results; got {s}" - ); -} - -#[test] -fn test_print_sarif_emits_violation_with_location() { - let analysis = make_analysis(vec![make_result( - "bad_fn", - Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![LogicOccurrence { - kind: "if".into(), - line: 5, - }], - call_locations: vec![CallOccurrence { - name: "helper".into(), - line: 6, - }], - }, - )]); - let s = build_sarif_string(&analysis); - let v: serde_json::Value = serde_json::from_str(&s).expect("valid SARIF JSON"); - let results = v["runs"][0]["results"].as_array().expect("results array"); - assert!( - !results.is_empty(), - "violation must produce SARIF result; got {s}" - ); - let r = &results[0]; - let physical = &r["locations"][0]["physicalLocation"]; - assert_eq!(physical["artifactLocation"]["uri"], "test.rs"); - assert_eq!(physical["region"]["startLine"], 1); - let rule_id = r["ruleId"].as_str().unwrap_or(""); - assert!(!rule_id.is_empty(), "rule_id must be set; got {s}"); -} - -#[test] -fn test_print_sarif_severity_for_many_violations_is_error_or_warning() { - let analysis = make_analysis(vec![make_result( - "complex_fn", - Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![ - LogicOccurrence { - kind: "if".into(), - line: 1, - }, - LogicOccurrence { - kind: "match".into(), - line: 2, - }, - LogicOccurrence { - kind: "for".into(), - line: 3, - }, - ], - call_locations: vec![ - CallOccurrence { - name: "a".into(), - line: 4, - }, - CallOccurrence { - name: "b".into(), - line: 5, - }, - CallOccurrence { - name: "c".into(), - line: 6, - }, - ], - }, - )]); - let s = build_sarif_string(&analysis); - let v: serde_json::Value = serde_json::from_str(&s).expect("valid SARIF JSON"); - let level = v["runs"][0]["results"][0]["level"].as_str().unwrap_or(""); - assert!( - matches!(level, "warning" | "error"), - "3+3 violation must map to warning or error level; got `{level}` in {s}" - ); -} - -#[test] -fn test_print_sarif_suppressed_skipped() { - let mut func = make_result( - "suppressed_fn", - Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![LogicOccurrence { - kind: "if".into(), - line: 1, - }], - call_locations: vec![CallOccurrence { - name: "f".into(), - line: 2, - }], - }, - ); - func.suppressed = true; - let analysis = make_analysis(vec![func]); - print_sarif(&analysis); -} - -#[test] -fn test_print_sarif_multiple_violations() { - let analysis = make_analysis(vec![ - make_result( - "bad1", - Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![LogicOccurrence { - kind: "if".into(), - line: 1, - }], - call_locations: vec![CallOccurrence { - name: "a".into(), - line: 2, - }], - }, - ), - make_result( - "bad2", - Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![LogicOccurrence { - kind: "while".into(), - line: 10, - }], - call_locations: vec![CallOccurrence { - name: "b".into(), - line: 12, - }], - }, - ), - ]); - print_sarif(&analysis); -} - -// ── Orphan-suppression SARIF coverage ───────────────────────── - -#[test] -fn sarif_reporter_emits_orphan_results_via_snapshot_view() { - use crate::domain::findings::OrphanSuppression; - let mut analysis = make_analysis(vec![]); - // Trait-driven path — populate `findings.orphan_suppressions` - // (NOT the legacy `analysis.orphan_suppressions` field). - analysis.findings.orphan_suppressions = vec![OrphanSuppression { - file: "src/foo.rs".into(), - line: 42, - dimensions: vec![crate::findings::Dimension::Srp], - reason: Some("legacy marker".into()), - }]; - let value = build_sarif_value(&analysis); - let results = value["runs"][0]["results"] - .as_array() - .expect("results array"); - let orphan = results - .iter() - .find(|r| r["ruleId"] == "ORPHAN-001") - .expect("orphan result in SARIF output"); - assert_eq!(orphan["level"], "warning"); - assert_eq!( - orphan["locations"][0]["physicalLocation"]["artifactLocation"]["uri"], - "src/foo.rs" - ); - assert_eq!( - orphan["locations"][0]["physicalLocation"]["region"]["startLine"], - 42 - ); - let msg = orphan["message"]["text"].as_str().expect("message text"); - assert!( - msg.contains("srp"), - "message should name suppressed dim: {msg}" - ); - assert!( - msg.contains("legacy marker"), - "message should carry reason: {msg}" - ); -} - -#[test] -fn sarif_rules_include_orphan_suppression() { - let analysis = make_analysis(vec![]); - let value = build_sarif_value(&analysis); - let rules = value["runs"][0]["tool"]["driver"]["rules"] - .as_array() - .expect("rules array"); - let orphan_rule = rules - .iter() - .find(|r| r["id"] == "ORPHAN-001") - .expect("ORPHAN-001 rule present in tool.driver.rules"); - let desc = orphan_rule["shortDescription"]["text"] - .as_str() - .expect("shortDescription text"); - assert!( - desc.to_lowercase().contains("orphan") || desc.to_lowercase().contains("stale"), - "rule description should name the orphan concept: {desc}" - ); -} - -// ── Architecture findings SARIF coverage (v1.2.1) ───────────── - -fn make_arch_finding(rule_id: &str, severity: crate::domain::Severity) -> crate::domain::Finding { - crate::domain::Finding { - file: "src/cli/handlers.rs".to_string(), - line: 17, - column: 0, - dimension: crate::findings::Dimension::Architecture, - rule_id: rule_id.to_string(), - severity, - message: format!("test message for {rule_id}"), - suppressed: false, - } -} - -#[test] -fn sarif_emits_architecture_call_parity_finding() { - let mut analysis = make_analysis(vec![]); - analysis.findings.architecture = vec![crate::domain::findings::ArchitectureFinding { - common: make_arch_finding( - "architecture/call_parity/no_delegation", - crate::domain::Severity::Medium, - ), - }]; - let value = build_sarif_value(&analysis); - let results = value["runs"][0]["results"] - .as_array() - .expect("results array"); - let hit = results - .iter() - .find(|r| r["ruleId"] == "architecture/call_parity/no_delegation") - .expect("call_parity finding emitted in SARIF"); - assert_eq!(hit["level"], "warning"); - assert_eq!( - hit["locations"][0]["physicalLocation"]["artifactLocation"]["uri"], - "src/cli/handlers.rs" - ); - assert_eq!( - hit["locations"][0]["physicalLocation"]["region"]["startLine"], - 17 - ); -} - -#[test] -fn sarif_maps_architecture_severities() { - let mut analysis = make_analysis(vec![]); - analysis.findings.architecture = vec![ - crate::domain::findings::ArchitectureFinding { - common: make_arch_finding( - "architecture/call_parity/multi_touchpoint", - crate::domain::Severity::Low, - ), - }, - crate::domain::findings::ArchitectureFinding { - common: make_arch_finding( - "architecture/call_parity/missing_adapter", - crate::domain::Severity::Medium, - ), - }, - crate::domain::findings::ArchitectureFinding { - common: make_arch_finding( - "architecture/trait_contract/object_safety", - crate::domain::Severity::High, - ), - }, - ]; - let value = build_sarif_value(&analysis); - let results = value["runs"][0]["results"] - .as_array() - .expect("results array"); - let level_for = |rid: &str| -> &str { - results - .iter() - .find(|r| r["ruleId"] == rid) - .unwrap_or_else(|| panic!("missing {rid}"))["level"] - .as_str() - .expect("level string") - }; - assert_eq!( - level_for("architecture/call_parity/multi_touchpoint"), - "note" - ); - assert_eq!( - level_for("architecture/call_parity/missing_adapter"), - "warning" - ); - assert_eq!( - level_for("architecture/trait_contract/object_safety"), - "error" - ); -} - -#[test] -fn sarif_skips_suppressed_architecture_findings() { - let mut analysis = make_analysis(vec![]); - let mut suppressed = make_arch_finding( - "architecture/call_parity/no_delegation", - crate::domain::Severity::Medium, - ); - suppressed.suppressed = true; - analysis.findings.architecture = - vec![crate::domain::findings::ArchitectureFinding { common: suppressed }]; - let value = build_sarif_value(&analysis); - let results = value["runs"][0]["results"] - .as_array() - .expect("results array"); - assert!( - !results - .iter() - .any(|r| r["ruleId"] == "architecture/call_parity/no_delegation"), - "suppressed architecture finding must not appear in SARIF" - ); -} diff --git a/src/adapters/report/sarif/tests/root/core.rs b/src/adapters/report/sarif/tests/root/core.rs new file mode 100644 index 00000000..13e5013f --- /dev/null +++ b/src/adapters/report/sarif/tests/root/core.rs @@ -0,0 +1,151 @@ +use super::*; + +#[test] +fn test_print_sarif_emits_no_results_when_clean() { + let analysis = make_analysis(vec![make_result("good_fn", Classification::Integration)]); + let s = build_sarif_string(&analysis); + let v: serde_json::Value = serde_json::from_str(&s).expect("valid SARIF JSON"); + let results = &v["runs"][0]["results"]; + assert_eq!( + results.as_array().map(Vec::len), + Some(0), + "Integration function should produce no SARIF results; got {s}" + ); +} + +#[test] +fn test_print_sarif_emits_violation_with_location() { + let analysis = make_analysis(vec![make_result( + "bad_fn", + Classification::Violation { + has_logic: true, + has_own_calls: true, + logic_locations: vec![LogicOccurrence { + kind: "if".into(), + line: 5, + }], + call_locations: vec![CallOccurrence { + name: "helper".into(), + line: 6, + }], + }, + )]); + let s = build_sarif_string(&analysis); + let v: serde_json::Value = serde_json::from_str(&s).expect("valid SARIF JSON"); + let results = v["runs"][0]["results"].as_array().expect("results array"); + assert!( + !results.is_empty(), + "violation must produce SARIF result; got {s}" + ); + let r = &results[0]; + let physical = &r["locations"][0]["physicalLocation"]; + assert_eq!(physical["artifactLocation"]["uri"], "test.rs"); + assert_eq!(physical["region"]["startLine"], 1); + let rule_id = r["ruleId"].as_str().unwrap_or(""); + assert!(!rule_id.is_empty(), "rule_id must be set; got {s}"); +} + +#[test] +fn test_print_sarif_severity_for_many_violations_is_error_or_warning() { + let analysis = make_analysis(vec![make_result( + "complex_fn", + Classification::Violation { + has_logic: true, + has_own_calls: true, + logic_locations: vec![ + LogicOccurrence { + kind: "if".into(), + line: 1, + }, + LogicOccurrence { + kind: "match".into(), + line: 2, + }, + LogicOccurrence { + kind: "for".into(), + line: 3, + }, + ], + call_locations: vec![ + CallOccurrence { + name: "a".into(), + line: 4, + }, + CallOccurrence { + name: "b".into(), + line: 5, + }, + CallOccurrence { + name: "c".into(), + line: 6, + }, + ], + }, + )]); + let s = build_sarif_string(&analysis); + let v: serde_json::Value = serde_json::from_str(&s).expect("valid SARIF JSON"); + let level = v["runs"][0]["results"][0]["level"].as_str().unwrap_or(""); + assert!( + matches!(level, "warning" | "error"), + "3+3 violation must map to warning or error level; got `{level}` in {s}" + ); +} + +#[test] +fn test_print_sarif_suppressed_skipped() { + let mut func = make_result( + "suppressed_fn", + Classification::Violation { + has_logic: true, + has_own_calls: true, + logic_locations: vec![LogicOccurrence { + kind: "if".into(), + line: 1, + }], + call_locations: vec![CallOccurrence { + name: "f".into(), + line: 2, + }], + }, + ); + func.suppressed = true; + let analysis = make_analysis(vec![func]); + print_sarif(&analysis); +} + +#[test] +fn test_print_sarif_multiple_violations() { + let analysis = make_analysis(vec![ + make_result( + "bad1", + Classification::Violation { + has_logic: true, + has_own_calls: true, + logic_locations: vec![LogicOccurrence { + kind: "if".into(), + line: 1, + }], + call_locations: vec![CallOccurrence { + name: "a".into(), + line: 2, + }], + }, + ), + make_result( + "bad2", + Classification::Violation { + has_logic: true, + has_own_calls: true, + logic_locations: vec![LogicOccurrence { + kind: "while".into(), + line: 10, + }], + call_locations: vec![CallOccurrence { + name: "b".into(), + line: 12, + }], + }, + ), + ]); + print_sarif(&analysis); +} diff --git a/src/adapters/report/sarif/tests/root/mod.rs b/src/adapters/report/sarif/tests/root/mod.rs new file mode 100644 index 00000000..d899c7ad --- /dev/null +++ b/src/adapters/report/sarif/tests/root/mod.rs @@ -0,0 +1,25 @@ +//! SARIF reporter tests, split into focused sub-files (each ≤ the SRP +//! file-length cap); shared imports + the `sarif_result_by_rule` helper live +//! here and reach the sub-modules via `use super::*`. + +pub(super) use crate::adapters::analyzers::iosp::{ + CallOccurrence, Classification, FunctionAnalysis, LogicOccurrence, +}; +pub(super) use crate::adapters::report::test_support::{make_analysis, make_result}; +pub(super) use crate::report::sarif::*; +pub(super) use crate::report::AnalysisResult; + +mod core; +mod orphan_and_architecture; + +/// The first SARIF result whose `ruleId` matches `rule_id`, panicking if none. +pub(super) fn sarif_result_by_rule(analysis: &AnalysisResult, rule_id: &str) -> serde_json::Value { + let value = build_sarif_value(analysis); + value["runs"][0]["results"] + .as_array() + .expect("results array") + .iter() + .find(|r| r["ruleId"] == rule_id) + .unwrap_or_else(|| panic!("expected a SARIF result for rule {rule_id}")) + .clone() +} diff --git a/src/adapters/report/sarif/tests/root/orphan_and_architecture.rs b/src/adapters/report/sarif/tests/root/orphan_and_architecture.rs new file mode 100644 index 00000000..97486ace --- /dev/null +++ b/src/adapters/report/sarif/tests/root/orphan_and_architecture.rs @@ -0,0 +1,163 @@ +use super::*; + +// ── Orphan-suppression SARIF coverage ───────────────────────── + +#[test] +fn sarif_reporter_emits_orphan_results_via_snapshot_view() { + use crate::domain::findings::OrphanSuppression; + let mut analysis = make_analysis(vec![]); + // Trait-driven path — populate `findings.orphan_suppressions` + // (NOT the legacy `analysis.orphan_suppressions` field). + analysis.findings.orphan_suppressions = vec![OrphanSuppression { + file: "src/foo.rs".into(), + line: 42, + dimensions: vec![crate::findings::Dimension::Srp], + reason: Some("legacy marker".into()), + }]; + let orphan = sarif_result_by_rule(&analysis, "ORPHAN-001"); + assert_eq!(orphan["level"], "warning"); + assert_eq!( + orphan["locations"][0]["physicalLocation"]["artifactLocation"]["uri"], + "src/foo.rs" + ); + assert_eq!( + orphan["locations"][0]["physicalLocation"]["region"]["startLine"], + 42 + ); + let msg = orphan["message"]["text"].as_str().expect("message text"); + assert!( + msg.contains("srp"), + "message should name suppressed dim: {msg}" + ); + assert!( + msg.contains("legacy marker"), + "message should carry reason: {msg}" + ); +} + +#[test] +fn sarif_rules_include_orphan_suppression() { + let analysis = make_analysis(vec![]); + let value = build_sarif_value(&analysis); + let rules = value["runs"][0]["tool"]["driver"]["rules"] + .as_array() + .expect("rules array"); + let orphan_rule = rules + .iter() + .find(|r| r["id"] == "ORPHAN-001") + .expect("ORPHAN-001 rule present in tool.driver.rules"); + let desc = orphan_rule["shortDescription"]["text"] + .as_str() + .expect("shortDescription text"); + assert!( + desc.to_lowercase().contains("orphan") || desc.to_lowercase().contains("stale"), + "rule description should name the orphan concept: {desc}" + ); +} + +// ── Architecture findings SARIF coverage (v1.2.1) ───────────── + +fn make_arch_finding(rule_id: &str, severity: crate::domain::Severity) -> crate::domain::Finding { + crate::domain::Finding { + file: "src/cli/handlers.rs".to_string(), + line: 17, + column: 0, + dimension: crate::findings::Dimension::Architecture, + rule_id: rule_id.to_string(), + severity, + message: format!("test message for {rule_id}"), + suppressed: false, + } +} + +#[test] +fn sarif_emits_architecture_call_parity_finding() { + let mut analysis = make_analysis(vec![]); + analysis.findings.architecture = vec![crate::domain::findings::ArchitectureFinding { + common: make_arch_finding( + "architecture/call_parity/no_delegation", + crate::domain::Severity::Medium, + ), + }]; + let hit = sarif_result_by_rule(&analysis, "architecture/call_parity/no_delegation"); + assert_eq!(hit["level"], "warning"); + assert_eq!( + hit["locations"][0]["physicalLocation"]["artifactLocation"]["uri"], + "src/cli/handlers.rs" + ); + assert_eq!( + hit["locations"][0]["physicalLocation"]["region"]["startLine"], + 17 + ); +} + +#[test] +fn sarif_maps_architecture_severities() { + let mut analysis = make_analysis(vec![]); + analysis.findings.architecture = vec![ + crate::domain::findings::ArchitectureFinding { + common: make_arch_finding( + "architecture/call_parity/multi_touchpoint", + crate::domain::Severity::Low, + ), + }, + crate::domain::findings::ArchitectureFinding { + common: make_arch_finding( + "architecture/call_parity/missing_adapter", + crate::domain::Severity::Medium, + ), + }, + crate::domain::findings::ArchitectureFinding { + common: make_arch_finding( + "architecture/trait_contract/object_safety", + crate::domain::Severity::High, + ), + }, + ]; + let value = build_sarif_value(&analysis); + let results = value["runs"][0]["results"] + .as_array() + .expect("results array"); + let level_for = |rid: &str| -> &str { + results + .iter() + .find(|r| r["ruleId"] == rid) + .unwrap_or_else(|| panic!("missing {rid}"))["level"] + .as_str() + .expect("level string") + }; + assert_eq!( + level_for("architecture/call_parity/multi_touchpoint"), + "note" + ); + assert_eq!( + level_for("architecture/call_parity/missing_adapter"), + "warning" + ); + assert_eq!( + level_for("architecture/trait_contract/object_safety"), + "error" + ); +} + +#[test] +fn sarif_skips_suppressed_architecture_findings() { + let mut analysis = make_analysis(vec![]); + let mut suppressed = make_arch_finding( + "architecture/call_parity/no_delegation", + crate::domain::Severity::Medium, + ); + suppressed.suppressed = true; + analysis.findings.architecture = + vec![crate::domain::findings::ArchitectureFinding { common: suppressed }]; + let value = build_sarif_value(&analysis); + let results = value["runs"][0]["results"] + .as_array() + .expect("results array"); + assert!( + !results + .iter() + .any(|r| r["ruleId"] == "architecture/call_parity/no_delegation"), + "suppressed architecture finding must not appear in SARIF" + ); +} diff --git a/src/adapters/report/sarif/tests/rules.rs b/src/adapters/report/sarif/tests/rules.rs index 2065cf1c..b202c4c7 100644 --- a/src/adapters/report/sarif/tests/rules.rs +++ b/src/adapters/report/sarif/tests/rules.rs @@ -42,20 +42,19 @@ fn make_analysis_for(findings: AnalysisFindings) -> AnalysisResult { } } -#[test] -fn every_emitted_rule_id_is_registered_in_rules_table() { - // Cover the variants whose rule_id was historically wrong: - // boilerplate (BP-007), wildcard (DRY-004), repeated_match (DRY-005), - // structural code (BTC), threshold-exceeded coupling (CP-002), - // architecture dynamic id (architecture/pattern/forbid_x). - let common = |kind: crate::findings::Dimension, rule_id: &str| { - let mut f = finding_with_rule_id(rule_id); - f.dimension = kind; - f - }; - let dry = vec![ +/// A `Finding` for `rule_id` with its dimension set to `kind`. +fn dim_finding(kind: crate::findings::Dimension, rule_id: &str) -> Finding { + let mut f = finding_with_rule_id(rule_id); + f.dimension = kind; + f +} + +/// The three DRY variants whose rule_ids were historically wrong: boilerplate +/// (BP-007), wildcard (DRY-004), repeated-match (DRY-005). +fn registry_dry_findings() -> Vec { + vec![ DryFinding { - common: common(crate::findings::Dimension::Dry, "dry/boilerplate"), + common: dim_finding(crate::findings::Dimension::Dry, "dry/boilerplate"), kind: DryFindingKind::Boilerplate, details: DryFindingDetails::Boilerplate { pattern_id: "BP-007".into(), @@ -64,23 +63,28 @@ fn every_emitted_rule_id_is_registered_in_rules_table() { }, }, DryFinding { - common: common(crate::findings::Dimension::Dry, "dry/wildcard"), + common: dim_finding(crate::findings::Dimension::Dry, "dry/wildcard"), kind: DryFindingKind::Wildcard, details: DryFindingDetails::Wildcard { module_path: "foo".into(), }, }, DryFinding { - common: common(crate::findings::Dimension::Dry, "dry/repeated_match"), + common: dim_finding(crate::findings::Dimension::Dry, "dry/repeated_match"), kind: DryFindingKind::RepeatedMatch, details: DryFindingDetails::RepeatedMatch { enum_name: "Color".into(), participants: vec![], }, }, - ]; + ] +} + +/// One finding per dimension/variant whose rule_id was historically wrong +/// (BP-007, DRY-004, DRY-005, BTC, CP-002, the dynamic architecture id, IOSP). +fn registry_coverage_analysis() -> AnalysisResult { let srp = vec![SrpFinding { - common: common(crate::findings::Dimension::Srp, "srp/structural"), + common: dim_finding(crate::findings::Dimension::Srp, "srp/structural"), kind: SrpFindingKind::Structural, details: SrpFindingDetails::Structural { item_name: "Foo".into(), @@ -89,7 +93,7 @@ fn every_emitted_rule_id_is_registered_in_rules_table() { }, }]; let coupling = vec![CouplingFinding { - common: common(crate::findings::Dimension::Coupling, "coupling/threshold"), + common: dim_finding(crate::findings::Dimension::Coupling, "coupling/threshold"), kind: CouplingFindingKind::ThresholdExceeded, details: CouplingFindingDetails::ThresholdExceeded { module_name: "m".into(), @@ -99,25 +103,30 @@ fn every_emitted_rule_id_is_registered_in_rules_table() { }, }]; let architecture = vec![ArchitectureFinding { - common: common( + common: dim_finding( crate::findings::Dimension::Architecture, "architecture/pattern/forbid_path_prefix", ), }]; let iosp = vec![IospFinding { - common: common(crate::findings::Dimension::Iosp, "iosp/violation"), + common: dim_finding(crate::findings::Dimension::Iosp, "iosp/violation"), logic_locations: vec![], call_locations: vec![], effort_score: None, }]; - let analysis = make_analysis_for(AnalysisFindings { + make_analysis_for(AnalysisFindings { iosp, - dry, + dry: registry_dry_findings(), srp, coupling, architecture, ..Default::default() - }); + }) +} + +#[test] +fn every_emitted_rule_id_is_registered_in_rules_table() { + let analysis = registry_coverage_analysis(); let value = build_sarif_value(&analysis); let registered: HashSet = value["runs"][0]["tool"]["driver"]["rules"] .as_array() diff --git a/src/adapters/report/test_support.rs b/src/adapters/report/test_support.rs new file mode 100644 index 00000000..e320fa0e --- /dev/null +++ b/src/adapters/report/test_support.rs @@ -0,0 +1,77 @@ +//! Shared fixtures for the report-reporter unit tests. +//! +//! Every reporter test (json, github, baseline, root, suggestions, html, +//! text, sarif, …) needs the same two builders: a single `FunctionAnalysis` +//! with sane defaults and an `AnalysisResult` wrapping a set of results with +//! the standard summary / projection. Keeping them here means one source of +//! truth, reachable from every `report::*::tests` module, instead of a copy +//! per test file. + +use crate::adapters::analyzers::iosp::{ + compute_severity, CallOccurrence, Classification, FunctionAnalysis, LogicOccurrence, +}; +use crate::report::{AnalysisResult, Summary}; + +/// A `Violation` classification with one logic location (`logic_kind` at +/// line 1) and one own-call location (`call_name` at line 2) — the shape +/// the reporter tests use to exercise violation rendering. +pub(crate) fn violation(logic_kind: &str, call_name: &str) -> Classification { + Classification::Violation { + has_logic: true, + has_own_calls: true, + logic_locations: vec![LogicOccurrence { + kind: logic_kind.into(), + line: 1, + }], + call_locations: vec![CallOccurrence { + name: call_name.into(), + line: 2, + }], + } +} + +/// A `FunctionAnalysis` for `name` with the given classification and all +/// warning/metric fields defaulted (file `test.rs`, line 1, no complexity). +pub(crate) fn make_result(name: &str, classification: Classification) -> FunctionAnalysis { + let severity = compute_severity(&classification); + FunctionAnalysis { + name: name.to_string(), + file: "test.rs".to_string(), + line: 1, + classification, + parent_type: None, + suppressed: false, + complexity: None, + qualified_name: name.to_string(), + severity, + cognitive_warning: false, + cyclomatic_warning: false, + nesting_depth_warning: false, + function_length_warning: false, + unsafe_warning: false, + error_handling_warning: false, + complexity_suppressed: false, + own_calls: vec![], + parameter_count: 0, + is_trait_impl: false, + is_test: false, + effort_score: None, + } +} + +/// Wrap `results` in an `AnalysisResult` with the standard summary and the +/// IOSP projection populated (other finding dimensions left empty). +pub(crate) fn make_analysis(results: Vec) -> AnalysisResult { + let summary = Summary::from_results(&results); + let data = crate::app::projection::project_data(&results, None); + let findings = crate::domain::AnalysisFindings { + iosp: crate::app::projection::project_iosp(&results), + ..Default::default() + }; + AnalysisResult { + results, + summary, + findings, + data, + } +} diff --git a/src/adapters/report/tests/ai.rs b/src/adapters/report/tests/ai.rs deleted file mode 100644 index 6796a23a..00000000 --- a/src/adapters/report/tests/ai.rs +++ /dev/null @@ -1,610 +0,0 @@ -//! AI reporter tests. -//! -//! Tests focus on `build_ai_value` (the public entry) plus per-method -//! AiReporter trait coverage. Loose content style: assert key fragments -//! and structural shape, not exact wording. - -use crate::adapters::analyzers::iosp::{ - CallOccurrence, Classification, ComplexityMetrics, FunctionAnalysis, LogicOccurrence, - MagicNumberOccurrence, -}; -use crate::config::Config; -use crate::domain::analysis_data::FunctionRecord; -use crate::domain::findings::{ - ArchitectureFinding, ComplexityFinding, ComplexityFindingKind, CouplingFinding, - CouplingFindingDetails, CouplingFindingKind, DryFinding, DryFindingDetails, DryFindingKind, - DuplicateParticipant, IospFinding, SrpFinding, SrpFindingDetails, SrpFindingKind, TqFinding, - TqFindingKind, -}; -use crate::domain::Finding; -use crate::ports::reporter::ReporterImpl; -use crate::ports::Reporter; -use crate::report::ai::{ - format_arch_entry, format_complexity_entry, format_coupling_entry, format_dry_entry, - format_iosp_entry, format_srp_entry, format_tq_entry, AiOutputFormat, AiReporter, -}; -use crate::report::AnalysisResult; -use serde_json::Value; - -/// Test-local helper: render via `AiReporter` with `Json` format and -/// parse back to `Value` so assertions can inspect structured data. -/// Lives here (not in production code) to keep the panic out of -/// production builds and avoid the architecture rule against loose -/// `#[cfg(test)]` items in production files. -fn build_ai_value(analysis: &AnalysisResult, config: &Config) -> Value { - let reporter = AiReporter { - config, - data: &analysis.data, - format: AiOutputFormat::Json, - }; - let json_str = reporter.render(&analysis.findings, &analysis.data); - serde_json::from_str(&json_str).expect("AiReporter::render(Json) must produce valid JSON") -} - -fn empty_analysis() -> AnalysisResult { - AnalysisResult { - results: vec![], - summary: crate::report::Summary::default(), - findings: crate::domain::AnalysisFindings::default(), - data: crate::domain::AnalysisData::default(), - } -} - -fn arch_common(file: &str, line: usize, severity: crate::domain::Severity) -> Finding { - Finding { - file: file.into(), - line, - column: 0, - dimension: crate::findings::Dimension::Architecture, - rule_id: "architecture/test".into(), - message: "test".into(), - severity, - suppressed: false, - } -} - -// ── build_ai_value: shape contract ───────────────────────────────── - -#[test] -fn build_ai_value_zero_findings_no_findings_by_file() { - let analysis = empty_analysis(); - let config = Config::default(); - let value = build_ai_value(&analysis, &config); - assert_eq!(value["version"], env!("CARGO_PKG_VERSION")); - assert_eq!(value["findings"], 0); - assert!( - value.get("findings_by_file").is_none(), - "no findings_by_file when 0 findings" - ); -} - -#[test] -fn build_ai_value_includes_architecture_finding() { - let mut analysis = empty_analysis(); - analysis.findings.architecture = vec![ArchitectureFinding { - common: Finding { - file: "src/cli/handlers.rs".into(), - line: 17, - column: 0, - dimension: crate::findings::Dimension::Architecture, - rule_id: "architecture/call_parity/no_delegation".into(), - message: "cli pub fn delegates to no application function".into(), - severity: crate::domain::Severity::Medium, - suppressed: false, - }, - }]; - let config = Config::default(); - let value = build_ai_value(&analysis, &config); - - assert_eq!(value["findings"], 1); - let by_file = value["findings_by_file"] - .as_object() - .expect("findings_by_file present when findings > 0"); - let entries = by_file["src/cli/handlers.rs"] - .as_array() - .expect("entries for the architecture finding's file"); - assert_eq!(entries.len(), 1); - assert_eq!(entries[0]["category"], "architecture"); - assert_eq!(entries[0]["line"], 17); -} - -#[test] -fn build_ai_value_groups_entries_by_file() { - let mut analysis = empty_analysis(); - analysis.findings.architecture = vec![ - ArchitectureFinding { - common: arch_common("src/a.rs", 10, crate::domain::Severity::Medium), - }, - ArchitectureFinding { - common: arch_common("src/a.rs", 20, crate::domain::Severity::Medium), - }, - ArchitectureFinding { - common: arch_common("src/b.rs", 5, crate::domain::Severity::Medium), - }, - ]; - let config = Config::default(); - let value = build_ai_value(&analysis, &config); - assert_eq!(value["findings"], 3); - let by_file = value["findings_by_file"].as_object().expect("by_file"); - assert_eq!(by_file.len(), 2); - assert!(by_file.contains_key("src/a.rs")); - assert!(by_file.contains_key("src/b.rs")); - assert_eq!(by_file["src/a.rs"].as_array().unwrap().len(), 2); - assert_eq!(by_file["src/b.rs"].as_array().unwrap().len(), 1); -} - -#[test] -fn build_ai_value_skips_suppressed() { - let mut analysis = empty_analysis(); - let mut common = arch_common("src/foo.rs", 5, crate::domain::Severity::Medium); - common.suppressed = true; - analysis.findings.architecture = vec![ArchitectureFinding { common }]; - let config = Config::default(); - let value = build_ai_value(&analysis, &config); - assert_eq!(value["findings"], 0); - assert!(value.get("findings_by_file").is_none()); -} - -// ── AiReporter trait methods: per-dimension entry shape ──────────── - -fn make_reporter<'a>(config: &'a Config, data: &'a crate::domain::AnalysisData) -> AiReporter<'a> { - AiReporter { - config, - data, - format: AiOutputFormat::Json, - } -} - -#[test] -fn build_iosp_emits_violation_with_logic_and_call_lines() { - use crate::domain::findings::{CallLocation, LogicLocation}; - let f = IospFinding { - common: Finding { - file: "src/lib.rs".into(), - line: 40, - column: 0, - dimension: crate::findings::Dimension::Iosp, - rule_id: "iosp/violation".into(), - message: "ignored".into(), - severity: crate::domain::Severity::Medium, - suppressed: false, - }, - logic_locations: vec![ - LogicLocation { - kind: "if".into(), - line: 44, - }, - LogicLocation { - kind: "for".into(), - line: 47, - }, - ], - call_locations: vec![CallLocation { - name: "helper".into(), - line: 50, - }], - effort_score: None, - }; - let config = Config::default(); - let data = crate::domain::AnalysisData::default(); - let reporter = make_reporter(&config, &data); - let rows = reporter.build_iosp(&[f]); - assert_eq!(rows.len(), 1); - let entries: Vec = rows.into_iter().map(format_iosp_entry).collect(); - let detail = entries[0]["detail"].as_str().unwrap(); - assert!(detail.contains("logic lines 44,47"), "got: {detail}"); - assert!(detail.contains("call lines 50"), "got: {detail}"); - assert_eq!(entries[0]["category"], "violation"); -} - -#[test] -fn build_iosp_resolves_function_name_via_data() { - use crate::domain::analysis_data::FunctionClassification; - let mut data = crate::domain::AnalysisData::default(); - data.functions.push(FunctionRecord { - name: "bad_fn".into(), - file: "src/lib.rs".into(), - line: 40, - qualified_name: "MyType::bad_fn".into(), - parent_type: Some("MyType".into()), - classification: FunctionClassification::Violation, - severity: Some(crate::domain::Severity::Medium), - complexity: None, - parameter_count: 0, - own_calls: vec![], - is_trait_impl: false, - is_test: false, - effort_score: None, - suppressed: false, - complexity_suppressed: false, - }); - let f = IospFinding { - common: Finding { - file: "src/lib.rs".into(), - line: 40, - column: 0, - dimension: crate::findings::Dimension::Iosp, - rule_id: "iosp/violation".into(), - message: "x".into(), - severity: crate::domain::Severity::Medium, - suppressed: false, - }, - logic_locations: vec![], - call_locations: vec![], - effort_score: None, - }; - let config = Config::default(); - let reporter = make_reporter(&config, &data); - let rows = reporter.build_iosp(&[f]); - let entries: Vec = rows.into_iter().map(format_iosp_entry).collect(); - assert_eq!(entries[0]["fn"], "MyType::bad_fn"); -} - -#[test] -fn report_complexity_threshold_findings_include_max() { - let f = ComplexityFinding { - common: Finding { - file: "src/lib.rs".into(), - line: 1, - column: 0, - dimension: crate::findings::Dimension::Complexity, - rule_id: "complexity/cognitive".into(), - message: "x".into(), - severity: crate::domain::Severity::Medium, - suppressed: false, - }, - kind: ComplexityFindingKind::Cognitive, - metric_value: 25, - threshold: 10, - hotspot: None, - }; - let config = Config::default(); - let data = crate::domain::AnalysisData::default(); - let reporter = make_reporter(&config, &data); - let rows = reporter.build_complexity(&[f]); - let entries: Vec = rows.into_iter().map(format_complexity_entry).collect(); - assert_eq!(entries[0]["category"], "cognitive_complexity"); - let detail = entries[0]["detail"].as_str().unwrap(); - assert!(detail.contains("25"), "got: {detail}"); - assert!(detail.contains("max 10"), "got: {detail}"); -} - -#[test] -fn report_dry_duplicate_includes_partner_locations() { - let f = DryFinding { - common: Finding { - file: "src/a.rs".into(), - line: 10, - column: 0, - dimension: crate::findings::Dimension::Dry, - rule_id: "dry/duplicate/exact".into(), - message: "x".into(), - severity: crate::domain::Severity::Medium, - suppressed: false, - }, - kind: DryFindingKind::DuplicateExact, - details: DryFindingDetails::Duplicate { - participants: vec![ - DuplicateParticipant { - function_name: "fn_a".into(), - file: "src/a.rs".into(), - line: 10, - }, - DuplicateParticipant { - function_name: "fn_b".into(), - file: "src/b.rs".into(), - line: 20, - }, - ], - similarity: None, - }, - }; - let config = Config::default(); - let data = crate::domain::AnalysisData::default(); - let reporter = make_reporter(&config, &data); - let rows = reporter.build_dry(&[f]); - let entries: Vec = rows.into_iter().map(format_dry_entry).collect(); - assert_eq!(entries[0]["category"], "duplicate"); - let detail = entries[0]["detail"].as_str().unwrap(); - assert!(detail.contains("src/b.rs:20"), "got: {detail}"); - assert!( - !detail.contains("src/a.rs:10"), - "self-link excluded; got: {detail}" - ); -} - -#[test] -fn report_dry_dead_code_uses_suggestion() { - let f = DryFinding { - common: Finding { - file: "src/foo.rs".into(), - line: 5, - column: 0, - dimension: crate::findings::Dimension::Dry, - rule_id: "dry/dead_code/uncalled".into(), - message: "x".into(), - severity: crate::domain::Severity::Medium, - suppressed: false, - }, - kind: DryFindingKind::DeadCodeUncalled, - details: DryFindingDetails::DeadCode { - qualified_name: "module::dead_fn".into(), - suggestion: Some("remove".into()), - }, - }; - let config = Config::default(); - let data = crate::domain::AnalysisData::default(); - let reporter = make_reporter(&config, &data); - let rows = reporter.build_dry(&[f]); - let entries: Vec = rows.into_iter().map(format_dry_entry).collect(); - let detail = entries[0]["detail"].as_str().unwrap(); - assert!(detail.contains("module::dead_fn")); - assert!(detail.contains("remove")); -} - -#[test] -fn build_srp_emit_dimension_specific_categories() { - let cohesion = SrpFinding { - common: Finding { - file: "src/a.rs".into(), - line: 10, - column: 0, - dimension: crate::findings::Dimension::Srp, - rule_id: "srp/struct_cohesion".into(), - message: "x".into(), - severity: crate::domain::Severity::Medium, - suppressed: false, - }, - kind: SrpFindingKind::StructCohesion, - details: SrpFindingDetails::StructCohesion { - struct_name: "Foo".into(), - lcom4: 4, - field_count: 6, - method_count: 8, - fan_out: 3, - composite_score: 0.0, - clusters: vec![], - }, - }; - let config = Config::default(); - let data = crate::domain::AnalysisData::default(); - let reporter = make_reporter(&config, &data); - let rows = reporter.build_srp(&[cohesion]); - let entries: Vec = rows - .into_iter() - .map(|r| format_srp_entry(r, &config)) - .collect(); - assert_eq!(entries[0]["category"], "srp_struct"); - assert!(entries[0]["detail"].as_str().unwrap().contains("LCOM4=4")); -} - -#[test] -fn report_coupling_cycle_emits_arrow_chain() { - let cycle = CouplingFinding { - common: Finding { - file: "".into(), - line: 0, - column: 0, - dimension: crate::findings::Dimension::Coupling, - rule_id: "coupling/cycle".into(), - message: "x".into(), - severity: crate::domain::Severity::Medium, - suppressed: false, - }, - kind: CouplingFindingKind::Cycle, - details: CouplingFindingDetails::Cycle { - modules: vec!["a".into(), "b".into(), "a".into()], - }, - }; - let config = Config::default(); - let data = crate::domain::AnalysisData::default(); - let reporter = make_reporter(&config, &data); - let rows = reporter.build_coupling(&[cycle]); - let entries: Vec = rows.into_iter().map(format_coupling_entry).collect(); - assert_eq!(entries[0]["category"], "cycle"); - let detail = entries[0]["detail"].as_str().unwrap(); - assert!(detail.contains("a -> b -> a"), "got: {detail}"); -} - -#[test] -fn build_test_quality_emit_correct_categories() { - let tq = TqFinding { - common: Finding { - file: "src/test.rs".into(), - line: 1, - column: 0, - dimension: crate::findings::Dimension::TestQuality, - rule_id: "tq/no_assertion".into(), - message: "test fn has no asserts".into(), - severity: crate::domain::Severity::Medium, - suppressed: false, - }, - kind: TqFindingKind::NoAssertion, - function_name: "test_fn".into(), - uncovered_lines: None, - }; - let config = Config::default(); - let data = crate::domain::AnalysisData::default(); - let reporter = make_reporter(&config, &data); - let rows = reporter.build_test_quality(&[tq]); - let entries: Vec = rows.into_iter().map(format_tq_entry).collect(); - assert_eq!(entries[0]["category"], "no_assertion"); -} - -#[test] -fn report_architecture_severity_maps_independently() { - let high = ArchitectureFinding { - common: arch_common("src/foo.rs", 1, crate::domain::Severity::High), - }; - let config = Config::default(); - let data = crate::domain::AnalysisData::default(); - let reporter = make_reporter(&config, &data); - let rows = reporter.build_architecture(&[high]); - let entries: Vec = rows.into_iter().map(format_arch_entry).collect(); - assert_eq!(entries[0]["category"], "architecture"); - assert!(entries[0]["detail"] - .as_str() - .unwrap() - .contains("architecture/test")); -} - -#[test] -fn empty_findings_produce_empty_chunks() { - let config = Config::default(); - let data = crate::domain::AnalysisData::default(); - let reporter = make_reporter(&config, &data); - assert!(reporter.build_iosp(&[]).is_empty()); - assert!(reporter.build_complexity(&[]).is_empty()); - assert!(reporter.build_dry(&[]).is_empty()); - assert!(reporter.build_srp(&[]).is_empty()); - assert!(reporter.build_coupling(&[]).is_empty()); - assert!(reporter.build_test_quality(&[]).is_empty()); - assert!(reporter.build_architecture(&[]).is_empty()); -} - -// ── Smoke tests ──────────────────────────────────────────────────── - -#[test] -fn ai_toon_render_on_empty_analysis_emits_zero_findings() { - let analysis = empty_analysis(); - let config = Config::default(); - let reporter = AiReporter { - config: &config, - data: &analysis.data, - format: AiOutputFormat::Toon, - }; - let output = reporter.render(&analysis.findings, &analysis.data); - assert!( - output.contains("findings"), - "TOON output must include the findings key; got {output}" - ); - assert!( - !output.contains("findings_by_file:"), - "no findings_by_file when zero findings; got {output}" - ); -} - -#[test] -fn ai_json_render_on_empty_analysis_emits_zero_findings() { - let analysis = empty_analysis(); - let config = Config::default(); - let value = build_ai_value(&analysis, &config); - assert_eq!( - value["findings"], 0, - "empty analysis must produce zero findings; got {value}" - ); -} - -#[test] -fn ai_value_includes_complexity_finding_metric_and_location() { - let mut analysis = empty_analysis(); - let _func = FunctionAnalysis { - name: "f".into(), - file: "test.rs".into(), - line: 1, - classification: Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![LogicOccurrence { - kind: "if".into(), - line: 2, - }], - call_locations: vec![CallOccurrence { - name: "g".into(), - line: 3, - }], - }, - parent_type: None, - suppressed: false, - complexity: Some(ComplexityMetrics { - magic_numbers: vec![MagicNumberOccurrence { - line: 4, - value: "42".into(), - }], - ..Default::default() - }), - qualified_name: "f".into(), - severity: None, - cognitive_warning: false, - cyclomatic_warning: false, - nesting_depth_warning: false, - function_length_warning: false, - unsafe_warning: false, - error_handling_warning: false, - complexity_suppressed: false, - own_calls: vec![], - parameter_count: 0, - is_trait_impl: false, - is_test: false, - effort_score: None, - }; - analysis.findings.complexity = vec![ComplexityFinding { - common: Finding { - file: "test.rs".into(), - line: 4, - column: 0, - dimension: crate::findings::Dimension::Complexity, - rule_id: "complexity/magic_number".into(), - message: "magic number 42 in f".into(), - severity: crate::domain::Severity::Medium, - suppressed: false, - }, - kind: ComplexityFindingKind::MagicNumber, - metric_value: 1, - threshold: 0, - hotspot: None, - }]; - let config = Config::default(); - let value = build_ai_value(&analysis, &config); - assert_eq!(value["findings"], 1, "one complexity finding: got {value}"); - let by_file = value["findings_by_file"] - .as_object() - .expect("findings_by_file present"); - let entries = by_file - .get("test.rs") - .and_then(|v| v.as_array()) - .expect("entries for test.rs"); - let magic_entries: Vec<_> = entries - .iter() - .filter(|e| e["category"].as_str() == Some("magic_number")) - .collect(); - assert_eq!( - magic_entries.len(), - 1, - "magic_number category preserved; got {value}" - ); - assert_eq!( - magic_entries[0]["line"], 4, - "line number preserved; got {value}" - ); -} - -#[test] -fn ai_reporter_includes_orphan_entries_via_snapshot_view() { - use crate::domain::findings::OrphanSuppression; - let mut analysis = empty_analysis(); - analysis.findings.orphan_suppressions = vec![OrphanSuppression { - file: "src/foo.rs".into(), - line: 42, - dimensions: vec![crate::findings::Dimension::Srp], - reason: Some("legacy".into()), - }]; - let config = Config::default(); - let value = build_ai_value(&analysis, &config); - assert_eq!( - value["findings"], 1, - "orphan must count as a finding, got value: {value}" - ); - let by_file = value["findings_by_file"] - .as_object() - .expect("findings_by_file present"); - let entries = by_file - .get("src/foo.rs") - .and_then(|v| v.as_array()) - .expect("entries for src/foo.rs"); - let orphan = entries - .iter() - .find(|e| e["category"] == "orphan_suppression") - .expect("orphan entry under src/foo.rs"); - assert_eq!(orphan["line"], 42); -} diff --git a/src/adapters/report/tests/ai/build_ai_value_shape.rs b/src/adapters/report/tests/ai/build_ai_value_shape.rs new file mode 100644 index 00000000..1a4c65f4 --- /dev/null +++ b/src/adapters/report/tests/ai/build_ai_value_shape.rs @@ -0,0 +1,83 @@ +use super::*; + +// ── build_ai_value: shape contract ───────────────────────────────── + +#[test] +fn build_ai_value_zero_findings_no_findings_by_file() { + let analysis = empty_analysis(); + let config = Config::default(); + let value = build_ai_value(&analysis, &config); + assert_eq!(value["version"], env!("CARGO_PKG_VERSION")); + assert_eq!(value["findings"], 0); + assert!( + value.get("findings_by_file").is_none(), + "no findings_by_file when 0 findings" + ); +} + +#[test] +fn build_ai_value_includes_architecture_finding() { + let mut analysis = empty_analysis(); + analysis.findings.architecture = vec![ArchitectureFinding { + common: Finding { + file: "src/cli/handlers.rs".into(), + line: 17, + column: 0, + dimension: crate::findings::Dimension::Architecture, + rule_id: "architecture/call_parity/no_delegation".into(), + message: "cli pub fn delegates to no application function".into(), + severity: crate::domain::Severity::Medium, + suppressed: false, + }, + }]; + let config = Config::default(); + let value = build_ai_value(&analysis, &config); + + assert_eq!(value["findings"], 1); + let by_file = value["findings_by_file"] + .as_object() + .expect("findings_by_file present when findings > 0"); + let entries = by_file["src/cli/handlers.rs"] + .as_array() + .expect("entries for the architecture finding's file"); + assert_eq!(entries.len(), 1); + assert_eq!(entries[0]["category"], "architecture"); + assert_eq!(entries[0]["line"], 17); +} + +#[test] +fn build_ai_value_groups_entries_by_file() { + let mut analysis = empty_analysis(); + analysis.findings.architecture = vec![ + ArchitectureFinding { + common: arch_common("src/a.rs", 10, crate::domain::Severity::Medium), + }, + ArchitectureFinding { + common: arch_common("src/a.rs", 20, crate::domain::Severity::Medium), + }, + ArchitectureFinding { + common: arch_common("src/b.rs", 5, crate::domain::Severity::Medium), + }, + ]; + let config = Config::default(); + let value = build_ai_value(&analysis, &config); + assert_eq!(value["findings"], 3); + let by_file = value["findings_by_file"].as_object().expect("by_file"); + assert_eq!(by_file.len(), 2); + assert!(by_file.contains_key("src/a.rs")); + assert!(by_file.contains_key("src/b.rs")); + assert_eq!(by_file["src/a.rs"].as_array().unwrap().len(), 2); + assert_eq!(by_file["src/b.rs"].as_array().unwrap().len(), 1); +} + +#[test] +fn build_ai_value_skips_suppressed() { + let mut analysis = empty_analysis(); + let mut common = arch_common("src/foo.rs", 5, crate::domain::Severity::Medium); + common.suppressed = true; + analysis.findings.architecture = vec![ArchitectureFinding { common }]; + let config = Config::default(); + let value = build_ai_value(&analysis, &config); + assert_eq!(value["findings"], 0); + assert!(value.get("findings_by_file").is_none()); +} diff --git a/src/adapters/report/tests/ai/dimension_entries_a.rs b/src/adapters/report/tests/ai/dimension_entries_a.rs new file mode 100644 index 00000000..92f3e2a1 --- /dev/null +++ b/src/adapters/report/tests/ai/dimension_entries_a.rs @@ -0,0 +1,188 @@ +use super::*; + +#[test] +fn build_iosp_emits_violation_with_logic_and_call_lines() { + use crate::domain::findings::{CallLocation, LogicLocation}; + let f = IospFinding { + common: Finding { + file: "src/lib.rs".into(), + line: 40, + column: 0, + dimension: crate::findings::Dimension::Iosp, + rule_id: "iosp/violation".into(), + message: "ignored".into(), + severity: crate::domain::Severity::Medium, + suppressed: false, + }, + logic_locations: vec![ + LogicLocation { + kind: "if".into(), + line: 44, + }, + LogicLocation { + kind: "for".into(), + line: 47, + }, + ], + call_locations: vec![CallLocation { + name: "helper".into(), + line: 50, + }], + effort_score: None, + }; + let config = Config::default(); + let data = crate::domain::AnalysisData::default(); + let reporter = make_reporter(&config, &data); + let rows = reporter.build_iosp(&[f]); + assert_eq!(rows.len(), 1); + let entries: Vec = rows.into_iter().map(format_iosp_entry).collect(); + let detail = entries[0]["detail"].as_str().unwrap(); + assert!(detail.contains("logic lines 44,47"), "got: {detail}"); + assert!(detail.contains("call lines 50"), "got: {detail}"); + assert_eq!(entries[0]["category"], "violation"); +} + +#[test] +fn build_iosp_resolves_function_name_via_data() { + use crate::domain::analysis_data::FunctionClassification; + let mut data = crate::domain::AnalysisData::default(); + data.functions.push(FunctionRecord { + name: "bad_fn".into(), + file: "src/lib.rs".into(), + line: 40, + qualified_name: "MyType::bad_fn".into(), + parent_type: Some("MyType".into()), + classification: FunctionClassification::Violation, + severity: Some(crate::domain::Severity::Medium), + complexity: None, + parameter_count: 0, + own_calls: vec![], + is_trait_impl: false, + is_test: false, + effort_score: None, + suppressed: false, + complexity_suppressed: false, + }); + let f = IospFinding { + common: Finding { + file: "src/lib.rs".into(), + line: 40, + column: 0, + dimension: crate::findings::Dimension::Iosp, + rule_id: "iosp/violation".into(), + message: "x".into(), + severity: crate::domain::Severity::Medium, + suppressed: false, + }, + logic_locations: vec![], + call_locations: vec![], + effort_score: None, + }; + let config = Config::default(); + let reporter = make_reporter(&config, &data); + let rows = reporter.build_iosp(&[f]); + let entries: Vec = rows.into_iter().map(format_iosp_entry).collect(); + assert_eq!(entries[0]["fn"], "MyType::bad_fn"); +} + +#[test] +fn report_complexity_threshold_findings_include_max() { + let f = ComplexityFinding { + common: Finding { + file: "src/lib.rs".into(), + line: 1, + column: 0, + dimension: crate::findings::Dimension::Complexity, + rule_id: "complexity/cognitive".into(), + message: "x".into(), + severity: crate::domain::Severity::Medium, + suppressed: false, + }, + kind: ComplexityFindingKind::Cognitive, + metric_value: 25, + threshold: 10, + hotspot: None, + }; + let config = Config::default(); + let data = crate::domain::AnalysisData::default(); + let reporter = make_reporter(&config, &data); + let rows = reporter.build_complexity(&[f]); + let entries: Vec = rows.into_iter().map(format_complexity_entry).collect(); + assert_eq!(entries[0]["category"], "cognitive_complexity"); + let detail = entries[0]["detail"].as_str().unwrap(); + assert!(detail.contains("25"), "got: {detail}"); + assert!(detail.contains("max 10"), "got: {detail}"); +} + +#[test] +fn report_dry_duplicate_includes_partner_locations() { + let f = DryFinding { + common: Finding { + file: "src/a.rs".into(), + line: 10, + column: 0, + dimension: crate::findings::Dimension::Dry, + rule_id: "dry/duplicate/exact".into(), + message: "x".into(), + severity: crate::domain::Severity::Medium, + suppressed: false, + }, + kind: DryFindingKind::DuplicateExact, + details: DryFindingDetails::Duplicate { + participants: vec![ + DuplicateParticipant { + function_name: "fn_a".into(), + file: "src/a.rs".into(), + line: 10, + }, + DuplicateParticipant { + function_name: "fn_b".into(), + file: "src/b.rs".into(), + line: 20, + }, + ], + similarity: None, + }, + }; + let config = Config::default(); + let data = crate::domain::AnalysisData::default(); + let reporter = make_reporter(&config, &data); + let rows = reporter.build_dry(&[f]); + let entries: Vec = rows.into_iter().map(format_dry_entry).collect(); + assert_eq!(entries[0]["category"], "duplicate"); + let detail = entries[0]["detail"].as_str().unwrap(); + assert!(detail.contains("src/b.rs:20"), "got: {detail}"); + assert!( + !detail.contains("src/a.rs:10"), + "self-link excluded; got: {detail}" + ); +} + +#[test] +fn report_dry_dead_code_uses_suggestion() { + let f = DryFinding { + common: Finding { + file: "src/foo.rs".into(), + line: 5, + column: 0, + dimension: crate::findings::Dimension::Dry, + rule_id: "dry/dead_code/uncalled".into(), + message: "x".into(), + severity: crate::domain::Severity::Medium, + suppressed: false, + }, + kind: DryFindingKind::DeadCodeUncalled, + details: DryFindingDetails::DeadCode { + qualified_name: "module::dead_fn".into(), + suggestion: Some("remove".into()), + }, + }; + let config = Config::default(); + let data = crate::domain::AnalysisData::default(); + let reporter = make_reporter(&config, &data); + let rows = reporter.build_dry(&[f]); + let entries: Vec = rows.into_iter().map(format_dry_entry).collect(); + let detail = entries[0]["detail"].as_str().unwrap(); + assert!(detail.contains("module::dead_fn")); + assert!(detail.contains("remove")); +} diff --git a/src/adapters/report/tests/ai/dimension_entries_b.rs b/src/adapters/report/tests/ai/dimension_entries_b.rs new file mode 100644 index 00000000..3e7c1dc6 --- /dev/null +++ b/src/adapters/report/tests/ai/dimension_entries_b.rs @@ -0,0 +1,121 @@ +use super::*; + +#[test] +fn build_srp_emit_dimension_specific_categories() { + let cohesion = SrpFinding { + common: Finding { + file: "src/a.rs".into(), + line: 10, + column: 0, + dimension: crate::findings::Dimension::Srp, + rule_id: "srp/struct_cohesion".into(), + message: "x".into(), + severity: crate::domain::Severity::Medium, + suppressed: false, + }, + kind: SrpFindingKind::StructCohesion, + details: SrpFindingDetails::StructCohesion { + struct_name: "Foo".into(), + lcom4: 4, + field_count: 6, + method_count: 8, + fan_out: 3, + composite_score: 0.0, + clusters: vec![], + }, + }; + let config = Config::default(); + let data = crate::domain::AnalysisData::default(); + let reporter = make_reporter(&config, &data); + let rows = reporter.build_srp(&[cohesion]); + let entries: Vec = rows + .into_iter() + .map(|r| format_srp_entry(r, &config)) + .collect(); + assert_eq!(entries[0]["category"], "srp_struct"); + assert!(entries[0]["detail"].as_str().unwrap().contains("LCOM4=4")); +} + +#[test] +fn report_coupling_cycle_emits_arrow_chain() { + let cycle = CouplingFinding { + common: Finding { + file: "".into(), + line: 0, + column: 0, + dimension: crate::findings::Dimension::Coupling, + rule_id: "coupling/cycle".into(), + message: "x".into(), + severity: crate::domain::Severity::Medium, + suppressed: false, + }, + kind: CouplingFindingKind::Cycle, + details: CouplingFindingDetails::Cycle { + modules: vec!["a".into(), "b".into(), "a".into()], + }, + }; + let config = Config::default(); + let data = crate::domain::AnalysisData::default(); + let reporter = make_reporter(&config, &data); + let rows = reporter.build_coupling(&[cycle]); + let entries: Vec = rows.into_iter().map(format_coupling_entry).collect(); + assert_eq!(entries[0]["category"], "cycle"); + let detail = entries[0]["detail"].as_str().unwrap(); + assert!(detail.contains("a -> b -> a"), "got: {detail}"); +} + +#[test] +fn build_test_quality_emit_correct_categories() { + let tq = TqFinding { + common: Finding { + file: "src/test.rs".into(), + line: 1, + column: 0, + dimension: crate::findings::Dimension::TestQuality, + rule_id: "tq/no_assertion".into(), + message: "test fn has no asserts".into(), + severity: crate::domain::Severity::Medium, + suppressed: false, + }, + kind: TqFindingKind::NoAssertion, + function_name: "test_fn".into(), + uncovered_lines: None, + }; + let config = Config::default(); + let data = crate::domain::AnalysisData::default(); + let reporter = make_reporter(&config, &data); + let rows = reporter.build_test_quality(&[tq]); + let entries: Vec = rows.into_iter().map(format_tq_entry).collect(); + assert_eq!(entries[0]["category"], "no_assertion"); +} + +#[test] +fn report_architecture_severity_maps_independently() { + let high = ArchitectureFinding { + common: arch_common("src/foo.rs", 1, crate::domain::Severity::High), + }; + let config = Config::default(); + let data = crate::domain::AnalysisData::default(); + let reporter = make_reporter(&config, &data); + let rows = reporter.build_architecture(&[high]); + let entries: Vec = rows.into_iter().map(format_arch_entry).collect(); + assert_eq!(entries[0]["category"], "architecture"); + assert!(entries[0]["detail"] + .as_str() + .unwrap() + .contains("architecture/test")); +} + +#[test] +fn empty_findings_produce_empty_chunks() { + let config = Config::default(); + let data = crate::domain::AnalysisData::default(); + let reporter = make_reporter(&config, &data); + assert!(reporter.build_iosp(&[]).is_empty()); + assert!(reporter.build_complexity(&[]).is_empty()); + assert!(reporter.build_dry(&[]).is_empty()); + assert!(reporter.build_srp(&[]).is_empty()); + assert!(reporter.build_coupling(&[]).is_empty()); + assert!(reporter.build_test_quality(&[]).is_empty()); + assert!(reporter.build_architecture(&[]).is_empty()); +} diff --git a/src/adapters/report/tests/ai/mod.rs b/src/adapters/report/tests/ai/mod.rs new file mode 100644 index 00000000..f89a0071 --- /dev/null +++ b/src/adapters/report/tests/ai/mod.rs @@ -0,0 +1,81 @@ +//! AI/TOON reporter tests, split into focused sub-files (each ≤ the SRP +//! file-length cap); shared imports + the build_ai_value/empty_analysis/ +//! arch_common/make_reporter helpers live here and reach the sub-modules via +//! `use super::*`. + +pub(super) use crate::adapters::analyzers::iosp::{ + CallOccurrence, Classification, ComplexityMetrics, FunctionAnalysis, LogicOccurrence, + MagicNumberOccurrence, +}; +pub(super) use crate::config::Config; +pub(super) use crate::domain::analysis_data::FunctionRecord; +pub(super) use crate::domain::findings::{ + ArchitectureFinding, ComplexityFinding, ComplexityFindingKind, CouplingFinding, + CouplingFindingDetails, CouplingFindingKind, DryFinding, DryFindingDetails, DryFindingKind, + DuplicateParticipant, IospFinding, SrpFinding, SrpFindingDetails, SrpFindingKind, TqFinding, + TqFindingKind, +}; +pub(super) use crate::domain::Finding; +pub(super) use crate::ports::reporter::ReporterImpl; +pub(super) use crate::ports::Reporter; +pub(super) use crate::report::ai::{ + format_arch_entry, format_complexity_entry, format_coupling_entry, format_dry_entry, + format_iosp_entry, format_srp_entry, format_tq_entry, AiOutputFormat, AiReporter, +}; +pub(super) use crate::report::AnalysisResult; +pub(super) use serde_json::Value; + +mod build_ai_value_shape; +mod dimension_entries_a; +mod dimension_entries_b; +mod smoke_and_orphan; + +/// Test-local helper: render via `AiReporter` with `Json` format and +/// parse back to `Value` so assertions can inspect structured data. +/// Lives here (not in production code) to keep the panic out of +/// production builds and avoid the architecture rule against loose +/// `#[cfg(test)]` items in production files. +pub(super) fn build_ai_value(analysis: &AnalysisResult, config: &Config) -> Value { + let reporter = AiReporter { + config, + data: &analysis.data, + format: AiOutputFormat::Json, + }; + let json_str = reporter.render(&analysis.findings, &analysis.data); + serde_json::from_str(&json_str).expect("AiReporter::render(Json) must produce valid JSON") +} + +pub(super) fn empty_analysis() -> AnalysisResult { + AnalysisResult { + results: vec![], + summary: crate::report::Summary::default(), + findings: crate::domain::AnalysisFindings::default(), + data: crate::domain::AnalysisData::default(), + } +} + +pub(super) fn arch_common(file: &str, line: usize, severity: crate::domain::Severity) -> Finding { + Finding { + file: file.into(), + line, + column: 0, + dimension: crate::findings::Dimension::Architecture, + rule_id: "architecture/test".into(), + message: "test".into(), + severity, + suppressed: false, + } +} + +// ── AiReporter trait methods: per-dimension entry shape ──────────── + +pub(super) fn make_reporter<'a>( + config: &'a Config, + data: &'a crate::domain::AnalysisData, +) -> AiReporter<'a> { + AiReporter { + config, + data, + format: AiOutputFormat::Json, + } +} diff --git a/src/adapters/report/tests/ai/smoke_and_orphan.rs b/src/adapters/report/tests/ai/smoke_and_orphan.rs new file mode 100644 index 00000000..25e7ae46 --- /dev/null +++ b/src/adapters/report/tests/ai/smoke_and_orphan.rs @@ -0,0 +1,108 @@ +use super::*; + +// ── Smoke tests ──────────────────────────────────────────────────── + +#[test] +fn ai_toon_render_on_empty_analysis_emits_zero_findings() { + let analysis = empty_analysis(); + let config = Config::default(); + let reporter = AiReporter { + config: &config, + data: &analysis.data, + format: AiOutputFormat::Toon, + }; + let output = reporter.render(&analysis.findings, &analysis.data); + assert!( + output.contains("findings"), + "TOON output must include the findings key; got {output}" + ); + assert!( + !output.contains("findings_by_file:"), + "no findings_by_file when zero findings; got {output}" + ); +} + +#[test] +fn ai_json_render_on_empty_analysis_emits_zero_findings() { + let analysis = empty_analysis(); + let config = Config::default(); + let value = build_ai_value(&analysis, &config); + assert_eq!( + value["findings"], 0, + "empty analysis must produce zero findings; got {value}" + ); +} + +#[test] +fn ai_value_includes_complexity_finding_metric_and_location() { + let mut analysis = empty_analysis(); + analysis.findings.complexity = vec![ComplexityFinding { + common: Finding { + file: "test.rs".into(), + line: 4, + column: 0, + dimension: crate::findings::Dimension::Complexity, + rule_id: "complexity/magic_number".into(), + message: "magic number 42 in f".into(), + severity: crate::domain::Severity::Medium, + suppressed: false, + }, + kind: ComplexityFindingKind::MagicNumber, + metric_value: 1, + threshold: 0, + hotspot: None, + }]; + let config = Config::default(); + let value = build_ai_value(&analysis, &config); + assert_eq!(value["findings"], 1, "one complexity finding: got {value}"); + let by_file = value["findings_by_file"] + .as_object() + .expect("findings_by_file present"); + let entries = by_file + .get("test.rs") + .and_then(|v| v.as_array()) + .expect("entries for test.rs"); + let magic_entries: Vec<_> = entries + .iter() + .filter(|e| e["category"].as_str() == Some("magic_number")) + .collect(); + assert_eq!( + magic_entries.len(), + 1, + "magic_number category preserved; got {value}" + ); + assert_eq!( + magic_entries[0]["line"], 4, + "line number preserved; got {value}" + ); +} + +#[test] +fn ai_reporter_includes_orphan_entries_via_snapshot_view() { + use crate::domain::findings::OrphanSuppression; + let mut analysis = empty_analysis(); + analysis.findings.orphan_suppressions = vec![OrphanSuppression { + file: "src/foo.rs".into(), + line: 42, + dimensions: vec![crate::findings::Dimension::Srp], + reason: Some("legacy".into()), + }]; + let config = Config::default(); + let value = build_ai_value(&analysis, &config); + assert_eq!( + value["findings"], 1, + "orphan must count as a finding, got value: {value}" + ); + let by_file = value["findings_by_file"] + .as_object() + .expect("findings_by_file present"); + let entries = by_file + .get("src/foo.rs") + .and_then(|v| v.as_array()) + .expect("entries for src/foo.rs"); + let orphan = entries + .iter() + .find(|e| e["category"] == "orphan_suppression") + .expect("orphan entry under src/foo.rs"); + assert_eq!(orphan["line"], 42); +} diff --git a/src/adapters/report/tests/baseline.rs b/src/adapters/report/tests/baseline.rs index 554def08..52efd94b 100644 --- a/src/adapters/report/tests/baseline.rs +++ b/src/adapters/report/tests/baseline.rs @@ -1,42 +1,38 @@ use crate::adapters::analyzers::iosp::{ - compute_severity, CallOccurrence, Classification, FunctionAnalysis, LogicOccurrence, + CallOccurrence, Classification, FunctionAnalysis, LogicOccurrence, }; +use crate::adapters::report::test_support::{make_result, violation}; use crate::report::baseline::{create_baseline, print_comparison}; use crate::report::Summary; -fn make_result(name: &str, classification: Classification) -> FunctionAnalysis { - let severity = compute_severity(&classification); - FunctionAnalysis { - name: name.to_string(), - file: "test.rs".to_string(), - line: 1, - classification, - parent_type: None, - suppressed: false, - complexity: None, - qualified_name: name.to_string(), - severity, - cognitive_warning: false, - cyclomatic_warning: false, - nesting_depth_warning: false, - function_length_warning: false, - unsafe_warning: false, - error_handling_warning: false, - complexity_suppressed: false, - own_calls: vec![], - parameter_count: 0, - is_trait_impl: false, - is_test: false, - effort_score: None, - } -} - fn make_summary(results: &[FunctionAnalysis]) -> Summary { let mut s = Summary::from_results(results); s.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); s } +/// Build a baseline from `results` and parse it back into a JSON `Value`. +fn baseline_json(results: &[FunctionAnalysis]) -> serde_json::Value { + let summary = make_summary(results); + serde_json::from_str(&create_baseline(results, &summary)).unwrap() +} + +/// Build a baseline from `old`, then compare `new` against it — returns +/// whether `new` is a regression. +fn compare(old: &[FunctionAnalysis], new: &[FunctionAnalysis]) -> bool { + let baseline = create_baseline(old, &make_summary(old)); + print_comparison(&baseline, new, &make_summary(new)) +} + +/// `[a: Integration, b: ]` — the two-function fixture the +/// comparison tests vary. +fn ab(b_class: Classification) -> Vec { + vec![ + make_result("a", Classification::Integration), + make_result("b", b_class), + ] +} + #[test] fn test_create_baseline_empty() { let results: Vec = vec![]; @@ -75,19 +71,16 @@ fn test_create_baseline_with_violations() { } #[test] -fn test_create_baseline_iosp_score() { - let results = vec![ - make_result("a", Classification::Integration), - make_result("b", Classification::Operation), - ]; - let summary = make_summary(&results); - let json = create_baseline(&results, &summary); - let parsed: serde_json::Value = serde_json::from_str(&json).unwrap(); - let score = parsed["iosp_score"].as_f64().unwrap(); - assert!( - (score - 1.0).abs() < f64::EPSILON, - "Score should be 1.0 with no violations" - ); +fn test_create_baseline_perfect_scores_are_one() { + // With no violations both the IOSP and the overall quality score are 1.0. + let parsed = baseline_json(&ab(Classification::Operation)); + for field in ["iosp_score", "quality_score"] { + let score = parsed[field].as_f64().unwrap(); + assert!( + (score - 1.0).abs() < 1e-10, + "{field} should be 1.0 with no violations; got {score}" + ); + } } #[test] @@ -128,76 +121,33 @@ fn test_create_baseline_suppressed_excluded() { } #[test] -fn test_print_comparison_no_regression() { - let results = vec![make_result("a", Classification::Integration)]; - let summary = make_summary(&results); - let baseline = create_baseline(&results, &summary); - let regressed = print_comparison(&baseline, &results, &summary); - assert!(!regressed, "Same scores should not be a regression"); -} - -#[test] -fn test_print_comparison_improvement() { - let old_results = vec![ - make_result("a", Classification::Integration), - make_result( - "b", - Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![LogicOccurrence { - kind: "if".into(), - line: 1, - }], - call_locations: vec![CallOccurrence { - name: "x".into(), - line: 2, - }], - }, +fn test_print_comparison_detects_only_regressions() { + // `print_comparison` flags a regression only when the new quality score + // is worse than the baseline: identical scores and improvements pass, + // a new violation (lower score) regresses. (label, old, new, regressed) + let cases: Vec<(&str, Vec, Vec, bool)> = vec![ + ( + "identical scores → no regression", + vec![make_result("a", Classification::Integration)], + vec![make_result("a", Classification::Integration)], + false, ), - ]; - let old_summary = make_summary(&old_results); - let baseline = create_baseline(&old_results, &old_summary); - - let new_results = vec![ - make_result("a", Classification::Integration), - make_result("b", Classification::Operation), - ]; - let new_summary = make_summary(&new_results); - let regressed = print_comparison(&baseline, &new_results, &new_summary); - assert!(!regressed, "Improvement should not be a regression"); -} - -#[test] -fn test_print_comparison_regression() { - let old_results = vec![ - make_result("a", Classification::Integration), - make_result("b", Classification::Operation), - ]; - let old_summary = make_summary(&old_results); - let baseline = create_baseline(&old_results, &old_summary); - - let new_results = vec![ - make_result("a", Classification::Integration), - make_result( - "b", - Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![LogicOccurrence { - kind: "if".into(), - line: 1, - }], - call_locations: vec![CallOccurrence { - name: "x".into(), - line: 2, - }], - }, + ( + "improvement (violation removed) → no regression", + ab(violation("if", "x")), + ab(Classification::Operation), + false, + ), + ( + "new violation (lower score) → regression", + ab(Classification::Operation), + ab(violation("if", "x")), + true, ), ]; - let new_summary = make_summary(&new_results); - let regressed = print_comparison(&baseline, &new_results, &new_summary); - assert!(regressed, "Score regression should be detected"); + for (label, old, new, regressed) in cases { + assert_eq!(compare(&old, &new), regressed, "case {label}"); + } } #[test] @@ -219,22 +169,6 @@ fn test_create_baseline_v2_has_version() { assert_eq!(parsed["version"].as_u64().unwrap(), 2); } -#[test] -fn test_create_baseline_v2_has_quality_score() { - let results = vec![ - make_result("a", Classification::Integration), - make_result("b", Classification::Operation), - ]; - let summary = make_summary(&results); - let json = create_baseline(&results, &summary); - let parsed: serde_json::Value = serde_json::from_str(&json).unwrap(); - let q = parsed["quality_score"].as_f64().unwrap(); - assert!( - (q - 1.0).abs() < 1e-10, - "quality_score near 1.0 (float tolerance): got {q}" - ); -} - #[test] fn test_create_baseline_v2_has_all_dimensions() { let results = vec![make_result("f", Classification::Operation)]; @@ -265,34 +199,10 @@ fn test_baseline_v1_compat_no_version() { #[test] fn test_baseline_v2_regression_by_quality_score() { - // V2 baseline with perfect score - let results_old = vec![ - make_result("a", Classification::Integration), - make_result("b", Classification::Operation), - ]; - let summary_old = make_summary(&results_old); - let baseline = create_baseline(&results_old, &summary_old); - - // New results: one violation → lower quality score - let results_new = vec![ - make_result("a", Classification::Integration), - make_result( - "b", - Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![LogicOccurrence { - kind: "if".into(), - line: 1, - }], - call_locations: vec![CallOccurrence { - name: "x".into(), - line: 2, - }], - }, - ), - ]; - let summary_new = make_summary(&results_new); - let regressed = print_comparison(&baseline, &results_new, &summary_new); + // V2 baselines compare by quality_score: a perfect-score baseline that + // gains a violation must regress. (Covered structurally by + // `test_print_comparison_detects_only_regressions`; this pins the V2 + // quality-score path explicitly.) + let regressed = compare(&ab(Classification::Operation), &ab(violation("if", "x"))); assert!(regressed, "Quality score regression should be detected"); } diff --git a/src/adapters/report/tests/github.rs b/src/adapters/report/tests/github.rs deleted file mode 100644 index 376befdf..00000000 --- a/src/adapters/report/tests/github.rs +++ /dev/null @@ -1,430 +0,0 @@ -use crate::adapters::analyzers::iosp::{compute_severity, CallOccurrence, LogicOccurrence}; -use crate::adapters::analyzers::iosp::{Classification, FunctionAnalysis}; -use crate::adapters::report::github::build::{ - build_architecture_view, build_complexity_view, build_coupling_view, build_dry_view, - build_iosp_view, build_srp_view, build_tq_view, -}; -use crate::adapters::report::github::format::{ - format_architecture, format_complexity, format_coupling, format_dry, format_iosp, format_srp, - format_tq, -}; -use crate::ports::Reporter; - -// Wrappers that preserve the test API: take a finding slice, return -// the formatted annotation block. They go through the new build → -// format pipeline so the tests exercise the real path. -fn render_iosp_chunk(findings: &[IospFinding]) -> String { - format_iosp(&build_iosp_view(findings)) -} -fn render_architecture_chunk(findings: &[ArchitectureFinding]) -> String { - format_architecture(&build_architecture_view(findings)) -} -fn render_complexity_chunk(findings: &[crate::domain::findings::ComplexityFinding]) -> String { - format_complexity(&build_complexity_view(findings)) -} -fn render_dry_chunk(findings: &[crate::domain::findings::DryFinding]) -> String { - format_dry(&build_dry_view(findings)) -} -fn render_srp_chunk(findings: &[crate::domain::findings::SrpFinding]) -> String { - format_srp(&build_srp_view(findings)) -} -fn render_coupling_chunk(findings: &[crate::domain::findings::CouplingFinding]) -> String { - format_coupling(&build_coupling_view(findings)) -} -fn render_tq_chunk(findings: &[crate::domain::findings::TqFinding]) -> String { - format_tq(&build_tq_view(findings)) -} -use crate::domain::findings::{ArchitectureFinding, IospFinding}; -use crate::domain::Finding; -use crate::report::github::*; -use crate::report::{AnalysisResult, Summary}; - -fn make_result(name: &str, classification: Classification) -> FunctionAnalysis { - let severity = compute_severity(&classification); - FunctionAnalysis { - name: name.to_string(), - file: "test.rs".to_string(), - line: 1, - classification, - parent_type: None, - suppressed: false, - complexity: None, - qualified_name: name.to_string(), - severity, - cognitive_warning: false, - cyclomatic_warning: false, - nesting_depth_warning: false, - function_length_warning: false, - unsafe_warning: false, - error_handling_warning: false, - complexity_suppressed: false, - own_calls: vec![], - parameter_count: 0, - is_trait_impl: false, - is_test: false, - effort_score: None, - } -} - -fn make_analysis(results: Vec) -> AnalysisResult { - let summary = Summary::from_results(&results); - let data = crate::app::projection::project_data(&results, None); - let findings = crate::domain::AnalysisFindings { - iosp: crate::app::projection::project_iosp(&results), - ..Default::default() - }; - AnalysisResult { - results, - summary, - findings, - data, - } -} - -// ── Smoke tests via the public entry point ───────────────────────── - -#[test] -fn test_print_github_emits_quality_notice_when_clean() { - let analysis = make_analysis(vec![make_result("good_fn", Classification::Integration)]); - let reporter = crate::adapters::report::github::GithubReporter { - summary: &analysis.summary, - }; - let out = reporter.render(&analysis.findings, &analysis.data); - assert!( - out.contains("::notice::") || out.contains("::error::"), - "github output must include a quality-score annotation prefix; got {out}" - ); - assert!( - !out.contains("::warning::"), - "clean analysis must not emit warning annotations; got {out}" - ); -} - -#[test] -fn test_print_github_emits_warning_for_violation_with_location() { - let analysis = make_analysis(vec![make_result( - "bad_fn", - Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![LogicOccurrence { - kind: "if".into(), - line: 5, - }], - call_locations: vec![CallOccurrence { - name: "helper".into(), - line: 6, - }], - }, - )]); - let reporter = crate::adapters::report::github::GithubReporter { - summary: &analysis.summary, - }; - let out = reporter.render(&analysis.findings, &analysis.data); - assert!( - out.contains("::warning") || out.contains("::error"), - "violation must emit warning/error annotation; got {out}" - ); - assert!( - out.contains("file=test.rs"), - "annotation must include file location; got {out}" - ); -} - -// ── Content tests against the GithubReporter trait directly ──────── -// -// These test the per-dimension trait methods. They're loose: they -// verify the general shape of the output (level prefix, file/line -// presence) without pinning exact wording, so message rewordings -// don't break them. - -#[test] -fn iosp_finding_emits_warning_with_file_and_line() { - use crate::domain::findings::{CallLocation, LogicLocation}; - let f = IospFinding { - common: Finding { - file: "src/lib.rs".into(), - line: 42, - column: 0, - dimension: crate::findings::Dimension::Iosp, - rule_id: "iosp/violation".into(), - message: "ignored".into(), - severity: crate::domain::Severity::Medium, - suppressed: false, - }, - logic_locations: vec![LogicLocation { - kind: "if".into(), - line: 44, - }], - call_locations: vec![CallLocation { - name: "helper".into(), - line: 50, - }], - effort_score: Some(2.5), - }; - let out = render_iosp_chunk(&[f]); - assert!( - out.starts_with("::warning"), - "expected ::warning prefix; got {out}" - ); - assert!(out.contains("file=src/lib.rs")); - assert!(out.contains("line=42")); - assert!(out.contains("IOSP violation")); - assert!(out.contains("if")); - assert!(out.contains("helper")); -} - -#[test] -fn iosp_suppressed_finding_skipped() { - let f = IospFinding { - common: Finding { - file: "src/lib.rs".into(), - line: 42, - column: 0, - dimension: crate::findings::Dimension::Iosp, - rule_id: "iosp/violation".into(), - message: "ignored".into(), - severity: crate::domain::Severity::Medium, - suppressed: true, - }, - logic_locations: vec![], - call_locations: vec![], - effort_score: None, - }; - let out = render_iosp_chunk(&[f]); - assert!(out.is_empty(), "suppressed finding must produce no output"); -} - -#[test] -fn architecture_finding_emits_severity_mapped_level() { - let high = ArchitectureFinding { - common: Finding { - file: "src/foo.rs".into(), - line: 17, - column: 0, - dimension: crate::findings::Dimension::Architecture, - rule_id: "architecture/layer/violation".into(), - message: "layer skip".into(), - severity: crate::domain::Severity::High, - suppressed: false, - }, - }; - let out = render_architecture_chunk(&[high]); - assert!( - out.starts_with("::error"), - "High severity → ::error; got {out}" - ); - assert!(out.contains("architecture/layer/violation")); -} - -#[test] -fn architecture_finding_low_severity_emits_notice() { - let low = ArchitectureFinding { - common: Finding { - file: "src/foo.rs".into(), - line: 17, - column: 0, - dimension: crate::findings::Dimension::Architecture, - rule_id: "architecture/call_parity/multi_touchpoint".into(), - message: "multi".into(), - severity: crate::domain::Severity::Low, - suppressed: false, - }, - }; - let out = render_architecture_chunk(&[low]); - assert!(out.starts_with("::notice")); -} - -#[test] -fn empty_findings_produce_empty_output() { - assert!(render_iosp_chunk(&[]).is_empty()); - assert!(render_complexity_chunk(&[]).is_empty()); - assert!(render_dry_chunk(&[]).is_empty()); - assert!(render_srp_chunk(&[]).is_empty()); - assert!(render_coupling_chunk(&[]).is_empty()); - assert!(render_tq_chunk(&[]).is_empty()); - assert!(render_architecture_chunk(&[]).is_empty()); -} - -#[test] -fn summary_annotation_no_violations_emits_notice() { - let summary = Summary { - total: 100, - quality_score: 1.0, - ..Default::default() - }; - let out = render_summary_annotation(&summary); - assert!(out.contains("::notice")); - assert!(out.contains("100.0%")); -} - -#[test] -fn summary_annotation_with_violations_emits_error() { - let summary = Summary { - total: 100, - violations: 3, - quality_score: 0.95, - ..Default::default() - }; - let out = render_summary_annotation(&summary); - assert!(out.contains("::error")); - assert!(out.contains("3 finding")); - assert!(out.contains("3 IOSP violation")); -} - -#[test] -fn summary_annotation_with_only_architecture_findings_emits_error() { - // Default-fail exits nonzero for any finding; the GitHub summary - // must reflect that and not say "::notice" when an architecture - // finding alone fails the run. - let summary = Summary { - total: 100, - violations: 0, - architecture_warnings: 2, - quality_score: 0.99, - ..Default::default() - }; - let out = render_summary_annotation(&summary); - assert!( - out.contains("::error"), - "non-IOSP findings must still produce ::error so the GitHub summary \ - agrees with the default-fail exit code; got: {out}" - ); -} - -#[test] -fn summary_annotation_with_suppression_excess_adds_warning() { - let summary = Summary { - total: 100, - suppressed: 50, - suppression_ratio_exceeded: true, - ..Default::default() - }; - let out = render_summary_annotation(&summary); - assert!(out.contains("::warning")); - assert!(out.contains("Suppression ratio")); -} - -// ── new ReporterImpl interface ────────────────────────────────── - -#[test] -fn test_github_render_includes_summary_annotation() { - use crate::ports::Reporter; - let summary = Summary { - total: 100, - quality_score: 1.0, - ..Default::default() - }; - let reporter = GithubReporter { summary: &summary }; - let findings = crate::domain::AnalysisFindings::default(); - let data = crate::domain::AnalysisData::default(); - let out = reporter.render(&findings, &data); - assert!( - out.contains("::notice"), - "render output must include summary annotation, got: {out}", - ); - assert!(out.contains("100.0%")); -} - -#[test] -fn test_github_render_emits_iosp_annotation_then_summary() { - use crate::domain::findings::{CallLocation, IospFinding, LogicLocation}; - use crate::ports::Reporter; - let summary = Summary { - total: 1, - violations: 1, - quality_score: 0.5, - ..Default::default() - }; - let mut findings = crate::domain::AnalysisFindings::default(); - findings.iosp.push(IospFinding { - common: Finding { - file: "src/lib.rs".into(), - line: 17, - column: 0, - dimension: crate::findings::Dimension::Iosp, - rule_id: "iosp/violation".into(), - message: "x".into(), - severity: crate::domain::Severity::Medium, - suppressed: false, - }, - logic_locations: vec![LogicLocation { - kind: "if".into(), - line: 18, - }], - call_locations: vec![CallLocation { - name: "h".into(), - line: 19, - }], - effort_score: None, - }); - let reporter = GithubReporter { summary: &summary }; - let out = reporter.render(&findings, &crate::domain::AnalysisData::default()); - let iosp_pos = out - .find("file=src/lib.rs") - .expect("iosp annotation missing"); - let summary_pos = out - .find("::error::Quality analysis") - .expect("summary missing"); - assert!( - iosp_pos < summary_pos, - "per-dim chunks must come before summary annotation in render output", - ); -} - -#[test] -fn architecture_message_with_special_chars_is_escaped() { - // GitHub workflow commands break on `%`, CR, LF in message bodies - // and on `,`/`:` in property values. The annotation must escape - // them so config-provided reason text or path fragments cannot - // corrupt the output or split it into a second workflow command. - let mut common = Finding { - file: "src/foo,with,comma.rs".into(), - line: 7, - column: 0, - dimension: crate::findings::Dimension::Architecture, - rule_id: "architecture/custom".into(), - message: "100% bad\nline2".into(), - severity: crate::domain::Severity::Medium, - suppressed: false, - }; - common.severity = crate::domain::Severity::Medium; - let arch = vec![ArchitectureFinding { common }]; - let out = render_architecture_chunk(&arch); - assert!( - out.contains("100%25 bad%0Aline2"), - "message must escape % and LF; got: {out}" - ); - assert!( - out.contains("file=src/foo%2Cwith%2Ccomma.rs"), - "property must escape commas; got: {out}" - ); - assert!( - !out.contains("\nline2"), - "no raw LF must remain in the annotation; got: {out}" - ); -} - -#[test] -fn github_reporter_emits_orphan_annotations_via_snapshot_view() { - use crate::domain::findings::OrphanSuppression; - use crate::ports::Reporter; - let summary = Summary { - total: 1, - quality_score: 1.0, - ..Default::default() - }; - let mut findings = crate::domain::AnalysisFindings::default(); - findings.orphan_suppressions = vec![OrphanSuppression { - file: "src/foo.rs".into(), - line: 42, - dimensions: vec![crate::findings::Dimension::Srp], - reason: Some("legacy".into()), - }]; - let reporter = GithubReporter { summary: &summary }; - let out = reporter.render(&findings, &crate::domain::AnalysisData::default()); - assert!( - out.contains("file=src/foo.rs") && out.contains("line=42"), - "orphan annotation must reach output via snapshot.orphans; got: {out}" - ); -} diff --git a/src/adapters/report/tests/github/annotations.rs b/src/adapters/report/tests/github/annotations.rs new file mode 100644 index 00000000..ff131dd4 --- /dev/null +++ b/src/adapters/report/tests/github/annotations.rs @@ -0,0 +1,203 @@ +use super::*; + +// ── Smoke tests via the public entry point ───────────────────────── + +#[test] +fn github_smoke_annotations() { + // End-to-end: a clean analysis emits a quality notice/error and no + // warnings; a violation emits a warning/error annotation carrying the + // file location. (label, results, predicate over the rendered output) + type Pred = fn(&str) -> bool; + let cases: Vec<(&str, Vec, Pred)> = vec![ + ( + "clean analysis → quality notice/error, no warnings", + vec![make_result("good_fn", Classification::Integration)], + |o| (o.contains("::notice::") || o.contains("::error::")) && !o.contains("::warning::"), + ), + ( + "violation → warning/error annotation with file location", + vec![make_result("bad_fn", violation("if", "helper"))], + |o| (o.contains("::warning") || o.contains("::error")) && o.contains("file=test.rs"), + ), + ]; + for (label, results, pred) in cases { + let out = render_github(&make_analysis(results)); + assert!(pred(&out), "case {label}: got {out}"); + } +} + +// ── Content tests against the GithubReporter trait directly ──────── +// +// These test the per-dimension trait methods. They're loose: they +// verify the general shape of the output (level prefix, file/line +// presence) without pinning exact wording, so message rewordings +// don't break them. + +#[test] +fn iosp_finding_emits_warning_with_file_and_line() { + use crate::domain::findings::{CallLocation, LogicLocation}; + let f = IospFinding { + common: Finding { + file: "src/lib.rs".into(), + line: 42, + column: 0, + dimension: crate::findings::Dimension::Iosp, + rule_id: "iosp/violation".into(), + message: "ignored".into(), + severity: crate::domain::Severity::Medium, + suppressed: false, + }, + logic_locations: vec![LogicLocation { + kind: "if".into(), + line: 44, + }], + call_locations: vec![CallLocation { + name: "helper".into(), + line: 50, + }], + effort_score: Some(2.5), + }; + let out = render_iosp_chunk(&[f]); + assert!( + out.starts_with("::warning"), + "expected ::warning prefix; got {out}" + ); + assert!(out.contains("file=src/lib.rs")); + assert!(out.contains("line=42")); + assert!(out.contains("IOSP violation")); + assert!(out.contains("if")); + assert!(out.contains("helper")); +} + +#[test] +fn iosp_suppressed_finding_skipped() { + let f = IospFinding { + common: Finding { + file: "src/lib.rs".into(), + line: 42, + column: 0, + dimension: crate::findings::Dimension::Iosp, + rule_id: "iosp/violation".into(), + message: "ignored".into(), + severity: crate::domain::Severity::Medium, + suppressed: true, + }, + logic_locations: vec![], + call_locations: vec![], + effort_score: None, + }; + let out = render_iosp_chunk(&[f]); + assert!(out.is_empty(), "suppressed finding must produce no output"); +} + +/// An architecture finding at `src/foo.rs:17` with the given rule and severity. +fn arch_finding(rule_id: &str, severity: crate::domain::Severity) -> ArchitectureFinding { + ArchitectureFinding { + common: Finding { + file: "src/foo.rs".into(), + line: 17, + column: 0, + dimension: crate::findings::Dimension::Architecture, + rule_id: rule_id.into(), + message: "msg".into(), + severity, + suppressed: false, + }, + } +} + +#[test] +fn architecture_finding_severity_maps_to_level() { + // Severity maps to the GitHub annotation level: High → ::error, + // Low → ::notice. (label, rule_id, severity, expected_prefix) + use crate::domain::Severity; + let cases: &[(&str, &str, Severity, &str)] = &[ + ( + "high → ::error", + "architecture/layer/violation", + Severity::High, + "::error", + ), + ( + "low → ::notice", + "architecture/call_parity/multi_touchpoint", + Severity::Low, + "::notice", + ), + ]; + for (label, rule_id, severity, prefix) in cases { + let out = render_architecture_chunk(&[arch_finding(rule_id, severity.clone())]); + assert!(out.starts_with(prefix), "case {label}: got {out}"); + assert!(out.contains(rule_id), "case {label}: got {out}"); + } +} + +#[test] +fn empty_findings_produce_empty_output() { + assert!(render_iosp_chunk(&[]).is_empty()); + assert!(render_complexity_chunk(&[]).is_empty()); + assert!(render_dry_chunk(&[]).is_empty()); + assert!(render_srp_chunk(&[]).is_empty()); + assert!(render_coupling_chunk(&[]).is_empty()); + assert!(render_tq_chunk(&[]).is_empty()); + assert!(render_architecture_chunk(&[]).is_empty()); +} + +#[test] +fn summary_annotation_no_violations_emits_notice() { + let summary = Summary { + total: 100, + quality_score: 1.0, + ..Default::default() + }; + let out = render_summary_annotation(&summary); + assert!(out.contains("::notice")); + assert!(out.contains("100.0%")); +} + +#[test] +fn summary_annotation_with_violations_emits_error() { + let summary = Summary { + total: 100, + violations: 3, + quality_score: 0.95, + ..Default::default() + }; + let out = render_summary_annotation(&summary); + assert!(out.contains("::error")); + assert!(out.contains("3 finding")); + assert!(out.contains("3 IOSP violation")); +} + +#[test] +fn summary_annotation_with_only_architecture_findings_emits_error() { + // Default-fail exits nonzero for any finding; the GitHub summary + // must reflect that and not say "::notice" when an architecture + // finding alone fails the run. + let summary = Summary { + total: 100, + violations: 0, + architecture_warnings: 2, + quality_score: 0.99, + ..Default::default() + }; + let out = render_summary_annotation(&summary); + assert!( + out.contains("::error"), + "non-IOSP findings must still produce ::error so the GitHub summary \ + agrees with the default-fail exit code; got: {out}" + ); +} + +#[test] +fn summary_annotation_with_suppression_excess_adds_warning() { + let summary = Summary { + total: 100, + suppressed: 50, + suppression_ratio_exceeded: true, + ..Default::default() + }; + let out = render_summary_annotation(&summary); + assert!(out.contains("::warning")); + assert!(out.contains("Suppression ratio")); +} diff --git a/src/adapters/report/tests/github/mod.rs b/src/adapters/report/tests/github/mod.rs new file mode 100644 index 00000000..61148fe8 --- /dev/null +++ b/src/adapters/report/tests/github/mod.rs @@ -0,0 +1,59 @@ +//! GitHub-annotation reporter tests, split into focused sub-files (each ≤ the +//! SRP file-length cap); shared imports + the render_*_chunk / render_github +//! helpers live here and reach the sub-modules via `use super::*`. + +pub(super) use crate::adapters::analyzers::iosp::{Classification, FunctionAnalysis}; +pub(super) use crate::adapters::report::github::build::{ + build_architecture_view, build_complexity_view, build_coupling_view, build_dry_view, + build_iosp_view, build_srp_view, build_tq_view, +}; +pub(super) use crate::adapters::report::github::format::{ + format_architecture, format_complexity, format_coupling, format_dry, format_iosp, format_srp, + format_tq, +}; +pub(super) use crate::adapters::report::test_support::{make_analysis, make_result, violation}; +pub(super) use crate::domain::findings::{ArchitectureFinding, IospFinding}; +pub(super) use crate::domain::Finding; +pub(super) use crate::ports::Reporter; +pub(super) use crate::report::github::*; +pub(super) use crate::report::{AnalysisResult, Summary}; + +mod annotations; +mod rendering; + +// Wrappers that preserve the test API: take a finding slice, return +// the formatted annotation block. They go through the new build → +// format pipeline so the tests exercise the real path. +pub(super) fn render_iosp_chunk(findings: &[IospFinding]) -> String { + format_iosp(&build_iosp_view(findings)) +} +pub(super) fn render_architecture_chunk(findings: &[ArchitectureFinding]) -> String { + format_architecture(&build_architecture_view(findings)) +} +pub(super) fn render_complexity_chunk( + findings: &[crate::domain::findings::ComplexityFinding], +) -> String { + format_complexity(&build_complexity_view(findings)) +} +pub(super) fn render_dry_chunk(findings: &[crate::domain::findings::DryFinding]) -> String { + format_dry(&build_dry_view(findings)) +} +pub(super) fn render_srp_chunk(findings: &[crate::domain::findings::SrpFinding]) -> String { + format_srp(&build_srp_view(findings)) +} +pub(super) fn render_coupling_chunk( + findings: &[crate::domain::findings::CouplingFinding], +) -> String { + format_coupling(&build_coupling_view(findings)) +} +pub(super) fn render_tq_chunk(findings: &[crate::domain::findings::TqFinding]) -> String { + format_tq(&build_tq_view(findings)) +} + +/// Render the full GitHub-annotation output for `analysis`. +pub(super) fn render_github(analysis: &AnalysisResult) -> String { + crate::adapters::report::github::GithubReporter { + summary: &analysis.summary, + } + .render(&analysis.findings, &analysis.data) +} diff --git a/src/adapters/report/tests/github/rendering.rs b/src/adapters/report/tests/github/rendering.rs new file mode 100644 index 00000000..1a6504b4 --- /dev/null +++ b/src/adapters/report/tests/github/rendering.rs @@ -0,0 +1,125 @@ +use super::*; + +// ── new ReporterImpl interface ────────────────────────────────── + +#[test] +fn test_github_render_includes_summary_annotation() { + use crate::ports::Reporter; + let summary = Summary { + total: 100, + quality_score: 1.0, + ..Default::default() + }; + let reporter = GithubReporter { summary: &summary }; + let findings = crate::domain::AnalysisFindings::default(); + let data = crate::domain::AnalysisData::default(); + let out = reporter.render(&findings, &data); + assert!( + out.contains("::notice"), + "render output must include summary annotation, got: {out}", + ); + assert!(out.contains("100.0%")); +} + +#[test] +fn test_github_render_emits_iosp_annotation_then_summary() { + use crate::domain::findings::{CallLocation, IospFinding, LogicLocation}; + use crate::ports::Reporter; + let summary = Summary { + total: 1, + violations: 1, + quality_score: 0.5, + ..Default::default() + }; + let mut findings = crate::domain::AnalysisFindings::default(); + findings.iosp.push(IospFinding { + common: Finding { + file: "src/lib.rs".into(), + line: 17, + column: 0, + dimension: crate::findings::Dimension::Iosp, + rule_id: "iosp/violation".into(), + message: "x".into(), + severity: crate::domain::Severity::Medium, + suppressed: false, + }, + logic_locations: vec![LogicLocation { + kind: "if".into(), + line: 18, + }], + call_locations: vec![CallLocation { + name: "h".into(), + line: 19, + }], + effort_score: None, + }); + let reporter = GithubReporter { summary: &summary }; + let out = reporter.render(&findings, &crate::domain::AnalysisData::default()); + let iosp_pos = out + .find("file=src/lib.rs") + .expect("iosp annotation missing"); + let summary_pos = out + .find("::error::Quality analysis") + .expect("summary missing"); + assert!( + iosp_pos < summary_pos, + "per-dim chunks must come before summary annotation in render output", + ); +} + +#[test] +fn architecture_message_with_special_chars_is_escaped() { + // GitHub workflow commands break on `%`, CR, LF in message bodies + // and on `,`/`:` in property values. The annotation must escape + // them so config-provided reason text or path fragments cannot + // corrupt the output or split it into a second workflow command. + let mut common = Finding { + file: "src/foo,with,comma.rs".into(), + line: 7, + column: 0, + dimension: crate::findings::Dimension::Architecture, + rule_id: "architecture/custom".into(), + message: "100% bad\nline2".into(), + severity: crate::domain::Severity::Medium, + suppressed: false, + }; + common.severity = crate::domain::Severity::Medium; + let arch = vec![ArchitectureFinding { common }]; + let out = render_architecture_chunk(&arch); + assert!( + out.contains("100%25 bad%0Aline2"), + "message must escape % and LF; got: {out}" + ); + assert!( + out.contains("file=src/foo%2Cwith%2Ccomma.rs"), + "property must escape commas; got: {out}" + ); + assert!( + !out.contains("\nline2"), + "no raw LF must remain in the annotation; got: {out}" + ); +} + +#[test] +fn github_reporter_emits_orphan_annotations_via_snapshot_view() { + use crate::domain::findings::OrphanSuppression; + use crate::ports::Reporter; + let summary = Summary { + total: 1, + quality_score: 1.0, + ..Default::default() + }; + let mut findings = crate::domain::AnalysisFindings::default(); + findings.orphan_suppressions = vec![OrphanSuppression { + file: "src/foo.rs".into(), + line: 42, + dimensions: vec![crate::findings::Dimension::Srp], + reason: Some("legacy".into()), + }]; + let reporter = GithubReporter { summary: &summary }; + let out = reporter.render(&findings, &crate::domain::AnalysisData::default()); + assert!( + out.contains("file=src/foo.rs") && out.contains("line=42"), + "orphan annotation must reach output via snapshot.orphans; got: {out}" + ); +} diff --git a/src/adapters/report/tests/json.rs b/src/adapters/report/tests/json.rs deleted file mode 100644 index 8525a3c9..00000000 --- a/src/adapters/report/tests/json.rs +++ /dev/null @@ -1,586 +0,0 @@ -use crate::adapters::analyzers::iosp::{ - compute_severity, CallOccurrence, Classification, ComplexityMetrics, FunctionAnalysis, - LogicOccurrence, -}; -use crate::report::json::*; -use crate::report::{AnalysisResult, Summary}; - -fn make_result(name: &str, classification: Classification) -> FunctionAnalysis { - let severity = compute_severity(&classification); - FunctionAnalysis { - name: name.to_string(), - file: "test.rs".to_string(), - line: 1, - classification, - parent_type: None, - suppressed: false, - complexity: None, - qualified_name: name.to_string(), - severity, - cognitive_warning: false, - cyclomatic_warning: false, - nesting_depth_warning: false, - function_length_warning: false, - unsafe_warning: false, - error_handling_warning: false, - complexity_suppressed: false, - own_calls: vec![], - parameter_count: 0, - is_trait_impl: false, - is_test: false, - effort_score: None, - } -} - -fn make_analysis(results: Vec) -> AnalysisResult { - let summary = Summary::from_results(&results); - let data = crate::app::projection::project_data(&results, None); - let findings = crate::domain::AnalysisFindings { - iosp: crate::app::projection::project_iosp(&results), - ..Default::default() - }; - AnalysisResult { - results, - summary, - findings, - data, - } -} - -#[test] -fn test_print_json_empty_yields_valid_json() { - let analysis = make_analysis(vec![]); - let json = crate::report::json::build_json_string(&analysis); - let v: serde_json::Value = serde_json::from_str(&json).expect("valid JSON on empty input"); - assert_eq!( - v["functions"].as_array().map(Vec::len), - Some(0), - "empty analysis produces empty functions array" - ); -} - -#[test] -fn test_print_json_carries_violation_logic_and_call_locations() { - let analysis = make_analysis(vec![make_result( - "bad_fn", - Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![LogicOccurrence { - kind: "if".into(), - line: 1, - }], - call_locations: vec![CallOccurrence { - name: "f".into(), - line: 2, - }], - }, - )]); - let json = crate::report::json::build_json_string(&analysis); - let v: serde_json::Value = serde_json::from_str(&json).expect("valid JSON"); - let f = v["functions"] - .as_array() - .and_then(|a| a.iter().find(|x| x["name"] == "bad_fn")) - .expect("function `bad_fn`"); - assert_eq!(f["classification"], "violation"); - let logic = f["logic"].as_array().expect("logic array"); - assert_eq!(logic.len(), 1, "one logic location; got {json}"); - assert_eq!(logic[0]["kind"], "if"); - assert_eq!(logic[0]["line"], "1"); - let calls = f["calls"].as_array().expect("calls array"); - assert_eq!(calls.len(), 1, "one call location; got {json}"); - assert_eq!(calls[0]["name"], "f"); - assert_eq!(calls[0]["line"], "2"); -} - -#[test] -fn test_print_json_classifications_all_four() { - let analysis = make_analysis(vec![ - make_result("a", Classification::Integration), - make_result("b", Classification::Operation), - make_result("c", Classification::Trivial), - make_result( - "d", - Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![LogicOccurrence { - kind: "match".into(), - line: 1, - }], - call_locations: vec![CallOccurrence { - name: "g".into(), - line: 2, - }], - }, - ), - ]); - let json = crate::report::json::build_json_string(&analysis); - let v: serde_json::Value = serde_json::from_str(&json).expect("valid JSON"); - let by_name: std::collections::HashMap = v["functions"] - .as_array() - .expect("functions array") - .iter() - .map(|f| { - ( - f["name"].as_str().unwrap().into(), - f["classification"].as_str().unwrap().into(), - ) - }) - .collect(); - assert_eq!(by_name.get("a").map(String::as_str), Some("integration")); - assert_eq!(by_name.get("b").map(String::as_str), Some("operation")); - assert_eq!(by_name.get("c").map(String::as_str), Some("trivial")); - assert_eq!(by_name.get("d").map(String::as_str), Some("violation")); -} - -#[test] -fn test_print_json_carries_near_duplicate_similarity() { - use crate::domain::findings::{ - DryFinding, DryFindingDetails, DryFindingKind, DuplicateParticipant, - }; - use crate::domain::{Dimension, Finding, Severity}; - let participants = vec![ - DuplicateParticipant { - function_name: "a".into(), - file: "lib.rs".into(), - line: 10, - }, - DuplicateParticipant { - function_name: "b".into(), - file: "lib.rs".into(), - line: 50, - }, - ]; - let mut analysis = make_analysis(vec![]); - analysis.findings.dry.push(DryFinding { - common: Finding { - file: "lib.rs".into(), - line: 10, - column: 0, - dimension: Dimension::Dry, - rule_id: "dry/duplicate/similar".into(), - message: "near duplicate".into(), - severity: Severity::Medium, - suppressed: false, - }, - kind: DryFindingKind::DuplicateSimilar, - details: DryFindingDetails::Duplicate { - participants, - similarity: Some(0.91), - }, - }); - let json = crate::report::json::build_json_string(&analysis); - let v: serde_json::Value = serde_json::from_str(&json).expect("valid JSON"); - let group = v["duplicates"] - .as_array() - .and_then(|a| a.first()) - .expect("at least one duplicate group"); - let sim = group["similarity"].as_f64(); - assert_eq!( - sim, - Some(0.91), - "NearDuplicate similarity must survive projection + reporter; got {json}" - ); -} - -#[test] -fn test_print_json_carries_repeated_match_arm_count_and_distinct_groups() { - use crate::domain::findings::{ - DryFinding, DryFindingDetails, DryFindingKind, RepeatedMatchParticipant, - }; - use crate::domain::{Dimension, Finding, Severity}; - let common = |line: usize| Finding { - file: "lib.rs".into(), - line, - column: 0, - dimension: Dimension::Dry, - rule_id: "dry/repeated_match".into(), - message: "repeated match".into(), - severity: Severity::Medium, - suppressed: false, - }; - let participant = |name: &str, line: usize, arms: usize| RepeatedMatchParticipant { - function_name: name.into(), - file: "lib.rs".into(), - line, - arm_count: arms, - }; - let group_a = vec![participant("fa1", 10, 4), participant("fa2", 20, 4)]; - let group_b = vec![participant("fb1", 50, 3), participant("fb2", 60, 3)]; - let make_match = |line: usize, participants: Vec| DryFinding { - common: common(line), - kind: DryFindingKind::RepeatedMatch, - details: DryFindingDetails::RepeatedMatch { - enum_name: "MyEnum".into(), - participants, - }, - }; - let mut analysis = make_analysis(vec![]); - analysis.findings.dry.push(make_match(10, group_a)); - analysis.findings.dry.push(make_match(50, group_b)); - let json = crate::report::json::build_json_string(&analysis); - let v: serde_json::Value = serde_json::from_str(&json).expect("valid JSON"); - let groups = v["repeated_matches"] - .as_array() - .expect("repeated_matches array"); - assert_eq!( - groups.len(), - 2, - "two distinct groups over same enum must NOT collapse by enum_name; got {json}" - ); - let arm_counts: Vec = groups - .iter() - .flat_map(|g| g["entries"].as_array().unwrap().iter()) - .map(|e| e["arm_count"].as_u64().unwrap_or(0)) - .collect(); - assert!( - arm_counts.contains(&4) && arm_counts.contains(&3), - "arm_count must survive projection (expected both 4 and 3); got {arm_counts:?} from {json}" - ); -} - -#[test] -fn test_print_json_carries_srp_composite_score_clusters_length_score() { - use crate::domain::findings::{ - ResponsibilityCluster, SrpFinding, SrpFindingDetails, SrpFindingKind, - }; - use crate::domain::{Dimension, Finding, Severity}; - let common = |line: usize| Finding { - file: "lib.rs".into(), - line, - column: 0, - dimension: Dimension::Srp, - rule_id: "srp/cohesion".into(), - message: "low cohesion".into(), - severity: Severity::Medium, - suppressed: false, - }; - let make_srp = |line: usize, kind: SrpFindingKind, details: SrpFindingDetails| SrpFinding { - common: common(line), - kind, - details, - }; - let mut analysis = make_analysis(vec![]); - analysis.findings.srp.push(make_srp( - 10, - SrpFindingKind::StructCohesion, - SrpFindingDetails::StructCohesion { - struct_name: "S".into(), - lcom4: 3, - field_count: 4, - method_count: 6, - fan_out: 2, - composite_score: 0.85, - clusters: vec![ResponsibilityCluster { - methods: vec!["m1".into(), "m2".into()], - fields: vec!["f1".into()], - }], - }, - )); - analysis.findings.srp.push(make_srp( - 20, - SrpFindingKind::ModuleLength, - SrpFindingDetails::ModuleLength { - module: "modA".into(), - production_lines: 500, - independent_clusters: 2, - cluster_names: vec![vec!["m1".into(), "m2".into()], vec!["m3".into()]], - length_score: 1.2, - }, - )); - let json = crate::report::json::build_json_string(&analysis); - let v: serde_json::Value = serde_json::from_str(&json).expect("valid JSON"); - let s = v["srp"]["struct_warnings"] - .as_array() - .and_then(|a| a.first()) - .expect("struct_warnings present"); - assert_eq!( - s["composite_score"].as_f64(), - Some(0.85), - "composite_score must survive; got {json}" - ); - let clusters = s["clusters"].as_array().expect("clusters array"); - assert_eq!(clusters.len(), 1, "one cluster; got {json}"); - assert_eq!( - clusters[0]["methods"].as_array().map(|a| a.len()), - Some(2), - "cluster methods preserved; got {json}" - ); - let m = v["srp"]["module_warnings"] - .as_array() - .and_then(|a| a.first()) - .expect("module_warnings present"); - assert_eq!( - m["length_score"].as_f64(), - Some(1.2), - "length_score must survive; got {json}" - ); - let cluster_names = m["cluster_names"].as_array().expect("cluster_names array"); - assert_eq!(cluster_names.len(), 2, "two clusters; got {json}"); - assert_eq!( - cluster_names[0].as_array().map(|a| a.len()), - Some(2), - "first cluster has 2 names; got {json}" - ); -} - -#[test] -fn test_print_json_carries_complexity_counts() { - // Build the JSON string, parse it, and assert the analyzer's - // non-zero `logic_count` / `call_count` survive the projection + - // reporter round-trip. Regression for v1.2.1: the typed-reporter - // refactor dropped both fields from the projection, so every - // function appeared as `logic_count: 0, call_count: 0` in JSON - // until the round-12 fix added them back to - // `ComplexityMetricsRecord` and the JSON projection. - let mut func = make_result("counted", Classification::Operation); - func.complexity = Some(ComplexityMetrics { - logic_count: 5, - call_count: 4, - max_nesting: 1, - ..Default::default() - }); - let analysis = make_analysis(vec![func]); - let json = crate::report::json::build_json_string(&analysis); - let v: serde_json::Value = serde_json::from_str(&json).expect("valid JSON"); - let f = v["functions"] - .as_array() - .and_then(|a| a.iter().find(|x| x["name"] == "counted")) - .expect("function `counted` present"); - let complexity = &f["complexity"]; - assert_eq!( - complexity["logic_count"].as_u64(), - Some(5), - "logic_count must survive projection + reporter; got {json}" - ); - assert_eq!( - complexity["call_count"].as_u64(), - Some(4), - "call_count must survive projection + reporter; got {json}" - ); -} - -#[test] -fn test_print_json_marks_suppressed_function() { - let mut func = make_result( - "suppressed", - Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![LogicOccurrence { - kind: "if".into(), - line: 1, - }], - call_locations: vec![CallOccurrence { - name: "f".into(), - line: 2, - }], - }, - ); - func.suppressed = true; - let analysis = make_analysis(vec![func]); - let json = crate::report::json::build_json_string(&analysis); - let v: serde_json::Value = serde_json::from_str(&json).expect("valid JSON"); - let f = v["functions"] - .as_array() - .and_then(|a| a.iter().find(|x| x["name"] == "suppressed")) - .expect("function `suppressed`"); - assert_eq!( - f["suppressed"].as_bool(), - Some(true), - "suppressed flag must propagate to JSON; got {json}" - ); -} - -#[test] -fn test_print_json_carries_high_severity_for_many_violations() { - let analysis = make_analysis(vec![make_result( - "complex", - Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![ - LogicOccurrence { - kind: "if".into(), - line: 1, - }, - LogicOccurrence { - kind: "match".into(), - line: 2, - }, - LogicOccurrence { - kind: "for".into(), - line: 3, - }, - ], - call_locations: vec![ - CallOccurrence { - name: "a".into(), - line: 4, - }, - CallOccurrence { - name: "b".into(), - line: 5, - }, - CallOccurrence { - name: "c".into(), - line: 6, - }, - ], - }, - )]); - let json = crate::report::json::build_json_string(&analysis); - let v: serde_json::Value = serde_json::from_str(&json).expect("valid JSON"); - let f = v["functions"] - .as_array() - .and_then(|a| a.iter().find(|x| x["name"] == "complex")) - .expect("function `complex`"); - let sev = f["severity"].as_str().unwrap_or(""); - assert!( - matches!(sev, "high" | "medium"), - "violations with 3+3 logic/call locations must map to medium/high severity; got `{sev}` in {json}" - ); - assert_eq!( - f["logic"].as_array().map(Vec::len), - Some(3), - "3 logic locations preserved" - ); - assert_eq!( - f["calls"].as_array().map(Vec::len), - Some(3), - "3 call locations preserved" - ); -} - -// ── JSON content tests (verifying fields are present) ────── - -#[test] -fn test_json_summary_has_complexity_warnings_field() { - let analysis = make_analysis(vec![make_result("f", Classification::Operation)]); - let json = build_json_string(&analysis); - let parsed: serde_json::Value = serde_json::from_str(&json).unwrap(); - assert!( - parsed["summary"]["complexity_warnings"].is_number(), - "JSON summary must include complexity_warnings field" - ); -} - -#[test] -fn test_json_summary_has_magic_number_warnings_field() { - let analysis = make_analysis(vec![make_result("f", Classification::Operation)]); - let json = build_json_string(&analysis); - let parsed: serde_json::Value = serde_json::from_str(&json).unwrap(); - assert!( - parsed["summary"]["magic_number_warnings"].is_number(), - "JSON summary must include magic_number_warnings field" - ); -} - -#[test] -fn test_json_summary_has_all_dimension_fields() { - let analysis = make_analysis(vec![make_result("f", Classification::Operation)]); - let json = build_json_string(&analysis); - let parsed: serde_json::Value = serde_json::from_str(&json).unwrap(); - let s = &parsed["summary"]; - let expected_fields = [ - "total", - "integrations", - "operations", - "violations", - "trivial", - "suppressed", - "all_suppressions", - "iosp_score", - "quality_score", - "complexity_warnings", - "magic_number_warnings", - "nesting_depth_warnings", - "function_length_warnings", - "unsafe_warnings", - "error_handling_warnings", - "coupling_warnings", - "coupling_cycles", - "duplicate_groups", - "dead_code_warnings", - "fragment_groups", - "boilerplate_warnings", - "srp_struct_warnings", - "srp_module_warnings", - "srp_param_warnings", - "tq_no_assertion_warnings", - "tq_no_sut_warnings", - "tq_untested_warnings", - "tq_uncovered_warnings", - "tq_untested_logic_warnings", - "suppression_ratio_exceeded", - ]; - expected_fields.iter().for_each(|&field| { - assert!(!s[field].is_null(), "JSON summary missing field: {field}"); - }); -} - -#[test] -fn test_json_complexity_has_extended_fields() { - let mut func = make_result("f", Classification::Operation); - func.complexity = Some(ComplexityMetrics { - logic_count: 3, - call_count: 1, - max_nesting: 2, - function_lines: 45, - unsafe_blocks: 1, - unwrap_count: 2, - expect_count: 1, - panic_count: 0, - todo_count: 0, - ..Default::default() - }); - let analysis = make_analysis(vec![func]); - let json = build_json_string(&analysis); - let parsed: serde_json::Value = serde_json::from_str(&json).unwrap(); - let c = &parsed["functions"][0]["complexity"]; - assert_eq!(c["function_lines"].as_u64().unwrap(), 45); - assert_eq!(c["unsafe_blocks"].as_u64().unwrap(), 1); - assert_eq!(c["unwrap_count"].as_u64().unwrap(), 2); - assert_eq!(c["expect_count"].as_u64().unwrap(), 1); - assert_eq!(c["panic_count"].as_u64().unwrap(), 0); - assert_eq!(c["todo_count"].as_u64().unwrap(), 0); -} - -#[test] -fn json_reporter_includes_orphan_suppressions_via_snapshot_view() { - // Populate `findings.orphan_suppressions` ONLY (not the legacy - // `analysis.orphan_suppressions` field) and verify the JSON - // output still includes the orphans — proving the JSON reporter - // reads them from the trait-driven `Snapshot::orphans` view. - use crate::domain::findings::OrphanSuppression; - let mut analysis = make_analysis(vec![]); - analysis.findings.orphan_suppressions = vec![OrphanSuppression { - file: "src/foo.rs".into(), - line: 42, - dimensions: vec![crate::findings::Dimension::Srp], - reason: Some("legacy".into()), - }]; - let json = build_json_string(&analysis); - let parsed: serde_json::Value = serde_json::from_str(&json).unwrap(); - let arr = parsed["orphan_suppressions"].as_array().unwrap(); - assert_eq!(arr.len(), 1); - assert_eq!(arr[0]["file"], "src/foo.rs"); - assert_eq!(arr[0]["line"], 42); - assert_eq!(arr[0]["dimensions"][0], "srp"); - assert_eq!(arr[0]["reason"], "legacy"); -} - -#[test] -fn test_json_omits_empty_orphan_suppressions() { - // When the list is empty (clean codebase), the field is elided - // to keep JSON compact — matches the policy for other optional - // arrays (duplicates, dead_code, etc.). - let analysis = make_analysis(vec![]); - let json = build_json_string(&analysis); - let parsed: serde_json::Value = serde_json::from_str(&json).unwrap(); - assert!( - parsed.get("orphan_suppressions").is_none(), - "empty orphan list should be elided from JSON" - ); -} diff --git a/src/adapters/report/tests/json/mod.rs b/src/adapters/report/tests/json/mod.rs new file mode 100644 index 00000000..b8c45095 --- /dev/null +++ b/src/adapters/report/tests/json/mod.rs @@ -0,0 +1,28 @@ +//! JSON reporter tests, split into focused sub-files (each ≤ the SRP +//! file-length cap); shared imports + the `json_value`/`function_named` +//! helpers live here and reach the sub-modules via `use super::*`. + +pub(super) use crate::adapters::analyzers::iosp::{ + CallOccurrence, Classification, ComplexityMetrics, FunctionAnalysis, LogicOccurrence, +}; +pub(super) use crate::adapters::report::test_support::{make_analysis, make_result}; +pub(super) use crate::report::json::*; +pub(super) use crate::report::AnalysisResult; + +mod srp_complexity_severity; +mod summary_fields_and_orphan; +mod violations_and_dups; + +/// Build the JSON report for `analysis` and parse it back into a `Value`. +pub(super) fn json_value(analysis: &AnalysisResult) -> serde_json::Value { + let json = crate::report::json::build_json_string(analysis); + serde_json::from_str(&json).expect("reporter must emit valid JSON") +} + +/// The `functions[]` entry named `name`, panicking if absent. +pub(super) fn function_named<'a>(v: &'a serde_json::Value, name: &str) -> &'a serde_json::Value { + v["functions"] + .as_array() + .and_then(|a| a.iter().find(|x| x["name"] == name)) + .unwrap_or_else(|| panic!("function `{name}` present")) +} diff --git a/src/adapters/report/tests/json/srp_complexity_severity.rs b/src/adapters/report/tests/json/srp_complexity_severity.rs new file mode 100644 index 00000000..54c2061f --- /dev/null +++ b/src/adapters/report/tests/json/srp_complexity_severity.rs @@ -0,0 +1,206 @@ +use super::*; + +/// Analysis with one struct-cohesion + one module-length SRP finding carrying +/// composite-score / clusters / length-score detail (the JSON-projection arrange). +fn srp_composite_analysis() -> AnalysisResult { + use crate::domain::findings::{ + ResponsibilityCluster, SrpFinding, SrpFindingDetails, SrpFindingKind, + }; + use crate::domain::{Dimension, Finding, Severity}; + let common = |line: usize| Finding { + file: "lib.rs".into(), + line, + column: 0, + dimension: Dimension::Srp, + rule_id: "srp/cohesion".into(), + message: "low cohesion".into(), + severity: Severity::Medium, + suppressed: false, + }; + let make_srp = |line: usize, kind: SrpFindingKind, details: SrpFindingDetails| SrpFinding { + common: common(line), + kind, + details, + }; + let mut analysis = make_analysis(vec![]); + analysis.findings.srp.push(make_srp( + 10, + SrpFindingKind::StructCohesion, + SrpFindingDetails::StructCohesion { + struct_name: "S".into(), + lcom4: 3, + field_count: 4, + method_count: 6, + fan_out: 2, + composite_score: 0.85, + clusters: vec![ResponsibilityCluster { + methods: vec!["m1".into(), "m2".into()], + fields: vec!["f1".into()], + }], + }, + )); + analysis.findings.srp.push(make_srp( + 20, + SrpFindingKind::ModuleLength, + SrpFindingDetails::ModuleLength { + module: "modA".into(), + production_lines: 500, + independent_clusters: 2, + cluster_names: vec![vec!["m1".into(), "m2".into()], vec!["m3".into()]], + length_score: 1.2, + }, + )); + analysis +} + +#[test] +fn test_print_json_carries_srp_composite_score_clusters_length_score() { + let v = json_value(&srp_composite_analysis()); + let s = v["srp"]["struct_warnings"] + .as_array() + .and_then(|a| a.first()) + .expect("struct_warnings present"); + assert_eq!( + s["composite_score"].as_f64(), + Some(0.85), + "composite_score must survive; got {v}" + ); + let clusters = s["clusters"].as_array().expect("clusters array"); + assert_eq!(clusters.len(), 1, "one cluster; got {v}"); + assert_eq!( + clusters[0]["methods"].as_array().map(|a| a.len()), + Some(2), + "cluster methods preserved; got {v}" + ); + let m = v["srp"]["module_warnings"] + .as_array() + .and_then(|a| a.first()) + .expect("module_warnings present"); + assert_eq!( + m["length_score"].as_f64(), + Some(1.2), + "length_score must survive; got {v}" + ); + let cluster_names = m["cluster_names"].as_array().expect("cluster_names array"); + assert_eq!(cluster_names.len(), 2, "two clusters; got {v}"); + assert_eq!( + cluster_names[0].as_array().map(|a| a.len()), + Some(2), + "first cluster has 2 names; got {v}" + ); +} + +#[test] +fn test_print_json_carries_complexity_counts() { + // Build the JSON string, parse it, and assert the analyzer's + // non-zero `logic_count` / `call_count` survive the projection + + // reporter round-trip. Regression for v1.2.1: the typed-reporter + // refactor dropped both fields from the projection, so every + // function appeared as `logic_count: 0, call_count: 0` in JSON + // until the round-12 fix added them back to + // `ComplexityMetricsRecord` and the JSON projection. + let mut func = make_result("counted", Classification::Operation); + func.complexity = Some(ComplexityMetrics { + logic_count: 5, + call_count: 4, + max_nesting: 1, + ..Default::default() + }); + let analysis = make_analysis(vec![func]); + let v = json_value(&analysis); + let complexity = &function_named(&v, "counted")["complexity"]; + assert_eq!( + complexity["logic_count"].as_u64(), + Some(5), + "logic_count must survive projection + reporter; got {v}" + ); + assert_eq!( + complexity["call_count"].as_u64(), + Some(4), + "call_count must survive projection + reporter; got {v}" + ); +} + +#[test] +fn test_print_json_marks_suppressed_function() { + let mut func = make_result( + "suppressed", + Classification::Violation { + has_logic: true, + has_own_calls: true, + logic_locations: vec![LogicOccurrence { + kind: "if".into(), + line: 1, + }], + call_locations: vec![CallOccurrence { + name: "f".into(), + line: 2, + }], + }, + ); + func.suppressed = true; + let analysis = make_analysis(vec![func]); + let v = json_value(&analysis); + let f = function_named(&v, "suppressed"); + assert_eq!( + f["suppressed"].as_bool(), + Some(true), + "suppressed flag must propagate to JSON; got {v}" + ); +} + +#[test] +fn test_print_json_carries_high_severity_for_many_violations() { + let analysis = make_analysis(vec![make_result( + "complex", + Classification::Violation { + has_logic: true, + has_own_calls: true, + logic_locations: vec![ + LogicOccurrence { + kind: "if".into(), + line: 1, + }, + LogicOccurrence { + kind: "match".into(), + line: 2, + }, + LogicOccurrence { + kind: "for".into(), + line: 3, + }, + ], + call_locations: vec![ + CallOccurrence { + name: "a".into(), + line: 4, + }, + CallOccurrence { + name: "b".into(), + line: 5, + }, + CallOccurrence { + name: "c".into(), + line: 6, + }, + ], + }, + )]); + let v = json_value(&analysis); + let f = function_named(&v, "complex"); + let sev = f["severity"].as_str().unwrap_or(""); + assert!( + matches!(sev, "high" | "medium"), + "violations with 3+3 logic/call locations must map to medium/high severity; got `{sev}` in {v}" + ); + assert_eq!( + f["logic"].as_array().map(Vec::len), + Some(3), + "3 logic locations preserved" + ); + assert_eq!( + f["calls"].as_array().map(Vec::len), + Some(3), + "3 call locations preserved" + ); +} diff --git a/src/adapters/report/tests/json/summary_fields_and_orphan.rs b/src/adapters/report/tests/json/summary_fields_and_orphan.rs new file mode 100644 index 00000000..76596477 --- /dev/null +++ b/src/adapters/report/tests/json/summary_fields_and_orphan.rs @@ -0,0 +1,119 @@ +use super::*; + +// ── JSON content tests (verifying fields are present) ────── + +#[test] +fn test_json_summary_warning_count_fields_are_numbers() { + let analysis = make_analysis(vec![make_result("f", Classification::Operation)]); + let parsed = json_value(&analysis); + for field in ["complexity_warnings", "magic_number_warnings"] { + assert!( + parsed["summary"][field].is_number(), + "JSON summary must include numeric `{field}` field" + ); + } +} + +#[test] +fn test_json_summary_has_all_dimension_fields() { + let analysis = make_analysis(vec![make_result("f", Classification::Operation)]); + let parsed = json_value(&analysis); + let s = &parsed["summary"]; + let expected_fields = [ + "total", + "integrations", + "operations", + "violations", + "trivial", + "suppressed", + "all_suppressions", + "iosp_score", + "quality_score", + "complexity_warnings", + "magic_number_warnings", + "nesting_depth_warnings", + "function_length_warnings", + "unsafe_warnings", + "error_handling_warnings", + "coupling_warnings", + "coupling_cycles", + "duplicate_groups", + "dead_code_warnings", + "fragment_groups", + "boilerplate_warnings", + "srp_struct_warnings", + "srp_module_warnings", + "srp_param_warnings", + "tq_no_assertion_warnings", + "tq_no_sut_warnings", + "tq_untested_warnings", + "tq_uncovered_warnings", + "tq_untested_logic_warnings", + "suppression_ratio_exceeded", + ]; + expected_fields.iter().for_each(|&field| { + assert!(!s[field].is_null(), "JSON summary missing field: {field}"); + }); +} + +#[test] +fn test_json_complexity_has_extended_fields() { + let mut func = make_result("f", Classification::Operation); + func.complexity = Some(ComplexityMetrics { + logic_count: 3, + call_count: 1, + max_nesting: 2, + function_lines: 45, + unsafe_blocks: 1, + unwrap_count: 2, + expect_count: 1, + panic_count: 0, + todo_count: 0, + ..Default::default() + }); + let analysis = make_analysis(vec![func]); + let parsed = json_value(&analysis); + let c = &parsed["functions"][0]["complexity"]; + assert_eq!(c["function_lines"].as_u64().unwrap(), 45); + assert_eq!(c["unsafe_blocks"].as_u64().unwrap(), 1); + assert_eq!(c["unwrap_count"].as_u64().unwrap(), 2); + assert_eq!(c["expect_count"].as_u64().unwrap(), 1); + assert_eq!(c["panic_count"].as_u64().unwrap(), 0); + assert_eq!(c["todo_count"].as_u64().unwrap(), 0); +} + +#[test] +fn json_reporter_includes_orphan_suppressions_via_snapshot_view() { + // Populate `findings.orphan_suppressions` ONLY (not the legacy + // `analysis.orphan_suppressions` field) and verify the JSON + // output still includes the orphans — proving the JSON reporter + // reads them from the trait-driven `Snapshot::orphans` view. + use crate::domain::findings::OrphanSuppression; + let mut analysis = make_analysis(vec![]); + analysis.findings.orphan_suppressions = vec![OrphanSuppression { + file: "src/foo.rs".into(), + line: 42, + dimensions: vec![crate::findings::Dimension::Srp], + reason: Some("legacy".into()), + }]; + let parsed = json_value(&analysis); + let arr = parsed["orphan_suppressions"].as_array().unwrap(); + assert_eq!(arr.len(), 1); + assert_eq!(arr[0]["file"], "src/foo.rs"); + assert_eq!(arr[0]["line"], 42); + assert_eq!(arr[0]["dimensions"][0], "srp"); + assert_eq!(arr[0]["reason"], "legacy"); +} + +#[test] +fn test_json_omits_empty_orphan_suppressions() { + // When the list is empty (clean codebase), the field is elided + // to keep JSON compact — matches the policy for other optional + // arrays (duplicates, dead_code, etc.). + let analysis = make_analysis(vec![]); + let parsed = json_value(&analysis); + assert!( + parsed.get("orphan_suppressions").is_none(), + "empty orphan list should be elided from JSON" + ); +} diff --git a/src/adapters/report/tests/json/violations_and_dups.rs b/src/adapters/report/tests/json/violations_and_dups.rs new file mode 100644 index 00000000..a6b3d269 --- /dev/null +++ b/src/adapters/report/tests/json/violations_and_dups.rs @@ -0,0 +1,186 @@ +use super::*; + +#[test] +fn test_print_json_empty_yields_valid_json() { + let analysis = make_analysis(vec![]); + let v = json_value(&analysis); + assert_eq!( + v["functions"].as_array().map(Vec::len), + Some(0), + "empty analysis produces empty functions array" + ); +} + +#[test] +fn test_print_json_carries_violation_logic_and_call_locations() { + let analysis = make_analysis(vec![make_result( + "bad_fn", + Classification::Violation { + has_logic: true, + has_own_calls: true, + logic_locations: vec![LogicOccurrence { + kind: "if".into(), + line: 1, + }], + call_locations: vec![CallOccurrence { + name: "f".into(), + line: 2, + }], + }, + )]); + let v = json_value(&analysis); + let f = function_named(&v, "bad_fn"); + assert_eq!(f["classification"], "violation"); + let logic = f["logic"].as_array().expect("logic array"); + assert_eq!(logic.len(), 1, "one logic location; got {v}"); + assert_eq!(logic[0]["kind"], "if"); + assert_eq!(logic[0]["line"], "1"); + let calls = f["calls"].as_array().expect("calls array"); + assert_eq!(calls.len(), 1, "one call location; got {v}"); + assert_eq!(calls[0]["name"], "f"); + assert_eq!(calls[0]["line"], "2"); +} + +#[test] +fn test_print_json_classifications_all_four() { + let analysis = make_analysis(vec![ + make_result("a", Classification::Integration), + make_result("b", Classification::Operation), + make_result("c", Classification::Trivial), + make_result( + "d", + Classification::Violation { + has_logic: true, + has_own_calls: true, + logic_locations: vec![LogicOccurrence { + kind: "match".into(), + line: 1, + }], + call_locations: vec![CallOccurrence { + name: "g".into(), + line: 2, + }], + }, + ), + ]); + let v = json_value(&analysis); + let by_name: std::collections::HashMap = v["functions"] + .as_array() + .expect("functions array") + .iter() + .map(|f| { + ( + f["name"].as_str().unwrap().into(), + f["classification"].as_str().unwrap().into(), + ) + }) + .collect(); + assert_eq!(by_name.get("a").map(String::as_str), Some("integration")); + assert_eq!(by_name.get("b").map(String::as_str), Some("operation")); + assert_eq!(by_name.get("c").map(String::as_str), Some("trivial")); + assert_eq!(by_name.get("d").map(String::as_str), Some("violation")); +} + +#[test] +fn test_print_json_carries_near_duplicate_similarity() { + use crate::domain::findings::{ + DryFinding, DryFindingDetails, DryFindingKind, DuplicateParticipant, + }; + use crate::domain::{Dimension, Finding, Severity}; + let participants = vec![ + DuplicateParticipant { + function_name: "a".into(), + file: "lib.rs".into(), + line: 10, + }, + DuplicateParticipant { + function_name: "b".into(), + file: "lib.rs".into(), + line: 50, + }, + ]; + let mut analysis = make_analysis(vec![]); + analysis.findings.dry.push(DryFinding { + common: Finding { + file: "lib.rs".into(), + line: 10, + column: 0, + dimension: Dimension::Dry, + rule_id: "dry/duplicate/similar".into(), + message: "near duplicate".into(), + severity: Severity::Medium, + suppressed: false, + }, + kind: DryFindingKind::DuplicateSimilar, + details: DryFindingDetails::Duplicate { + participants, + similarity: Some(0.91), + }, + }); + let v = json_value(&analysis); + let group = v["duplicates"] + .as_array() + .and_then(|a| a.first()) + .expect("at least one duplicate group"); + let sim = group["similarity"].as_f64(); + assert_eq!( + sim, + Some(0.91), + "NearDuplicate similarity must survive projection + reporter; got {v}" + ); +} + +#[test] +fn test_print_json_carries_repeated_match_arm_count_and_distinct_groups() { + use crate::domain::findings::{ + DryFinding, DryFindingDetails, DryFindingKind, RepeatedMatchParticipant, + }; + use crate::domain::{Dimension, Finding, Severity}; + let common = |line: usize| Finding { + file: "lib.rs".into(), + line, + column: 0, + dimension: Dimension::Dry, + rule_id: "dry/repeated_match".into(), + message: "repeated match".into(), + severity: Severity::Medium, + suppressed: false, + }; + let participant = |name: &str, line: usize, arms: usize| RepeatedMatchParticipant { + function_name: name.into(), + file: "lib.rs".into(), + line, + arm_count: arms, + }; + let group_a = vec![participant("fa1", 10, 4), participant("fa2", 20, 4)]; + let group_b = vec![participant("fb1", 50, 3), participant("fb2", 60, 3)]; + let make_match = |line: usize, participants: Vec| DryFinding { + common: common(line), + kind: DryFindingKind::RepeatedMatch, + details: DryFindingDetails::RepeatedMatch { + enum_name: "MyEnum".into(), + participants, + }, + }; + let mut analysis = make_analysis(vec![]); + analysis.findings.dry.push(make_match(10, group_a)); + analysis.findings.dry.push(make_match(50, group_b)); + let v = json_value(&analysis); + let groups = v["repeated_matches"] + .as_array() + .expect("repeated_matches array"); + assert_eq!( + groups.len(), + 2, + "two distinct groups over same enum must NOT collapse by enum_name; got {v}" + ); + let arm_counts: Vec = groups + .iter() + .flat_map(|g| g["entries"].as_array().unwrap().iter()) + .map(|e| e["arm_count"].as_u64().unwrap_or(0)) + .collect(); + assert!( + arm_counts.contains(&4) && arm_counts.contains(&3), + "arm_count must survive projection (expected both 4 and 3); got {arm_counts:?} from {v}" + ); +} diff --git a/src/adapters/report/tests/root/mod.rs b/src/adapters/report/tests/root/mod.rs new file mode 100644 index 00000000..25eeee1c --- /dev/null +++ b/src/adapters/report/tests/root/mod.rs @@ -0,0 +1,12 @@ +//! Reporter `root` tests (summary counts, JSON projection, quality-score +//! formulas). Split into focused sub-files (each ≤ the SRP file-length cap); +//! shared imports reach the sub-modules via `use super::*`. + +pub(super) use crate::adapters::analyzers::iosp::{ + CallOccurrence, Classification, ComplexityMetrics, FunctionAnalysis, LogicOccurrence, +}; +pub(super) use crate::adapters::report::test_support::make_result; +pub(super) use crate::report::*; + +mod quality_score; +mod summary_and_json; diff --git a/src/adapters/report/tests/root/quality_score.rs b/src/adapters/report/tests/root/quality_score.rs new file mode 100644 index 00000000..75acd28d --- /dev/null +++ b/src/adapters/report/tests/root/quality_score.rs @@ -0,0 +1,183 @@ +use super::*; + +#[test] +fn test_quality_score_perfect() { + let results = vec![ + make_result("a", Classification::Integration), + make_result("b", Classification::Operation), + ]; + let mut summary = Summary::from_results(&results); + summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); + assert!((summary.quality_score - 1.0).abs() < 1e-10); +} + +#[test] +fn test_quality_score_with_violations() { + let results = vec![ + make_result("a", Classification::Integration), + make_result( + "b", + Classification::Violation { + has_logic: true, + has_own_calls: true, + logic_locations: vec![LogicOccurrence { + kind: "if".into(), + line: 1, + }], + call_locations: vec![CallOccurrence { + name: "f".into(), + line: 2, + }], + }, + ), + ]; + let mut summary = Summary::from_results(&results); + summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); + assert!(summary.quality_score < 1.0); + assert!(summary.quality_score > 0.0); +} + +#[test] +fn test_quality_score_empty() { + let results: Vec = vec![]; + let mut summary = Summary::from_results(&results); + summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); + assert!((summary.quality_score - 1.0).abs() < 1e-10); +} + +#[test] +fn test_quality_score_with_warnings() { + let results = vec![ + make_result("a", Classification::Integration), + make_result("b", Classification::Operation), + make_result("c", Classification::Operation), + make_result("d", Classification::Operation), + ]; + let mut summary = Summary::from_results(&results); + summary.complexity_warnings = 2; + summary.duplicate_groups = 1; + summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); + assert!(summary.quality_score < 1.0); + assert!(summary.dimension_scores[1] < 1.0); // complexity + assert!(summary.dimension_scores[2] < 1.0); // DRY +} + +#[test] +fn test_score_reflects_total_findings_realistically() { + // 100 functions, 10 IOSP violations + 10 complexity warnings = 20 findings + // With default weights (IOSP=0.25, CX=0.20), score should be significantly < 90% + let mut summary = Summary { + total: 100, + violations: 10, + iosp_score: 0.9, // 10/100 violations + complexity_warnings: 10, + ..Default::default() + }; + summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); + assert!( + summary.quality_score < 0.85, + "20 findings / 100 functions should be < 85%, got {:.1}%", + summary.quality_score * 100.0 + ); + assert!( + summary.quality_score > 0.50, + "20 findings / 100 functions should be > 50%, got {:.1}%", + summary.quality_score * 100.0 + ); +} + +#[test] +fn test_score_100_percent_only_with_zero_findings() { + // Any finding should prevent 100% + let mut summary = Summary { + total: 100, + iosp_score: 1.0, + magic_number_warnings: 1, + ..Default::default() + }; + summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); + assert!( + summary.quality_score < 1.0, + "1 finding should prevent 100%, got {:.1}%", + summary.quality_score * 100.0 + ); +} + +#[test] +fn test_score_all_violations_is_near_zero() { + // 100/100 IOSP violations → score should be very low, not 75% + let mut summary = Summary { + total: 100, + violations: 100, + iosp_score: 0.0, // 100% violations + ..Default::default() + }; + summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); + assert!( + summary.quality_score < 0.10, + "100% violations should give score < 10%, got {:.1}%", + summary.quality_score * 100.0 + ); +} + +#[test] +fn test_total_findings() { + let summary = Summary { + violations: 1, + complexity_warnings: 2, + magic_number_warnings: 1, + duplicate_groups: 1, + coupling_cycles: 1, + ..Summary::default() + }; + assert_eq!(summary.total_findings(), 6); +} + +#[test] +fn test_complexity_in_function_analysis() { + let func = FunctionAnalysis { + name: "f".to_string(), + file: "test.rs".to_string(), + line: 1, + classification: Classification::Operation, + parent_type: None, + suppressed: false, + complexity: Some(ComplexityMetrics { + logic_count: 3, + call_count: 0, + max_nesting: 2, + ..Default::default() + }), + qualified_name: "f".to_string(), + severity: None, + cognitive_warning: false, + cyclomatic_warning: false, + nesting_depth_warning: false, + function_length_warning: false, + unsafe_warning: false, + error_handling_warning: false, + complexity_suppressed: false, + own_calls: vec![], + parameter_count: 0, + is_trait_impl: false, + is_test: false, + effort_score: None, + }; + assert_eq!(func.complexity.as_ref().unwrap().logic_count, 3); + assert_eq!(func.complexity.as_ref().unwrap().max_nesting, 2); +} + +#[test] +fn test_suppression_ratio_default_false() { + let summary = Summary::default(); + assert!(!summary.suppression_ratio_exceeded); +} + +#[test] +fn test_suppression_ratio_flag_preserved() { + let summary = Summary { + suppression_ratio_exceeded: true, + ..Summary::default() + }; + assert!(summary.suppression_ratio_exceeded); +} diff --git a/src/adapters/report/tests/root.rs b/src/adapters/report/tests/root/summary_and_json.rs similarity index 54% rename from src/adapters/report/tests/root.rs rename to src/adapters/report/tests/root/summary_and_json.rs index 9c0e4c77..190ef900 100644 --- a/src/adapters/report/tests/root.rs +++ b/src/adapters/report/tests/root/summary_and_json.rs @@ -1,35 +1,4 @@ -use crate::adapters::analyzers::iosp::{ - compute_severity, CallOccurrence, Classification, ComplexityMetrics, FunctionAnalysis, - LogicOccurrence, -}; -use crate::report::*; - -fn make_result(name: &str, classification: Classification) -> FunctionAnalysis { - let severity = compute_severity(&classification); - FunctionAnalysis { - name: name.to_string(), - file: "test.rs".to_string(), - line: 1, - classification, - parent_type: None, - suppressed: false, - complexity: None, - qualified_name: name.to_string(), - severity, - cognitive_warning: false, - cyclomatic_warning: false, - nesting_depth_warning: false, - function_length_warning: false, - unsafe_warning: false, - error_handling_warning: false, - complexity_suppressed: false, - own_calls: vec![], - parameter_count: 0, - is_trait_impl: false, - is_test: false, - effort_score: None, - } -} +use super::*; #[test] fn test_summary_counts() { @@ -135,31 +104,11 @@ fn test_json_structure() { assert_eq!(funcs[0]["classification"], "integration"); } -#[test] -fn test_json_violation_has_logic_and_calls() { - let results = vec![make_result( - "bad_fn", - Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![ - LogicOccurrence { - kind: "if".into(), - line: 3, - }, - LogicOccurrence { - kind: "match".into(), - line: 7, - }, - ], - call_locations: vec![CallOccurrence { - name: "helper".into(), - line: 5, - }], - }, - )]; - let summary = Summary::from_results(&results); - +/// Project `results` to the test's expected JSON shape (summary + per-function +/// classification/logic/call locations) — the inline projection this test asserts +/// against, lifted to a helper so the test body stays act+assert. +fn project_violation_results(results: &[FunctionAnalysis]) -> serde_json::Value { + let summary = Summary::from_results(results); let json_functions: Vec = results .iter() .map(|f| { @@ -192,8 +141,7 @@ fn test_json_violation_has_logic_and_calls() { }) }) .collect(); - - let output = serde_json::json!({ + serde_json::json!({ "summary": { "total": summary.total, "integrations": summary.integrations, @@ -202,7 +150,33 @@ fn test_json_violation_has_logic_and_calls() { "trivial": summary.trivial, }, "functions": json_functions, - }); + }) +} + +#[test] +fn test_json_violation_has_logic_and_calls() { + let results = vec![make_result( + "bad_fn", + Classification::Violation { + has_logic: true, + has_own_calls: true, + logic_locations: vec![ + LogicOccurrence { + kind: "if".into(), + line: 3, + }, + LogicOccurrence { + kind: "match".into(), + line: 7, + }, + ], + call_locations: vec![CallOccurrence { + name: "helper".into(), + line: 5, + }], + }, + )]; + let output = project_violation_results(&results); let func = &output["functions"][0]; assert_eq!(func["classification"], "violation"); @@ -299,185 +273,3 @@ fn test_baseline_roundtrip() { assert!(parsed["iosp_score"].as_f64().is_some()); assert_eq!(parsed["violations"].as_u64().unwrap(), 1); } - -#[test] -fn test_quality_score_perfect() { - let results = vec![ - make_result("a", Classification::Integration), - make_result("b", Classification::Operation), - ]; - let mut summary = Summary::from_results(&results); - summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); - assert!((summary.quality_score - 1.0).abs() < 1e-10); -} - -#[test] -fn test_quality_score_with_violations() { - let results = vec![ - make_result("a", Classification::Integration), - make_result( - "b", - Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![LogicOccurrence { - kind: "if".into(), - line: 1, - }], - call_locations: vec![CallOccurrence { - name: "f".into(), - line: 2, - }], - }, - ), - ]; - let mut summary = Summary::from_results(&results); - summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); - assert!(summary.quality_score < 1.0); - assert!(summary.quality_score > 0.0); -} - -#[test] -fn test_quality_score_empty() { - let results: Vec = vec![]; - let mut summary = Summary::from_results(&results); - summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); - assert!((summary.quality_score - 1.0).abs() < 1e-10); -} - -#[test] -fn test_quality_score_with_warnings() { - let results = vec![ - make_result("a", Classification::Integration), - make_result("b", Classification::Operation), - make_result("c", Classification::Operation), - make_result("d", Classification::Operation), - ]; - let mut summary = Summary::from_results(&results); - summary.complexity_warnings = 2; - summary.duplicate_groups = 1; - summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); - assert!(summary.quality_score < 1.0); - assert!(summary.dimension_scores[1] < 1.0); // complexity - assert!(summary.dimension_scores[2] < 1.0); // DRY -} - -#[test] -fn test_score_reflects_total_findings_realistically() { - // 100 functions, 10 IOSP violations + 10 complexity warnings = 20 findings - // With default weights (IOSP=0.25, CX=0.20), score should be significantly < 90% - let mut summary = Summary { - total: 100, - violations: 10, - iosp_score: 0.9, // 10/100 violations - complexity_warnings: 10, - ..Default::default() - }; - summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); - assert!( - summary.quality_score < 0.85, - "20 findings / 100 functions should be < 85%, got {:.1}%", - summary.quality_score * 100.0 - ); - assert!( - summary.quality_score > 0.50, - "20 findings / 100 functions should be > 50%, got {:.1}%", - summary.quality_score * 100.0 - ); -} - -#[test] -fn test_score_100_percent_only_with_zero_findings() { - // Any finding should prevent 100% - let mut summary = Summary { - total: 100, - iosp_score: 1.0, - magic_number_warnings: 1, - ..Default::default() - }; - summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); - assert!( - summary.quality_score < 1.0, - "1 finding should prevent 100%, got {:.1}%", - summary.quality_score * 100.0 - ); -} - -#[test] -fn test_score_all_violations_is_near_zero() { - // 100/100 IOSP violations → score should be very low, not 75% - let mut summary = Summary { - total: 100, - violations: 100, - iosp_score: 0.0, // 100% violations - ..Default::default() - }; - summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); - assert!( - summary.quality_score < 0.10, - "100% violations should give score < 10%, got {:.1}%", - summary.quality_score * 100.0 - ); -} - -#[test] -fn test_total_findings() { - let summary = Summary { - violations: 1, - complexity_warnings: 2, - magic_number_warnings: 1, - duplicate_groups: 1, - coupling_cycles: 1, - ..Summary::default() - }; - assert_eq!(summary.total_findings(), 6); -} - -#[test] -fn test_complexity_in_function_analysis() { - let func = FunctionAnalysis { - name: "f".to_string(), - file: "test.rs".to_string(), - line: 1, - classification: Classification::Operation, - parent_type: None, - suppressed: false, - complexity: Some(ComplexityMetrics { - logic_count: 3, - call_count: 0, - max_nesting: 2, - ..Default::default() - }), - qualified_name: "f".to_string(), - severity: None, - cognitive_warning: false, - cyclomatic_warning: false, - nesting_depth_warning: false, - function_length_warning: false, - unsafe_warning: false, - error_handling_warning: false, - complexity_suppressed: false, - own_calls: vec![], - parameter_count: 0, - is_trait_impl: false, - is_test: false, - effort_score: None, - }; - assert_eq!(func.complexity.as_ref().unwrap().logic_count, 3); - assert_eq!(func.complexity.as_ref().unwrap().max_nesting, 2); -} - -#[test] -fn test_suppression_ratio_default_false() { - let summary = Summary::default(); - assert!(!summary.suppression_ratio_exceeded); -} - -#[test] -fn test_suppression_ratio_flag_preserved() { - let summary = Summary { - suppression_ratio_exceeded: true, - ..Summary::default() - }; - assert!(summary.suppression_ratio_exceeded); -} diff --git a/src/adapters/report/tests/suggestions.rs b/src/adapters/report/tests/suggestions.rs index 286389bd..f101c95a 100644 --- a/src/adapters/report/tests/suggestions.rs +++ b/src/adapters/report/tests/suggestions.rs @@ -1,34 +1,8 @@ -use crate::adapters::analyzers::iosp::{compute_severity, CallOccurrence, LogicOccurrence}; +use crate::adapters::analyzers::iosp::{CallOccurrence, LogicOccurrence}; use crate::adapters::analyzers::iosp::{Classification, FunctionAnalysis}; +use crate::adapters::report::test_support::make_result; use crate::report::suggestions::*; -fn make_result(name: &str, classification: Classification) -> FunctionAnalysis { - let severity = compute_severity(&classification); - FunctionAnalysis { - name: name.to_string(), - file: "test.rs".to_string(), - line: 1, - classification, - parent_type: None, - suppressed: false, - complexity: None, - qualified_name: name.to_string(), - severity, - cognitive_warning: false, - cyclomatic_warning: false, - nesting_depth_warning: false, - function_length_warning: false, - unsafe_warning: false, - error_handling_warning: false, - complexity_suppressed: false, - own_calls: vec![], - parameter_count: 0, - is_trait_impl: false, - is_test: false, - effort_score: None, - } -} - #[test] fn test_print_suggestions_no_violations() { let results = vec![ diff --git a/src/adapters/report/text/tests/root.rs b/src/adapters/report/text/tests/root.rs index 606997a1..f29fd378 100644 --- a/src/adapters/report/text/tests/root.rs +++ b/src/adapters/report/text/tests/root.rs @@ -1,37 +1,10 @@ use crate::adapters::analyzers::iosp::{ - compute_severity, CallOccurrence, Classification, ComplexityMetrics, FunctionAnalysis, - LogicOccurrence, + CallOccurrence, Classification, ComplexityMetrics, FunctionAnalysis, LogicOccurrence, }; +use crate::adapters::report::test_support::make_result; use crate::report::text::*; use crate::report::Summary; -fn make_result(name: &str, classification: Classification) -> FunctionAnalysis { - let severity = compute_severity(&classification); - FunctionAnalysis { - name: name.to_string(), - file: "test.rs".to_string(), - line: 1, - classification, - parent_type: None, - suppressed: false, - complexity: None, - qualified_name: name.to_string(), - severity, - cognitive_warning: false, - cyclomatic_warning: false, - nesting_depth_warning: false, - function_length_warning: false, - unsafe_warning: false, - error_handling_warning: false, - complexity_suppressed: false, - own_calls: vec![], - parameter_count: 0, - is_trait_impl: false, - is_test: false, - effort_score: None, - } -} - fn render_text(results: &[FunctionAnalysis], verbose: bool) -> String { use crate::domain::{AnalysisData, AnalysisFindings}; use crate::ports::Reporter; diff --git a/src/adapters/shared/tests/cfg_test_files.rs b/src/adapters/shared/tests/cfg_test_files.rs index f878eecb..0c46891d 100644 --- a/src/adapters/shared/tests/cfg_test_files.rs +++ b/src/adapters/shared/tests/cfg_test_files.rs @@ -1,53 +1,70 @@ use crate::adapters::shared::cfg_test_files::collect_cfg_test_file_paths; +// A `(path, code)` workspace and the paths expected present/absent in the +// resulting cfg-test set. +type ClassifyCase = ( + &'static str, + &'static [(&'static str, &'static str)], + &'static [&'static str], + &'static [&'static str], +); + #[test] -fn cfg_test_propagates_transitively_through_mod_chain() { - // Reproduces the bug where a test-file's own sub-module is not - // recognised as cfg-test. - // - // src/parent.rs has `#[cfg(test)] mod tests;` → cfg-test - // src/parent/tests/mod.rs has `mod golden;` → should be cfg-test - // src/parent/tests/golden.rs has `fn helper() {}` → should be cfg-test - // - // Previously only tests/mod.rs was tagged cfg-test; golden.rs was - // treated as production code and its helper was reported as - // test-only dead code even though it lives in a test-only file. - let parent_code = r#" - #[cfg(test)] - mod tests; - "#; - let tests_mod_code = r#" - mod golden; - "#; - let golden_code = r#" - pub fn helper() -> u32 { 42 } - "#; - let parsed = vec![ +fn cfg_test_classification_propagates_and_honours_package_roots() { + let cases: &[ClassifyCase] = &[ + // Propagation bug: a test-file's OWN sub-module must inherit cfg-test + // status. Previously only tests/mod.rs was tagged; golden.rs was + // treated as production and its helper falsely reported as dead code. ( - "src/parent.rs".to_string(), - parent_code.to_string(), - syn::parse_file(parent_code).unwrap(), + "cfg-test status propagates transitively through a mod chain", + &[ + ("src/parent.rs", "#[cfg(test)]\nmod tests;"), + ("src/parent/tests/mod.rs", "mod golden;"), + ( + "src/parent/tests/golden.rs", + "pub fn helper() -> u32 { 42 }", + ), + ], + &["src/parent/tests/mod.rs", "src/parent/tests/golden.rs"], + &[], ), + // Edge case: a real package whose path contains an EARLIER `tests` + // segment (`fixtures/tests/retry/`). The owner of its own `tests/` is + // the package root; the outer `fixtures/tests/other.rs` (no package + // root there) must still NOT be classified. ( - "src/parent/tests/mod.rs".to_string(), - tests_mod_code.to_string(), - syn::parse_file(tests_mod_code).unwrap(), - ), - ( - "src/parent/tests/golden.rs".to_string(), - golden_code.to_string(), - syn::parse_file(golden_code).unwrap(), + "a package nested under an outer `tests` segment classifies its own tests/", + &[ + ("fixtures/tests/retry/src/lib.rs", "pub fn run() {}"), + ( + "fixtures/tests/retry/tests/integration.rs", + "#[test] fn it() {}", + ), + ("fixtures/tests/other.rs", "pub fn outer() {}"), + ], + &["fixtures/tests/retry/tests/integration.rs"], + &["fixtures/tests/other.rs"], ), ]; - let result = collect_cfg_test_file_paths(&parsed); - assert!( - result.contains("src/parent/tests/mod.rs"), - "direct cfg-test mod target not detected: {result:?}" - ); - assert!( - result.contains("src/parent/tests/golden.rs"), - "sub-module of cfg-test file must propagate cfg-test status: {result:?}" - ); + for (label, files, present, absent) in cases { + let parsed: Vec<(String, String, syn::File)> = files + .iter() + .map(|(p, c)| (p.to_string(), c.to_string(), syn::parse_file(c).unwrap())) + .collect(); + let result = collect_cfg_test_file_paths(&parsed); + for p in *present { + assert!( + result.contains(*p), + "case {label}: {p} must be cfg-test: {result:?}" + ); + } + for a in *absent { + assert!( + !result.contains(*a), + "case {label}: {a} must NOT be cfg-test: {result:?}" + ); + } + } } #[test] @@ -188,45 +205,6 @@ fn tests_dir_only_classified_at_a_real_package_root() { ); } -#[test] -fn package_nested_under_a_tests_dir_recognizes_its_own_tests() { - // Edge case: a real package whose path contains an earlier `tests` - // segment (`fixtures/tests/retry/`). Its OWN integration tests live at - // `fixtures/tests/retry/tests/…`; the owner of *that* `tests/` is the - // package root, even though an outer `tests` segment appears first. - // The outer `fixtures/tests/other.rs` (no package root there) must - // still NOT be classified. - let lib = "pub fn run() {}"; - let it = "#[test] fn it() {}"; - let outer = "pub fn outer() {}"; - let parsed = vec![ - ( - "fixtures/tests/retry/src/lib.rs".to_string(), - lib.to_string(), - syn::parse_file(lib).unwrap(), - ), - ( - "fixtures/tests/retry/tests/integration.rs".to_string(), - it.to_string(), - syn::parse_file(it).unwrap(), - ), - ( - "fixtures/tests/other.rs".to_string(), - outer.to_string(), - syn::parse_file(outer).unwrap(), - ), - ]; - let result = collect_cfg_test_file_paths(&parsed); - assert!( - result.contains("fixtures/tests/retry/tests/integration.rs"), - "the package's own tests/ (owner = package root) must be cfg-test: {result:?}" - ); - assert!( - !result.contains("fixtures/tests/other.rs"), - "an outer `tests` dir that is not a package root must NOT be cfg-test: {result:?}" - ); -} - #[test] fn tests_dir_next_to_src_without_crate_root_file_not_classified() { // The package-root signal is Cargo's crate-root file (`src/lib.rs` or diff --git a/src/adapters/shared/tests/normalize.rs b/src/adapters/shared/tests/normalize.rs index b2e233a1..80a1f040 100644 --- a/src/adapters/shared/tests/normalize.rs +++ b/src/adapters/shared/tests/normalize.rs @@ -30,30 +30,52 @@ fn test_normalize_let_binding() { assert!(tokens.contains(&NormalizedToken::Semi)); } -#[test] -fn test_normalize_same_structure_different_names_same_hash() { - let body_a = parse_body("let x = a + b;"); - let body_b = parse_body("let y = p + q;"); - let hash_a = structural_hash(&normalize_body(&body_a)); - let hash_b = structural_hash(&normalize_body(&body_b)); - assert_eq!(hash_a, hash_b); -} - -#[test] -fn test_normalize_different_structure_different_hash() { - let body_a = parse_body("let x = a + b;"); - let body_b = parse_body("let x = a * b;"); - let hash_a = structural_hash(&normalize_body(&body_a)); - let hash_b = structural_hash(&normalize_body(&body_b)); - assert_ne!(hash_a, hash_b); -} - -#[test] -fn test_structural_hash_deterministic() { - let body = parse_body("let x = foo(a, b);"); - let hash1 = structural_hash(&normalize_body(&body)); - let hash2 = structural_hash(&normalize_body(&body)); - assert_eq!(hash1, hash2); +/// Structural hash of a function body parsed from `code`. +fn hash_of(code: &str) -> u64 { + structural_hash(&normalize_body(&parse_body(code))) +} + +#[test] +fn structural_hash_equality_by_structure() { + // The structural hash ignores identifier names (so renamed-but-isomorphic + // bodies collide) and is deterministic, but distinguishes operators, bool + // literals, and overall shape. (label, code_a, code_b, same_hash) + let cases: &[(&str, &str, &str, bool)] = &[ + ( + "same structure, different names → same hash", + "let x = a + b;", + "let y = p + q;", + true, + ), + ( + "different operator → different hash", + "let x = a + b;", + "let x = a * b;", + false, + ), + ( + "deterministic: same body hashes equal", + "let x = foo(a, b);", + "let x = foo(a, b);", + true, + ), + ( + "bool true vs false → different hash", + "return true;", + "return false;", + false, + ), + ( + "complex isomorphic bodies (renamed) → same hash", + "for item in items { if item.is_valid() { results.push(item.name()); } }", + "for entry in data { if entry.is_valid() { output.push(entry.name()); } }", + true, + ), + ]; + for (label, code_a, code_b, same) in cases { + let (a, b) = (hash_of(code_a), hash_of(code_b)); + assert_eq!(a == b, *same, "case {label}: hash_a={a}, hash_b={b}"); + } } #[test] @@ -128,15 +150,6 @@ fn test_normalize_field_access_preserves_name() { assert!(tokens.contains(&NormalizedToken::FieldAccess("name".to_string()))); } -#[test] -fn test_normalize_bool_values_distinct() { - let body_true = parse_body("return true;"); - let body_false = parse_body("return false;"); - let hash_true = structural_hash(&normalize_body(&body_true)); - let hash_false = structural_hash(&normalize_body(&body_false)); - assert_ne!(hash_true, hash_false); -} - #[test] fn test_normalize_stmts_subset() { let body = parse_body("let a = 1; let b = 2; let c = 3;"); @@ -196,15 +209,3 @@ fn test_normalize_macro_call() { let tokens = normalize_body(&body); assert!(tokens.contains(&NormalizedToken::MacroCall("println".to_string()))); } - -#[test] -fn test_normalize_complex_same_structure() { - // Two functions with same structure: iterate, check condition, push to vec - let body_a = - parse_body("for item in items { if item.is_valid() { results.push(item.name()); } }"); - let body_b = - parse_body("for entry in data { if entry.is_valid() { output.push(entry.name()); } }"); - let hash_a = structural_hash(&normalize_body(&body_a)); - let hash_b = structural_hash(&normalize_body(&body_b)); - assert_eq!(hash_a, hash_b); -} diff --git a/src/adapters/source/tests/filesystem.rs b/src/adapters/source/tests/filesystem.rs index 1b4f3ad0..afc7ac2c 100644 --- a/src/adapters/source/tests/filesystem.rs +++ b/src/adapters/source/tests/filesystem.rs @@ -21,47 +21,37 @@ fn test_collect_rust_files_dot_prefix_path() { ); } -#[test] -fn test_collect_rust_files_hidden_dir_excluded() { +/// In a fresh tempdir, put a `.rs` file inside `excluded_subdir` and a +/// visible `.rs` at the root, then collect — returning the found paths. +fn collect_with_excluded_subdir(excluded_subdir: &str) -> Vec { let dir = tempfile::Builder::new() .prefix("rustqual_test_") .tempdir() .unwrap(); - let hidden = dir.path().join(".hidden"); - std::fs::create_dir_all(&hidden).unwrap(); - std::fs::write(hidden.join("lib.rs"), "fn foo() {}").unwrap(); - // Also add a visible file - std::fs::write(dir.path().join("main.rs"), "fn main() {}").unwrap(); - - let files = collect_rust_files(dir.path()); - assert!( - files - .iter() - .all(|f| !f.to_string_lossy().contains(".hidden")), - "Hidden directories should be excluded" - ); - assert!(!files.is_empty(), "Visible files should still be found"); + let sub = dir.path().join(excluded_subdir); + std::fs::create_dir_all(&sub).unwrap(); + std::fs::write(sub.join("excluded.rs"), "fn x() {}").unwrap(); + std::fs::write(dir.path().join("visible.rs"), "fn v() {}").unwrap(); + collect_rust_files(dir.path()) } #[test] -fn test_collect_rust_files_target_dir_excluded() { - let dir = tempfile::Builder::new() - .prefix("rustqual_test_") - .tempdir() - .unwrap(); - let target = dir.path().join("target"); - std::fs::create_dir_all(&target).unwrap(); - std::fs::write(target.join("generated.rs"), "fn gen() {}").unwrap(); - std::fs::write(dir.path().join("lib.rs"), "fn lib() {}").unwrap(); - - let files = collect_rust_files(dir.path()); - assert!( - files - .iter() - .all(|f| !f.to_string_lossy().contains("target")), - "target/ directory should be excluded" - ); - assert!(!files.is_empty()); +fn collect_rust_files_excludes_hidden_and_target_dirs() { + // Hidden (`.`-prefixed) and `target/` directories are skipped, but a + // visible sibling file is still found. (label, excluded_subdir) + for (label, excluded) in [("hidden dir", ".hidden"), ("target dir", "target")] { + let files = collect_with_excluded_subdir(excluded); + assert!( + files + .iter() + .all(|f| !f.to_string_lossy().contains(excluded)), + "case {label}: `{excluded}/` should be excluded" + ); + assert!( + !files.is_empty(), + "case {label}: the visible sibling file should still be found" + ); + } } #[test] @@ -111,52 +101,45 @@ fn parsed_single(path: &str, source: &str) -> Vec<(String, String, syn::File)> { vec![(path.to_string(), source.to_string(), syntax)] } -#[test] -fn qual_allow_honors_marker_inside_contiguous_comment_block() { - // Layout: - // line 1: // qual:allow(srp) — rustqual false-positive LCOM4=2 - // line 2: // The struct's methods form one coherent data layer. - // line 3: // See docs/rustqual-bugs.md. - // line 4: #[derive(Default)] - // line 5: pub struct Foo { ... } - // - // Without the block-end shift, ANNOTATION_WINDOW=3 from line 1 - // reaches only line 4 — too short to cover the struct on line 5. - // With the shift, the effective marker line is 3 (last // of the - // contiguous block) and the window 3..=6 covers the struct. - let source = "// qual:allow(srp) — rustqual false-positive LCOM4=2\n\ - // The struct's methods form one coherent data layer.\n\ - // See docs/rustqual-bugs.md.\n\ - #[derive(Default)]\n\ - pub struct Foo { x: i32, y: i32 }\n"; +/// Parse `source`, collect suppression markers, and return the (single) +/// suppression's effective line for `test.rs`. +fn single_suppression_line(source: &str) -> usize { let parsed = parsed_single("test.rs", source); let map = collect_suppression_lines(&parsed); let sups = map.get("test.rs").expect("file recorded"); assert_eq!(sups.len(), 1, "exactly one suppression"); - assert_eq!( - sups[0].line, 3, - "marker should be shifted to last // line of the contiguous block (line 3), got {}", - sups[0].line - ); + sups[0].line } #[test] -fn qual_allow_does_not_reach_across_blank_lines() { - // Marker on line 1, blank line on line 2 breaks the block. Marker - // line stays at 1; struct on line 4 is outside the 3-line window - // from line 1. - let source = "// qual:allow(srp)\n\ - \n\ - #[derive(Default)]\n\ - pub struct Foo { x: i32 }\n"; - let parsed = parsed_single("test.rs", source); - let map = collect_suppression_lines(&parsed); - let sups = map.get("test.rs").expect("file recorded"); - assert_eq!(sups.len(), 1, "marker still parsed"); - assert_eq!( - sups[0].line, 1, - "blank line breaks the block; marker stays at its original line" - ); +fn qual_allow_marker_line_follows_contiguous_comment_block() { + // A `qual:allow` marker's effective line shifts to the LAST `//` line of + // its contiguous comment block (so ANNOTATION_WINDOW=3 reaches the item a + // multi-line rationale would otherwise push out of range); a blank line + // breaks the block and the marker stays on its own line. (label, source, + // expected_line) + let cases: &[(&str, &str, usize)] = &[ + ( + "contiguous 3-line block shifts to line 3", + "// qual:allow(srp) — rustqual false-positive LCOM4=2\n\ + // The struct's methods form one coherent data layer.\n\ + // See docs/rustqual-bugs.md.\n\ + #[derive(Default)]\n\ + pub struct Foo { x: i32, y: i32 }\n", + 3, + ), + ( + "blank line breaks the block; marker stays at line 1", + "// qual:allow(srp)\n\ + \n\ + #[derive(Default)]\n\ + pub struct Foo { x: i32 }\n", + 1, + ), + ]; + for (label, source, expected) in cases { + assert_eq!(single_suppression_line(source), *expected, "case {label}"); + } } #[test] diff --git a/src/app/metrics.rs b/src/app/metrics.rs index a49d3449..ea279bbc 100644 --- a/src/app/metrics.rs +++ b/src/app/metrics.rs @@ -305,10 +305,21 @@ pub(super) fn compute_srp( if !config.srp.enabled { return None; } + let test_length_thresholds = ( + config + .tests + .file_length_baseline + .unwrap_or(config.srp.file_length_baseline), + config + .tests + .file_length_ceiling + .unwrap_or(config.srp.file_length_ceiling), + ); Some(crate::adapters::analyzers::srp::analyze_srp( parsed, &config.srp, file_call_graph, + test_length_thresholds, )) } diff --git a/src/app/orphan_suppressions/complexity_predicates.rs b/src/app/orphan_suppressions/complexity_predicates.rs index 73dac769..5faffbc0 100644 --- a/src/app/orphan_suppressions/complexity_predicates.rs +++ b/src/app/orphan_suppressions/complexity_predicates.rs @@ -17,9 +17,10 @@ pub(super) fn would_trigger( f: &FunctionAnalysis, c: &ComplexityMetrics, cx: &ComplexityConfig, + test_max_lines: usize, ) -> bool { exceeds_basic_thresholds(c, cx) - || exceeds_length(f, c, cx) + || exceeds_length(f, c, cx, test_max_lines) || exceeds_unsafe(c, cx) || exceeds_error_handling(f, c, cx) } @@ -32,10 +33,22 @@ fn exceeds_basic_thresholds(c: &ComplexityMetrics, cx: &ComplexityConfig) -> boo || c.max_nesting > cx.max_nesting_depth } -/// True if the function (production, not test) exceeds the length cap. -/// Operation: comparison logic. -fn exceeds_length(f: &FunctionAnalysis, c: &ComplexityMetrics, cx: &ComplexityConfig) -> bool { - !f.is_test && c.function_lines > cx.max_function_lines +/// True if the function exceeds its length cap — test fns use `test_max_lines` +/// (`[tests].max_function_lines`, defaulting to production), production fns use +/// `[complexity].max_function_lines`. Mirrors `warnings::is_length_over`. +/// Operation: threshold selection + comparison. +fn exceeds_length( + f: &FunctionAnalysis, + c: &ComplexityMetrics, + cx: &ComplexityConfig, + test_max_lines: usize, +) -> bool { + let max = if f.is_test { + test_max_lines + } else { + cx.max_function_lines + }; + c.function_lines > max } /// True if unsafe detection is enabled and the function contains at diff --git a/src/app/orphan_suppressions/mod.rs b/src/app/orphan_suppressions/mod.rs index 57b7929f..da9c05b8 100644 --- a/src/app/orphan_suppressions/mod.rs +++ b/src/app/orphan_suppressions/mod.rs @@ -222,6 +222,10 @@ fn collect_iosp_complexity_positions( use crate::findings::Dimension; let mode = MatchMode::LineWindow(windows::DEFAULT); let complexity_enabled = config.complexity.enabled; + let test_max_lines = config + .tests + .max_function_lines + .unwrap_or(config.complexity.max_function_lines); analysis.results.iter().for_each(|f| { if matches!(f.classification, Classification::Violation { .. }) { push(&f.file, f.line, Dimension::Iosp, mode); @@ -230,7 +234,7 @@ fn collect_iosp_complexity_positions( return; } if let Some(c) = &f.complexity { - if complexity_predicates::would_trigger(f, c, &config.complexity) { + if complexity_predicates::would_trigger(f, c, &config.complexity, test_max_lines) { push(&f.file, f.line, Dimension::Complexity, mode); } push_magic_numbers(f, c, &config.complexity, push); diff --git a/src/app/secondary.rs b/src/app/secondary.rs index 517a5878..0126ab2f 100644 --- a/src/app/secondary.rs +++ b/src/app/secondary.rs @@ -127,7 +127,7 @@ fn run_dry_pass( use crate::adapters::analyzers::dry::match_patterns::detect_repeated_matches; let mut repeated_matches = run_guarded_detection( ctx.config.duplicates.detect_repeated_matches, - |p, c| detect_repeated_matches(p, &c.duplicates), + |p, _c| detect_repeated_matches(p), ctx.parsed, ctx.config, ); diff --git a/src/app/tests/metrics.rs b/src/app/tests/metrics.rs deleted file mode 100644 index cd482f32..00000000 --- a/src/app/tests/metrics.rs +++ /dev/null @@ -1,385 +0,0 @@ -use crate::adapters::analyzers::iosp::{compute_severity, Classification, FunctionAnalysis}; -use crate::app::dry_suppressions::{mark_dry_suppressions, mark_inverse_suppressions}; -use crate::app::metrics::*; -use crate::config::sections::SrpConfig; -use crate::findings::Suppression; -use crate::report::Summary; - -fn make_func(name: &str, param_count: usize, trait_impl: bool) -> FunctionAnalysis { - let severity = compute_severity(&Classification::Operation); - FunctionAnalysis { - name: name.to_string(), - file: "test.rs".to_string(), - line: 1, - classification: Classification::Operation, - parent_type: None, - suppressed: false, - complexity: None, - qualified_name: name.to_string(), - severity, - cognitive_warning: false, - cyclomatic_warning: false, - nesting_depth_warning: false, - function_length_warning: false, - unsafe_warning: false, - error_handling_warning: false, - complexity_suppressed: false, - own_calls: vec![], - parameter_count: param_count, - is_trait_impl: trait_impl, - is_test: false, - effort_score: None, - } -} - -fn make_srp() -> crate::adapters::analyzers::srp::SrpAnalysis { - crate::adapters::analyzers::srp::SrpAnalysis { - struct_warnings: vec![], - module_warnings: vec![], - param_warnings: vec![], - } -} - -#[test] -fn test_param_warning_exceeds_threshold() { - let config = SrpConfig::default(); - let results = vec![make_func("many_params", 7, false)]; - let mut srp = make_srp(); - apply_parameter_warnings(&results, Some(&mut srp), &config); - assert_eq!(srp.param_warnings.len(), 1); - assert_eq!(srp.param_warnings[0].parameter_count, 7); - assert_eq!(srp.param_warnings[0].function_name, "many_params"); -} - -#[test] -fn test_param_warning_at_threshold_no_warning() { - let config = SrpConfig::default(); - let results = vec![make_func("ok_params", 5, false)]; - let mut srp = make_srp(); - apply_parameter_warnings(&results, Some(&mut srp), &config); - assert!(srp.param_warnings.is_empty(), "5 == threshold, no warning"); -} - -#[test] -fn test_param_warning_trait_impl_excluded() { - let config = SrpConfig::default(); - let results = vec![make_func("trait_fn", 10, true)]; - let mut srp = make_srp(); - apply_parameter_warnings(&results, Some(&mut srp), &config); - assert!( - srp.param_warnings.is_empty(), - "trait impl should be excluded" - ); -} - -#[test] -fn test_param_warning_suppressed_fn_is_flagged_but_marked_suppressed() { - // Suppressed over-threshold functions now emit a warning with - // `suppressed=true` instead of being filtered out silently. This - // lets the orphan-suppression checker see that a `qual:allow(srp)` - // marker did have a target. `summary.srp_param_warnings` still - // counts only non-suppressed entries, so user-visible behavior - // (finding count, quality score) is unchanged. - let config = SrpConfig::default(); - let mut func = make_func("suppressed_fn", 10, false); - func.suppressed = true; - let results = vec![func]; - let mut srp = make_srp(); - apply_parameter_warnings(&results, Some(&mut srp), &config); - assert_eq!(srp.param_warnings.len(), 1, "entry recorded"); - assert!( - srp.param_warnings[0].suppressed, - "entry must be marked suppressed" - ); -} - -#[test] -#[allow(clippy::field_reassign_with_default)] -fn test_param_warning_custom_threshold() { - let mut config = SrpConfig::default(); - config.max_parameters = 3; - let results = vec![make_func("four_params", 4, false)]; - let mut srp = make_srp(); - apply_parameter_warnings(&results, Some(&mut srp), &config); - assert_eq!(srp.param_warnings.len(), 1, "4 > custom threshold 3"); -} - -#[test] -fn test_param_warning_srp_none() { - let config = SrpConfig::default(); - let results = vec![make_func("fn", 10, false)]; - apply_parameter_warnings(&results, None, &config); - // No panic, no-op when SRP is None -} - -// ── SDP suppression tests ────────────────────────────── - -#[test] -fn test_count_sdp_violations_excludes_suppressed() { - let analysis = crate::adapters::analyzers::coupling::CouplingAnalysis { - metrics: vec![], - cycles: vec![], - sdp_violations: vec![ - crate::adapters::analyzers::coupling::sdp::SdpViolation { - from_module: "a".into(), - to_module: "b".into(), - from_instability: 0.2, - to_instability: 0.8, - suppressed: true, - }, - crate::adapters::analyzers::coupling::sdp::SdpViolation { - from_module: "c".into(), - to_module: "d".into(), - from_instability: 0.3, - to_instability: 0.9, - suppressed: false, - }, - ], - graph: crate::adapters::analyzers::coupling::ModuleGraph::default(), - }; - let config = crate::config::sections::CouplingConfig::default(); - let mut summary = Summary::from_results(&[]); - count_sdp_violations(Some(&analysis), &config, &mut summary); - assert_eq!( - summary.sdp_violations, 1, - "Only unsuppressed violations counted" - ); -} - -#[test] -fn test_mark_dry_suppressions() { - use crate::adapters::analyzers::dry::functions::{ - DuplicateEntry, DuplicateGroup, DuplicateKind, - }; - - let mut groups = vec![DuplicateGroup { - entries: vec![ - DuplicateEntry { - name: "as_str".to_string(), - qualified_name: "Foo::as_str".to_string(), - file: "test.rs".to_string(), - line: 5, - }, - DuplicateEntry { - name: "parse".to_string(), - qualified_name: "Foo::parse".to_string(), - file: "test.rs".to_string(), - line: 15, - }, - ], - kind: DuplicateKind::NearDuplicate { similarity: 0.91 }, - suppressed: false, - }]; - - // Suppression on line 4 (one line before as_str at line 5) with dry dimension - let sup = Suppression { - line: 4, - dimensions: vec![crate::findings::Dimension::Dry], - reason: None, - }; - let suppression_lines: std::collections::HashMap> = - [("test.rs".to_string(), vec![sup])].into(); - - mark_dry_suppressions(&mut groups, &suppression_lines); - assert!( - groups[0].suppressed, - "Group should be suppressed when any member has qual:allow(dry)" - ); -} - -#[test] -fn test_duplicate_without_suppression_not_marked() { - use crate::adapters::analyzers::dry::functions::{ - DuplicateEntry, DuplicateGroup, DuplicateKind, - }; - - let mut groups = vec![DuplicateGroup { - entries: vec![ - DuplicateEntry { - name: "foo".to_string(), - qualified_name: "foo".to_string(), - file: "test.rs".to_string(), - line: 5, - }, - DuplicateEntry { - name: "bar".to_string(), - qualified_name: "bar".to_string(), - file: "test.rs".to_string(), - line: 15, - }, - ], - kind: DuplicateKind::Exact, - suppressed: false, - }]; - - let suppression_lines: std::collections::HashMap> = - std::collections::HashMap::new(); - - mark_dry_suppressions(&mut groups, &suppression_lines); - assert!( - !groups[0].suppressed, - "Group without suppression should not be marked" - ); -} - -#[test] -fn test_inverse_annotation_suppresses_duplicate() { - use crate::adapters::analyzers::dry::functions::{ - DuplicateEntry, DuplicateGroup, DuplicateKind, - }; - - let mut groups = vec![DuplicateGroup { - entries: vec![ - DuplicateEntry { - name: "as_str".to_string(), - qualified_name: "Foo::as_str".to_string(), - file: "test.rs".to_string(), - line: 5, - }, - DuplicateEntry { - name: "parse".to_string(), - qualified_name: "Foo::parse".to_string(), - file: "test.rs".to_string(), - line: 15, - }, - ], - kind: DuplicateKind::NearDuplicate { similarity: 0.91 }, - suppressed: false, - }]; - - // qual:inverse(parse) on line 4 (one before as_str at line 5) - let inverse_lines: std::collections::HashMap> = - [("test.rs".to_string(), vec![(4, "parse".to_string())])].into(); - - mark_inverse_suppressions(&mut groups, &inverse_lines); - assert!( - groups[0].suppressed, - "Inverse-annotated pair should be suppressed" - ); -} - -#[test] -fn test_inverse_annotation_must_target_group_member() { - use crate::adapters::analyzers::dry::functions::{ - DuplicateEntry, DuplicateGroup, DuplicateKind, - }; - - let mut groups = vec![DuplicateGroup { - entries: vec![ - DuplicateEntry { - name: "foo".to_string(), - qualified_name: "foo".to_string(), - file: "test.rs".to_string(), - line: 5, - }, - DuplicateEntry { - name: "bar".to_string(), - qualified_name: "bar".to_string(), - file: "test.rs".to_string(), - line: 15, - }, - ], - kind: DuplicateKind::Exact, - suppressed: false, - }]; - - // qual:inverse(baz) targets a function not in the group - let inverse_lines: std::collections::HashMap> = - [("test.rs".to_string(), vec![(4, "baz".to_string())])].into(); - - mark_inverse_suppressions(&mut groups, &inverse_lines); - assert!( - !groups[0].suppressed, - "Inverse targeting non-member should not suppress" - ); -} - -#[test] -fn test_repeated_match_suppression() { - use crate::adapters::analyzers::dry::match_patterns::{RepeatedMatchEntry, RepeatedMatchGroup}; - - let mut groups = vec![RepeatedMatchGroup { - enum_name: "MyEnum".to_string(), - entries: vec![RepeatedMatchEntry { - file: "test.rs".to_string(), - line: 10, - function_name: "handle_a".to_string(), - arm_count: 5, - }], - suppressed: false, - }]; - - let sup = Suppression { - line: 9, - dimensions: vec![crate::findings::Dimension::Dry], - reason: None, - }; - let suppression_lines: std::collections::HashMap> = - [("test.rs".to_string(), vec![sup])].into(); - - mark_dry_suppressions(&mut groups, &suppression_lines); - assert!( - groups[0].suppressed, - "RepeatedMatchGroup should be suppressed by qual:allow(dry)" - ); -} - -#[test] -fn test_fragment_suppression() { - use crate::adapters::analyzers::dry::fragments::{FragmentEntry, FragmentGroup}; - - let mut groups = vec![FragmentGroup { - entries: vec![FragmentEntry { - function_name: "foo".to_string(), - qualified_name: "foo".to_string(), - file: "test.rs".to_string(), - start_line: 5, - end_line: 10, - }], - statement_count: 3, - suppressed: false, - }]; - - let sup = Suppression { - line: 4, - dimensions: vec![crate::findings::Dimension::Dry], - reason: None, - }; - let suppression_lines: std::collections::HashMap> = - [("test.rs".to_string(), vec![sup])].into(); - - mark_dry_suppressions(&mut groups, &suppression_lines); - assert!( - groups[0].suppressed, - "FragmentGroup should be suppressed by qual:allow(dry)" - ); -} - -#[test] -fn test_boilerplate_suppression() { - use crate::adapters::analyzers::dry::boilerplate::BoilerplateFind; - - let mut findings = vec![BoilerplateFind { - pattern_id: "BP-003".to_string(), - file: "test.rs".to_string(), - line: 10, - struct_name: Some("MyStruct".to_string()), - description: "3 trivial getters".to_string(), - suggestion: "Consider derive macro".to_string(), - suppressed: false, - }]; - - let sup = Suppression { - line: 9, - dimensions: vec![crate::findings::Dimension::Dry], - reason: None, - }; - let suppression_lines: std::collections::HashMap> = - [("test.rs".to_string(), vec![sup])].into(); - - mark_dry_suppressions(&mut findings, &suppression_lines); - assert!( - findings[0].suppressed, - "BoilerplateFind should be suppressed by qual:allow(dry)" - ); -} diff --git a/src/app/tests/metrics/mod.rs b/src/app/tests/metrics/mod.rs new file mode 100644 index 00000000..2caa2b79 --- /dev/null +++ b/src/app/tests/metrics/mod.rs @@ -0,0 +1,128 @@ +//! Tests for app::metrics — parameter-count SRP warnings, SDP/DRY/inverse +//! suppression marking. Split into focused sub-files (each ≤ the SRP +//! file-length cap); shared imports + make_func/make_srp/dry_suppression_at/ +//! dry_group_fixtures helpers live here and reach the sub-modules via +//! `use super::*`. + +pub(super) use crate::adapters::analyzers::dry::boilerplate::BoilerplateFind; +pub(super) use crate::adapters::analyzers::dry::fragments::{FragmentEntry, FragmentGroup}; +pub(super) use crate::adapters::analyzers::dry::functions::{ + DuplicateEntry, DuplicateGroup, DuplicateKind, +}; +pub(super) use crate::adapters::analyzers::dry::match_patterns::{ + RepeatedMatchEntry, RepeatedMatchGroup, +}; +pub(super) use crate::adapters::analyzers::iosp::{ + compute_severity, Classification, FunctionAnalysis, +}; +pub(super) use crate::app::dry_suppressions::{mark_dry_suppressions, mark_inverse_suppressions}; +pub(super) use crate::app::metrics::*; +pub(super) use crate::config::sections::SrpConfig; +pub(super) use crate::findings::Suppression; +pub(super) use crate::report::Summary; + +mod param_warnings; +mod suppression; + +pub(super) fn make_func(name: &str, param_count: usize, trait_impl: bool) -> FunctionAnalysis { + let severity = compute_severity(&Classification::Operation); + FunctionAnalysis { + name: name.to_string(), + file: "test.rs".to_string(), + line: 1, + classification: Classification::Operation, + parent_type: None, + suppressed: false, + complexity: None, + qualified_name: name.to_string(), + severity, + cognitive_warning: false, + cyclomatic_warning: false, + nesting_depth_warning: false, + function_length_warning: false, + unsafe_warning: false, + error_handling_warning: false, + complexity_suppressed: false, + own_calls: vec![], + parameter_count: param_count, + is_trait_impl: trait_impl, + is_test: false, + effort_score: None, + } +} + +pub(super) fn make_srp() -> crate::adapters::analyzers::srp::SrpAnalysis { + crate::adapters::analyzers::srp::SrpAnalysis { + struct_warnings: vec![], + module_warnings: vec![], + param_warnings: vec![], + } +} + +/// A single `qual:allow(dry)` suppression at `line` in `test.rs`. +pub(super) fn dry_suppression_at( + line: usize, +) -> std::collections::HashMap> { + [( + "test.rs".to_string(), + vec![Suppression { + line, + dimensions: vec![crate::findings::Dimension::Dry], + reason: None, + }], + )] + .into() +} + +pub(super) type DryFixtures = ( + DuplicateGroup, + RepeatedMatchGroup, + FragmentGroup, + BoilerplateFind, +); + +/// One fixture per DRY group kind, each with an entry on line 5. +pub(super) fn dry_group_fixtures() -> DryFixtures { + ( + DuplicateGroup { + entries: vec![DuplicateEntry { + name: "as_str".to_string(), + qualified_name: "Foo::as_str".to_string(), + file: "test.rs".to_string(), + line: 5, + }], + kind: DuplicateKind::NearDuplicate { similarity: 0.91 }, + suppressed: false, + }, + RepeatedMatchGroup { + enum_name: "MyEnum".to_string(), + entries: vec![RepeatedMatchEntry { + file: "test.rs".to_string(), + line: 5, + function_name: "handle_a".to_string(), + arm_count: 5, + }], + suppressed: false, + }, + FragmentGroup { + entries: vec![FragmentEntry { + function_name: "foo".to_string(), + qualified_name: "foo".to_string(), + file: "test.rs".to_string(), + start_line: 5, + end_line: 10, + }], + statement_count: 3, + suppressed: false, + }, + BoilerplateFind { + pattern_id: "BP-003".to_string(), + file: "test.rs".to_string(), + line: 5, + struct_name: Some("MyStruct".to_string()), + description: "3 trivial getters".to_string(), + suggestion: "Consider derive macro".to_string(), + suppressed: false, + }, + ) +} diff --git a/src/app/tests/metrics/param_warnings.rs b/src/app/tests/metrics/param_warnings.rs new file mode 100644 index 00000000..f30d468d --- /dev/null +++ b/src/app/tests/metrics/param_warnings.rs @@ -0,0 +1,73 @@ +use super::*; + +#[test] +fn test_param_warning_exceeds_threshold() { + let config = SrpConfig::default(); + let results = vec![make_func("many_params", 7, false)]; + let mut srp = make_srp(); + apply_parameter_warnings(&results, Some(&mut srp), &config); + assert_eq!(srp.param_warnings.len(), 1); + assert_eq!(srp.param_warnings[0].parameter_count, 7); + assert_eq!(srp.param_warnings[0].function_name, "many_params"); +} + +#[test] +fn test_param_warning_at_threshold_no_warning() { + let config = SrpConfig::default(); + let results = vec![make_func("ok_params", 5, false)]; + let mut srp = make_srp(); + apply_parameter_warnings(&results, Some(&mut srp), &config); + assert!(srp.param_warnings.is_empty(), "5 == threshold, no warning"); +} + +#[test] +fn test_param_warning_trait_impl_excluded() { + let config = SrpConfig::default(); + let results = vec![make_func("trait_fn", 10, true)]; + let mut srp = make_srp(); + apply_parameter_warnings(&results, Some(&mut srp), &config); + assert!( + srp.param_warnings.is_empty(), + "trait impl should be excluded" + ); +} + +#[test] +fn test_param_warning_suppressed_fn_is_flagged_but_marked_suppressed() { + // Suppressed over-threshold functions now emit a warning with + // `suppressed=true` instead of being filtered out silently. This + // lets the orphan-suppression checker see that a `qual:allow(srp)` + // marker did have a target. `summary.srp_param_warnings` still + // counts only non-suppressed entries, so user-visible behavior + // (finding count, quality score) is unchanged. + let config = SrpConfig::default(); + let mut func = make_func("suppressed_fn", 10, false); + func.suppressed = true; + let results = vec![func]; + let mut srp = make_srp(); + apply_parameter_warnings(&results, Some(&mut srp), &config); + assert_eq!(srp.param_warnings.len(), 1, "entry recorded"); + assert!( + srp.param_warnings[0].suppressed, + "entry must be marked suppressed" + ); +} + +#[test] +#[allow(clippy::field_reassign_with_default)] +fn test_param_warning_custom_threshold() { + let mut config = SrpConfig::default(); + config.max_parameters = 3; + let results = vec![make_func("four_params", 4, false)]; + let mut srp = make_srp(); + apply_parameter_warnings(&results, Some(&mut srp), &config); + assert_eq!(srp.param_warnings.len(), 1, "4 > custom threshold 3"); +} + +#[test] +fn test_param_warning_srp_none() { + let config = SrpConfig::default(); + let results = vec![make_func("fn", 10, false)]; + apply_parameter_warnings(&results, None, &config); + // No panic, no-op when SRP is None +} diff --git a/src/app/tests/metrics/suppression.rs b/src/app/tests/metrics/suppression.rs new file mode 100644 index 00000000..a04e6ae1 --- /dev/null +++ b/src/app/tests/metrics/suppression.rs @@ -0,0 +1,162 @@ +use super::*; + +// ── SDP suppression tests ────────────────────────────── + +#[test] +fn test_count_sdp_violations_excludes_suppressed() { + let analysis = crate::adapters::analyzers::coupling::CouplingAnalysis { + metrics: vec![], + cycles: vec![], + sdp_violations: vec![ + crate::adapters::analyzers::coupling::sdp::SdpViolation { + from_module: "a".into(), + to_module: "b".into(), + from_instability: 0.2, + to_instability: 0.8, + suppressed: true, + }, + crate::adapters::analyzers::coupling::sdp::SdpViolation { + from_module: "c".into(), + to_module: "d".into(), + from_instability: 0.3, + to_instability: 0.9, + suppressed: false, + }, + ], + graph: crate::adapters::analyzers::coupling::ModuleGraph::default(), + }; + let config = crate::config::sections::CouplingConfig::default(); + let mut summary = Summary::from_results(&[]); + count_sdp_violations(Some(&analysis), &config, &mut summary); + assert_eq!( + summary.sdp_violations, 1, + "Only unsuppressed violations counted" + ); +} + +#[test] +fn dry_suppression_marks_every_group_kind() { + // `qual:allow(dry)` on the line before an entry (line 4 → entry line 5) + // suppresses every DRY finding kind: duplicate, repeated-match, fragment, + // and boilerplate. + let sups = dry_suppression_at(4); + let (mut dup, mut rep, mut frag, mut bp) = dry_group_fixtures(); + mark_dry_suppressions(std::slice::from_mut(&mut dup), &sups); + mark_dry_suppressions(std::slice::from_mut(&mut rep), &sups); + mark_dry_suppressions(std::slice::from_mut(&mut frag), &sups); + mark_dry_suppressions(std::slice::from_mut(&mut bp), &sups); + assert!( + dup.suppressed, + "duplicate group suppressed by qual:allow(dry)" + ); + assert!(rep.suppressed, "repeated-match group suppressed"); + assert!(frag.suppressed, "fragment group suppressed"); + assert!(bp.suppressed, "boilerplate find suppressed"); +} + +#[test] +fn test_duplicate_without_suppression_not_marked() { + use crate::adapters::analyzers::dry::functions::{ + DuplicateEntry, DuplicateGroup, DuplicateKind, + }; + + let mut groups = vec![DuplicateGroup { + entries: vec![ + DuplicateEntry { + name: "foo".to_string(), + qualified_name: "foo".to_string(), + file: "test.rs".to_string(), + line: 5, + }, + DuplicateEntry { + name: "bar".to_string(), + qualified_name: "bar".to_string(), + file: "test.rs".to_string(), + line: 15, + }, + ], + kind: DuplicateKind::Exact, + suppressed: false, + }]; + + let suppression_lines: std::collections::HashMap> = + std::collections::HashMap::new(); + + mark_dry_suppressions(&mut groups, &suppression_lines); + assert!( + !groups[0].suppressed, + "Group without suppression should not be marked" + ); +} + +#[test] +fn test_inverse_annotation_suppresses_duplicate() { + use crate::adapters::analyzers::dry::functions::{ + DuplicateEntry, DuplicateGroup, DuplicateKind, + }; + + let mut groups = vec![DuplicateGroup { + entries: vec![ + DuplicateEntry { + name: "as_str".to_string(), + qualified_name: "Foo::as_str".to_string(), + file: "test.rs".to_string(), + line: 5, + }, + DuplicateEntry { + name: "parse".to_string(), + qualified_name: "Foo::parse".to_string(), + file: "test.rs".to_string(), + line: 15, + }, + ], + kind: DuplicateKind::NearDuplicate { similarity: 0.91 }, + suppressed: false, + }]; + + // qual:inverse(parse) on line 4 (one before as_str at line 5) + let inverse_lines: std::collections::HashMap> = + [("test.rs".to_string(), vec![(4, "parse".to_string())])].into(); + + mark_inverse_suppressions(&mut groups, &inverse_lines); + assert!( + groups[0].suppressed, + "Inverse-annotated pair should be suppressed" + ); +} + +#[test] +fn test_inverse_annotation_must_target_group_member() { + use crate::adapters::analyzers::dry::functions::{ + DuplicateEntry, DuplicateGroup, DuplicateKind, + }; + + let mut groups = vec![DuplicateGroup { + entries: vec![ + DuplicateEntry { + name: "foo".to_string(), + qualified_name: "foo".to_string(), + file: "test.rs".to_string(), + line: 5, + }, + DuplicateEntry { + name: "bar".to_string(), + qualified_name: "bar".to_string(), + file: "test.rs".to_string(), + line: 15, + }, + ], + kind: DuplicateKind::Exact, + suppressed: false, + }]; + + // qual:inverse(baz) targets a function not in the group + let inverse_lines: std::collections::HashMap> = + [("test.rs".to_string(), vec![(4, "baz".to_string())])].into(); + + mark_inverse_suppressions(&mut groups, &inverse_lines); + assert!( + !groups[0].suppressed, + "Inverse targeting non-member should not suppress" + ); +} diff --git a/src/app/tests/pipeline.rs b/src/app/tests/pipeline.rs index 16c1ba46..d72a9198 100644 --- a/src/app/tests/pipeline.rs +++ b/src/app/tests/pipeline.rs @@ -47,26 +47,28 @@ fn test_collect_rust_files_directory() { assert!(files.iter().all(|f| f.extension().unwrap() == "rs")); } -#[test] -fn test_collect_rust_files_skips_target() { +/// In a fresh tempdir, put a `.rs` inside `excluded_subdir` and a visible +/// `.rs` at the root, then collect — returning how many files were found. +fn collect_count_excluding(excluded_subdir: &str) -> usize { let tmp = test_dir(); - let target_dir = tmp.path().join("target"); - fs::create_dir(&target_dir).unwrap(); - fs::write(target_dir.join("compiled.rs"), "fn c() {}").unwrap(); - fs::write(tmp.path().join("src.rs"), "fn s() {}").unwrap(); - let files = collect_rust_files(tmp.path()); - assert_eq!(files.len(), 1); + let sub = tmp.path().join(excluded_subdir); + fs::create_dir(&sub).unwrap(); + fs::write(sub.join("excluded.rs"), "fn x() {}").unwrap(); + fs::write(tmp.path().join("visible.rs"), "fn v() {}").unwrap(); + collect_rust_files(tmp.path()).len() } #[test] -fn test_collect_rust_files_skips_hidden() { - let tmp = test_dir(); - let hidden_dir = tmp.path().join(".hidden"); - fs::create_dir(&hidden_dir).unwrap(); - fs::write(hidden_dir.join("secret.rs"), "fn h() {}").unwrap(); - fs::write(tmp.path().join("visible.rs"), "fn v() {}").unwrap(); - let files = collect_rust_files(tmp.path()); - assert_eq!(files.len(), 1); +fn test_collect_rust_files_skips_target_and_hidden_dirs() { + // `target/` and `.`-prefixed directories are excluded; only the visible + // root file is collected. + for excluded in ["target", ".hidden"] { + assert_eq!( + collect_count_excluding(excluded), + 1, + "`{excluded}/` should be excluded, leaving only the visible file" + ); + } } #[test] @@ -320,36 +322,43 @@ fn test_mark_coupling_suppressions_marks_module() { assert!(!analysis.metrics[1].suppressed); // config } -#[test] -fn test_mark_coupling_suppressions_qual_allow_all_covers_coupling() { +/// Mark a `pipeline.rs`-line-1 suppression with `dims` against the standard +/// coupling analysis, and report whether its first metric got suppressed. +fn coupling_metric0_suppressed_by(dims: Vec) -> bool { let mut analysis = make_coupling_analysis(); - let sup = Suppression { - line: 1, - dimensions: vec![], // all dimensions - reason: None, - }; let mut suppression_lines = std::collections::HashMap::new(); - suppression_lines.insert("pipeline.rs".to_string(), vec![sup]); - - mark_coupling_suppressions(Some(&mut analysis), &suppression_lines); - - assert!(analysis.metrics[0].suppressed); // pipeline -} - -#[test] -fn test_mark_coupling_suppressions_iosp_only_does_not_cover_coupling() { - let mut analysis = make_coupling_analysis(); - let sup = Suppression { - line: 1, - dimensions: vec![crate::findings::Dimension::Iosp], - reason: None, - }; - let mut suppression_lines = std::collections::HashMap::new(); - suppression_lines.insert("pipeline.rs".to_string(), vec![sup]); - + suppression_lines.insert( + "pipeline.rs".to_string(), + vec![Suppression { + line: 1, + dimensions: dims, + reason: None, + }], + ); mark_coupling_suppressions(Some(&mut analysis), &suppression_lines); - - assert!(!analysis.metrics[0].suppressed); // not suppressed + analysis.metrics[0].suppressed +} + +#[test] +fn test_mark_coupling_suppressions_dimension_coverage() { + use crate::findings::Dimension; + // A wildcard (`qual:allow` with no dims) covers coupling; an unrelated + // single dimension (iosp) does not. (label, dims, covers_coupling) + let cases: &[(&str, &[Dimension], bool)] = &[ + ("wildcard (no dims) covers coupling", &[], true), + ( + "iosp-only does not cover coupling", + &[Dimension::Iosp], + false, + ), + ]; + for (label, dims, covers) in cases { + assert_eq!( + coupling_metric0_suppressed_by(dims.to_vec()), + *covers, + "case {label}" + ); + } } #[test] diff --git a/src/app/tests/warnings.rs b/src/app/tests/warnings.rs deleted file mode 100644 index 2f93332f..00000000 --- a/src/app/tests/warnings.rs +++ /dev/null @@ -1,1392 +0,0 @@ -use crate::adapters::analyzers::iosp::{Classification, ComplexityMetrics, FunctionAnalysis}; -use crate::app::warnings::*; -use crate::config::Config; -use crate::report::Summary; -use std::collections::{HashMap, HashSet}; - -// ── count_rust_allow_attrs ──────────────────────────────────── - -#[test] -fn test_allow_before_cfg_test_excluded() { - // #[allow(...)] directly before #[cfg(test)] belongs to the test module - let source = "#[allow(dead_code)]\n#[cfg(test)]\nmod tests {}"; - assert_eq!(count_rust_allow_attrs(source), 0); -} - -#[test] -fn test_allow_with_gap_before_cfg_test_counted() { - // #[allow(...)] with a non-attribute line gap → production code - let source = "#[allow(dead_code)]\nfn foo() {}\n#[cfg(test)]\nmod tests {}"; - assert_eq!(count_rust_allow_attrs(source), 1); -} - -#[test] -fn test_derive_and_allow_before_cfg_test_excluded() { - // #[derive(Debug)] + #[allow(...)] both part of test module attribute group - let source = "#[derive(Debug)]\n#[allow(dead_code)]\n#[cfg(test)]\nmod tests {}"; - assert_eq!(count_rust_allow_attrs(source), 0); -} - -#[test] -fn test_no_cfg_test_counts_all() { - let source = "#[allow(dead_code)]\nfn foo() {}\n#[allow(unused)]\nfn bar() {}"; - assert_eq!(count_rust_allow_attrs(source), 2); -} - -#[test] -fn test_cfg_test_on_first_line() { - let source = "#[cfg(test)]\nmod tests {\n#[allow(dead_code)]\nfn x() {}\n}"; - assert_eq!(count_rust_allow_attrs(source), 0); -} - -#[test] -fn test_empty_source() { - assert_eq!(count_rust_allow_attrs(""), 0); -} - -#[test] -fn test_production_allow_before_test_section() { - let source = "#[allow(clippy::too_many_arguments)]\nfn big() {}\n\n#[cfg(test)]\nmod tests {}"; - assert_eq!(count_rust_allow_attrs(source), 1); -} - -#[test] -fn test_allow_inside_test_module_excluded() { - let source = "fn good() {}\n#[cfg(test)]\nmod tests {\n#[allow(dead_code)]\nfn helper() {}\n}"; - assert_eq!(count_rust_allow_attrs(source), 0); -} - -// ── apply_extended_warnings ─────────────────────────────────── - -use crate::adapters::analyzers::iosp::compute_severity; - -fn make_func_with_metrics(metrics: ComplexityMetrics) -> FunctionAnalysis { - let severity = compute_severity(&Classification::Operation); - FunctionAnalysis { - name: "test_fn".to_string(), - file: "test.rs".to_string(), - line: 1, - classification: Classification::Operation, - parent_type: None, - suppressed: false, - complexity: Some(metrics), - qualified_name: "test_fn".to_string(), - severity, - cognitive_warning: false, - cyclomatic_warning: false, - nesting_depth_warning: false, - function_length_warning: false, - unsafe_warning: false, - error_handling_warning: false, - complexity_suppressed: false, - own_calls: vec![], - parameter_count: 0, - is_trait_impl: false, - effort_score: None, - is_test: false, - } -} - -#[test] -fn test_nesting_depth_warning_set() { - let config = Config::default(); - let mut summary = Summary::default(); - let mut results = vec![make_func_with_metrics(ComplexityMetrics { - max_nesting: 5, - ..Default::default() - })]; - apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); - assert!(results[0].nesting_depth_warning, "Should flag nesting > 4"); - assert_eq!(summary.nesting_depth_warnings, 1); -} - -#[test] -fn test_nesting_depth_at_threshold_no_warning() { - let config = Config::default(); - let mut summary = Summary::default(); - let mut results = vec![make_func_with_metrics(ComplexityMetrics { - max_nesting: 4, - ..Default::default() - })]; - apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); - assert!(!results[0].nesting_depth_warning, "4 == threshold, no warn"); -} - -#[test] -fn test_function_length_warning_set() { - let config = Config::default(); - let mut summary = Summary::default(); - let mut results = vec![make_func_with_metrics(ComplexityMetrics { - function_lines: 61, - ..Default::default() - })]; - apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); - assert!(results[0].function_length_warning, "Should flag >60 lines"); - assert_eq!(summary.function_length_warnings, 1); -} - -#[test] -fn test_function_length_at_threshold_no_warning() { - let config = Config::default(); - let mut summary = Summary::default(); - let mut results = vec![make_func_with_metrics(ComplexityMetrics { - function_lines: 60, - ..Default::default() - })]; - apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); - assert!( - !results[0].function_length_warning, - "60 == threshold, no warn" - ); -} - -#[test] -fn test_unsafe_warning_set() { - let config = Config::default(); - let mut summary = Summary::default(); - let mut results = vec![make_func_with_metrics(ComplexityMetrics { - unsafe_blocks: 1, - ..Default::default() - })]; - apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); - assert!(results[0].unsafe_warning, "Should flag unsafe blocks"); - assert_eq!(summary.unsafe_warnings, 1); -} - -#[test] -fn test_error_handling_unwrap_warning() { - let config = Config::default(); - let mut summary = Summary::default(); - let mut results = vec![make_func_with_metrics(ComplexityMetrics { - unwrap_count: 1, - ..Default::default() - })]; - apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); - assert!(results[0].error_handling_warning, "Should flag unwrap"); - assert_eq!(summary.error_handling_warnings, 1); -} - -#[test] -fn test_error_handling_expect_allowed() { - let mut config = Config::default(); - config.complexity.allow_expect = true; - let mut summary = Summary::default(); - let mut results = vec![make_func_with_metrics(ComplexityMetrics { - expect_count: 3, - ..Default::default() - })]; - apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); - assert!( - !results[0].error_handling_warning, - "expect allowed, no warn" - ); -} - -#[test] -fn test_error_handling_expect_not_allowed() { - let mut config = Config::default(); - config.complexity.allow_expect = false; - let mut summary = Summary::default(); - let mut results = vec![make_func_with_metrics(ComplexityMetrics { - expect_count: 1, - ..Default::default() - })]; - apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); - assert!( - results[0].error_handling_warning, - "expect not allowed, should warn" - ); -} - -#[test] -fn test_suppressed_functions_skipped() { - let config = Config::default(); - let mut summary = Summary::default(); - let mut func = make_func_with_metrics(ComplexityMetrics { - max_nesting: 10, - function_lines: 100, - unsafe_blocks: 3, - unwrap_count: 5, - ..Default::default() - }); - func.suppressed = true; - let mut results = vec![func]; - apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); - assert!(!results[0].nesting_depth_warning); - assert!(!results[0].function_length_warning); - assert!(!results[0].unsafe_warning); - assert!(!results[0].error_handling_warning); -} - -#[test] -fn test_complexity_suppressed_functions_skipped() { - let config = Config::default(); - let mut summary = Summary::default(); - let mut func = make_func_with_metrics(ComplexityMetrics { - max_nesting: 10, - function_lines: 100, - ..Default::default() - }); - func.complexity_suppressed = true; - let mut results = vec![func]; - apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); - assert!(!results[0].nesting_depth_warning); - assert!(!results[0].function_length_warning); -} - -// ── exclude_test_violations ────────────────────────────────── - -#[test] -fn test_exclude_test_violations_reclassifies() { - let mut fa = make_func_with_metrics(ComplexityMetrics::default()); - fa.is_test = true; - fa.classification = Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![], - call_locations: vec![], - }; - fa.severity = Some(crate::adapters::analyzers::iosp::Severity::Low); - fa.effort_score = Some(3.0); - let mut results = vec![fa]; - exclude_test_violations(&mut results); - assert_eq!(results[0].classification, Classification::Trivial); - assert!(results[0].severity.is_none()); - assert!(results[0].effort_score.is_none()); -} - -#[test] -fn test_exclude_test_violations_keeps_non_test() { - let mut fa = make_func_with_metrics(ComplexityMetrics::default()); - fa.is_test = false; - fa.classification = Classification::Violation { - has_logic: true, - has_own_calls: true, - logic_locations: vec![], - call_locations: vec![], - }; - let mut results = vec![fa]; - exclude_test_violations(&mut results); - assert!(matches!( - results[0].classification, - Classification::Violation { .. } - )); -} - -// ── error handling skipped for tests ───────────────────────── - -#[test] -fn test_error_handling_skipped_for_test_fn() { - let config = Config::default(); - let mut summary = Summary::default(); - let mut fa = make_func_with_metrics(ComplexityMetrics { - unwrap_count: 3, - ..Default::default() - }); - fa.is_test = true; - let mut results = vec![fa]; - apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); - assert!(!results[0].error_handling_warning); - assert_eq!(summary.error_handling_warnings, 0); -} - -#[test] -fn test_error_handling_flagged_for_non_test_fn() { - let config = Config::default(); - let mut summary = Summary::default(); - let mut fa = make_func_with_metrics(ComplexityMetrics { - unwrap_count: 1, - ..Default::default() - }); - fa.is_test = false; - let mut results = vec![fa]; - apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); - assert!(results[0].error_handling_warning); - assert_eq!(summary.error_handling_warnings, 1); -} - -#[test] -fn test_unsafe_suppressed_by_allow_annotation() { - let config = Config::default(); - let mut summary = Summary::default(); - let mut fa = make_func_with_metrics(ComplexityMetrics { - unsafe_blocks: 1, - ..Default::default() - }); - fa.line = 5; - let mut results = vec![fa]; - - // qual:allow(unsafe) on line 4 (one line before fn at line 5) - let unsafe_lines: HashMap> = - [("test.rs".to_string(), [4].into_iter().collect())].into(); - - apply_extended_warnings(&mut results, &config, &mut summary, &unsafe_lines); - assert!( - !results[0].unsafe_warning, - "qual:allow(unsafe) should suppress unsafe warning" - ); - assert_eq!(summary.unsafe_warnings, 0); -} - -#[test] -fn test_unsafe_without_allow_still_warned() { - let config = Config::default(); - let mut summary = Summary::default(); - let mut results = vec![make_func_with_metrics(ComplexityMetrics { - unsafe_blocks: 1, - ..Default::default() - })]; - - apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); - assert!( - results[0].unsafe_warning, - "Without annotation, unsafe should still warn" - ); - assert_eq!(summary.unsafe_warnings, 1); -} - -// ── detect_orphan_suppressions ───────────────────────────────── - -fn empty_analysis() -> crate::report::AnalysisResult { - crate::report::AnalysisResult { - results: vec![], - summary: Summary::default(), - findings: crate::domain::AnalysisFindings::default(), - data: crate::domain::AnalysisData::default(), - } -} - -fn make_finding( - file: &str, - line: usize, - dimension: crate::findings::Dimension, - rule_id: &str, -) -> crate::domain::Finding { - crate::domain::Finding { - file: file.into(), - line, - column: 0, - dimension, - rule_id: rule_id.into(), - message: String::new(), - severity: crate::domain::Severity::Medium, - suppressed: false, - } -} - -fn make_srp_struct_finding(file: &str, line: usize) -> crate::domain::findings::SrpFinding { - crate::domain::findings::SrpFinding { - common: make_finding( - file, - line, - crate::findings::Dimension::Srp, - "srp/struct_cohesion", - ), - kind: crate::domain::findings::SrpFindingKind::StructCohesion, - details: crate::domain::findings::SrpFindingDetails::StructCohesion { - struct_name: "Foo".into(), - lcom4: 3, - field_count: 5, - method_count: 5, - fan_out: 2, - composite_score: 0.0, - clusters: vec![], - }, - } -} - -fn make_srp_module_finding(file: &str) -> crate::domain::findings::SrpFinding { - crate::domain::findings::SrpFinding { - common: make_finding( - file, - 1, - crate::findings::Dimension::Srp, - "srp/module_length", - ), - kind: crate::domain::findings::SrpFindingKind::ModuleLength, - details: crate::domain::findings::SrpFindingDetails::ModuleLength { - module: file.into(), - production_lines: 900, - independent_clusters: 1, - cluster_names: vec![], - length_score: 0.0, - }, - } -} - -fn make_srp_param_finding( - file: &str, - line: usize, - suppressed: bool, -) -> crate::domain::findings::SrpFinding { - let mut common = make_finding( - file, - line, - crate::findings::Dimension::Srp, - "srp/parameter_count", - ); - common.suppressed = suppressed; - crate::domain::findings::SrpFinding { - common, - kind: crate::domain::findings::SrpFindingKind::ParameterCount, - details: crate::domain::findings::SrpFindingDetails::ParameterCount { - function_name: "big_factory".into(), - parameter_count: 7, - }, - } -} - -fn make_tq_finding( - file: &str, - line: usize, - kind: crate::domain::findings::TqFindingKind, -) -> crate::domain::findings::TqFinding { - crate::domain::findings::TqFinding { - common: make_finding( - file, - line, - crate::findings::Dimension::TestQuality, - "tq/no_assertion", - ), - kind, - function_name: "test_it".into(), - uncovered_lines: None, - } -} - -fn make_dry_dead_code_finding(file: &str, line: usize) -> crate::domain::findings::DryFinding { - crate::domain::findings::DryFinding { - common: make_finding( - file, - line, - crate::findings::Dimension::Dry, - "dry/dead_code/uncalled", - ), - kind: crate::domain::findings::DryFindingKind::DeadCodeUncalled, - details: crate::domain::findings::DryFindingDetails::DeadCode { - qualified_name: "helper".into(), - suggestion: None, - }, - } -} - -fn make_dry_wildcard_finding(file: &str, line: usize) -> crate::domain::findings::DryFinding { - crate::domain::findings::DryFinding { - common: make_finding(file, line, crate::findings::Dimension::Dry, "dry/wildcard"), - kind: crate::domain::findings::DryFindingKind::Wildcard, - details: crate::domain::findings::DryFindingDetails::Wildcard { - module_path: "foo::*".into(), - }, - } -} - -fn make_structural_srp_finding(file: &str, line: usize) -> crate::domain::findings::SrpFinding { - crate::domain::findings::SrpFinding { - common: make_finding( - file, - line, - crate::findings::Dimension::Srp, - "srp/structural/SLM", - ), - kind: crate::domain::findings::SrpFindingKind::Structural, - details: crate::domain::findings::SrpFindingDetails::Structural { - item_name: "Foo::bar".into(), - code: "SLM".into(), - detail: "selfless method".into(), - }, - } -} - -fn make_structural_coupling_finding( - file: &str, - line: usize, -) -> crate::domain::findings::CouplingFinding { - crate::domain::findings::CouplingFinding { - common: make_finding( - file, - line, - crate::findings::Dimension::Coupling, - "coupling/structural/SIT", - ), - kind: crate::domain::findings::CouplingFindingKind::Structural, - details: crate::domain::findings::CouplingFindingDetails::Structural { - item_name: "Foo".into(), - code: "SIT".into(), - detail: "single-impl trait".into(), - }, - } -} - -fn make_architecture_finding( - file: &str, - line: usize, -) -> crate::domain::findings::ArchitectureFinding { - crate::domain::findings::ArchitectureFinding { - common: make_finding( - file, - line, - crate::findings::Dimension::Architecture, - "architecture::layer", - ), - } -} - -#[test] -fn orphan_suppression_without_matching_finding_is_counted() { - // Suppression marker at line 5 with no finding in the window: - // this is an orphan and must be counted. - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/foo.rs".to_string(), - vec![Suppression { - line: 5, - dimensions: vec![crate::findings::Dimension::Srp], - reason: None, - }], - ); - let analysis = empty_analysis(); - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ) - .len(); - assert_eq!(orphans, 1, "unmatched marker should count as orphan"); -} - -#[test] -fn suppression_covering_finding_in_window_is_not_orphan() { - // SRP struct finding at line 8; suppression marker at line 5 with - // ANNOTATION_WINDOW=3 reaches line 8. Must NOT be orphan. - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/foo.rs".to_string(), - vec![Suppression { - line: 5, - dimensions: vec![crate::findings::Dimension::Srp], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis - .findings - .srp - .push(make_srp_struct_finding("src/foo.rs", 8)); - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ) - .len(); - assert_eq!(orphans, 0, "in-window finding matches the marker"); -} - -#[test] -fn suppression_with_wrong_dimension_is_orphan() { - // Finding is SRP, but marker suppresses only DRY → no dimension - // match → orphan. - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/foo.rs".to_string(), - vec![Suppression { - line: 5, - dimensions: vec![crate::findings::Dimension::Dry], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis - .findings - .srp - .push(make_srp_struct_finding("src/foo.rs", 7)); - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ) - .len(); - assert_eq!(orphans, 1, "dimension mismatch should still flag as orphan"); -} - -#[test] -fn empty_dim_suppression_acts_as_wildcard_defensive() { - // Defensive: bare `// qual:allow` no longer parses to a - // Suppression (the parser drops it), so this code path is - // unreachable in production. If a Suppression with empty - // dimensions somehow appears (test fixture, internal API - // misuse), the orphan detector still treats it as a wildcard - // — keeping the behaviour stable rather than producing a - // confusing false-orphan report. - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/foo.rs".to_string(), - vec![Suppression { - line: 5, - dimensions: vec![], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis - .findings - .srp - .push(make_srp_struct_finding("src/foo.rs", 6)); - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ) - .len(); - assert_eq!(orphans, 0, "empty-dim Suppression still matches any dim"); -} - -// ── Regression tests: no false-positive orphans when the marker ── -// ── clears warning flags via suppression. ── -// -// These tests reproduce the Bug 3 iteration where my first orphan -// checker read `fa.cognitive_warning` and friends — flags that -// `apply_file_suppressions` clears when `// qual:allow(complexity)` -// matches. The checker then saw no position and flagged the marker -// as orphan, even though it was actively doing its job. The fixed -// checker reads raw `complexity` metrics against config thresholds, -// independent of the suppression flags. - -fn make_fa_with_complexity( - file: &str, - line: usize, - metrics: crate::adapters::analyzers::iosp::ComplexityMetrics, -) -> FunctionAnalysis { - FunctionAnalysis { - name: "f".into(), - qualified_name: "f".into(), - file: file.into(), - line, - classification: Classification::Operation, - parent_type: None, - suppressed: false, - complexity: Some(metrics), - severity: None, - cognitive_warning: false, - cyclomatic_warning: false, - nesting_depth_warning: false, - function_length_warning: false, - unsafe_warning: false, - error_handling_warning: false, - complexity_suppressed: true, - own_calls: vec![], - parameter_count: 0, - is_trait_impl: false, - is_test: false, - effort_score: None, - } -} - -#[test] -fn suppressed_cognitive_over_threshold_is_not_orphan() { - // `qual:allow(complexity)` cleared cognitive_warning but the raw - // metric still exceeds max_cognitive — marker is not orphan. - use crate::adapters::analyzers::iosp::ComplexityMetrics; - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/x.rs".to_string(), - vec![Suppression { - line: 5, - dimensions: vec![crate::findings::Dimension::Complexity], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis.results = vec![make_fa_with_complexity( - "src/x.rs", - 6, - ComplexityMetrics { - cognitive_complexity: 99, - ..Default::default() - }, - )]; - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert!( - orphans.is_empty(), - "complexity marker clearing cognitive flag must not be orphan, got: {orphans:?}" - ); -} - -#[test] -fn suppressed_cyclomatic_over_threshold_is_not_orphan() { - use crate::adapters::analyzers::iosp::ComplexityMetrics; - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/x.rs".to_string(), - vec![Suppression { - line: 5, - dimensions: vec![crate::findings::Dimension::Complexity], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis.results = vec![make_fa_with_complexity( - "src/x.rs", - 6, - ComplexityMetrics { - cyclomatic_complexity: 99, - ..Default::default() - }, - )]; - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert!(orphans.is_empty(), "got: {orphans:?}"); -} - -#[test] -fn suppressed_function_length_over_threshold_is_not_orphan() { - use crate::adapters::analyzers::iosp::ComplexityMetrics; - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/x.rs".to_string(), - vec![Suppression { - line: 5, - dimensions: vec![crate::findings::Dimension::Complexity], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis.results = vec![make_fa_with_complexity( - "src/x.rs", - 6, - ComplexityMetrics { - function_lines: 200, - ..Default::default() - }, - )]; - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert!(orphans.is_empty(), "got: {orphans:?}"); -} - -#[test] -fn suppressed_nesting_over_threshold_is_not_orphan() { - use crate::adapters::analyzers::iosp::ComplexityMetrics; - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/x.rs".to_string(), - vec![Suppression { - line: 5, - dimensions: vec![crate::findings::Dimension::Complexity], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis.results = vec![make_fa_with_complexity( - "src/x.rs", - 6, - ComplexityMetrics { - max_nesting: 10, - ..Default::default() - }, - )]; - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert!(orphans.is_empty(), "got: {orphans:?}"); -} - -#[test] -fn suppressed_unsafe_block_is_not_orphan() { - use crate::adapters::analyzers::iosp::ComplexityMetrics; - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/x.rs".to_string(), - vec![Suppression { - line: 5, - dimensions: vec![crate::findings::Dimension::Complexity], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis.results = vec![make_fa_with_complexity( - "src/x.rs", - 6, - ComplexityMetrics { - unsafe_blocks: 1, - ..Default::default() - }, - )]; - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert!(orphans.is_empty(), "got: {orphans:?}"); -} - -#[test] -fn suppressed_error_handling_unwrap_is_not_orphan() { - use crate::adapters::analyzers::iosp::ComplexityMetrics; - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/x.rs".to_string(), - vec![Suppression { - line: 5, - dimensions: vec![crate::findings::Dimension::Complexity], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis.results = vec![make_fa_with_complexity( - "src/x.rs", - 6, - ComplexityMetrics { - unwrap_count: 3, - ..Default::default() - }, - )]; - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert!(orphans.is_empty(), "got: {orphans:?}"); -} - -#[test] -fn suppressed_magic_number_is_not_orphan() { - use crate::adapters::analyzers::iosp::{ComplexityMetrics, MagicNumberOccurrence}; - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/x.rs".to_string(), - vec![Suppression { - line: 10, - dimensions: vec![crate::findings::Dimension::Complexity], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis.results = vec![make_fa_with_complexity( - "src/x.rs", - 6, - ComplexityMetrics { - magic_numbers: vec![MagicNumberOccurrence { - line: 12, - value: "42".into(), - }], - ..Default::default() - }, - )]; - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert!(orphans.is_empty(), "got: {orphans:?}"); -} - -#[test] -fn suppressed_srp_param_over_threshold_is_not_orphan() { - // A `// qual:allow(srp)` marker on a function with >5 parameters: - // `apply_parameter_warnings` now records the warning with - // suppressed=true (it used to filter them out), so the orphan - // checker finds a matching SRP position. - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/x.rs".to_string(), - vec![Suppression { - line: 5, - dimensions: vec![crate::findings::Dimension::Srp], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis - .findings - .srp - .push(make_srp_param_finding("src/x.rs", 6, true)); - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert!( - orphans.is_empty(), - "SRP param marker must match even on suppressed warnings, got: {orphans:?}" - ); -} - -#[test] -fn coupling_marker_is_not_orphan_for_structural_coupling_finding() { - // Structural binary checks (OI, SIT, DEH, IET) carry - // `dimension == Coupling` and are line-anchored — a 5-line - // qual:allow(coupling) window DOES suppress them. The orphan - // checker must treat coupling-only markers as verifiable when a - // line-anchored coupling position is available in the file. - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/foo.rs".to_string(), - vec![Suppression { - line: 10, - dimensions: vec![crate::findings::Dimension::Coupling], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis - .findings - .coupling - .push(make_structural_coupling_finding("src/foo.rs", 12)); - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert!( - orphans.is_empty(), - "coupling marker for a line-anchored structural finding must not be orphan, got: {orphans:?}" - ); -} - -#[test] -fn coupling_only_marker_with_no_line_anchored_finding_is_skipped() { - // When the file has no line-anchored Coupling position, a - // coupling-only marker is unverifiable (pure module-level - // coupling is global). We skip it rather than emit a - // potentially-false orphan. - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/foo.rs".to_string(), - vec![Suppression { - line: 5, - dimensions: vec![crate::findings::Dimension::Coupling], - reason: None, - }], - ); - let analysis = empty_analysis(); - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert!( - orphans.is_empty(), - "coupling-only marker without a line-anchored Coupling finding must be skipped, got: {orphans:?}" - ); -} - -#[test] -fn dry_marker_on_dead_code_only_is_orphan() { - // `qual:allow(dry)` does NOT suppress dead-code warnings (there - // is no mark_dead_code_suppressions pass — exclusions happen via - // qual:api / qual:test_helper / is_test / has_allow_dead_code). - // So a qual:allow(dry) marker whose only nearby finding is - // DEAD_CODE should be reported as orphan. - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/foo.rs".to_string(), - vec![Suppression { - line: 5, - dimensions: vec![crate::findings::Dimension::Dry], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis - .findings - .dry - .push(make_dry_dead_code_finding("src/foo.rs", 7)); - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert_eq!( - orphans.len(), - 1, - "dry marker near dead_code only must be orphan (dead_code not dry-suppressible), got: {orphans:?}" - ); -} - -#[test] -fn dry_marker_two_lines_above_wildcard_is_orphan() { - // `mark_wildcard_suppressions` accepts markers only on the same - // line or one line above. A marker two lines above the wildcard - // would NOT suppress it, so the orphan checker must report it. - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/foo.rs".to_string(), - vec![Suppression { - line: 5, - dimensions: vec![crate::findings::Dimension::Dry], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis - .findings - .dry - .push(make_dry_wildcard_finding("src/foo.rs", 7)); - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert_eq!( - orphans.len(), - 1, - "dry marker two lines above wildcard must be orphan (wildcard window is 1), got: {orphans:?}" - ); -} - -#[test] -fn dry_marker_one_line_above_wildcard_is_not_orphan() { - // Guard: the wildcard window is exactly 0 or 1 — same line or - // line above. 1-line distance must still count as non-orphan. - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/foo.rs".to_string(), - vec![Suppression { - line: 6, - dimensions: vec![crate::findings::Dimension::Dry], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis - .findings - .dry - .push(make_dry_wildcard_finding("src/foo.rs", 7)); - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert!( - orphans.is_empty(), - "dry marker one line above wildcard must not be orphan, got: {orphans:?}" - ); -} - -#[test] -fn complexity_marker_is_orphan_when_complexity_dimension_disabled() { - // Config disables the complexity dimension entirely. A - // `qual:allow(complexity)` marker can't suppress what doesn't - // run, so it IS orphan even on a function with over-threshold - // metrics. - use crate::adapters::analyzers::iosp::ComplexityMetrics; - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/x.rs".to_string(), - vec![Suppression { - line: 5, - dimensions: vec![crate::findings::Dimension::Complexity], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis.results = vec![make_fa_with_complexity( - "src/x.rs", - 6, - ComplexityMetrics { - cognitive_complexity: 99, - ..Default::default() - }, - )]; - let mut config = Config::default(); - config.complexity.enabled = false; - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &config, - ); - assert_eq!( - orphans.len(), - 1, - "complexity marker with dimension disabled must be orphan" - ); -} - -#[test] -fn srp_marker_is_orphan_when_srp_dimension_disabled() { - // Same pattern for SRP: disable the dimension, a qual:allow(srp) - // can't suppress anything → orphan even if a SrpWarning is in - // the analysis struct (stale from a previous run, or leftover). - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/foo.rs".to_string(), - vec![Suppression { - line: 2, - dimensions: vec![crate::findings::Dimension::Srp], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis - .findings - .srp - .push(make_srp_struct_finding("src/foo.rs", 7)); - let mut config = Config::default(); - config.srp.enabled = false; - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &config, - ); - assert_eq!( - orphans.len(), - 1, - "SRP marker with dimension disabled must be orphan" - ); -} - -#[test] -fn srp_struct_marker_within_5_line_window_is_not_orphan() { - // SRP struct suppressions use SRP_STRUCT_SUPPRESSION_WINDOW=5 - // (wider than ANNOTATION_WINDOW=3) because #[derive(...)] - // attributes can push the marker further from the struct. A - // marker at line 2 matching a struct at line 7 (diff=5) must not - // be flagged as orphan. - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/foo.rs".to_string(), - vec![Suppression { - line: 2, - dimensions: vec![crate::findings::Dimension::Srp], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis - .findings - .srp - .push(make_srp_struct_finding("src/foo.rs", 7)); - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert!( - orphans.is_empty(), - "SRP struct marker within the 5-line window must not be orphan, got: {orphans:?}" - ); -} - -#[test] -fn srp_module_marker_anywhere_in_file_is_not_orphan() { - // SRP module warnings are suppressed file-globally by - // `mark_srp_suppressions` — any qual:allow(srp) anywhere in the - // file matches. The orphan checker must not require line - // proximity for module-level SRP findings. - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/big.rs".to_string(), - vec![Suppression { - line: 500, - dimensions: vec![crate::findings::Dimension::Srp], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis - .findings - .srp - .push(make_srp_module_finding("src/big.rs")); - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert!( - orphans.is_empty(), - "SRP module marker at any line must match the file-global module finding, got: {orphans:?}" - ); -} - -#[test] -fn tq_marker_within_5_line_window_is_not_orphan() { - // TQ suppressions use a 5-line window (mark_tq_suppressions). - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/foo.rs".to_string(), - vec![Suppression { - line: 10, - dimensions: vec![crate::findings::Dimension::TestQuality], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis.findings.test_quality.push(make_tq_finding( - "src/foo.rs", - 15, - crate::domain::findings::TqFindingKind::NoAssertion, - )); - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert!( - orphans.is_empty(), - "TQ marker within 5-line window must not be orphan, got: {orphans:?}" - ); -} - -#[test] -fn structural_marker_within_5_line_window_is_not_orphan() { - // Structural binary checks use a 5-line window - // (mark_structural_suppressions). - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/foo.rs".to_string(), - vec![Suppression { - line: 10, - dimensions: vec![crate::findings::Dimension::Srp], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis - .findings - .srp - .push(make_structural_srp_finding("src/foo.rs", 15)); - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert!( - orphans.is_empty(), - "Structural marker within 5-line window must not be orphan, got: {orphans:?}" - ); -} - -#[test] -fn architecture_marker_only_matches_findings_in_window() { - // Architecture suppressions must be scoped to the marker's - // annotation window, not the whole file. A `qual:allow(architecture)` - // for one helper must not silence unrelated layer / forbidden / - // call-parity findings elsewhere in the same file, and the orphan - // checker must report a stale marker whose only architecture - // finding lives outside the window. - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/foo.rs".to_string(), - vec![Suppression { - line: 1, - dimensions: vec![crate::findings::Dimension::Architecture], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis - .findings - .architecture - .push(make_architecture_finding("src/foo.rs", 500)); - let mut config = Config::default(); - config.architecture.enabled = true; - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &config, - ); - assert!( - !orphans.is_empty(), - "Architecture marker at line 1 with only a finding at line 500 must \ - be reported as orphan (window-scoped, not file-scoped); got: {orphans:?}" - ); -} - -#[test] -fn complexity_marker_without_any_overshoot_is_orphan() { - // Sanity: if a marker truly has no target — all complexity metrics - // are within limits — it IS orphan. - use crate::adapters::analyzers::iosp::ComplexityMetrics; - use crate::findings::Suppression; - let mut sups = HashMap::new(); - sups.insert( - "src/x.rs".to_string(), - vec![Suppression { - line: 5, - dimensions: vec![crate::findings::Dimension::Complexity], - reason: None, - }], - ); - let mut analysis = empty_analysis(); - analysis.results = vec![make_fa_with_complexity( - "src/x.rs", - 6, - ComplexityMetrics { - cognitive_complexity: 1, - cyclomatic_complexity: 1, - function_lines: 5, - ..Default::default() - }, - )]; - let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( - &sups, - &std::collections::HashMap::new(), - &analysis, - &Config::default(), - ); - assert_eq!( - orphans.len(), - 1, - "marker with no over-threshold target must be orphan" - ); -} diff --git a/src/app/tests/warnings/exclude_and_error_handling.rs b/src/app/tests/warnings/exclude_and_error_handling.rs new file mode 100644 index 00000000..4e22d23c --- /dev/null +++ b/src/app/tests/warnings/exclude_and_error_handling.rs @@ -0,0 +1,110 @@ +use super::*; + +#[test] +fn test_exclude_test_violations_reclassifies() { + let mut fa = make_func_with_metrics(ComplexityMetrics::default()); + fa.is_test = true; + fa.classification = Classification::Violation { + has_logic: true, + has_own_calls: true, + logic_locations: vec![], + call_locations: vec![], + }; + fa.severity = Some(crate::adapters::analyzers::iosp::Severity::Low); + fa.effort_score = Some(3.0); + let mut results = vec![fa]; + exclude_test_violations(&mut results); + assert_eq!(results[0].classification, Classification::Trivial); + assert!(results[0].severity.is_none()); + assert!(results[0].effort_score.is_none()); +} + +#[test] +fn test_exclude_test_violations_keeps_non_test() { + let mut fa = make_func_with_metrics(ComplexityMetrics::default()); + fa.is_test = false; + fa.classification = Classification::Violation { + has_logic: true, + has_own_calls: true, + logic_locations: vec![], + call_locations: vec![], + }; + let mut results = vec![fa]; + exclude_test_violations(&mut results); + assert!(matches!( + results[0].classification, + Classification::Violation { .. } + )); +} + +// ── error handling skipped for tests ───────────────────────── + +#[test] +fn test_error_handling_skipped_for_test_fn() { + let config = Config::default(); + let mut summary = Summary::default(); + let mut fa = make_func_with_metrics(ComplexityMetrics { + unwrap_count: 3, + ..Default::default() + }); + fa.is_test = true; + let mut results = vec![fa]; + apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); + assert!(!results[0].error_handling_warning); + assert_eq!(summary.error_handling_warnings, 0); +} + +#[test] +fn test_error_handling_flagged_for_non_test_fn() { + let config = Config::default(); + let mut summary = Summary::default(); + let mut fa = make_func_with_metrics(ComplexityMetrics { + unwrap_count: 1, + ..Default::default() + }); + fa.is_test = false; + let mut results = vec![fa]; + apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); + assert!(results[0].error_handling_warning); + assert_eq!(summary.error_handling_warnings, 1); +} + +#[test] +fn test_unsafe_suppressed_by_allow_annotation() { + let config = Config::default(); + let mut summary = Summary::default(); + let mut fa = make_func_with_metrics(ComplexityMetrics { + unsafe_blocks: 1, + ..Default::default() + }); + fa.line = 5; + let mut results = vec![fa]; + + // qual:allow(unsafe) on line 4 (one line before fn at line 5) + let unsafe_lines: HashMap> = + [("test.rs".to_string(), [4].into_iter().collect())].into(); + + apply_extended_warnings(&mut results, &config, &mut summary, &unsafe_lines); + assert!( + !results[0].unsafe_warning, + "qual:allow(unsafe) should suppress unsafe warning" + ); + assert_eq!(summary.unsafe_warnings, 0); +} + +#[test] +fn test_unsafe_without_allow_still_warned() { + let config = Config::default(); + let mut summary = Summary::default(); + let mut results = vec![make_func_with_metrics(ComplexityMetrics { + unsafe_blocks: 1, + ..Default::default() + })]; + + apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); + assert!( + results[0].unsafe_warning, + "Without annotation, unsafe should still warn" + ); + assert_eq!(summary.unsafe_warnings, 1); +} diff --git a/src/app/tests/warnings/extended_warnings.rs b/src/app/tests/warnings/extended_warnings.rs new file mode 100644 index 00000000..f5c0b7dc --- /dev/null +++ b/src/app/tests/warnings/extended_warnings.rs @@ -0,0 +1,203 @@ +use super::*; + +#[test] +fn count_rust_allow_attrs_excludes_test_module_attrs() { + // Only production `#[allow(...)]` attrs count toward the suppression + // ratio — attrs that belong to a `#[cfg(test)] mod tests` attribute + // group (contiguous, no blank-line gap) or live inside it are excluded. + // (label, source, expected) + let cases: &[(&str, &str, usize)] = &[ + ( + // #[allow] directly before #[cfg(test)] belongs to the test module + "allow directly before cfg(test)", + "#[allow(dead_code)]\n#[cfg(test)]\nmod tests {}", + 0, + ), + ( + // a non-attribute line breaks the group → production code + "allow with a gap before cfg(test)", + "#[allow(dead_code)]\nfn foo() {}\n#[cfg(test)]\nmod tests {}", + 1, + ), + ( + // #[derive] + #[allow] both part of the test-module attr group + "derive and allow before cfg(test)", + "#[derive(Debug)]\n#[allow(dead_code)]\n#[cfg(test)]\nmod tests {}", + 0, + ), + ( + "no cfg(test) counts all", + "#[allow(dead_code)]\nfn foo() {}\n#[allow(unused)]\nfn bar() {}", + 2, + ), + ( + "cfg(test) on the first line", + "#[cfg(test)]\nmod tests {\n#[allow(dead_code)]\nfn x() {}\n}", + 0, + ), + ("empty source", "", 0), + ( + // blank-line gap separates a production allow from the test section + "production allow before the test section", + "#[allow(clippy::too_many_arguments)]\nfn big() {}\n\n#[cfg(test)]\nmod tests {}", + 1, + ), + ( + "allow inside the test module", + "fn good() {}\n#[cfg(test)]\nmod tests {\n#[allow(dead_code)]\nfn helper() {}\n}", + 0, + ), + ]; + for (label, source, expected) in cases { + assert_eq!(count_rust_allow_attrs(source), *expected, "case {label}"); + } +} + +#[test] +fn extended_warning_flags_set_over_threshold() { + // Each metric over its threshold sets the matching per-function warning + // flag and increments the matching summary counter exactly once. + // (label, metrics, flag, count) + let cases: &[(&str, ComplexityMetrics, FlagFn, CountFn)] = &[ + ( + "nesting depth > 4", + ComplexityMetrics { + max_nesting: 5, + ..Default::default() + }, + (|f| f.nesting_depth_warning) as FlagFn, + (|s| s.nesting_depth_warnings) as CountFn, + ), + ( + "function length > 60", + ComplexityMetrics { + function_lines: 61, + ..Default::default() + }, + |f| f.function_length_warning, + |s| s.function_length_warnings, + ), + ( + "unsafe block present", + ComplexityMetrics { + unsafe_blocks: 1, + ..Default::default() + }, + |f| f.unsafe_warning, + |s| s.unsafe_warnings, + ), + ( + "unwrap present", + ComplexityMetrics { + unwrap_count: 1, + ..Default::default() + }, + |f| f.error_handling_warning, + |s| s.error_handling_warnings, + ), + ]; + for (label, metrics, flag, count) in cases { + let (f, s) = apply_warnings( + make_func_with_metrics(metrics.clone()), + &Config::default(), + &HashMap::new(), + ); + assert!(flag(&f), "case {label}: flag should be set"); + assert_eq!(count(&s), 1, "case {label}: summary count"); + } +} + +#[test] +fn test_nesting_depth_at_threshold_no_warning() { + let config = Config::default(); + let mut summary = Summary::default(); + let mut results = vec![make_func_with_metrics(ComplexityMetrics { + max_nesting: 4, + ..Default::default() + })]; + apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); + assert!(!results[0].nesting_depth_warning, "4 == threshold, no warn"); +} + +#[test] +fn test_function_length_at_threshold_no_warning() { + let config = Config::default(); + let mut summary = Summary::default(); + let mut results = vec![make_func_with_metrics(ComplexityMetrics { + function_lines: 60, + ..Default::default() + })]; + apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); + assert!( + !results[0].function_length_warning, + "60 == threshold, no warn" + ); +} + +#[test] +fn test_error_handling_expect_allowed() { + let mut config = Config::default(); + config.complexity.allow_expect = true; + let mut summary = Summary::default(); + let mut results = vec![make_func_with_metrics(ComplexityMetrics { + expect_count: 3, + ..Default::default() + })]; + apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); + assert!( + !results[0].error_handling_warning, + "expect allowed, no warn" + ); +} + +#[test] +fn test_error_handling_expect_not_allowed() { + let mut config = Config::default(); + config.complexity.allow_expect = false; + let mut summary = Summary::default(); + let mut results = vec![make_func_with_metrics(ComplexityMetrics { + expect_count: 1, + ..Default::default() + })]; + apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); + assert!( + results[0].error_handling_warning, + "expect not allowed, should warn" + ); +} + +#[test] +fn test_suppressed_functions_skipped() { + let config = Config::default(); + let mut summary = Summary::default(); + let mut func = make_func_with_metrics(ComplexityMetrics { + max_nesting: 10, + function_lines: 100, + unsafe_blocks: 3, + unwrap_count: 5, + ..Default::default() + }); + func.suppressed = true; + let mut results = vec![func]; + apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); + assert!(!results[0].nesting_depth_warning); + assert!(!results[0].function_length_warning); + assert!(!results[0].unsafe_warning); + assert!(!results[0].error_handling_warning); +} + +#[test] +fn test_complexity_suppressed_functions_skipped() { + let config = Config::default(); + let mut summary = Summary::default(); + let mut func = make_func_with_metrics(ComplexityMetrics { + max_nesting: 10, + function_lines: 100, + ..Default::default() + }); + func.complexity_suppressed = true; + let mut results = vec![func]; + apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); + assert!(!results[0].nesting_depth_warning); + assert!(!results[0].function_length_warning); +} diff --git a/src/app/tests/warnings/mod.rs b/src/app/tests/warnings/mod.rs new file mode 100644 index 00000000..c060f82d --- /dev/null +++ b/src/app/tests/warnings/mod.rs @@ -0,0 +1,136 @@ +//! Tests for `app::warnings` — rust-allow counting, extended-warning flag +//! application, test-violation exclusion, and orphan-suppression detection. +//! Split into focused sub-files (each ≤ the SRP file-length cap); shared +//! imports + the apply_warnings / *_orphan_count helpers live here (the +//! orphan finding-builders live in `orphan_support`, re-exported below) and +//! reach the sub-modules via `use super::*`. + +pub(super) use crate::adapters::analyzers::iosp::{ + Classification, ComplexityMetrics, FunctionAnalysis, +}; +pub(super) use crate::app::warnings::*; +pub(super) use crate::config::Config; +pub(super) use crate::report::Summary; +pub(super) use std::collections::{HashMap, HashSet}; + +mod exclude_and_error_handling; +mod extended_warnings; +mod orphan_basics_and_suppression; +mod orphan_dry_and_disabled; +mod orphan_module_tq_arch; +mod orphan_support; +pub(super) use orphan_support::*; + +// ── apply_extended_warnings ─────────────────────────────────── + +pub(super) use crate::adapters::analyzers::iosp::compute_severity; + +pub(super) fn make_func_with_metrics(metrics: ComplexityMetrics) -> FunctionAnalysis { + let severity = compute_severity(&Classification::Operation); + FunctionAnalysis { + name: "test_fn".to_string(), + file: "test.rs".to_string(), + line: 1, + classification: Classification::Operation, + parent_type: None, + suppressed: false, + complexity: Some(metrics), + qualified_name: "test_fn".to_string(), + severity, + cognitive_warning: false, + cyclomatic_warning: false, + nesting_depth_warning: false, + function_length_warning: false, + unsafe_warning: false, + error_handling_warning: false, + complexity_suppressed: false, + own_calls: vec![], + parameter_count: 0, + is_trait_impl: false, + effort_score: None, + is_test: false, + } +} + +/// Run `apply_extended_warnings` over a single function and return the +/// (possibly flag-mutated) function plus the populated summary. +pub(super) fn apply_warnings( + func: FunctionAnalysis, + config: &Config, + unsafe_lines: &HashMap>, +) -> (FunctionAnalysis, Summary) { + let mut summary = Summary::default(); + let mut results = vec![func]; + apply_extended_warnings(&mut results, config, &mut summary, unsafe_lines); + (results.into_iter().next().unwrap(), summary) +} + +pub(super) type FlagFn = fn(&FunctionAnalysis) -> bool; +pub(super) type CountFn = fn(&Summary) -> usize; + +// ── Regression tests: no false-positive orphans when the marker ── +// ── clears warning flags via suppression. ── +// +// These tests reproduce the Bug 3 iteration where my first orphan +// checker read `fa.cognitive_warning` and friends — flags that +// `apply_file_suppressions` clears when `// qual:allow(complexity)` +// matches. The checker then saw no position and flagged the marker +// as orphan, even though it was actively doing its job. The fixed +// checker reads raw `complexity` metrics against config thresholds, +// independent of the suppression flags. + +pub(super) fn make_fa_with_complexity( + file: &str, + line: usize, + metrics: crate::adapters::analyzers::iosp::ComplexityMetrics, +) -> FunctionAnalysis { + FunctionAnalysis { + name: "f".into(), + qualified_name: "f".into(), + file: file.into(), + line, + classification: Classification::Operation, + parent_type: None, + suppressed: false, + complexity: Some(metrics), + severity: None, + cognitive_warning: false, + cyclomatic_warning: false, + nesting_depth_warning: false, + function_length_warning: false, + unsafe_warning: false, + error_handling_warning: false, + complexity_suppressed: true, + own_calls: vec![], + parameter_count: 0, + is_trait_impl: false, + is_test: false, + effort_score: None, + } +} + +/// Run the orphan detector for a single `qual:allow(complexity)` marker at +/// `sup_line` against a function at `fn_line` carrying `metrics`. +pub(super) fn complexity_sup_orphans( + sup_line: usize, + fn_line: usize, + metrics: crate::adapters::analyzers::iosp::ComplexityMetrics, +) -> Vec { + let mut sups = HashMap::new(); + sups.insert( + "src/x.rs".to_string(), + vec![crate::findings::Suppression { + line: sup_line, + dimensions: vec![crate::findings::Dimension::Complexity], + reason: None, + }], + ); + let mut analysis = empty_analysis(); + analysis.results = vec![make_fa_with_complexity("src/x.rs", fn_line, metrics)]; + crate::app::orphan_suppressions::detect_orphan_suppressions( + &sups, + &std::collections::HashMap::new(), + &analysis, + &Config::default(), + ) +} diff --git a/src/app/tests/warnings/orphan_basics_and_suppression.rs b/src/app/tests/warnings/orphan_basics_and_suppression.rs new file mode 100644 index 00000000..45101c71 --- /dev/null +++ b/src/app/tests/warnings/orphan_basics_and_suppression.rs @@ -0,0 +1,218 @@ +use super::*; + +#[test] +fn orphan_suppression_window_and_dimension_matching() { + // An orphan is a marker with no matching in-window finding. The marker + // (line 5) matches an SRP finding within ANNOTATION_WINDOW=3 lines that + // shares its dimension; a wrong dimension still orphans; an empty-dim + // marker acts as a wildcard (defensive — the parser no longer emits one). + // (label, dims, finding_line, expected_orphans) + use crate::findings::Dimension; + let cases: &[(&str, &[Dimension], Option, usize)] = &[ + ("unmatched marker, no finding", &[Dimension::Srp], None, 1), + ("in-window finding matches", &[Dimension::Srp], Some(8), 0), + ("dimension mismatch orphans", &[Dimension::Dry], Some(7), 1), + ("empty-dim acts as wildcard", &[], Some(6), 0), + ]; + for (label, dims, finding_line, expected) in cases { + assert_eq!( + srp_orphan_count(dims, *finding_line), + *expected, + "case {label}" + ); + } +} + +/// Flag-style complexity metrics (cognitive / cyclomatic / length / nesting), +/// each over its threshold: `(label, sup_line, fn_line, metrics)`. +fn complexity_flag_cases() -> Vec<(&'static str, usize, usize, ComplexityMetrics)> { + vec![ + ( + "cognitive", + 5, + 6, + ComplexityMetrics { + cognitive_complexity: 99, + ..Default::default() + }, + ), + ( + "cyclomatic", + 5, + 6, + ComplexityMetrics { + cyclomatic_complexity: 99, + ..Default::default() + }, + ), + ( + "function length", + 5, + 6, + ComplexityMetrics { + function_lines: 200, + ..Default::default() + }, + ), + ( + "nesting", + 5, + 6, + ComplexityMetrics { + max_nesting: 10, + ..Default::default() + }, + ), + ] +} + +/// The remaining over-threshold metric kinds: unsafe blocks, unwrap count, and +/// a magic number. `(label, sup_line, fn_line, metrics)`. +fn complexity_metric_extra_cases() -> Vec<(&'static str, usize, usize, ComplexityMetrics)> { + use crate::adapters::analyzers::iosp::MagicNumberOccurrence; + vec![ + ( + "unsafe block", + 5, + 6, + ComplexityMetrics { + unsafe_blocks: 1, + ..Default::default() + }, + ), + ( + "error handling unwrap", + 5, + 6, + ComplexityMetrics { + unwrap_count: 3, + ..Default::default() + }, + ), + ( + "magic number", + 10, + 6, + ComplexityMetrics { + magic_numbers: vec![MagicNumberOccurrence { + line: 12, + value: "42".into(), + }], + ..Default::default() + }, + ), + ] +} + +#[test] +fn suppressed_complexity_metric_over_threshold_is_not_orphan() { + // A `qual:allow(complexity)` marker clears the matching *_warning flag, but + // the orphan detector reads RAW metrics against config thresholds — when the + // raw metric still exceeds threshold the marker matches a real (suppressed) + // finding and must NOT be flagged orphan. Covers every complexity metric kind. + let mut cases = complexity_flag_cases(); + cases.extend(complexity_metric_extra_cases()); + for (label, sup_line, fn_line, metrics) in &cases { + let orphans = complexity_sup_orphans(*sup_line, *fn_line, metrics.clone()); + assert!( + orphans.is_empty(), + "case {label}: marker clearing a complexity flag must not be orphan, got {orphans:?}" + ); + } +} + +#[test] +fn suppressed_srp_param_over_threshold_is_not_orphan() { + // A `// qual:allow(srp)` marker on a function with >5 parameters: + // `apply_parameter_warnings` now records the warning with + // suppressed=true (it used to filter them out), so the orphan + // checker finds a matching SRP position. + use crate::findings::Suppression; + let mut sups = HashMap::new(); + sups.insert( + "src/x.rs".to_string(), + vec![Suppression { + line: 5, + dimensions: vec![crate::findings::Dimension::Srp], + reason: None, + }], + ); + let mut analysis = empty_analysis(); + analysis + .findings + .srp + .push(make_srp_param_finding("src/x.rs", 6, true)); + let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( + &sups, + &std::collections::HashMap::new(), + &analysis, + &Config::default(), + ); + assert!( + orphans.is_empty(), + "SRP param marker must match even on suppressed warnings, got: {orphans:?}" + ); +} + +#[test] +fn coupling_marker_is_not_orphan_for_structural_coupling_finding() { + // Structural binary checks (OI, SIT, DEH, IET) carry + // `dimension == Coupling` and are line-anchored — a 5-line + // qual:allow(coupling) window DOES suppress them. The orphan + // checker must treat coupling-only markers as verifiable when a + // line-anchored coupling position is available in the file. + use crate::findings::Suppression; + let mut sups = HashMap::new(); + sups.insert( + "src/foo.rs".to_string(), + vec![Suppression { + line: 10, + dimensions: vec![crate::findings::Dimension::Coupling], + reason: None, + }], + ); + let mut analysis = empty_analysis(); + analysis + .findings + .coupling + .push(make_structural_coupling_finding("src/foo.rs", 12)); + let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( + &sups, + &std::collections::HashMap::new(), + &analysis, + &Config::default(), + ); + assert!( + orphans.is_empty(), + "coupling marker for a line-anchored structural finding must not be orphan, got: {orphans:?}" + ); +} + +#[test] +fn coupling_only_marker_with_no_line_anchored_finding_is_skipped() { + // When the file has no line-anchored Coupling position, a + // coupling-only marker is unverifiable (pure module-level + // coupling is global). We skip it rather than emit a + // potentially-false orphan. + use crate::findings::Suppression; + let mut sups = HashMap::new(); + sups.insert( + "src/foo.rs".to_string(), + vec![Suppression { + line: 5, + dimensions: vec![crate::findings::Dimension::Coupling], + reason: None, + }], + ); + let analysis = empty_analysis(); + let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( + &sups, + &std::collections::HashMap::new(), + &analysis, + &Config::default(), + ); + assert!( + orphans.is_empty(), + "coupling-only marker without a line-anchored Coupling finding must be skipped, got: {orphans:?}" + ); +} diff --git a/src/app/tests/warnings/orphan_dry_and_disabled.rs b/src/app/tests/warnings/orphan_dry_and_disabled.rs new file mode 100644 index 00000000..4e253941 --- /dev/null +++ b/src/app/tests/warnings/orphan_dry_and_disabled.rs @@ -0,0 +1,176 @@ +use super::*; + +#[test] +fn dry_marker_orphan_depends_on_finding_kind_and_window() { + // `qual:allow(dry)` matches a line-anchored DRY finding only within the + // relevant window. DEAD_CODE isn't dry-suppressible at all → orphan; a + // wildcard finding has a 1-line window, so a marker 2 lines above is + // orphan but 1 line above is not. (label, sup_line, finding, expected) + type DryMaker = fn(&str, usize) -> crate::domain::findings::DryFinding; + let cases: &[(&str, usize, DryMaker, usize)] = &[ + ( + "dead_code is not dry-suppressible → orphan", + 5, + make_dry_dead_code_finding, + 1, + ), + ( + "two lines above a wildcard (window 1) → orphan", + 5, + make_dry_wildcard_finding, + 1, + ), + ( + "one line above a wildcard (window 1) → not orphan", + 6, + make_dry_wildcard_finding, + 0, + ), + ]; + for (label, sup_line, finding, expected) in cases { + let mut sups = HashMap::new(); + sups.insert( + "src/foo.rs".to_string(), + vec![crate::findings::Suppression { + line: *sup_line, + dimensions: vec![crate::findings::Dimension::Dry], + reason: None, + }], + ); + let mut analysis = empty_analysis(); + analysis.findings.dry.push(finding("src/foo.rs", 7)); + let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( + &sups, + &std::collections::HashMap::new(), + &analysis, + &Config::default(), + ); + assert_eq!(orphans.len(), *expected, "case {label}: got {orphans:?}"); + } +} + +#[test] +fn complexity_marker_is_orphan_when_complexity_dimension_disabled() { + // Config disables the complexity dimension entirely. A + // `qual:allow(complexity)` marker can't suppress what doesn't + // run, so it IS orphan even on a function with over-threshold + // metrics. + use crate::adapters::analyzers::iosp::ComplexityMetrics; + use crate::findings::Suppression; + let mut sups = HashMap::new(); + sups.insert( + "src/x.rs".to_string(), + vec![Suppression { + line: 5, + dimensions: vec![crate::findings::Dimension::Complexity], + reason: None, + }], + ); + let mut analysis = empty_analysis(); + analysis.results = vec![make_fa_with_complexity( + "src/x.rs", + 6, + ComplexityMetrics { + cognitive_complexity: 99, + ..Default::default() + }, + )]; + let mut config = Config::default(); + config.complexity.enabled = false; + let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( + &sups, + &std::collections::HashMap::new(), + &analysis, + &config, + ); + assert_eq!( + orphans.len(), + 1, + "complexity marker with dimension disabled must be orphan" + ); +} + +#[test] +fn srp_marker_is_orphan_when_srp_dimension_disabled() { + // Same pattern for SRP: disable the dimension, a qual:allow(srp) + // can't suppress anything → orphan even if a SrpWarning is in + // the analysis struct (stale from a previous run, or leftover). + use crate::findings::Suppression; + let mut sups = HashMap::new(); + sups.insert( + "src/foo.rs".to_string(), + vec![Suppression { + line: 2, + dimensions: vec![crate::findings::Dimension::Srp], + reason: None, + }], + ); + let mut analysis = empty_analysis(); + analysis + .findings + .srp + .push(make_srp_struct_finding("src/foo.rs", 7)); + let mut config = Config::default(); + config.srp.enabled = false; + let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( + &sups, + &std::collections::HashMap::new(), + &analysis, + &config, + ); + assert_eq!( + orphans.len(), + 1, + "SRP marker with dimension disabled must be orphan" + ); +} + +#[test] +fn srp_marker_within_5_line_window_is_not_orphan() { + // SRP struct + structural-binary suppressions both use a 5-line window + // (wider than ANNOTATION_WINDOW=3) because `#[derive(...)]` attributes + // can push the marker further from the item. A `qual:allow(srp)` marker + // matching an in-window SRP finding must not be flagged as orphan. + // (label, sup_line, finding_line, finding maker) + type SrpMaker = fn(&str, usize) -> crate::domain::findings::SrpFinding; + let cases: &[(&str, usize, usize, SrpMaker)] = &[ + ( + "struct finding at diff=5", + 2, + 7, + make_srp_struct_finding as SrpMaker, + ), + ( + "structural-binary finding at diff=5", + 10, + 15, + make_structural_srp_finding, + ), + ]; + for (label, sup_line, finding_line, maker) in cases { + let mut sups = HashMap::new(); + sups.insert( + "src/foo.rs".to_string(), + vec![crate::findings::Suppression { + line: *sup_line, + dimensions: vec![crate::findings::Dimension::Srp], + reason: None, + }], + ); + let mut analysis = empty_analysis(); + analysis + .findings + .srp + .push(maker("src/foo.rs", *finding_line)); + let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( + &sups, + &std::collections::HashMap::new(), + &analysis, + &Config::default(), + ); + assert!( + orphans.is_empty(), + "case {label}: in-window SRP marker must not be orphan, got {orphans:?}" + ); + } +} diff --git a/src/app/tests/warnings/orphan_module_tq_arch.rs b/src/app/tests/warnings/orphan_module_tq_arch.rs new file mode 100644 index 00000000..a5c280d3 --- /dev/null +++ b/src/app/tests/warnings/orphan_module_tq_arch.rs @@ -0,0 +1,142 @@ +use super::*; + +#[test] +fn srp_module_marker_anywhere_in_file_is_not_orphan() { + // SRP module warnings are suppressed file-globally by + // `mark_srp_suppressions` — any qual:allow(srp) anywhere in the + // file matches. The orphan checker must not require line + // proximity for module-level SRP findings. + use crate::findings::Suppression; + let mut sups = HashMap::new(); + sups.insert( + "src/big.rs".to_string(), + vec![Suppression { + line: 500, + dimensions: vec![crate::findings::Dimension::Srp], + reason: None, + }], + ); + let mut analysis = empty_analysis(); + analysis + .findings + .srp + .push(make_srp_module_finding("src/big.rs")); + let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( + &sups, + &std::collections::HashMap::new(), + &analysis, + &Config::default(), + ); + assert!( + orphans.is_empty(), + "SRP module marker at any line must match the file-global module finding, got: {orphans:?}" + ); +} + +#[test] +fn tq_marker_within_5_line_window_is_not_orphan() { + // TQ suppressions use a 5-line window (mark_tq_suppressions). + use crate::findings::Suppression; + let mut sups = HashMap::new(); + sups.insert( + "src/foo.rs".to_string(), + vec![Suppression { + line: 10, + dimensions: vec![crate::findings::Dimension::TestQuality], + reason: None, + }], + ); + let mut analysis = empty_analysis(); + analysis.findings.test_quality.push(make_tq_finding( + "src/foo.rs", + 15, + crate::domain::findings::TqFindingKind::NoAssertion, + )); + let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( + &sups, + &std::collections::HashMap::new(), + &analysis, + &Config::default(), + ); + assert!( + orphans.is_empty(), + "TQ marker within 5-line window must not be orphan, got: {orphans:?}" + ); +} + +#[test] +fn architecture_marker_only_matches_findings_in_window() { + // Architecture suppressions must be scoped to the marker's + // annotation window, not the whole file. A `qual:allow(architecture)` + // for one helper must not silence unrelated layer / forbidden / + // call-parity findings elsewhere in the same file, and the orphan + // checker must report a stale marker whose only architecture + // finding lives outside the window. + use crate::findings::Suppression; + let mut sups = HashMap::new(); + sups.insert( + "src/foo.rs".to_string(), + vec![Suppression { + line: 1, + dimensions: vec![crate::findings::Dimension::Architecture], + reason: None, + }], + ); + let mut analysis = empty_analysis(); + analysis + .findings + .architecture + .push(make_architecture_finding("src/foo.rs", 500)); + let mut config = Config::default(); + config.architecture.enabled = true; + let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( + &sups, + &std::collections::HashMap::new(), + &analysis, + &config, + ); + assert!( + !orphans.is_empty(), + "Architecture marker at line 1 with only a finding at line 500 must \ + be reported as orphan (window-scoped, not file-scoped); got: {orphans:?}" + ); +} + +#[test] +fn complexity_marker_without_any_overshoot_is_orphan() { + // Sanity: if a marker truly has no target — all complexity metrics + // are within limits — it IS orphan. + use crate::adapters::analyzers::iosp::ComplexityMetrics; + use crate::findings::Suppression; + let mut sups = HashMap::new(); + sups.insert( + "src/x.rs".to_string(), + vec![Suppression { + line: 5, + dimensions: vec![crate::findings::Dimension::Complexity], + reason: None, + }], + ); + let mut analysis = empty_analysis(); + analysis.results = vec![make_fa_with_complexity( + "src/x.rs", + 6, + ComplexityMetrics { + cognitive_complexity: 1, + cyclomatic_complexity: 1, + function_lines: 5, + ..Default::default() + }, + )]; + let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( + &sups, + &std::collections::HashMap::new(), + &analysis, + &Config::default(), + ); + assert_eq!( + orphans.len(), + 1, + "marker with no over-threshold target must be orphan" + ); +} diff --git a/src/app/tests/warnings/orphan_support.rs b/src/app/tests/warnings/orphan_support.rs new file mode 100644 index 00000000..e051bcb9 --- /dev/null +++ b/src/app/tests/warnings/orphan_support.rs @@ -0,0 +1,233 @@ +//! Orphan-suppression finding-builder fixtures for the warnings tests +//! (extracted so mod.rs stays ≤ the SRP file-length cap). + +use super::*; + +// ── detect_orphan_suppressions ───────────────────────────────── + +pub(crate) fn empty_analysis() -> crate::report::AnalysisResult { + crate::report::AnalysisResult { + results: vec![], + summary: Summary::default(), + findings: crate::domain::AnalysisFindings::default(), + data: crate::domain::AnalysisData::default(), + } +} + +pub(crate) fn make_finding( + file: &str, + line: usize, + dimension: crate::findings::Dimension, + rule_id: &str, +) -> crate::domain::Finding { + crate::domain::Finding { + file: file.into(), + line, + column: 0, + dimension, + rule_id: rule_id.into(), + message: String::new(), + severity: crate::domain::Severity::Medium, + suppressed: false, + } +} + +pub(crate) fn make_srp_struct_finding( + file: &str, + line: usize, +) -> crate::domain::findings::SrpFinding { + crate::domain::findings::SrpFinding { + common: make_finding( + file, + line, + crate::findings::Dimension::Srp, + "srp/struct_cohesion", + ), + kind: crate::domain::findings::SrpFindingKind::StructCohesion, + details: crate::domain::findings::SrpFindingDetails::StructCohesion { + struct_name: "Foo".into(), + lcom4: 3, + field_count: 5, + method_count: 5, + fan_out: 2, + composite_score: 0.0, + clusters: vec![], + }, + } +} + +pub(crate) fn make_srp_module_finding(file: &str) -> crate::domain::findings::SrpFinding { + crate::domain::findings::SrpFinding { + common: make_finding( + file, + 1, + crate::findings::Dimension::Srp, + "srp/module_length", + ), + kind: crate::domain::findings::SrpFindingKind::ModuleLength, + details: crate::domain::findings::SrpFindingDetails::ModuleLength { + module: file.into(), + production_lines: 900, + independent_clusters: 1, + cluster_names: vec![], + length_score: 0.0, + }, + } +} + +pub(crate) fn make_srp_param_finding( + file: &str, + line: usize, + suppressed: bool, +) -> crate::domain::findings::SrpFinding { + let mut common = make_finding( + file, + line, + crate::findings::Dimension::Srp, + "srp/parameter_count", + ); + common.suppressed = suppressed; + crate::domain::findings::SrpFinding { + common, + kind: crate::domain::findings::SrpFindingKind::ParameterCount, + details: crate::domain::findings::SrpFindingDetails::ParameterCount { + function_name: "big_factory".into(), + parameter_count: 7, + }, + } +} + +pub(crate) fn make_tq_finding( + file: &str, + line: usize, + kind: crate::domain::findings::TqFindingKind, +) -> crate::domain::findings::TqFinding { + crate::domain::findings::TqFinding { + common: make_finding( + file, + line, + crate::findings::Dimension::TestQuality, + "tq/no_assertion", + ), + kind, + function_name: "test_it".into(), + uncovered_lines: None, + } +} + +pub(crate) fn make_dry_dead_code_finding( + file: &str, + line: usize, +) -> crate::domain::findings::DryFinding { + crate::domain::findings::DryFinding { + common: make_finding( + file, + line, + crate::findings::Dimension::Dry, + "dry/dead_code/uncalled", + ), + kind: crate::domain::findings::DryFindingKind::DeadCodeUncalled, + details: crate::domain::findings::DryFindingDetails::DeadCode { + qualified_name: "helper".into(), + suggestion: None, + }, + } +} + +pub(crate) fn make_dry_wildcard_finding( + file: &str, + line: usize, +) -> crate::domain::findings::DryFinding { + crate::domain::findings::DryFinding { + common: make_finding(file, line, crate::findings::Dimension::Dry, "dry/wildcard"), + kind: crate::domain::findings::DryFindingKind::Wildcard, + details: crate::domain::findings::DryFindingDetails::Wildcard { + module_path: "foo::*".into(), + }, + } +} + +pub(crate) fn make_structural_srp_finding( + file: &str, + line: usize, +) -> crate::domain::findings::SrpFinding { + crate::domain::findings::SrpFinding { + common: make_finding( + file, + line, + crate::findings::Dimension::Srp, + "srp/structural/SLM", + ), + kind: crate::domain::findings::SrpFindingKind::Structural, + details: crate::domain::findings::SrpFindingDetails::Structural { + item_name: "Foo::bar".into(), + code: "SLM".into(), + detail: "selfless method".into(), + }, + } +} + +pub(crate) fn make_structural_coupling_finding( + file: &str, + line: usize, +) -> crate::domain::findings::CouplingFinding { + crate::domain::findings::CouplingFinding { + common: make_finding( + file, + line, + crate::findings::Dimension::Coupling, + "coupling/structural/SIT", + ), + kind: crate::domain::findings::CouplingFindingKind::Structural, + details: crate::domain::findings::CouplingFindingDetails::Structural { + item_name: "Foo".into(), + code: "SIT".into(), + detail: "single-impl trait".into(), + }, + } +} + +pub(crate) fn make_architecture_finding( + file: &str, + line: usize, +) -> crate::domain::findings::ArchitectureFinding { + crate::domain::findings::ArchitectureFinding { + common: make_finding( + file, + line, + crate::findings::Dimension::Architecture, + "architecture::layer", + ), + } +} + +/// Count orphan suppressions for a single marker at line 5 carrying `dims`, +/// against an analysis with an optional SRP-struct finding at `finding_line`. +pub(crate) fn srp_orphan_count( + dims: &[crate::findings::Dimension], + finding_line: Option, +) -> usize { + let mut sups = HashMap::new(); + sups.insert( + "src/foo.rs".to_string(), + vec![crate::findings::Suppression { + line: 5, + dimensions: dims.to_vec(), + reason: None, + }], + ); + let mut analysis = empty_analysis(); + if let Some(line) = finding_line { + analysis + .findings + .srp + .push(make_srp_struct_finding("src/foo.rs", line)); + } + crate::app::orphan_suppressions::detect_orphan_suppressions( + &sups, + &std::collections::HashMap::new(), + &analysis, + &Config::default(), + ) + .len() +} diff --git a/src/app/warnings.rs b/src/app/warnings.rs index 75ce0e35..f10c6b64 100644 --- a/src/app/warnings.rs +++ b/src/app/warnings.rs @@ -137,18 +137,18 @@ fn has_error_handling_issue( > 0) } -/// Check if a function exceeds the length threshold in production code. -/// Tests are excluded — arrange-act-assert sequences are legitimately long. -/// Operation: trivial field read. -fn is_production_length_over( +/// Check if a function exceeds the LONG_FN length threshold. Test fns use the +/// `[tests].max_function_lines` override (which defaults to the production +/// limit); production fns use `[complexity].max_function_lines`. +/// Operation: threshold selection + comparison. +fn is_length_over( fa: &FunctionAnalysis, m: &crate::adapters::analyzers::iosp::ComplexityMetrics, - max_lines: usize, + prod_max: usize, + test_max: usize, ) -> bool { - if fa.is_test { - return false; - } - m.function_lines > max_lines + let max = if fa.is_test { test_max } else { prod_max }; + m.function_lines > max } /// Check if a function has a `// qual:allow(unsafe)` annotation within the window. @@ -174,6 +174,7 @@ pub(super) fn apply_extended_warnings( } let max_nesting = config.complexity.max_nesting_depth; let max_lines = config.complexity.max_function_lines; + let test_max_lines = config.tests.max_function_lines.unwrap_or(max_lines); let check_unsafe = config.complexity.detect_unsafe; let check_errors = config.complexity.detect_error_handling; let expect_threshold = if config.complexity.allow_expect { 0 } else { 1 }; @@ -190,11 +191,11 @@ pub(super) fn apply_extended_warnings( has_error_handling_issue(fa, m, check_errors, expect_threshold) }; - // Tests legitimately contain long arrange-act-assert sequences; skip - // LONG_FN for them to keep the check focused on production code. + // LONG_FN applies to test fns too (at `[tests].max_function_lines`, + // defaulting to the production limit). let has_length_issue = |fa: &FunctionAnalysis, m: &crate::adapters::analyzers::iosp::ComplexityMetrics| { - is_production_length_over(fa, m, max_lines) + is_length_over(fa, m, max_lines, test_max_lines) }; results From af94712ef67209704f020c489761e8f4dbfa0516 Mon Sep 17 00:00:00 2001 From: Sascha <18143567+SaschaOnTour@users.noreply.github.com> Date: Tue, 2 Jun 2026 20:12:28 +0200 Subject: [PATCH 6/7] test(phase-2): mutation-proven test suite + prop_assert/F1 fixes (v1.4.1) Phase 2 of the test-quality effort: prove the suite actually catches defects (cargo-mutants) and close the gaps it surfaced. Mutation coverage (cargo-mutants, --no-shuffle, nextest): - shared/cfg_test*: 89/89 non-equivalent viable mutants caught. - normalize.rs + macro_expansion.rs: survivors 70 -> 4 (128/132 caught); the 4 remaining are documented semantic equivalents (jaccard ||->&&, and the Call/Block/Paren arm deletions that fall to an identical default-recurse). Tests added: - shared/tests/normalize_coverage.rs: enumeration tests pinning the exact NormalizedToken for every binary op (28), unary op (3), expr-kind (incl. an expr-position `let _ = m!();` reaching the Expr::Macro arm), pattern-kind (11), and an or-pattern pipe-count test. - shared/tests/cfg_test.rs: path x test-attribute variant matrix + two proptest properties (qualified `::test` always recognized; non-test attrs never recognized). - shared/tests/cfg_test_files.rs: nested-src/bin and inline-mod propagation mutation-killers. - macro_expansion: non_test_macro_left_untouched strengthened to carry a parseable fn so `is_test_macro -> true` is forced to surface it. Production fixes surfaced during the effort: - TQ-001: is_assertion_macro now recognizes proptest's prop_assert!/ prop_assert_eq!/prop_assert_ne! so property tests are not false-flagged as assertion-free. - F1: architecture matcher's has_cfg_test_attr delegates to the shared cfg_test::has_cfg_test, giving #[cfg(test)] detection one source of truth. proptest added as a dev-dependency. .gitignore excludes mutants.out/. Version 1.4.1, CHANGELOG updated. Co-Authored-By: Claude Opus 4.8 (1M context) --- .gitignore | 2 + CHANGELOG.md | 30 +++ Cargo.lock | 180 +++++++++++++++++- Cargo.toml | 3 +- .../architecture/matcher/item_kind.rs | 19 +- src/adapters/analyzers/tq/assertions.rs | 5 +- src/adapters/analyzers/tq/tests/assertions.rs | 21 ++ src/adapters/shared/tests/cfg_test.rs | 68 +++++++ src/adapters/shared/tests/cfg_test_files.rs | 66 +++++++ src/adapters/shared/tests/macro_expansion.rs | 10 +- src/adapters/shared/tests/mod.rs | 1 + .../shared/tests/normalize_coverage.rs | 137 +++++++++++++ 12 files changed, 520 insertions(+), 22 deletions(-) create mode 100644 src/adapters/shared/tests/normalize_coverage.rs diff --git a/.gitignore b/.gitignore index 3264d6d9..87ce8065 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,8 @@ *.baseline.json coverage.lcov *.profraw +mutants.out/ +mutants.out.old/ CLAUDE.md bugs/ bugs.txt diff --git a/CHANGELOG.md b/CHANGELOG.md index 65df4aba..b23ee398 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,36 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [1.4.1] - 2026-06-02 + +Patch release: **test-suite effectiveness, proven by mutation testing** (Phase 2 +of the test-quality effort). No change to how the tool scores user code, except +the `prop_assert!` recognition fix below. + +### Fixed +- **TQ-001 no longer flags proptest property tests as assertion-free.** + `is_assertion_macro` now recognises proptest's `prop_assert!` / + `prop_assert_eq!` / `prop_assert_ne!` (the `prop_assert` prefix) in addition + to `assert*` / `debug_assert*`. A property test that asserts only via + `prop_assert!` is no longer a false TQ_NO_ASSERT. + +### Changed +- **Internal consistency:** the architecture matcher's `has_cfg_test_attr` now + delegates to the shared `adapters::shared::cfg_test::has_cfg_test` recogniser + instead of a local copy, so `#[cfg(test)]` detection has a single source of + truth across all seven dimensions (consistency-audit finding F1). + +### Tests +- **Mutation-proven coverage** (`cargo-mutants`). The test-recognition core + (`shared/cfg_test*`) and the structural normalizer (`shared/normalize.rs` + + `macro_expansion.rs`) now catch every non-equivalent viable mutant; the only + survivors are documented semantic equivalents. New enumeration tests + (`normalize_coverage.rs`) pin the exact `NormalizedToken` each operator / + expression-kind / pattern-kind emits. +- **proptest** added as a dev-dependency. A path × test-attribute property / + variant matrix on the recognisers guards against the decentralised + test-detection bug class that motivated the effort. + ## [1.4.0] - 2026-06-02 Minor release: **quality checks now run on test code.** DRY (duplicate-function diff --git a/Cargo.lock b/Cargo.lock index e87e8cf4..5e8fb695 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -67,6 +67,27 @@ version = "1.0.102" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c" +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "bit-set" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3" +dependencies = [ + "bit-vec", +] + +[[package]] +name = "bit-vec" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" + [[package]] name = "bitflags" version = "1.3.2" @@ -254,6 +275,12 @@ dependencies = [ "libredox", ] +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + [[package]] name = "foldhash" version = "0.1.5" @@ -269,6 +296,18 @@ dependencies = [ "libc", ] +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi 5.3.0", + "wasip2", +] + [[package]] name = "getrandom" version = "0.4.2" @@ -277,7 +316,7 @@ checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555" dependencies = [ "cfg-if", "libc", - "r-efi", + "r-efi 6.0.0", "wasip2", "wasip3", ] @@ -465,6 +504,15 @@ dependencies = [ "windows-sys 0.48.0", ] +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + [[package]] name = "once_cell" version = "1.21.4" @@ -483,6 +531,15 @@ version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6" +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -502,6 +559,31 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "proptest" +version = "1.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b45fcc2344c680f5025fe57779faef368840d0bd1f42f216291f0dc4ace4744" +dependencies = [ + "bit-set", + "bit-vec", + "bitflags 2.11.0", + "num-traits", + "rand", + "rand_chacha", + "rand_xorshift", + "regex-syntax", + "rusty-fork", + "tempfile", + "unarray", +] + +[[package]] +name = "quick-error" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0" + [[package]] name = "quote" version = "1.0.45" @@ -511,12 +593,56 @@ dependencies = [ "proc-macro2", ] +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + [[package]] name = "r-efi" version = "6.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" +[[package]] +name = "rand" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea" +dependencies = [ + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c" +dependencies = [ + "getrandom 0.3.4", +] + +[[package]] +name = "rand_xorshift" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a" +dependencies = [ + "rand_core", +] + [[package]] name = "rayon" version = "1.11.0" @@ -578,7 +704,7 @@ dependencies = [ [[package]] name = "rustqual" -version = "1.4.0" +version = "1.4.1" dependencies = [ "clap", "clap_complete", @@ -587,6 +713,7 @@ dependencies = [ "globset", "notify", "proc-macro2", + "proptest", "quote", "rayon", "serde", @@ -599,6 +726,18 @@ dependencies = [ "walkdir", ] +[[package]] +name = "rusty-fork" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc6bf79ff24e648f6da1f8d1f011e9cac26491b619e6b9280f2b47f1774e6ee2" +dependencies = [ + "fnv", + "quick-error", + "tempfile", + "wait-timeout", +] + [[package]] name = "same-file" version = "1.0.6" @@ -690,7 +829,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" dependencies = [ "fastrand", - "getrandom", + "getrandom 0.4.2", "once_cell", "rustix", "windows-sys 0.61.2", @@ -767,6 +906,12 @@ dependencies = [ "serde_json", ] +[[package]] +name = "unarray" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94" + [[package]] name = "unicode-ident" version = "1.0.24" @@ -785,6 +930,15 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" +[[package]] +name = "wait-timeout" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11" +dependencies = [ + "libc", +] + [[package]] name = "walkdir" version = "2.5.0" @@ -1113,6 +1267,26 @@ dependencies = [ "wasmparser", ] +[[package]] +name = "zerocopy" +version = "0.8.50" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b065d4f0e55f82fae73202e189638116a87c55ab6b8e6c2721e13dd9d854ad1" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.50" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b631b19d36a892ab55420c92dbc83ccd79274f25be714855d3074aa71cab639" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "zmij" version = "1.0.21" diff --git a/Cargo.toml b/Cargo.toml index 40fa36e4..f7c6d7ea 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "rustqual" -version = "1.4.0" +version = "1.4.1" edition = "2021" description = "Comprehensive Rust code quality analyzer — seven dimensions: IOSP, Complexity, DRY, SRP, Coupling, Test Quality, Architecture" license = "MIT" @@ -33,4 +33,5 @@ toon-encode = "0.1" thiserror = "2" [dev-dependencies] +proptest = "1" tempfile = "3" diff --git a/src/adapters/analyzers/architecture/matcher/item_kind.rs b/src/adapters/analyzers/architecture/matcher/item_kind.rs index 4e18da62..09df4414 100644 --- a/src/adapters/analyzers/architecture/matcher/item_kind.rs +++ b/src/adapters/analyzers/architecture/matcher/item_kind.rs @@ -153,21 +153,12 @@ fn top_level_hit(file: &str, entry: TopLevelEntry) -> MatchLocation { } } -/// Check if any of `attrs` is `#[cfg(test)]`. -/// Operation: iterator scan over attributes. +/// Check if any of `attrs` is `#[cfg(test)]`. Delegates to the single shared +/// `cfg_test::has_cfg_test` so cfg-test recognition stays uniform across all +/// analyzers (S2.3 consistency-audit finding F1). +/// Integration: routes to the shared detector. fn has_cfg_test_attr(attrs: &[syn::Attribute]) -> bool { - attrs.iter().any(is_cfg_test) -} - -/// True when an attribute is literally `#[cfg(test)]`. -/// Operation: pattern-match on Attribute shape. -fn is_cfg_test(attr: &syn::Attribute) -> bool { - if !attr.path().is_ident("cfg") { - return false; - } - attr.parse_args::() - .map(|p| p.is_ident("test")) - .unwrap_or(false) + crate::adapters::shared::cfg_test::has_cfg_test(attrs) } // ── Recursive visitor (async/unsafe fn, unsafe impl, static mut, extern) ── diff --git a/src/adapters/analyzers/tq/assertions.rs b/src/adapters/analyzers/tq/assertions.rs index 65694072..9a9fe12a 100644 --- a/src/adapters/analyzers/tq/assertions.rs +++ b/src/adapters/analyzers/tq/assertions.rs @@ -99,11 +99,14 @@ struct TestAssertionVisitor<'cfg> { extra_macros: &'cfg [String], } -/// Check if a macro name is an assertion: `assert*` or `debug_assert*` prefix, or in extra list. +/// Check if a macro name is an assertion: `assert*`, `debug_assert*` or +/// proptest's `prop_assert*` (`prop_assert!` / `prop_assert_eq!` / +/// `prop_assert_ne!`) prefix, or in the extra list. /// Operation: string prefix + linear search. fn is_assertion_macro(name: &str, extra_macros: &[String]) -> bool { name.starts_with("assert") || name.starts_with("debug_assert") + || name.starts_with("prop_assert") || extra_macros.iter().any(|m| m == name) } diff --git a/src/adapters/analyzers/tq/tests/assertions.rs b/src/adapters/analyzers/tq/tests/assertions.rs index 70cff87e..6e871ec0 100644 --- a/src/adapters/analyzers/tq/tests/assertions.rs +++ b/src/adapters/analyzers/tq/tests/assertions.rs @@ -126,6 +126,27 @@ fn test_debug_assert_no_warning() { assert!(warnings.is_empty()); } +#[test] +fn test_prop_assert_no_warning() { + // proptest's `prop_assert!` / `prop_assert_eq!` are assertions too — a + // property test that uses only them must not be flagged TQ_NO_ASSERT. + let warnings = parse_and_detect( + r#" + #[cfg(test)] + mod tests { + #[test] + fn prop_something() { + prop_assert_eq!(1, 1); + } + } + "#, + ); + assert!( + warnings.is_empty(), + "prop_assert_eq! must count as an assertion: {warnings:?}" + ); +} + #[test] fn test_assert_ne_no_warning() { let warnings = parse_and_detect( diff --git a/src/adapters/shared/tests/cfg_test.rs b/src/adapters/shared/tests/cfg_test.rs index d094d63d..905ce38b 100644 --- a/src/adapters/shared/tests/cfg_test.rs +++ b/src/adapters/shared/tests/cfg_test.rs @@ -1,4 +1,5 @@ use crate::adapters::shared::cfg_test::{has_cfg_test, has_test_attr}; +use proptest::prelude::*; /// Parse a single free function and return its attributes. fn fn_attrs(code: &str) -> Vec { @@ -61,3 +62,70 @@ fn cfg_test_attribute_still_distinct() { assert!(has_cfg_test(&fn_attrs("#[cfg(test)] fn t() {}"))); assert!(!has_cfg_test(&fn_attrs("#[test] fn t() {}"))); } + +/// Canonical attribute matrix: `(decorated fn, has_test_attr?, has_cfg_test?)`. +/// One row per recognised entry-point form + edge spellings + the cfg(test) / +/// test distinction. A missed variant here is exactly the v1.3.0 bug class. +const ATTR_MATRIX: &[(&str, bool, bool)] = &[ + ("#[test] fn t() {}", true, false), + ("#[::core::prelude::v1::test] fn t() {}", true, false), + ("#[tokio::test] async fn t() {}", true, false), + ( + "#[tokio::test(flavor = \"multi_thread\")] async fn t() {}", + true, + false, + ), + ("#[async_std::test] async fn t() {}", true, false), + ("#[googletest::test] fn t() {}", true, false), + ("#[rstest] fn t() {}", true, false), + ("#[rstest::rstest] fn t() {}", true, false), + ("#[test_case(1)] fn t() {}", true, false), + ("#[quickcheck] fn p(x: u8) -> bool { true }", true, false), + ("#[cfg(test)] fn t() {}", false, true), + ("#[cfg(test)]\n#[test] fn t() {}", true, true), + ("#[inline] fn t() {}", false, false), + ("#[allow(dead_code)] fn t() {}", false, false), + ("#[doc = \"x\"] fn t() {}", false, false), + ("fn t() {}", false, false), +]; + +#[test] +fn test_attribute_variant_matrix() { + for (code, want_test, want_cfg) in ATTR_MATRIX { + let attrs = fn_attrs(code); + assert_eq!(has_test_attr(&attrs), *want_test, "has_test_attr: {code}"); + assert_eq!(has_cfg_test(&attrs), *want_cfg, "has_cfg_test: {code}"); + } +} + +proptest! { + /// `has_test_attr` recognises a `…::test` entry point under ANY module-path + /// prefix and depth (`#[a::b::test]`), not just the bare `#[test]` — the + /// "last path segment is `test`" contract, checked generatively. + #[test] + fn qualified_test_path_always_recognized( + prefix in prop::collection::vec( + prop::sample::select(vec!["tokio", "async_std", "rt", "crate", "a", "b"]), + 0..4usize, + ) + ) { + let path: String = prefix.iter().map(|s| format!("{s}::")).collect(); + let code = format!("#[{path}test] fn t() {{}}"); + prop_assert!( + has_test_attr(&fn_attrs(&code)), + "qualified test path not recognised: {code}" + ); + } + + /// A single non-test attribute ident is never a test entry point. Draws from + /// real attribute names so every case parses. + #[test] + fn non_test_attribute_never_recognized( + attr in prop::sample::select(vec![ + "inline", "cold", "must_use", "no_mangle", "non_exhaustive", "ignore", + ]) + ) { + let code = format!("#[{attr}] fn t() {{}}"); + prop_assert!(!has_test_attr(&fn_attrs(&code)), "false positive: {code}"); + } +} diff --git a/src/adapters/shared/tests/cfg_test_files.rs b/src/adapters/shared/tests/cfg_test_files.rs index 0c46891d..625b5ce6 100644 --- a/src/adapters/shared/tests/cfg_test_files.rs +++ b/src/adapters/shared/tests/cfg_test_files.rs @@ -497,3 +497,69 @@ fn path_attribute_resolves_relative_to_parent_dir() { "relative `#[path]` must resolve against the parent file's directory: {result:?}" ); } + +#[test] +fn nested_file_under_src_bin_is_not_an_autobinary_crate_root() { + // Only a file DIRECTLY in `src/bin/` is an autobinary crate root; a deeper + // `src/bin//.rs` is just a module of that binary, not a package + // root. So a sibling `tests/` next to such a nested file must NOT be + // classified as an integration test. (Kills the `&&` → `||` mutant in + // `bin_crate_root_owner`, which would accept the nested file as a root.) + let parsed = vec![ + ( + "myapp/src/bin/sub/deep.rs".to_string(), + "fn main() {}".to_string(), + syn::parse_file("fn main() {}").unwrap(), + ), + ( + "myapp/tests/it.rs".to_string(), + "#[test] fn it() {}".to_string(), + syn::parse_file("#[test] fn it() {}").unwrap(), + ), + ]; + let result = collect_cfg_test_file_paths(&parsed); + assert!( + !result.contains("myapp/tests/it.rs"), + "tests/ next to a NESTED src/bin file (not a real crate root) must not \ + be classified as integration: {result:?}" + ); +} + +#[test] +fn inline_mod_does_not_propagate_cfg_test_to_same_named_external_file() { + // `propagate_cfg_test_through_plain_mods` only follows EXTERNAL `mod foo;` + // declarations. An INLINE `mod foo { … }` in a cfg-test file must NOT drag a + // coincidentally same-named external file into the cfg-test set. (Kills the + // `is_any_ext_mod(m)` → `true` match-guard mutant, which would resolve + // inline mods too.) + let lib = "#[cfg(test)]\nmod c;\npub fn run() {}"; + let c = "mod m { pub fn x() -> u32 { 1 } }"; // INLINE mod m + let m = "pub fn y() -> u32 { 2 }"; // external file; only reachable as `c::m` if external + let parsed = vec![ + ( + "pkg/src/lib.rs".to_string(), + lib.to_string(), + syn::parse_file(lib).unwrap(), + ), + ( + "pkg/src/c.rs".to_string(), + c.to_string(), + syn::parse_file(c).unwrap(), + ), + ( + "pkg/src/c/m.rs".to_string(), + m.to_string(), + syn::parse_file(m).unwrap(), + ), + ]; + let result = collect_cfg_test_file_paths(&parsed); + assert!( + result.contains("pkg/src/c.rs"), + "c.rs is reached via `#[cfg(test)] mod c;` and must be cfg-test: {result:?}" + ); + assert!( + !result.contains("pkg/src/c/m.rs"), + "an INLINE `mod m` must not propagate cfg-test to the external file \ + `c/m.rs`: {result:?}" + ); +} diff --git a/src/adapters/shared/tests/macro_expansion.rs b/src/adapters/shared/tests/macro_expansion.rs index 845bb0c2..e6eb3635 100644 --- a/src/adapters/shared/tests/macro_expansion.rs +++ b/src/adapters/shared/tests/macro_expansion.rs @@ -121,16 +121,20 @@ mod tests { #[test] fn non_test_macro_left_untouched() { + // The body holds a *parseable* `fn` on purpose: if `is_test_macro` ever + // returned `true` for an arbitrary macro, this fn would be surfaced. The + // empty-fn assertion is what kills that `-> true` mutant — a body with no + // fn (e.g. a `static ref`) would let it survive. let file = expand( r#" -lazy_static! { - static ref VALUE: u32 = 5; +define_helpers! { + fn generated_helper() -> bool { true } } "#, ); assert!( collect_fns(&file.items).is_empty(), - "a non-test macro must not produce any fn" + "a non-test macro must not have its inner fn surfaced" ); assert!( has_macro_item(&file.items), diff --git a/src/adapters/shared/tests/mod.rs b/src/adapters/shared/tests/mod.rs index 88acc2e4..642cab00 100644 --- a/src/adapters/shared/tests/mod.rs +++ b/src/adapters/shared/tests/mod.rs @@ -3,4 +3,5 @@ mod cfg_test_files; mod file_to_module; mod macro_expansion; mod normalize; +mod normalize_coverage; mod use_tree; diff --git a/src/adapters/shared/tests/normalize_coverage.rs b/src/adapters/shared/tests/normalize_coverage.rs new file mode 100644 index 00000000..8900762e --- /dev/null +++ b/src/adapters/shared/tests/normalize_coverage.rs @@ -0,0 +1,137 @@ +//! Per-construct token coverage for the structural normalizer (S2.6). +//! +//! The S2.2 mutation run left 69 survivors in `normalize.rs`: deleting any +//! `bin_op_str` / `un_op_str` arm, or any `visit_expr` / `visit_pat` match arm +//! that pushes a discriminator token, went undetected. These enumeration tests +//! pin the exact `NormalizedToken` each construct must emit, so a dropped arm +//! (which falls through to the catch-all / default walk and loses the token) +//! now fails a test. + +use crate::adapters::shared::normalize::{normalize_body, NormalizedToken}; +use NormalizedToken::{BoolLit, CharLit, FloatLit, IntLit, Keyword, MacroCall, Operator, StrLit}; + +/// Normalize statement-level `code` into its token stream. +fn toks(code: &str) -> Vec { + let wrapped = format!("fn f() {{ {code} }}"); + let file = syn::parse_file(&wrapped).unwrap_or_else(|e| panic!("parse {code:?}: {e}")); + let syn::Item::Fn(f) = &file.items[0] else { + unreachable!("wrapped code is a fn") + }; + normalize_body(&f.block) +} + +fn assert_emits(code: &str, want: &NormalizedToken) { + let got = toks(code); + assert!( + got.contains(want), + "{code:?} must emit {want:?}; got {got:?}" + ); +} + +#[test] +fn binary_operators_each_emit_their_token() { + let cases: [(&str, &str); 28] = [ + ("a + b;", "+"), + ("a - b;", "-"), + ("a * b;", "*"), + ("a / b;", "/"), + ("a % b;", "%"), + ("a && b;", "&&"), + ("a || b;", "||"), + ("a ^ b;", "^"), + ("a & b;", "&"), + ("a | b;", "|"), + ("a << b;", "<<"), + ("a >> b;", ">>"), + ("a == b;", "=="), + ("a < b;", "<"), + ("a <= b;", "<="), + ("a != b;", "!="), + ("a >= b;", ">="), + ("a > b;", ">"), + ("a += b;", "+="), + ("a -= b;", "-="), + ("a *= b;", "*="), + ("a /= b;", "/="), + ("a %= b;", "%="), + ("a ^= b;", "^="), + ("a &= b;", "&="), + ("a |= b;", "|="), + ("a <<= b;", "<<="), + ("a >>= b;", ">>="), + ]; + for (code, op) in cases { + assert_emits(code, &Operator(op)); + } +} + +#[test] +fn unary_operators_each_emit_their_token() { + // Also kills the `un_op_str -> ""` / `"xyzzy"` return-replacement mutants. + for (code, op) in [("-a;", "-"), ("!a;", "!"), ("*a;", "*")] { + assert_emits(code, &Operator(op)); + } +} + +#[test] +fn expr_kinds_each_emit_their_marker() { + let cases: [(&str, NormalizedToken); 17] = [ + ("a = b;", Operator("=")), + ("while a {}", Keyword("while")), + ("loop {}", Keyword("loop")), + ("break;", Keyword("break")), + ("continue;", Keyword("continue")), + ("a[b];", Operator("[]")), + ("(a, b);", Keyword("tuple")), + ("[a, b];", Keyword("array")), + ("a.await;", Keyword("await")), + ("a..b;", Operator("..")), + ("a as u8;", Keyword("as")), + ("[a; 3];", Keyword("array")), + ("if let Some(a) = b {}", Keyword("let")), + ("yield a;", Keyword("yield")), + ("m!();", MacroCall("m".to_string())), + // Expr-position macro (`Expr::Macro`, distinct from the `Stmt::Macro` + // path above): the let-initialiser is the only way to reach the arm. + ("let _ = m!();", MacroCall("m".to_string())), + ("1.5;", FloatLit), + ]; + for (code, want) in &cases { + assert_emits(code, want); + } + // String + char literals in expression position. + assert_emits("\"x\";", &StrLit); + assert_emits("'c';", &CharLit); +} + +#[test] +fn pat_kinds_each_emit_their_marker() { + let cases: [(&str, NormalizedToken); 11] = [ + ("match v { (a, b) => {} }", Keyword("tuple")), + ("match v { Foo(a) => {} }", Keyword("tuple")), + ("match v { &a => {} }", Operator("&")), + ("match v { [a, b] => {} }", Keyword("array")), + ("match v { [a, ..] => {} }", Operator("..")), + ("match v { 1..=5 => {} }", Operator("..")), + ("match v { 1 => {} }", IntLit), + ("match v { 1.5 => {} }", FloatLit), + ("match v { \"x\" => {} }", StrLit), + ("match v { true => {} }", BoolLit(true)), + ("match v { 'c' => {} }", CharLit), + ]; + for (code, want) in &cases { + assert_emits(code, want); + } +} + +#[test] +fn or_pattern_emits_a_pipe_between_each_case() { + // Kills the `Pat::Or` arm deletion (0 pipes) AND the `i > 0` comparison + // mutants (`==` → 1, `<` → 0, `>=` → 3 pipes). + let got = toks("match v { 1 | 2 | 3 => {} }"); + let pipes = got.iter().filter(|t| **t == Operator("|")).count(); + assert_eq!( + pipes, 2, + "`1 | 2 | 3` needs exactly 2 separating pipes; got {got:?}" + ); +} From 3de44a4df3373765252131abfddc1d10ea885b2a Mon Sep 17 00:00:00 2001 From: Sascha <18143567+SaschaOnTour@users.noreply.github.com> Date: Thu, 4 Jun 2026 15:38:33 +0200 Subject: [PATCH 7/7] test(phase-3-4): full mutation sweep + relevance review + review fixes MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Phase 3 — full mutation sweep (cargo-mutants) extended from the shared core to every dimension plus app and report. All reachable survivors killed; only documented semantic equivalents remain. Drove asserts/oracles into many existing tests and split oversized test files along behaviour seams. Phase 4 — per-dimension relevance review against book/*-quality.md: positive AND negative per-rule coverage, oracle quality, behaviour- vs implementation-coupling, redundancy, test intent. Strengthened weak oracles (dry near-duplicate threshold, srp named clusters, architecture PatternScope::accepts scoping, coupling SDP-from-source) and added missing end-to-end pins. Follow-up design + review-finding fixes: - SRP: the god-struct check (SRP-001) deliberately applies to test code (a god-fixture wiring up many concerns is a real smell); only module-cohesion (independent clusters) stays production-only. Removed the dead [tests].max_methods knob and pinned the contract. - TQ-001: no longer flags quickcheck! `-> bool` properties as assertion-free — the boolean return is the property's oracle (a plain #[test] can't return bool). - DEH: honours a function's own #[test]/#[cfg(test)] attrs, so expanded quickcheck!/proptest! property bodies (and hand-written top-level #[test] fns) are no longer falsely flagged as production downcast escape hatches. - `rustqual --init` templates now include the [tests] section. - Docs: book BTC stub forms drop Default::default(); CLAUDE.md DRY rule IDs match the emitted ones (DRY-003 fragment, DRY-004 wildcard). Four gates green: cargo fmt, 1851 nextest, self-analysis 0 findings, clippy. CHANGELOG updated under [1.4.1]; no version bump. Co-Authored-By: Claude Opus 4.8 (1M context) --- .gitignore | 1 + CHANGELOG.md | 62 ++- book/function-quality.md | 2 +- book/reference-configuration.md | 13 +- rustqual.toml | 10 +- .../analyzers/architecture/analyzer.rs | 12 +- .../architecture/call_parity_rule/bindings.rs | 6 +- .../architecture/call_parity_rule/calls.rs | 6 +- .../architecture/call_parity_rule/check_b.rs | 4 +- .../call_parity_rule/check_b_coverage.rs | 2 +- .../architecture/call_parity_rule/check_d.rs | 2 +- .../call_parity_rule/hint/candidates.rs | 1 + .../architecture/call_parity_rule/hint/mod.rs | 2 +- .../architecture/call_parity_rule/mod.rs | 4 +- .../architecture/call_parity_rule/pub_fns.rs | 2 +- .../call_parity_rule/reexports.rs | 6 +- .../call_parity_rule/signature_params.rs | 2 +- .../call_parity_rule/tests/calls/mod.rs | 1 + .../tests/calls/pattern_collectors.rs | 126 ++++++ .../tests/collect_findings_integration.rs | 71 ++++ .../tests/collectors_internal.rs | 227 +++++++++++ .../call_parity_rule/tests/hint.rs | 164 ++++++++ .../call_parity_rule/tests/mod.rs | 8 + .../call_parity_rule/tests/peel_internal.rs | 130 +++++++ .../tests/predicates_internal.rs | 365 ++++++++++++++++++ .../tests/reachable_targets.rs | 56 +++ .../tests/reexports_internal.rs | 80 ++++ .../tests/workspace_graph_internals.rs | 142 +++++++ .../type_infer/tests/infer_call.rs | 52 +++ .../call_parity_rule/type_infer/tests/mod.rs | 1 + .../type_infer/tests/patterns_destructure.rs | 13 + .../type_infer/tests/resolve_internals.rs | 233 +++++++++++ .../type_infer/tests/workspace_index/mod.rs | 1 + .../tests/workspace_index/visitor_walks.rs | 150 +++++++ .../workspace_graph/edge_rewrite.rs | 2 +- .../call_parity_rule/workspace_graph/mod.rs | 2 +- .../analyzers/architecture/compiled.rs | 4 +- .../analyzers/architecture/forbidden_rule.rs | 2 +- .../architecture/matcher/tests/item_kind.rs | 21 + .../analyzers/architecture/tests/analyzer.rs | 232 +++++++++++ .../analyzers/architecture/tests/compiled.rs | 48 +++ .../analyzers/architecture/tests/explain.rs | 92 ++++- .../architecture/tests/forbidden_rule.rs | 46 +++ .../analyzers/architecture/tests/mod.rs | 1 + .../analyzers/architecture/tests/rendering.rs | 129 +++++++ .../architecture/tests/trait_contract.rs | 97 +++++ .../architecture/trait_contract_rule/mod.rs | 4 +- .../trait_contract_rule/rendering.rs | 2 +- .../analyzers/coupling/tests/integration.rs | 88 +++++ src/adapters/analyzers/coupling/tests/mod.rs | 14 + src/adapters/analyzers/coupling/tests/root.rs | 79 +--- src/adapters/analyzers/coupling/tests/sdp.rs | 112 +++--- .../boilerplate/tests/root/bp001_to_005.rs | 83 ++++ .../boilerplate/tests/root/bp006_to_008.rs | 64 +++ .../boilerplate/tests/root/bp009_onward.rs | 96 +++++ .../boilerplate/tests/root/bp_predicates.rs | 125 ++++++ .../dry/boilerplate/tests/root/mod.rs | 1 + src/adapters/analyzers/dry/tests/dead_code.rs | 16 + src/adapters/analyzers/dry/tests/fragments.rs | 32 ++ src/adapters/analyzers/dry/tests/functions.rs | 80 +++- .../analyzers/dry/tests/match_patterns.rs | 59 +++ src/adapters/analyzers/dry/tests/wildcards.rs | 12 + .../iosp/tests/root/analysis_structure.rs | 149 +++++++ .../iosp/tests/root/dispatch_and_getters.rs | 46 +-- .../iosp/tests/root/metrics_exact.rs | 171 ++++++++ src/adapters/analyzers/iosp/tests/root/mod.rs | 42 +- .../iosp/tests/root/own_call_resolution.rs | 195 ++++++++++ .../analyzers/srp/tests/cohesion/scoring.rs | 46 +++ .../analyzers/srp/tests/cohesion/warnings.rs | 50 ++- .../srp/tests/module/production_lines.rs | 14 + src/adapters/analyzers/srp/tests/root.rs | 59 ++- src/adapters/analyzers/structural/deh.rs | 17 +- .../analyzers/structural/tests/btc.rs | 41 ++ .../analyzers/structural/tests/deh.rs | 60 +++ .../analyzers/structural/tests/iet.rs | 15 + .../analyzers/structural/tests/nms.rs | 91 +++++ .../analyzers/structural/tests/sit.rs | 16 + src/adapters/analyzers/tq/assertions.rs | 23 +- src/adapters/analyzers/tq/tests/assertions.rs | 156 +++++++- src/adapters/analyzers/tq/tests/lcov.rs | 18 + src/adapters/analyzers/tq/tests/sut.rs | 95 +++-- src/adapters/analyzers/tq/tests/untested.rs | 27 ++ src/adapters/config/init.rs | 21 + src/adapters/config/sections.rs | 14 +- src/adapters/config/tests/init.rs | 2 + src/adapters/config/tests/sections.rs | 3 - src/adapters/report/baseline.rs | 139 ++++--- src/adapters/report/html/tests/complexity.rs | 155 ++++++++ src/adapters/report/html/tests/dashboard.rs | 52 +++ src/adapters/report/html/tests/dry.rs | 74 ++++ src/adapters/report/html/tests/iosp.rs | 76 ++++ src/adapters/report/html/tests/mod.rs | 6 + src/adapters/report/html/tests/sections.rs | 98 +++++ src/adapters/report/html/tests/srp_tables.rs | 76 ++++ src/adapters/report/sarif/tests/mappers.rs | 194 ++++++++++ src/adapters/report/sarif/tests/mod.rs | 1 + src/adapters/report/sarif/tests/rules.rs | 126 +++++- src/adapters/report/suggestions.rs | 112 +++--- src/adapters/report/tests/ai/details.rs | 152 ++++++++ .../report/tests/ai/dimension_entries_a.rs | 35 +- src/adapters/report/tests/ai/mod.rs | 42 ++ src/adapters/report/tests/baseline.rs | 91 +++++ src/adapters/report/tests/dot.rs | 17 + .../report/tests/findings_list_categories.rs | 323 ++++++++++++++++ src/adapters/report/tests/github/messages.rs | 214 ++++++++++ src/adapters/report/tests/github/mod.rs | 1 + src/adapters/report/tests/json/functions.rs | 83 ++++ src/adapters/report/tests/json/mod.rs | 2 + src/adapters/report/tests/json/sections.rs | 290 ++++++++++++++ src/adapters/report/tests/mod.rs | 2 + src/adapters/report/tests/projections_dry.rs | 91 +++++ .../report/tests/projections_extra.rs | 185 +++++++++ .../report/tests/root/quality_score.rs | 139 +++++++ src/adapters/report/tests/suggestions.rs | 89 +++++ src/adapters/report/text/mod.rs | 2 +- src/adapters/report/text/tests/coupling.rs | 87 +++++ src/adapters/report/text/tests/dry.rs | 97 +++++ src/adapters/report/text/tests/files.rs | 205 ++++++++++ src/adapters/report/text/tests/mod.rs | 6 + src/adapters/report/text/tests/sections.rs | 118 ++++++ src/adapters/report/text/tests/srp.rs | 84 ++++ src/adapters/report/text/tests/summary.rs | 257 ++++++++++++ src/app/architecture.rs | 10 +- src/app/exit_gates.rs | 18 +- src/app/pipeline.rs | 5 +- src/app/tests/architecture.rs | 71 ++++ src/app/tests/gates.rs | 181 +++++++++ src/app/tests/metrics/counters.rs | 296 ++++++++++++++ src/app/tests/metrics/dry_detection.rs | 56 +++ src/app/tests/metrics/mod.rs | 3 + src/app/tests/metrics/srp_suppression.rs | 87 +++++ src/app/tests/metrics/suppression.rs | 83 ++++ src/app/tests/mod.rs | 24 ++ src/app/tests/pipeline.rs | 30 +- src/app/tests/projection.rs | 101 +++++ src/app/tests/projection_secondary.rs | 189 +++++++++ src/app/tests/run.rs | 113 ------ src/app/tests/structural_metrics.rs | 72 ++++ src/app/tests/tq_metrics.rs | 63 +++ src/app/tests/warnings/complexity_flags.rs | 96 +++++ .../warnings/exclude_and_error_handling.rs | 20 + src/app/tests/warnings/flag_application.rs | 70 ++++ src/app/tests/warnings/mod.rs | 4 + .../warnings/orphan_complexity_thresholds.rs | 82 ++++ .../tests/warnings/orphan_mod_internals.rs | 175 +++++++++ src/app/tests/warnings/orphan_support.rs | 36 ++ 146 files changed, 9946 insertions(+), 531 deletions(-) create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/calls/pattern_collectors.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/collect_findings_integration.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/collectors_internal.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/hint.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/peel_internal.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/predicates_internal.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/reachable_targets.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/reexports_internal.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/tests/workspace_graph_internals.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve_internals.rs create mode 100644 src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/visitor_walks.rs create mode 100644 src/adapters/analyzers/architecture/tests/analyzer.rs create mode 100644 src/adapters/analyzers/coupling/tests/integration.rs create mode 100644 src/adapters/analyzers/dry/boilerplate/tests/root/bp_predicates.rs create mode 100644 src/adapters/analyzers/iosp/tests/root/analysis_structure.rs create mode 100644 src/adapters/analyzers/iosp/tests/root/metrics_exact.rs create mode 100644 src/adapters/analyzers/iosp/tests/root/own_call_resolution.rs create mode 100644 src/adapters/report/html/tests/complexity.rs create mode 100644 src/adapters/report/html/tests/dashboard.rs create mode 100644 src/adapters/report/html/tests/dry.rs create mode 100644 src/adapters/report/html/tests/iosp.rs create mode 100644 src/adapters/report/html/tests/sections.rs create mode 100644 src/adapters/report/html/tests/srp_tables.rs create mode 100644 src/adapters/report/sarif/tests/mappers.rs create mode 100644 src/adapters/report/tests/ai/details.rs create mode 100644 src/adapters/report/tests/findings_list_categories.rs create mode 100644 src/adapters/report/tests/github/messages.rs create mode 100644 src/adapters/report/tests/json/functions.rs create mode 100644 src/adapters/report/tests/json/sections.rs create mode 100644 src/adapters/report/tests/projections_extra.rs create mode 100644 src/adapters/report/text/tests/coupling.rs create mode 100644 src/adapters/report/text/tests/dry.rs create mode 100644 src/adapters/report/text/tests/files.rs create mode 100644 src/adapters/report/text/tests/sections.rs create mode 100644 src/adapters/report/text/tests/srp.rs create mode 100644 src/adapters/report/text/tests/summary.rs create mode 100644 src/app/tests/architecture.rs create mode 100644 src/app/tests/gates.rs create mode 100644 src/app/tests/metrics/counters.rs create mode 100644 src/app/tests/metrics/dry_detection.rs create mode 100644 src/app/tests/metrics/srp_suppression.rs create mode 100644 src/app/tests/projection.rs create mode 100644 src/app/tests/projection_secondary.rs create mode 100644 src/app/tests/structural_metrics.rs create mode 100644 src/app/tests/tq_metrics.rs create mode 100644 src/app/tests/warnings/complexity_flags.rs create mode 100644 src/app/tests/warnings/flag_application.rs create mode 100644 src/app/tests/warnings/orphan_complexity_thresholds.rs create mode 100644 src/app/tests/warnings/orphan_mod_internals.rs diff --git a/.gitignore b/.gitignore index 87ce8065..d4798c3c 100644 --- a/.gitignore +++ b/.gitignore @@ -14,3 +14,4 @@ bugs/ bugs.txt docs/ prd-*.md +docs/report-survivors.txt diff --git a/CHANGELOG.md b/CHANGELOG.md index b23ee398..0a22aa01 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,9 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [1.4.1] - 2026-06-02 -Patch release: **test-suite effectiveness, proven by mutation testing** (Phase 2 -of the test-quality effort). No change to how the tool scores user code, except -the `prop_assert!` recognition fix below. +Patch release: **test-suite effectiveness, proven by mutation testing** (Phases +2–4 of the test-quality effort). No change to how the tool scores user code, +except the `prop_assert!` recognition fix below and the removal of the +never-read `[tests].max_methods` config key. ### Fixed - **TQ-001 no longer flags proptest property tests as assertion-free.** @@ -17,12 +18,50 @@ the `prop_assert!` recognition fix below. `prop_assert_eq!` / `prop_assert_ne!` (the `prop_assert` prefix) in addition to `assert*` / `debug_assert*`. A property test that asserts only via `prop_assert!` is no longer a false TQ_NO_ASSERT. +- **TQ-001 no longer flags `quickcheck!` boolean properties as assertion-free.** + The macro-expansion pre-pass surfaces `quickcheck! { fn p(x: T) -> bool { … } + }` as a synthetic `#[test] fn p() -> bool { … }` (params dropped), so a + property whose body is a bare boolean — e.g. `{ x < 100 }`, with no assertion + macro or call — was wrongly reported as `TQ_NO_ASSERT`. TQ now treats a + `-> bool` return as the property's oracle (the value quickcheck checks across + every input), which a plain `#[test]` can never have. Present since + macro-body walking shipped in v1.3.2. +- **DEH (downcast escape-hatch) no longer flags `#[test]` function bodies.** + The detector derived its test-exempt state only from whole-file and + `#[cfg(test)] mod` context, never a function's own attributes, so a top-level + `#[test] fn { x.downcast_ref::<…>(); }` was wrongly reported. This surfaced + via the macro-expansion pre-pass, which emits `quickcheck!` / `proptest!` + properties as synthetic `#[test]` fns whose original `#[cfg(test)]` wrapper is + gone — flipping a test body into apparent production code. DEH now honours a + function's own `#[test]` / `#[cfg(test)]` attribute (consistent with the + cross-dimension `has_test_attr` rule). The other structural detectors are + unaffected — they key off impl methods, trait impls, or `pub` signatures, none + of which a free property fn produces. ### Changed - **Internal consistency:** the architecture matcher's `has_cfg_test_attr` now delegates to the shared `adapters::shared::cfg_test::has_cfg_test` recogniser instead of a local copy, so `#[cfg(test)]` detection has a single source of truth across all seven dimensions (consistency-audit finding F1). +- **`rustqual --init` templates now include the `[tests]` section.** Both the + default and the calibrated template previously jumped from `[test_quality]` + straight to `[weights]`, so generated configs never surfaced the test-code + threshold knobs (`max_function_lines` / `file_length_baseline` / + `file_length_ceiling`). They are now emitted commented-out (inherit + production), matching `rustqual.toml`. +- **Removed the dead `[tests].max_methods` config key.** It was never read, so + it changed no analysis — the god-struct check (`SRP-001`) already evaluates + test-file structs at the production `[srp]` thresholds, and a lone per-test + method-count override (without the other four composite inputs: + `max_fields` / `max_fan_out` / `lcom4_threshold` / `smell_threshold`) would be + incoherent. The applied behaviour is unchanged and now made explicit: struct + SRP-001 deliberately runs on test code (a god-fixture wiring up many concerns + is a real smell); only the SRP *module*-cohesion (independent-cluster) check + stays production-only, because a test file's independent `#[test]` fns are its + purpose. Use `// qual:allow(srp)` for the rare legitimate fixture. `[tests]` + still configures `max_function_lines` / `file_length_baseline` / + `file_length_ceiling`. (Note: a `rustqual.toml` that set the removed key now + errors under `deny_unknown_fields` — delete the line.) ### Tests - **Mutation-proven coverage** (`cargo-mutants`). The test-recognition core @@ -31,10 +70,27 @@ the `prop_assert!` recognition fix below. survivors are documented semantic equivalents. New enumeration tests (`normalize_coverage.rs`) pin the exact `NormalizedToken` each operator / expression-kind / pattern-kind emits. +- **Mutation sweep extended to the whole analyzer** (Phase 3): all seven + dimensions plus `app` and `report` are now mutation-proven; every reachable + survivor was killed, only documented semantic equivalents remain. +- **Per-dimension relevance review** (Phase 4): each dimension's tests were + audited against the `book/*-quality.md` specs for positive *and* negative + per-rule coverage, oracle quality (assert the meaningful output, not + incidentals), and behaviour- vs implementation-coupling. Weak oracles were + strengthened (e.g. the DRY near-duplicate threshold test, the SRP named-cluster + assertions, the architecture `PatternScope::accepts` scoping test) and a + god-fixture-in-a-test-file pin was added for struct SRP-001. - **proptest** added as a dev-dependency. A path × test-attribute property / variant matrix on the recognisers guards against the decentralised test-detection bug class that motivated the effort. +### Docs +- **Corrected two spec-vs-code deviations** surfaced by the Phase-4 review: + `book/function-quality.md` no longer lists `Default::default()` as a `BTC` + stub form (`is_stub_body` recognises only the `todo!` / `unimplemented!` / + `panic!("not implemented")` macros), and the `CLAUDE.md` DRY note now matches + the emitted rule IDs (DRY-003 = duplicate fragment, DRY-004 = wildcard import). + ## [1.4.0] - 2026-06-02 Minor release: **quality checks now run on test code.** DRY (duplicate-function diff --git a/book/function-quality.md b/book/function-quality.md index 696e25d3..3e3bd43c 100644 --- a/book/function-quality.md +++ b/book/function-quality.md @@ -91,7 +91,7 @@ Beyond IOSP and complexity, rustqual flags structural smells at the method level |---|---| | `SLM` | **Selfless method** — takes `self` but never references it. Should be a free function or associated function. | | `NMS` | **Needless `&mut self`** — declares mutable receiver but never mutates. Tighten the signature to `&self`. | -| `BTC` | **Broken trait contract** — every method in an `impl Trait` is a stub (`unimplemented!`, `todo!`, `Default::default()`). The trait is unimplemented in spirit. | +| `BTC` | **Broken trait contract** — a method in an `impl Trait` block is a stub (`todo!`, `unimplemented!`, or `panic!("not implemented")`). The trait is unimplemented in spirit. | Configure under `[structural]`: diff --git a/book/reference-configuration.md b/book/reference-configuration.md index 379db7eb..f42008bd 100644 --- a/book/reference-configuration.md +++ b/book/reference-configuration.md @@ -119,10 +119,13 @@ subset of checks to test code — `DRY-001`/`DRY-004`/`DRY-005`, `LONG_FN` (function length), and SRP **file-length** (`SRP_MODULE`). The rest stay test-exempt (`ERROR_HANDLING`, `MAGIC_NUMBER`, IOSP, `DRY-002` dead code, `DRY-003` wildcard imports, Coupling, all Structural detectors). The SRP -**cohesion** check (independent function clusters) is also **production-only**: -a test file's many independent `#[test]` fns are its purpose, not a low-cohesion -smell — so only file-length is judged on test files. Which checks apply is -**not** configurable; only the thresholds below are. +**module-cohesion** check (independent function clusters) is also +**production-only**: a test file's many independent `#[test]` fns are its +purpose, not a low-cohesion smell. The **god-struct** check (`SRP-001`) *does* +fire on test structs — a god-fixture wiring up many concerns is a real smell — +but at production thresholds, with no separate test knob (use `// qual:allow(srp)` +for the rare legitimate fixture). Which checks apply is **not** configurable; +only the thresholds below are. Each key overrides the matching production threshold *for test code only*. An unset key inherits the production value, so by default test code is judged @@ -134,14 +137,12 @@ by the same limits as production. Field names mirror `[complexity]` and | `max_function_lines` | `[complexity].max_function_lines` | `LONG_FN` limit for test fns | | `file_length_baseline` | `[srp].file_length_baseline` | File-length score baseline for test files | | `file_length_ceiling` | `[srp].file_length_ceiling` | File-length score ceiling for test files | -| `max_methods` | `[srp].max_methods` | Method-count limit for test impls | ```toml [tests] max_function_lines = 120 file_length_baseline = 500 file_length_ceiling = 1200 -max_methods = 40 ``` ## `[weights]` diff --git a/rustqual.toml b/rustqual.toml index 349262d2..18ebf47b 100644 --- a/rustqual.toml +++ b/rustqual.toml @@ -90,9 +90,12 @@ enabled = true # ── Test-Code Thresholds ─────────────────────────────────────────────── # # rustqual applies a curated subset of checks to test code: DRY-001/004/005, -# LONG_FN (function length), and SRP size (file/module length, method count). -# Everything else stays test-exempt (ERROR_HANDLING, MAGIC_NUMBER, IOSP, -# DRY-002 dead code, DRY-003 wildcards, Coupling, all Structural detectors). +# LONG_FN (function length), and SRP file-length (SRP_MODULE). The god-struct +# check (SRP-001) also fires on test structs (a god-fixture is a real smell) at +# production thresholds — no separate test knob; use `// qual:allow(srp)` for the +# rare legitimate fixture. Everything else stays test-exempt (ERROR_HANDLING, +# MAGIC_NUMBER, IOSP, DRY-002 dead code, DRY-003 wildcards, Coupling, all +# Structural detectors, and the SRP module-cohesion / independent-cluster check). # This split is fixed; only the thresholds are configurable. # # Each key overrides the matching production threshold FOR TEST CODE ONLY. @@ -104,7 +107,6 @@ enabled = true # max_function_lines = 60 # overrides [complexity].max_function_lines (LONG_FN) # file_length_baseline = 300 # overrides [srp].file_length_baseline # file_length_ceiling = 600 # overrides [srp].file_length_ceiling -# max_methods = 20 # overrides [srp].max_methods # ── Quality Score Weights ────────────────────────────────────────────── diff --git a/src/adapters/analyzers/architecture/analyzer.rs b/src/adapters/analyzers/architecture/analyzer.rs index 4f1f8058..a3b4f27b 100644 --- a/src/adapters/analyzers/architecture/analyzer.rs +++ b/src/adapters/analyzers/architecture/analyzer.rs @@ -105,14 +105,14 @@ fn collect_pattern_findings(ctx: &AnalysisContext<'_>, pattern: &SymbolPattern) } /// Compiled scope decision for one pattern. -struct PatternScope { +pub(super) struct PatternScope { kind: ScopeKind, paths: GlobSet, except: GlobSet, } /// Whitelist or blocklist interpretation of `paths`. -enum ScopeKind { +pub(super) enum ScopeKind { AllowedIn, ForbiddenIn, } @@ -120,7 +120,7 @@ enum ScopeKind { impl PatternScope { /// True when the pattern applies to `path` (i.e. matchers should run). /// Operation: glob-lookup logic. - fn accepts(&self, path: &str) -> bool { + pub(super) fn accepts(&self, path: &str) -> bool { if self.except.is_match(path) { return false; } @@ -133,7 +133,7 @@ impl PatternScope { /// Compile a pattern's scope fields into matching globs. /// Operation: XOR validation + glob compilation. -fn compile_pattern_scope(pattern: &SymbolPattern) -> Option { +pub(super) fn compile_pattern_scope(pattern: &SymbolPattern) -> Option { let (kind, raw_paths) = match (&pattern.allowed_in, &pattern.forbidden_in) { (Some(p), None) => (ScopeKind::AllowedIn, p.as_slice()), (None, Some(p)) => (ScopeKind::ForbiddenIn, p.as_slice()), @@ -249,7 +249,7 @@ fn collect_layer_findings( /// Project a layer/unmatched `MatchLocation` into a Finding. /// Operation: rule_id selection + field copy. -fn layer_hit_to_finding(hit: MatchLocation) -> Finding { +pub(super) fn layer_hit_to_finding(hit: MatchLocation) -> Finding { let rule_id = match &hit.kind { ViolationKind::UnmatchedLayer { .. } => "architecture/layer/unmatched", _ => "architecture/layer", @@ -285,7 +285,7 @@ fn collect_forbidden_findings( /// Project a forbidden-edge hit into a Finding. /// Operation: field copy with dimension rule_id. -fn forbidden_hit_to_finding(hit: MatchLocation) -> Finding { +pub(super) fn forbidden_hit_to_finding(hit: MatchLocation) -> Finding { let reason = if let ViolationKind::ForbiddenEdge { reason, .. } = &hit.kind { reason.clone() } else { diff --git a/src/adapters/analyzers/architecture/call_parity_rule/bindings.rs b/src/adapters/analyzers/architecture/call_parity_rule/bindings.rs index 90d13af2..637aed2d 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/bindings.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/bindings.rs @@ -56,7 +56,7 @@ pub(super) fn canonical_from_type( /// else. `Arc>` → `Inner`. Conservative — only the well-known /// wrapper names are stripped so generics we don't understand remain as-is. // qual:recursive -fn strip_wrappers(ty: &syn::Type) -> &syn::Type { +pub(super) fn strip_wrappers(ty: &syn::Type) -> &syn::Type { match ty { syn::Type::Reference(r) => strip_wrappers(&r.elem), syn::Type::Paren(p) => strip_wrappers(&p.elem), @@ -277,7 +277,7 @@ fn lookup_alias<'a>(scope: &'a CanonScope<'a>, name: &str) -> Option<&'a AliasTa /// flag we MUST NOT apply workspace canonicalisation (sibling-submodule /// promotion, crate-root prepending) — that's the exact bug the /// in-tree alias-map leading-colon drift caused before v1.2.4. -fn normalize_after_alias( +pub(super) fn normalize_after_alias( expanded: Vec, absolute_root: bool, scope: &CanonScope<'_>, @@ -409,7 +409,7 @@ fn extract_pat_name_and_type(pat: &syn::Pat) -> Option<(String, Option<&syn::Typ /// explicit annotation is present. Unwraps `?`, `.await`, and parens, /// then looks for a constructor pattern `Type::ctor(args)` and maps the /// prefix to a canonical path via alias_map / resolve_to_crate_absolute. -fn binding_type_from_init( +pub(super) fn binding_type_from_init( expr: &syn::Expr, alias_map: &AliasMap, local_symbols: &HashSet, diff --git a/src/adapters/analyzers/architecture/call_parity_rule/calls.rs b/src/adapters/analyzers/architecture/call_parity_rule/calls.rs index a18bedf2..bb891c81 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/calls.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/calls.rs @@ -710,7 +710,7 @@ enum PatKind { /// Still silent-skips on total parse failure (extern-DSL macros, custom /// grammar) — a documented limitation of syntax-level call-graph /// construction. -fn parse_macro_tokens(tokens: proc_macro2::TokenStream) -> Vec { +pub(super) fn parse_macro_tokens(tokens: proc_macro2::TokenStream) -> Vec { use syn::parse::Parser; use syn::punctuated::Punctuated; use syn::Token; @@ -838,7 +838,7 @@ impl BindingLookup for CollectorBindings<'_> { /// patterns — those flow through `patterns::extract_bindings`. /// Operation: recursive pattern peel. // qual:recursive -fn extract_pat_ident_name(pat: &syn::Pat) -> Option { +pub(super) fn extract_pat_ident_name(pat: &syn::Pat) -> Option { match pat { syn::Pat::Ident(pi) => Some(pi.ident.to_string()), syn::Pat::Type(pt) => extract_pat_ident_name(&pt.pat), @@ -852,7 +852,7 @@ fn extract_pat_ident_name(pat: &syn::Pat) -> Option { /// matched type couldn't be inferred. Integration: dispatch over pat /// variants, each arm delegates to a recursive helper. // qual:recursive -fn collect_pattern_idents(pat: &syn::Pat, out: &mut Vec) { +pub(super) fn collect_pattern_idents(pat: &syn::Pat, out: &mut Vec) { match pat { syn::Pat::Ident(pi) => push_pat_ident(pi, out), syn::Pat::Type(pt) => collect_pattern_idents(&pt.pat, out), diff --git a/src/adapters/analyzers/architecture/call_parity_rule/check_b.rs b/src/adapters/analyzers/architecture/call_parity_rule/check_b.rs index 22a536e8..f824cb06 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/check_b.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/check_b.rs @@ -170,14 +170,14 @@ fn inspect_target(info: &PubFnInfo<'_>, ctx: &TargetCtx<'_>) -> Option bool { +pub(super) fn any_adapter_reaches_concrete(concrete: &str, coverage: &AdapterCoverage) -> bool { coverage.values().any(|set| set.contains(concrete)) } /// True iff any backed impl-method canonical is covered or /// transitively reachable. Drives the anchor-orphan suppression so /// all-direct-concrete coverage doesn't fire a false orphan. -fn any_impl_canonical_covered_or_reachable( +pub(super) fn any_impl_canonical_covered_or_reachable( info: &AnchorInfo, coverage: &AdapterCoverage, reachable: &HashSet, diff --git a/src/adapters/analyzers/architecture/call_parity_rule/check_b_coverage.rs b/src/adapters/analyzers/architecture/call_parity_rule/check_b_coverage.rs index e83bb591..86865b89 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/check_b_coverage.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/check_b_coverage.rs @@ -144,7 +144,7 @@ fn propagate_callees( /// Phantom edge sinks (e.g. fabricated `::` canonicals /// from inherited-default impls) carry a cached `layer_of` but no /// `forward` entry; they must not propagate as target capabilities. -fn is_target_capability_node( +pub(super) fn is_target_capability_node( canonical: &str, graph: &CallGraph, target_layer: &str, diff --git a/src/adapters/analyzers/architecture/call_parity_rule/check_d.rs b/src/adapters/analyzers/architecture/call_parity_rule/check_d.rs index d42f74c0..b438f3c1 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/check_d.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/check_d.rs @@ -94,7 +94,7 @@ fn inspect_anchor( /// True iff any adapter has `concrete` in its count map. Mirror of /// `check_b::any_adapter_reaches_concrete` for Check D's count shape. -fn any_adapter_counts_concrete(concrete: &str, counts: &AdapterTargetCounts) -> bool { +pub(super) fn any_adapter_counts_concrete(concrete: &str, counts: &AdapterTargetCounts) -> bool { counts.values().any(|m| m.contains_key(concrete)) } diff --git a/src/adapters/analyzers/architecture/call_parity_rule/hint/candidates.rs b/src/adapters/analyzers/architecture/call_parity_rule/hint/candidates.rs index 66976890..b4ab45fd 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/hint/candidates.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/hint/candidates.rs @@ -44,6 +44,7 @@ const STDLIB_ATTRS: &[&str] = &[ /// One private + attributed fn that survives the stdlib-attribute /// filter. Carries the source location for hint rendering and the /// attribute names so the hint can name them explicitly. +#[derive(Debug)] pub(crate) struct PrivateCandidate { pub canonical: String, pub file: String, diff --git a/src/adapters/analyzers/architecture/call_parity_rule/hint/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/hint/mod.rs index 11a8674b..c5f859db 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/hint/mod.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/hint/mod.rs @@ -157,7 +157,7 @@ fn group_by_adapter(candidates: &[PrivateCandidate]) -> HashMap<&str, Vec<&Priva /// Render the final hint string. Operation: per-adapter block /// assembly. -fn format_hint(by_adapter: &[(String, Vec<&PrivateCandidate>)]) -> String { +pub(super) fn format_hint(by_adapter: &[(String, Vec<&PrivateCandidate>)]) -> String { let mut lines: Vec = Vec::new(); for (adapter, hits) in by_adapter { let (noun, verb) = if hits.len() == 1 { diff --git a/src/adapters/analyzers/architecture/call_parity_rule/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/mod.rs index 32688082..a1e1fd43 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/mod.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/mod.rs @@ -218,7 +218,7 @@ fn collect_active_handler_canonicals( out } -fn project_call_parity(hit: MatchLocation, cp: &CompiledCallParity) -> Finding { +pub(super) fn project_call_parity(hit: MatchLocation, cp: &CompiledCallParity) -> Finding { let rule_id = match &hit.kind { ViolationKind::CallParityNoDelegation { .. } => RULE_NO_DELEGATION, ViolationKind::CallParityMissingAdapter { .. } => RULE_MISSING_ADAPTER, @@ -234,7 +234,7 @@ fn project_call_parity(hit: MatchLocation, cp: &CompiledCallParity) -> Finding { /// (Warn → Low, Error → Medium; Off is filtered out before projection). /// All other call-parity findings are Medium. /// Operation: variant dispatch. -fn severity_for(kind: &ViolationKind, cp: &CompiledCallParity) -> Severity { +pub(super) fn severity_for(kind: &ViolationKind, cp: &CompiledCallParity) -> Severity { match kind { ViolationKind::CallParityMultiTouchpoint { .. } => match cp.single_touchpoint { SingleTouchpointMode::Error => Severity::Medium, diff --git a/src/adapters/analyzers/architecture/call_parity_rule/pub_fns.rs b/src/adapters/analyzers/architecture/call_parity_rule/pub_fns.rs index 4e8c8cfe..7d46c0bc 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/pub_fns.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/pub_fns.rs @@ -169,7 +169,7 @@ impl WorkspaceSetup { /// `collect_findings` runs `pub_fns` before `build_call_graph`. A /// future v1.2.6 refactor can hoist this into a shared `WorkspaceSetup` /// owned by `collect_findings` and threaded into both passes. -fn build_reexports_for_pub_fns( +pub(super) fn build_reexports_for_pub_fns( files: &[(&str, &syn::File)], aliases_per_file: &HashMap, workspace: &super::local_symbols::WorkspaceLookup<'_>, diff --git a/src/adapters/analyzers/architecture/call_parity_rule/reexports.rs b/src/adapters/analyzers/architecture/call_parity_rule/reexports.rs index 8d543f26..3eb55424 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/reexports.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/reexports.rs @@ -221,7 +221,7 @@ fn build_reexport_canonical(file_path: &str, mod_stack: &[String], name: &str) - /// True iff `vis` is anything other than `Inherited`. `pub`, /// `pub(crate)`, `pub(super)`, `pub(in path)` all create re-exports; /// only the bare-private form skips registration. -fn is_pub_use(vis: &syn::Visibility) -> bool { +pub(super) fn is_pub_use(vis: &syn::Visibility) -> bool { !matches!(vis, syn::Visibility::Inherited) } @@ -231,7 +231,7 @@ fn is_pub_use(vis: &syn::Visibility) -> bool { /// reexport and target canonicals. /// Operation: recursive AST walk, own calls hidden in closure. // qual:recursive -fn collect_pub_use_leaves( +pub(super) fn collect_pub_use_leaves( prefix: &[String], tree: &syn::UseTree, out: &mut Vec<(Vec, String)>, @@ -284,7 +284,7 @@ fn collect_pub_use_leaves( /// re-export key, replace with its target. Bounded by /// `MAX_REEXPORT_CHAIN_DEPTH` so a malformed cyclic input can't /// hang. Operation. -fn flatten_chains(map: &mut ReexportMap) { +pub(super) fn flatten_chains(map: &mut ReexportMap) { let keys: Vec = map.keys().cloned().collect(); for key in keys { let mut current = map.get(&key).cloned().unwrap_or_default(); diff --git a/src/adapters/analyzers/architecture/call_parity_rule/signature_params.rs b/src/adapters/analyzers/architecture/call_parity_rule/signature_params.rs index f640e95a..89043df5 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/signature_params.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/signature_params.rs @@ -319,7 +319,7 @@ fn trait_bound_paths( /// `Path(p)`, `Json(body)`, `Data(ctx)`). Returns `None` for deeper /// destructuring that the resolver can't express yet. /// Operation: pattern peel. -fn param_name_from_pat(pat: &syn::Pat) -> Option { +pub(super) fn param_name_from_pat(pat: &syn::Pat) -> Option { match pat { syn::Pat::Ident(pi) => Some(pi.ident.to_string()), syn::Pat::TupleStruct(ts) if ts.elems.len() == 1 => { diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/mod.rs index 8cbe1e68..f0f0b3f2 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/mod.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/mod.rs @@ -11,6 +11,7 @@ pub(super) use std::collections::{HashMap, HashSet}; mod basic; mod inference_fallback; +mod pattern_collectors; mod receiver_tracking; mod resolution_misc; mod turbofish; diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/pattern_collectors.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/pattern_collectors.rs new file mode 100644 index 00000000..ecb2fc21 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/calls/pattern_collectors.rs @@ -0,0 +1,126 @@ +//! Tests for the private pattern-ident collectors in `calls.rs` +//! (`extract_pat_ident_name`, `collect_pattern_idents` + its +//! `walk_each`/`push_pat_ident` helpers), the macro-body token parser +//! (`parse_macro_tokens`), and the `while`-loop visitor. Each isolates +//! one match arm / `-> ()` / `Stmt::Local` extraction. + +use super::*; + +/// Parse a pattern source into `syn::Pat` via a `let`-binding wrapper +/// (syn parses refutable patterns here without a refutability check, so +/// `Some(x)` / `A(x) | B(y)` work too). Nested `match` extraction keeps +/// this a 2-statement body — not the 3-`let` shape the DRY fragment +/// detector flags against `type_infer`'s pattern helper. +fn parse_pat(src: &str) -> syn::Pat { + if let Ok(file) = syn::parse_str::(&format!("fn _t() {{ let {src} = _x; }}")) { + if let syn::Item::Fn(f) = &file.items[0] { + if let syn::Stmt::Local(local) = &f.block.stmts[0] { + return local.pat.clone(); + } + } + } + // Or-patterns (`A | B`) are only valid in a match arm. Nested `match` + // extraction (not 3 `let`s) keeps this clear of the DRY fragment + // detector vs `type_infer`'s pattern helper. + let file: syn::File = + syn::parse_str(&format!("fn _t() {{ match _x {{ {src} => () }} }}")).expect("parse pat"); + match &file.items[0] { + syn::Item::Fn(f) => match &f.block.stmts[0] { + syn::Stmt::Expr(syn::Expr::Match(m), _) => m.arms[0].pat.clone(), + _ => unreachable!("match stmt"), + }, + _ => unreachable!("fn item"), + } +} + +fn idents(src: &str) -> Vec { + let mut out = Vec::new(); + collect_pattern_idents(&parse_pat(src), &mut out); + out +} + +// ── extract_pat_ident_name ────────────────────────────────────────────── + +#[test] +fn extract_pat_ident_name_peels_ident_and_type() { + // `x` → Some; `x: u8` peels the `Pat::Type` wrapper → Some; a tuple + // binds no single ident → None. Pins `-> None`, the `Pat::Ident` arm, + // and the `Pat::Type` arm. + assert_eq!( + extract_pat_ident_name(&parse_pat("x")).as_deref(), + Some("x") + ); + assert_eq!( + extract_pat_ident_name(&parse_pat("x: u8")).as_deref(), + Some("x"), + "Pat::Type peeled to inner ident" + ); + assert_eq!(extract_pat_ident_name(&parse_pat("(a, b)")), None); +} + +// ── collect_pattern_idents (one arm per pattern kind) ─────────────────── + +#[test] +fn collect_pattern_idents_covers_every_binding_kind() { + // Each arm contributes its bound idents. Pins the Ident/Type/Reference/ + // Paren/Tuple/TupleStruct/Struct/Slice/Or arms + `walk_each`/ + // `push_pat_ident` against deletion / `-> ()`. + assert_eq!(idents("x"), vec!["x"], "Ident (push_pat_ident)"); + assert_eq!(idents("x: u8"), vec!["x"], "Type"); + assert_eq!(idents("&x"), vec!["x"], "Reference"); + assert_eq!(idents("(x)"), vec!["x"], "Paren"); + assert_eq!(idents("(a, b)"), vec!["a", "b"], "Tuple (walk_each)"); + assert_eq!(idents("Some(x)"), vec!["x"], "TupleStruct"); + assert_eq!(idents("Foo { a, b }"), vec!["a", "b"], "Struct"); + assert_eq!(idents("[a, b]"), vec!["a", "b"], "Slice"); + // Or takes the first case only. + assert_eq!(idents("A(x) | B(y)"), vec!["x"], "Or (first case)"); +} + +#[test] +fn push_pat_ident_recurses_into_at_subpattern() { + // `whole @ Some(inner)` binds both names — pins `push_pat_ident`'s + // subpattern recursion against `-> ()`. + assert_eq!(idents("whole @ Some(inner)"), vec!["whole", "inner"]); +} + +// ── parse_macro_tokens ────────────────────────────────────────────────── + +fn rendered(exprs: &[syn::Expr]) -> String { + use quote::ToTokens; + exprs + .iter() + .map(|e| e.to_token_stream().to_string()) + .collect::>() + .join(" | ") +} + +#[test] +fn parse_macro_tokens_extracts_let_init_exprs() { + // A `let x = foo();` statement in a macro body contributes its init + // expression. Pins the `Stmt::Local(l)` arm against deletion (which + // would drop the init through the `_ => None` fallback). + let exprs = parse_macro_tokens(quote::quote! { let x = foo(); }); + assert!( + !exprs.is_empty() && rendered(&exprs).contains("foo"), + "let-init expr extracted: {}", + rendered(&exprs) + ); +} + +// ── visit_expr_while ──────────────────────────────────────────────────── + +#[test] +fn calls_inside_while_loop_are_collected() { + // A call in a `while` body must be collected — pins `visit_expr_while` + // against `-> ()` (which would skip the loop body entirely). + let calls = calls_in( + "pub fn f() { while cond() { helper_in_loop(); } }", + "src/cli/h.rs", + "f", + ); + assert!( + calls.iter().any(|c| c.contains("helper_in_loop")), + "call in while body collected: {calls:?}" + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/collect_findings_integration.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/collect_findings_integration.rs new file mode 100644 index 00000000..0d7779d3 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/collect_findings_integration.rs @@ -0,0 +1,71 @@ +//! Integration test for the `collect_findings` orchestrator — the only +//! place that gates hint enrichment behind `!check_b_hits.is_empty()`. +//! (The unit-level `tests/check_b/hints.rs` exercises enrichment through +//! the manual `run_check_b` path, which has no such guard.) + +use super::support::{cli_mcp_config, ports_app_cli_mcp}; +use crate::adapters::analyzers::architecture::call_parity_rule::collect_findings; +use crate::adapters::analyzers::architecture::compiled::CompiledArchitecture; +use crate::adapters::analyzers::architecture::layer_rule::UnmatchedBehavior; +use crate::config::Config; +use crate::ports::{AnalysisContext, ParsedFile}; +use globset::GlobSet; +use std::collections::HashMap; + +fn parsed(path: &str, src: &str) -> ParsedFile { + ParsedFile { + path: path.to_string(), + content: src.to_string(), + ast: syn::parse_file(src).expect("parse file"), + } +} + +fn compiled_with_call_parity() -> CompiledArchitecture { + CompiledArchitecture { + layers: ports_app_cli_mcp(), + reexport_points: GlobSet::empty(), + unmatched_behavior: UnmatchedBehavior::CompositionRoot, + external_exact: HashMap::new(), + external_glob: Vec::new(), + forbidden: Vec::new(), + trait_contracts: Vec::new(), + call_parity: Some(cli_mcp_config(2)), + } +} + +#[test] +fn collect_findings_enriches_missing_adapter_findings_with_hints() { + // cli reaches `Session::open` directly; mcp reaches it only through a + // PRIVATE `#[tool]` fn → a missing-adapter finding for mcp plus a hint + // naming that private fn. `collect_findings` only enriches when + // `!check_b_hits.is_empty()` — deleting the `!` skips enrichment for + // real findings, so the hint text disappears from the message. + let files = vec![ + parsed( + "src/application/session.rs", + "pub struct Session;\npub struct MyErr;\nimpl Session { pub fn open(_p: &str) -> Result { todo!() } }", + ), + parsed( + "src/cli/handlers.rs", + "use crate::application::session::Session;\npub fn cmd_search() { let _ = Session::open(\"/p\"); }", + ), + parsed( + "src/mcp/server.rs", + "use crate::application::session::{Session, MyErr};\npub struct Server;\nimpl Server { #[tool(description = \"search\")] async fn search(&self) -> Result<(), MyErr> { let _ = Session::open(\"/p\"); Ok(()) } }", + ), + ]; + let config = Config::default(); + let ctx = AnalysisContext { + files: &files, + config: &config, + }; + let compiled = compiled_with_call_parity(); + let findings = collect_findings(&ctx, &compiled); + assert!( + findings + .iter() + .any(|f| f.message.contains("transitively reach")), + "missing-adapter finding carries the private-fn hint: {:?}", + findings.iter().map(|f| &f.message).collect::>() + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/collectors_internal.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/collectors_internal.rs new file mode 100644 index 00000000..5fcf7795 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/collectors_internal.rs @@ -0,0 +1,227 @@ +//! Tests for the symbol/type collectors that feed the call-parity +//! pipeline: `collect_local_symbols` (item-name table), the workspace +//! type-canonical walker (`pub_fns_alias_chain`), and the call-graph +//! `FileFnCollector` test-attr skip. Each isolates one match arm / +//! cfg-test guard / `||`→`&&`. + +use super::support::{build_graph_only, build_workspace, three_layer}; +use crate::adapters::analyzers::architecture::call_parity_rule::file_visibility::collect_file_root_visibility; +use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::{ + collect_local_symbols, collect_workspace_module_paths, WorkspaceLookup, +}; +use crate::adapters::analyzers::architecture::call_parity_rule::pub_fns::build_reexports_for_pub_fns; +use crate::adapters::analyzers::architecture::call_parity_rule::pub_fns_alias_chain::{ + collect_alias_chain, collect_workspace_type_canonicals, +}; +use crate::adapters::analyzers::architecture::call_parity_rule::pub_fns_visibility::collect_visible_type_canonicals_workspace; +use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::collect_crate_root_modules; +use crate::adapters::shared::use_tree::{gather_alias_map, AliasMap}; +use std::collections::{HashMap, HashSet}; + +fn parse(src: &str) -> syn::File { + syn::parse_str(src).expect("parse") +} + +// ── local_symbols::item_name table ────────────────────────────────────── + +#[test] +fn collect_local_symbols_covers_every_item_kind() { + // Each item kind contributes its declared name. Pins the + // `Item::Enum/Union/Const/Static` arms of `item_name` against + // deletion (which would drop that name). + let ast = parse( + "fn f() {}\nstruct S;\nenum E {}\nunion U { a: u8 }\ntrait T {}\ntype Ty = u8;\nconst C: u8 = 0;\nstatic St: u8 = 0;", + ); + let syms = collect_local_symbols(&ast); + for name in ["f", "S", "E", "U", "T", "Ty", "C", "St"] { + assert!(syms.contains(name), "`{name}` collected: {syms:?}"); + } +} + +// ── pub_fns_alias_chain::walk_type_canonicals ─────────────────────────── + +#[test] +fn workspace_type_canonicals_cover_kinds_and_skip_cfg_test_mod() { + // struct/enum/union/trait/type each contribute a canonical; a type + // inside a `#[cfg(test)] mod` is excluded. Pins the + // `Enum/Union/Trait` arms against deletion and the + // `!has_cfg_test(&m.attrs)` mod guard against `true`. + let src = "pub struct S; pub enum E {} pub union U { a: u8 } pub trait T {} pub type Ty = u8;\n#[cfg(test)] mod tests { pub struct Hidden; }"; + let ast = parse(src); + let files = vec![("src/app/a.rs", &ast)]; + let cfg_test = HashSet::new(); + let canon = collect_workspace_type_canonicals(&files, &cfg_test); + for leaf in ["::S", "::E", "::U", "::T", "::Ty"] { + assert!( + canon.iter().any(|c| c.ends_with(leaf)), + "canonical ending {leaf} present: {canon:?}" + ); + } + assert!( + !canon.iter().any(|c| c.ends_with("::Hidden")), + "type inside #[cfg(test)] mod excluded: {canon:?}" + ); +} + +// ── file_fn_collector test-attr skip ──────────────────────────────────── + +#[test] +fn graph_excludes_test_fns_as_callers() { + // A `#[test]` fn that calls a production fn must NOT become a graph + // caller node — pins `visit_item_fn`'s `has_cfg_test || has_test_attr` + // skip against `&&` (which would record the test fn and its edge). + let ws = build_workspace(&[( + "src/application/a.rs", + "pub fn prod() {}\n#[test]\nfn t_caller() { prod(); }", + )]); + let graph = build_graph_only(&ws, &three_layer(), &HashSet::new(), &HashSet::new()); + assert!( + !graph.forward.keys().any(|k| k.ends_with("::t_caller")), + "test fn must not be a caller node: {:?}", + graph.forward.keys().collect::>() + ); +} + +#[test] +fn graph_excludes_test_impl_methods_as_callers() { + // Same skip for impl methods — pins `visit_impl_item_fn`'s + // `has_cfg_test || has_test_attr` against `&&`. + let ws = build_workspace(&[( + "src/application/a.rs", + "pub fn prod() {}\npub struct S;\nimpl S { #[test] fn t_method(&self) { prod(); } }", + )]); + let graph = build_graph_only(&ws, &three_layer(), &HashSet::new(), &HashSet::new()); + assert!( + !graph.forward.keys().any(|k| k.ends_with("::t_method")), + "test impl method must not be a caller node: {:?}", + graph.forward.keys().collect::>() + ); +} + +// ── collect_visible_type_canonicals_workspace (is_visible guards) ──────── + +fn workspace_lookup<'a>( + crate_roots: &'a HashSet, + module_paths: &'a HashSet>, + cfg_test: &'a HashSet, +) -> WorkspaceLookup<'a> { + WorkspaceLookup { + cfg_test_files: cfg_test, + crate_root_modules: crate_roots, + workspace_module_paths: module_paths, + } +} + +#[test] +fn visible_type_canonicals_include_public_decls_only() { + // Public struct/enum/union/trait are visible; private ones are not. + // Pins the `is_visible(&_.vis)` guards on the Enum/Union/Trait arms of + // `collect_in_items` against `true`/`false`. + let ast = parse( + "pub enum PubE {} enum PrivE {} pub union PubU { a: u8 } union PrivU { a: u8 } pub trait PubT {} trait PrivT {} pub type PubTy = u8; type PrivTy = u8;", + ); + let files = vec![("src/app/a.rs", &ast)]; + let aliases: HashMap = HashMap::new(); + let roots = collect_crate_root_modules(&files); + let module_paths = collect_workspace_module_paths(&files); + let cfg_test = HashSet::new(); + let workspace = workspace_lookup(&roots, &module_paths, &cfg_test); + let visible = + collect_visible_type_canonicals_workspace(&files, &aliases, &workspace, &HashSet::new()); + for leaf in ["::PubE", "::PubU", "::PubT", "::PubTy"] { + assert!( + visible.iter().any(|c| c.ends_with(leaf)), + "public {leaf} visible: {visible:?}" + ); + } + // Each private decl must be EXCLUDED — pins every `is_visible(&_.vis)` + // guard (enum/union/trait/type) against `-> true`. + for leaf in ["::PrivE", "::PrivU", "::PrivT", "::PrivTy"] { + assert!( + !visible.iter().any(|c| c.ends_with(leaf)), + "private {leaf} not visible: {visible:?}" + ); + } +} + +// ── collect_alias_chain (cfg-test mod guard) ──────────────────────────── + +#[test] +fn alias_chain_skips_aliases_inside_cfg_test_mod() { + // A `type` alias inside a `#[cfg(test)] mod` is excluded from the + // alias chain; a top-level one is kept. Pins `walk_alias_chain`'s + // `!has_cfg_test(&m.attrs)` mod guard against `true`. + let src = "pub struct Real;\npub type TopAlias = Real;\n#[cfg(test)] mod tests { pub type HiddenAlias = super::Real; }"; + let ast = parse(src); + let files = vec![("src/app/a.rs", &ast)]; + let mut aliases: HashMap = HashMap::new(); + aliases.insert("src/app/a.rs".to_string(), gather_alias_map(&ast)); + let roots = collect_crate_root_modules(&files); + let module_paths = collect_workspace_module_paths(&files); + let cfg_test = HashSet::new(); + let workspace = workspace_lookup(&roots, &module_paths, &cfg_test); + let chain = collect_alias_chain(&files, &aliases, &workspace, &HashSet::new()); + assert!( + chain.keys().any(|k| k.ends_with("::TopAlias")), + "top-level alias collected: {chain:?}" + ); + assert!( + !chain.keys().any(|k| k.ends_with("::HiddenAlias")), + "alias inside #[cfg(test)] mod excluded: {chain:?}" + ); +} + +// ── file_visibility::descend_into_mod (via collect_file_root_visibility) ── + +#[test] +fn file_root_visibility_descends_the_module_chain_to_nested_files() { + // `src/a/sub.rs` is reachable via `mod a; mod sub;` and so is visible. + // Reaching it requires `descend_into_mod` to recurse into `a` and then + // resolve the nested `sub` — pins it against `-> Some(false)` (would + // mark the nested file invisible) and `-> None` (which flattens to a + // non-visible result for the deeper path). + let lib = parse("pub mod a;"); + let a = parse("pub mod sub;"); + let sub = parse("pub fn f() {}"); + let files = vec![ + ("src/lib.rs", &lib), + ("src/a.rs", &a), + ("src/a/sub.rs", &sub), + ]; + let vis = collect_file_root_visibility(&files); + assert_eq!( + vis.get("src/a/sub.rs"), + Some(&true), + "nested module file resolved through the chain: {vis:?}" + ); +} + +// ── pub_fns::build_reexports_for_pub_fns (cfg-test filter) ─────────────── + +#[test] +fn build_reexports_resolves_non_test_file_pub_uses() { + // A bare `pub use Widget as W;` in a non-test file resolves `Widget` + // through THAT file's local symbols to `crate::app::prod::Widget`. The + // `!cfg_test_files.contains` filters keep the non-test file in the + // symbol/alias context; deleting a `!` keeps ONLY the test file, so + // `Widget` no longer resolves and the re-export target changes. Assert + // the resolved TARGET, not just the key. + let prod = parse("pub struct Widget;\npub use Widget as W;"); + let testf = parse("pub fn helper() {}"); + let files = vec![("src/app/prod.rs", &prod), ("src/app/tests.rs", &testf)]; + let aliases: HashMap = files + .iter() + .map(|(p, ast)| (p.to_string(), gather_alias_map(ast))) + .collect(); + let roots = collect_crate_root_modules(&files); + let module_paths = collect_workspace_module_paths(&files); + let cfg_test: HashSet = HashSet::from(["src/app/tests.rs".to_string()]); + let workspace = workspace_lookup(&roots, &module_paths, &cfg_test); + let reexports = build_reexports_for_pub_fns(&files, &aliases, &workspace); + assert!( + reexports + .iter() + .any(|(k, v)| k.ends_with("::W") && v.ends_with("::Widget")), + "W re-export resolves to the local Widget: {reexports:?}" + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/hint.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/hint.rs new file mode 100644 index 00000000..cbd9f096 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/hint.rs @@ -0,0 +1,164 @@ +//! Tests for the call-parity hint subsystem (`hint/`): the +//! `CandidateCollector` visitor that records promotable private fns and +//! the `format_hint` renderer. Each test isolates one visitor predicate +//! (visibility chain, test-attr skip, impl/mod nesting) or the +//! singular/plural rendering branch so the corresponding mutant dies. + +use super::support::{borrowed_files, build_workspace, three_layer}; +use crate::adapters::analyzers::architecture::call_parity_rule::hint::{ + collect_private_candidates, format_hint, PrivateCandidate, +}; +use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::{ + collect_workspace_module_paths, WorkspaceLookup, +}; +use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::collect_crate_root_modules; +use std::collections::HashSet; + +/// Collect promotable private candidates from a single in-memory file +/// under the `three_layer` layout (application/cli/mcp), no cfg-test +/// files and no transparent wrappers. Integration: builds the +/// `WorkspaceLookup` the collector needs, then delegates. +fn candidates_of(path: &str, src: &str) -> Vec { + let ws = build_workspace(&[(path, src)]); + let borrowed = borrowed_files(&ws); + let crate_root_modules = collect_crate_root_modules(&borrowed); + let workspace_module_paths = collect_workspace_module_paths(&borrowed); + let cfg_test = HashSet::new(); + let workspace = WorkspaceLookup { + cfg_test_files: &cfg_test, + crate_root_modules: &crate_root_modules, + workspace_module_paths: &workspace_module_paths, + }; + collect_private_candidates( + &borrowed, + &ws.aliases_per_file, + &three_layer(), + &HashSet::new(), + &workspace, + ) +} + +fn has_candidate(cands: &[PrivateCandidate], fn_name: &str) -> bool { + cands.iter().any(|c| c.fn_name == fn_name) +} + +#[test] +fn free_private_attributed_fn_is_recorded() { + // A file-root private fn carrying a non-stdlib attribute is exactly + // what a hint points at. Pins `visit_item_fn` against `-> ()` (which + // would never call `record_if_candidate`) and the `attr_names` + // projection. + let cands = candidates_of("src/application/h.rs", "#[handler]\nfn make_widget() {}"); + assert!( + has_candidate(&cands, "make_widget"), + "free attributed fn collected: {cands:?}" + ); + let c = cands + .iter() + .find(|c| c.fn_name == "make_widget") + .expect("present"); + assert_eq!(c.attr_names, vec!["handler".to_string()], "attr recorded"); +} + +#[test] +fn fn_in_pub_inline_mod_is_recorded() { + // The collector descends into a `pub mod` and records candidates + // inside it. Pins `visit_item_mod` against `-> ()` (which would stop + // the walk at the module boundary, hiding `nested_fn`). + let cands = candidates_of( + "src/application/h.rs", + "pub mod inner { #[handler] fn nested_fn() {} }", + ); + assert!( + has_candidate(&cands, "nested_fn"), + "fn inside pub mod collected: {cands:?}" + ); +} + +#[test] +fn fn_in_private_inline_mod_is_not_recorded() { + // A private inline `mod` is not visible, so a hint pointing inside it + // would never resolve after promotion — the fn must be skipped while a + // sibling top-level fn is still collected. Pins the + // `parent_visible && is_visible(vis)` mod-visibility update against + // `||` (which would keep the buried fn visible). + let cands = candidates_of( + "src/application/h.rs", + "#[handler] fn top_fn() {}\nmod inner { #[handler] fn buried_fn() {} }", + ); + assert!( + has_candidate(&cands, "top_fn"), + "control present: {cands:?}" + ); + assert!( + !has_candidate(&cands, "buried_fn"), + "fn in private mod skipped: {cands:?}" + ); +} + +#[test] +fn fn_in_invisible_impl_is_not_recorded() { + // A method on a private (non-visible) type sits behind an invisible + // impl self-type; promotion can't reach it. Pins both the + // `!impl_stack.is_empty() && !current_impl_visible()` skip (the `!`) + // and the `!segs.is_empty() && visible_canonicals.contains(..)` + // impl-visibility `&&` — either mutation would surface `method_fn`. + let cands = candidates_of( + "src/application/h.rs", + "struct Hidden;\nimpl Hidden { #[handler] fn method_fn() {} }\n#[handler] fn free_fn() {}", + ); + assert!( + has_candidate(&cands, "free_fn"), + "control present: {cands:?}" + ); + assert!( + !has_candidate(&cands, "method_fn"), + "method on private type skipped: {cands:?}" + ); +} + +#[test] +fn test_attributed_fn_is_not_recorded() { + // A `#[test]` fn disappears from the call graph, so it must never be a + // hint candidate even when it also carries a promotable attribute. + // Pins the `has_cfg_test(attrs) || has_test_attr(attrs)` skip against + // `&&` (which would require BOTH, letting the `#[test]`-only fn pass). + let cands = candidates_of( + "src/application/h.rs", + "#[test]\n#[handler]\nfn test_like() {}\n#[handler]\nfn real() {}", + ); + assert!(has_candidate(&cands, "real"), "control present: {cands:?}"); + assert!( + !has_candidate(&cands, "test_like"), + "#[test] fn skipped despite handler attr: {cands:?}" + ); +} + +fn candidate(file: &str, fn_name: &str) -> PrivateCandidate { + PrivateCandidate { + canonical: format!("crate::cli::{fn_name}"), + file: file.to_string(), + line: 1, + fn_name: fn_name.to_string(), + layer: Some("cli".to_string()), + attr_names: vec!["handler".to_string()], + } +} + +#[test] +fn format_hint_uses_singular_vs_plural_per_count() { + // One hit → "1 private fn …"; two hits → "2 private fns …". Pins the + // `hits.len() == 1` branch against `!=` (which would swap the forms). + let a = candidate("src/cli/a.rs", "alpha"); + let b = candidate("src/cli/b.rs", "beta"); + let singular = format_hint(&[("cli".to_string(), vec![&a])]); + assert!( + singular.contains("1 private fn in cli") && singular.contains("transitively reaches"), + "singular noun + verb: {singular}" + ); + let plural = format_hint(&[("cli".to_string(), vec![&a, &b])]); + assert!( + plural.contains("2 private fns in cli") && plural.contains("transitively reach this"), + "plural noun + verb: {plural}" + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/mod.rs index 2f777b40..1ab75005 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/tests/mod.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/mod.rs @@ -4,12 +4,20 @@ mod check_a; mod check_b; mod check_c; mod check_d; +mod collect_findings_integration; +mod collectors_internal; mod end_to_end_snapshot; +mod hint; mod module_resolution; +mod peel_internal; +mod predicates_internal; mod pub_fns; +mod reachable_targets; mod receiver_tracing; mod reexport_resolution; +mod reexports_internal; mod regressions; mod support; mod target_anchors; mod touchpoints; +mod workspace_graph_internals; diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/peel_internal.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/peel_internal.rs new file mode 100644 index 00000000..0c247a16 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/peel_internal.rs @@ -0,0 +1,130 @@ +//! Unit tests for the type-peeling helpers: `bindings::strip_wrappers` +//! (parenthesis + stdlib-ownership peel) and +//! `pub_fns_visibility::peel_to_inner_path` (reference/paren arms + +//! `is_transparent_wrapper`'s single-segment `&&`). + +use crate::adapters::analyzers::architecture::call_parity_rule::bindings::strip_wrappers; +use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; +use crate::adapters::analyzers::architecture::call_parity_rule::pub_fns_visibility::peel_to_inner_path; +use crate::adapters::shared::use_tree::{AliasMap, ScopedAliasMap}; +use std::collections::{HashMap, HashSet}; + +fn ty(src: &str) -> syn::Type { + syn::parse_str(src).expect("parse type") +} + +fn render(ty: &syn::Type) -> String { + use quote::ToTokens; + ty.to_token_stream().to_string() +} + +// ── bindings::strip_wrappers ──────────────────────────────────────────── + +#[test] +fn strip_wrappers_peels_parens_and_stdlib_owners() { + // `(Box)` peels the paren then the `Box` to reach `Inner`. Pins + // the `Type::Paren` arm against deletion (which would return the + // parenthesised type unpeeled). + assert_eq!(render(strip_wrappers(&ty("(Box)"))), "Inner"); + // A non-wrapper is returned unchanged (positive control). + assert_eq!(render(strip_wrappers(&ty("Plain"))), "Plain"); +} + +// ── pub_fns_visibility::peel_to_inner_path ────────────────────────────── + +struct Scope { + alias_map: AliasMap, + aliases_per_scope: ScopedAliasMap, + local_symbols: HashSet, + local_decl_scopes: HashMap>>, + crate_roots: HashSet, +} + +impl Scope { + fn new() -> Self { + Self { + alias_map: HashMap::new(), + aliases_per_scope: ScopedAliasMap::new(), + local_symbols: HashSet::new(), + local_decl_scopes: HashMap::new(), + crate_roots: HashSet::new(), + } + } + + fn file_scope(&self) -> FileScope<'_> { + FileScope { + path: "src/app/x.rs", + alias_map: &self.alias_map, + aliases_per_scope: &self.aliases_per_scope, + local_symbols: &self.local_symbols, + local_decl_scopes: &self.local_decl_scopes, + crate_root_modules: &self.crate_roots, + workspace_module_paths: None, + } + } +} + +fn peel_leaf(src: &str) -> Option { + let scope = Scope::new(); + let wraps = HashSet::new(); + peel_to_inner_path(&ty(src), &wraps, &scope.file_scope(), &[]).map(|tp| { + tp.path + .segments + .last() + .map(|s| s.ident.to_string()) + .unwrap_or_default() + }) +} + +#[test] +fn peel_to_inner_path_unwraps_references_and_parens() { + // `&Inner` and `(Inner)` peel to the inner `Inner` path. Pins the + // `Type::Reference` and `Type::Paren` arms against deletion (which + // would drop to the `_ => None` fallback). + assert_eq!(peel_leaf("&Inner").as_deref(), Some("Inner"), "reference"); + assert_eq!(peel_leaf("(Inner)").as_deref(), Some("Inner"), "paren"); +} + +#[test] +fn peel_to_inner_path_peels_stdlib_wrapper_but_not_other_generics() { + // `Box` is a transparent stdlib owner → peels to `Inner`; + // `Mutex` is NOT transparent → stays `Mutex`. Pins + // `is_transparent_wrapper`'s `single && is_stdlib_direct` against `||` + // (which would peel `Mutex` too). + assert_eq!( + peel_leaf("Box").as_deref(), + Some("Inner"), + "Box peeled" + ); + assert_eq!( + peel_leaf("Mutex").as_deref(), + Some("Mutex"), + "non-transparent wrapper kept" + ); + // Leading-colon paths bypass the canonicaliser (extern-root gate) and + // hit the `single && is_stdlib_direct` fallback: `::Box` peels, + // `::Mutex` does not. Pins that `&&` (line 317) against `||`. + assert_eq!( + peel_leaf("::Box").as_deref(), + Some("Inner"), + "::Box peeled via single-segment fallback" + ); + assert_eq!( + peel_leaf("::Mutex").as_deref(), + Some("Mutex"), + "::Mutex not peeled (single && is_stdlib_direct)" + ); + // Explicit-stdlib multi-segment paths hit the `explicit_stdlib && + // is_stdlib_direct` branch: `std::boxed::Box` peels, `std::sync::Mutex` + // does not. Pins that `&&` against `||` (which would peel `Mutex`). + assert_eq!( + peel_leaf("std::boxed::Box").as_deref(), + Some("Inner"), + "explicit-std Box peeled" + ); + assert_eq!( + peel_leaf("std::sync::Mutex").as_deref(), + Some("Mutex"), + "explicit-std Mutex not peeled (explicit_stdlib && is_stdlib_direct)" + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/predicates_internal.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/predicates_internal.rs new file mode 100644 index 00000000..f444ba57 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/predicates_internal.rs @@ -0,0 +1,365 @@ +//! Unit tests for small pure predicates across the top-level +//! call-parity modules: the Check B/D adapter-coverage probes, the +//! reachability `is_target_capability_node`, the `project_call_parity` / +//! `severity_for` projections, `param_name_from_pat`, and the +//! binding-init / alias-normalisation peels. + +use crate::adapters::analyzers::architecture::call_parity_rule::anchor_index::AnchorInfo; +use crate::adapters::analyzers::architecture::call_parity_rule::bindings::{ + binding_type_from_init, normalize_after_alias, CanonScope, +}; +use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; +use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::CallGraph; +use crate::adapters::analyzers::architecture::{MatchLocation, ViolationKind}; +use crate::adapters::shared::use_tree::{AliasMap, ScopedAliasMap}; +use crate::config::architecture::SingleTouchpointMode; +use crate::domain::Severity; +use std::collections::{HashMap, HashSet}; + +// ── check_b / check_d adapter-coverage probes ─────────────────────────── + +#[test] +fn any_adapter_reaches_concrete_requires_a_real_hit() { + use crate::adapters::analyzers::architecture::call_parity_rule::check_b::any_adapter_reaches_concrete; + let mut coverage: HashMap> = HashMap::new(); + coverage.insert( + "cli".into(), + HashSet::from(["crate::app::handle".to_string()]), + ); + assert!(any_adapter_reaches_concrete( + "crate::app::handle", + &coverage + )); + // No adapter covers it → false (pins `-> true`). + assert!(!any_adapter_reaches_concrete( + "crate::app::other", + &coverage + )); +} + +#[test] +fn any_adapter_counts_concrete_requires_a_real_count() { + use crate::adapters::analyzers::architecture::call_parity_rule::check_d::any_adapter_counts_concrete; + let mut counts: HashMap> = HashMap::new(); + counts.insert( + "cli".into(), + HashMap::from([("crate::app::h".to_string(), 1)]), + ); + assert!(any_adapter_counts_concrete("crate::app::h", &counts)); + assert!(!any_adapter_counts_concrete("crate::app::missing", &counts)); +} + +#[test] +fn any_impl_canonical_covered_or_reachable_is_a_disjunction() { + use crate::adapters::analyzers::architecture::call_parity_rule::check_b::any_impl_canonical_covered_or_reachable; + let info = AnchorInfo { + impl_layers: HashSet::new(), + impl_method_canonicals: HashSet::from(["crate::app::Impl::m".to_string()]), + decl_layer: None, + has_default_body: false, + trait_visible: true, + location: None, + }; + let empty_cov: HashMap> = HashMap::new(); + // Reachable but NOT covered → true via the `||` left operand. Pins + // `||`→`&&` (which would also require coverage). + let reachable = HashSet::from(["crate::app::Impl::m".to_string()]); + assert!(any_impl_canonical_covered_or_reachable( + &info, &empty_cov, &reachable + )); + // Neither reachable nor covered → false. + assert!(!any_impl_canonical_covered_or_reachable( + &info, + &empty_cov, + &HashSet::new() + )); +} + +// ── check_b_coverage::is_target_capability_node ───────────────────────── + +fn graph_with_layer(node: &str, layer: &str, in_forward: bool) -> CallGraph { + let mut layer_of = HashMap::new(); + layer_of.insert(node.to_string(), Some(layer.to_string())); + let mut forward = HashMap::new(); + if in_forward { + forward.insert(node.to_string(), HashSet::new()); + } + CallGraph { + forward, + reverse: HashMap::new(), + layer_of, + trait_method_anchors: HashMap::new(), + } +} + +#[test] +fn is_target_capability_node_needs_layer_and_a_forward_entry() { + use crate::adapters::analyzers::architecture::call_parity_rule::check_b_coverage::is_target_capability_node; + // Target layer + present in `forward` → a real capability node. + let real = graph_with_layer("crate::app::X", "app", true); + assert!(is_target_capability_node( + "crate::app::X", + &real, + "app", + &[] + )); + // Same layer but NO forward entry (phantom sink) and no anchor → + // false. Pins the `layer == target && forward.contains_key` against + // `||` and the whole fn against `-> true`. + let phantom = graph_with_layer("crate::app::X", "app", false); + assert!(!is_target_capability_node( + "crate::app::X", + &phantom, + "app", + &[] + )); +} + +// ── mod::project_call_parity / severity_for ───────────────────────────── + +fn loc(kind: ViolationKind) -> MatchLocation { + MatchLocation { + file: "src/cli/a.rs".into(), + line: 3, + column: 0, + kind, + } +} + +fn multi_touchpoint() -> ViolationKind { + ViolationKind::CallParityMultiTouchpoint { + fn_name: "cmd".into(), + adapter_layer: "cli".into(), + touchpoints: vec!["crate::app::a".into(), "crate::app::b".into()], + } +} + +fn multiplicity_mismatch() -> ViolationKind { + ViolationKind::CallParityMultiplicityMismatch { + target_fn: "crate::app::search".into(), + target_layer: "app".into(), + counts_per_adapter: vec![("cli".into(), 2), ("mcp".into(), 1)], + } +} + +fn cp_with( + mode: SingleTouchpointMode, +) -> crate::adapters::analyzers::architecture::compiled::CompiledCallParity { + let mut cp = super::support::cli_mcp_config(2); + cp.single_touchpoint = mode; + cp +} + +#[test] +fn project_call_parity_maps_each_kind_to_its_rule_id() { + use crate::adapters::analyzers::architecture::call_parity_rule::project_call_parity; + let cp = cp_with(SingleTouchpointMode::Error); + let mm = project_call_parity(loc(multiplicity_mismatch()), &cp); + assert_eq!( + mm.rule_id, "architecture/call_parity/multiplicity_mismatch", + "multiplicity arm" + ); + let mt = project_call_parity(loc(multi_touchpoint()), &cp); + assert_eq!( + mt.rule_id, "architecture/call_parity/multi_touchpoint", + "multi-touchpoint arm" + ); +} + +#[test] +fn severity_for_multi_touchpoint_follows_single_touchpoint_mode() { + use crate::adapters::analyzers::architecture::call_parity_rule::severity_for; + // Error → Medium; Warn → Low. Pins the MultiTouchpoint arm against + // deletion (which would fall through to the `_ => Medium` default). + assert_eq!( + severity_for(&multi_touchpoint(), &cp_with(SingleTouchpointMode::Error)), + Severity::Medium + ); + assert_eq!( + severity_for(&multi_touchpoint(), &cp_with(SingleTouchpointMode::Warn)), + Severity::Low, + "Warn → Low pins the arm vs the Medium default" + ); +} + +// ── signature_params::param_name_from_pat ─────────────────────────────── + +fn pat(src: &str) -> syn::Pat { + let file: syn::File = + syn::parse_str(&format!("fn _t() {{ let {src} = _x; }}")).expect("parse pat"); + match &file.items[0] { + syn::Item::Fn(f) => match &f.block.stmts[0] { + syn::Stmt::Local(local) => local.pat.clone(), + _ => unreachable!(), + }, + _ => unreachable!(), + } +} + +#[test] +fn param_name_from_pat_handles_single_element_extractors_only() { + use crate::adapters::analyzers::architecture::call_parity_rule::signature_params::param_name_from_pat; + // `State(db)` (one-element tuple-struct extractor) → `db`. + assert_eq!( + param_name_from_pat(&pat("State(db)")).as_deref(), + Some("db") + ); + // A two-element tuple struct is NOT a single-arg extractor → None. + // Pins the `ts.elems.len() == 1` guard against `false`/`true`/`!=`. + assert_eq!(param_name_from_pat(&pat("State(a, b)")), None); +} + +// ── bindings::binding_type_from_init ──────────────────────────────────── + +fn expr(src: &str) -> syn::Expr { + syn::parse_str(src).expect("parse expr") +} + +#[test] +fn binding_type_from_init_peels_try_await_and_parens() { + // The init peel loop unwraps `?`, `.await`, and parens before the + // `Type::ctor()` lookup, so all four forms resolve identically. Pins + // the `Expr::Try`/`Await`/`Paren` arms against deletion. + let locals = HashSet::from(["Foo".to_string()]); + let alias = AliasMap::new(); + let roots = HashSet::new(); + let call = + |src: &str| binding_type_from_init(&expr(src), &alias, &locals, &roots, "src/app/x.rs"); + let base = call("Foo::new()"); + assert!(base.is_some(), "bare ctor resolves: {base:?}"); + assert_eq!(call("Foo::new()?"), base, "Try peeled"); + assert_eq!(call("Foo::new().await"), base, "Await peeled"); + assert_eq!(call("(Foo::new())"), base, "Paren peeled"); +} + +#[test] +fn binding_type_from_init_accepts_multi_segment_type_paths() { + // A 3-segment `app::Foo::new()` splits to the 2-segment type prefix + // `app::Foo`. Pins the `segments.len() < 2` guard against `>` (which + // would reject the 3-segment path). + let alias = AliasMap::new(); + let roots = HashSet::from(["app".to_string()]); + let got = binding_type_from_init( + &expr("app::Foo::new()"), + &alias, + &HashSet::new(), + &roots, + "src/app/x.rs", + ); + assert!(got.is_some(), "multi-segment ctor resolves: {got:?}"); +} + +// ── shared minimal FileScope (empty maps) ─────────────────────────────── + +/// Owns the empty maps a `FileScope` borrows, so a single `.file_scope()` +/// call replaces the repeated 5-statement construction (DRY-005). +#[derive(Default)] +struct EmptyScope { + alias_map: AliasMap, + aliases_per_scope: ScopedAliasMap, + local_symbols: HashSet, + local_decl_scopes: HashMap>>, + crate_roots: HashSet, +} + +impl EmptyScope { + fn file_scope(&self) -> FileScope<'_> { + FileScope { + path: "src/app/x.rs", + alias_map: &self.alias_map, + aliases_per_scope: &self.aliases_per_scope, + local_symbols: &self.local_symbols, + local_decl_scopes: &self.local_decl_scopes, + crate_root_modules: &self.crate_roots, + workspace_module_paths: None, + } + } +} + +// ── bindings::normalize_after_alias ───────────────────────────────────── + +#[test] +fn normalize_after_alias_keeps_crate_rooted_paths() { + // A `crate::…` expansion is returned as-is. Pins the `Some("crate")` + // arm against deletion (which would fall through to the submodule / + // crate-root heuristics and mis-handle it). + let scope_owner = EmptyScope::default(); + let file = scope_owner.file_scope(); + let scope = CanonScope { + file: &file, + mod_stack: &[], + reexports: None, + }; + let got = normalize_after_alias( + vec!["crate".to_string(), "app".to_string(), "Foo".to_string()], + false, + &scope, + ); + assert_eq!( + got, + Some(vec![ + "crate".to_string(), + "app".to_string(), + "Foo".to_string() + ]), + "crate-rooted path passes through unchanged" + ); +} + +// ── signature_params::method_canonical_generics (where-bound extending) ── + +#[test] +fn method_where_bound_extends_an_impl_level_generic() { + use crate::adapters::analyzers::architecture::call_parity_rule::signature_params::method_canonical_generics; + // A method `where Q: ExtraBound` for an impl-level generic `Q` must + // merge that bound onto Q's entry. Pins `merge_where_bounds_extending`'s + // `extending_names.iter().any(|n| *n == name)` against `!=` (which would + // drop the where-bound, leaving Q with only its impl-level bound). + let item: syn::ItemFn = + syn::parse_str("fn m(&self) where Q: crate::Marker {}").expect("parse fn"); + let impl_generics = vec![( + "Q".to_string(), + vec![vec!["crate".to_string(), "Base".to_string()]], + )]; + let scope_owner = EmptyScope::default(); + let file = scope_owner.file_scope(); + let out = method_canonical_generics(&item.sig, &impl_generics, &file, &[], None); + let q = out.get("Q").expect("Q present"); + assert!( + q.bounds + .iter() + .any(|b| b.last().is_some_and(|s| s == "Marker")), + "where-clause Marker bound merged onto Q: {:?}", + q.bounds + ); +} + +#[test] +fn method_where_bound_extends_an_existing_method_generic() { + use crate::adapters::analyzers::architecture::call_parity_rule::signature_params::method_canonical_generics; + // A method generic `Q` with an inline bound AND a where-clause bound: + // `merge_where_bounds_extending` must `find` Q's existing inline entry + // and EXTEND it. Pins the `find(|(n, _)| n == &name)` lookup against + // `!=` (which would miss Q's entry → fall through → drop the where-bound + // since Q is not an outer/impl name). + let item: syn::ItemFn = + syn::parse_str("fn m(&self) where Q: crate::Extra {}").expect("parse fn"); + let scope_owner = EmptyScope::default(); + let file = scope_owner.file_scope(); + let out = method_canonical_generics(&item.sig, &[], &file, &[], None); + let q = out.get("Q").expect("Q present"); + assert!( + q.bounds + .iter() + .any(|b| b.last().is_some_and(|s| s == "Base")), + "inline Base bound kept: {:?}", + q.bounds + ); + assert!( + q.bounds + .iter() + .any(|b| b.last().is_some_and(|s| s == "Extra")), + "where-clause Extra bound merged onto the existing Q entry: {:?}", + q.bounds + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/reachable_targets.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/reachable_targets.rs new file mode 100644 index 00000000..d5518d8c --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/reachable_targets.rs @@ -0,0 +1,56 @@ +//! Unit test for `check_b_coverage::build_adapter_reachable_targets` — the +//! anchor-impl propagation step of the reachability BFS that drives Check B's +//! anchor-orphan suppression. + +use crate::adapters::analyzers::architecture::call_parity_rule::anchor_index::AnchorInfo; +use crate::adapters::analyzers::architecture::call_parity_rule::check_b_coverage::build_adapter_reachable_targets; +use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::CallGraph; +use std::collections::{HashMap, HashSet}; + +#[test] +fn reachable_targets_only_propagate_capability_anchor_impls() { + // Anchor "A" (seeded via coverage) lists a phantom impl with a cached + // layer but NO forward entry — NOT a target-capability node. The + // `is_target_capability_node(..) && reachable.insert(..)` short-circuit + // must keep it OUT of the reachable set. Pins that `&&` against `||` + // (which would run the insert side-effect and add the phantom). + let mut layer_of = HashMap::new(); + layer_of.insert("crate::app::A".to_string(), Some("application".to_string())); + layer_of.insert( + "crate::app::Phantom::m".to_string(), + Some("application".to_string()), + ); + let mut anchors = HashMap::new(); + anchors.insert( + "crate::app::A".to_string(), + AnchorInfo { + impl_layers: HashSet::new(), + impl_method_canonicals: HashSet::from(["crate::app::Phantom::m".to_string()]), + decl_layer: Some("application".to_string()), + has_default_body: false, + trait_visible: true, + location: None, + }, + ); + let graph = CallGraph { + forward: HashMap::new(), // no forward entry for Phantom::m → not a capability node + reverse: HashMap::new(), + layer_of, + trait_method_anchors: anchors, + }; + let mut coverage: HashMap> = HashMap::new(); + coverage.insert( + "cli".to_string(), + HashSet::from(["crate::app::A".to_string()]), + ); + let adapters = vec!["cli".to_string(), "mcp".to_string()]; + let reachable = build_adapter_reachable_targets(&coverage, &graph, "application", &adapters); + assert!( + reachable.contains("crate::app::A"), + "seeded anchor present: {reachable:?}" + ); + assert!( + !reachable.contains("crate::app::Phantom::m"), + "non-capability phantom impl not propagated: {reachable:?}" + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/reexports_internal.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/reexports_internal.rs new file mode 100644 index 00000000..50700491 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/reexports_internal.rs @@ -0,0 +1,80 @@ +//! Unit tests for `reexports.rs` internals: the `pub`-visibility gate +//! (`is_pub_use`), the use-tree leaf collector's `self` handling +//! (`collect_pub_use_leaves`), and the chain-flattening loop bounds +//! (`flatten_chains`). + +use crate::adapters::analyzers::architecture::call_parity_rule::reexports::{ + collect_pub_use_leaves, flatten_chains, is_pub_use, ReexportMap, +}; + +// ── is_pub_use ────────────────────────────────────────────────────────── + +fn vis_of(src: &str) -> syn::Visibility { + let item: syn::ItemUse = syn::parse_str(src).expect("parse use"); + item.vis +} + +#[test] +fn is_pub_use_true_only_for_non_inherited_visibility() { + // `pub use` registers a re-export; bare `use` (Inherited) does not. + // Pins `is_pub_use -> true` (which would register private imports). + assert!(is_pub_use(&vis_of("pub use a::B;")), "pub → reexport"); + assert!( + !is_pub_use(&vis_of("use a::B;")), + "private use → not a reexport" + ); +} + +// ── collect_pub_use_leaves ────────────────────────────────────────────── + +fn leaves(src: &str) -> Vec<(Vec, String)> { + let item: syn::ItemUse = syn::parse_str(src).expect("parse use"); + let mut out = Vec::new(); + collect_pub_use_leaves(&[], &item.tree, &mut out); + out +} + +#[test] +fn collect_leaves_maps_self_to_the_enclosing_module_name() { + // `use a::b::{self}` re-exports module `b` under the name `b`, NOT + // `self`. Pins the `ident == "self"` check against `!=` (which would + // emit a `self` leaf and append `self` to the path). + let out = leaves("pub use a::b::{self};"); + assert_eq!(out.len(), 1, "one leaf: {out:?}"); + assert_eq!(out[0].1, "b", "self leaf named after the module"); + assert_eq!(out[0].0, vec!["a".to_string(), "b".to_string()], "{out:?}"); + // A normal name is unaffected. + let normal = leaves("pub use a::C;"); + assert_eq!(normal[0].1, "C"); + // `self as Bar` (the Rename arm) re-exports module `b` under `Bar` + // with the path staying `a::b` (NOT `a::b::self`). Pins the Rename + // arm's `r.ident == "self"` check against `!=`. + let renamed = leaves("pub use a::b::{self as Bar};"); + assert_eq!(renamed.len(), 1, "one leaf: {renamed:?}"); + assert_eq!(renamed[0].1, "Bar", "renamed to Bar"); + assert_eq!( + renamed[0].0, + vec!["a".to_string(), "b".to_string()], + "self-rename keeps the module path: {renamed:?}" + ); +} + +// ── flatten_chains ────────────────────────────────────────────────────── + +#[test] +fn flatten_chains_resolves_a_terminal_chain_to_its_endpoint() { + // n0→n1→n2→"end". Every key flattens to the terminal `end`. Pins + // `flatten_chains -> ()` (would leave n0→n1), the `depth < MAX` start + // (`==`/`>` break immediately → n0→n1), the `next != current` guard + // (`==`/false → break immediately), and `depth += 1` → `-=` (usize + // underflow panic on the first advancing iteration). The `<=`/`*=` + // mutants only alter the cyclic-input cap, which acyclic real chains + // never reach — see the docs equivalents note. + let mut map: ReexportMap = [("n0", "n1"), ("n1", "n2"), ("n2", "end")] + .into_iter() + .map(|(k, v)| (k.to_string(), v.to_string())) + .collect(); + flatten_chains(&mut map); + assert_eq!(map["n0"], "end", "n0 flattened to terminal: {map:?}"); + assert_eq!(map["n1"], "end", "n1 flattened to terminal: {map:?}"); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/tests/workspace_graph_internals.rs b/src/adapters/analyzers/architecture/call_parity_rule/tests/workspace_graph_internals.rs new file mode 100644 index 00000000..2b8a8197 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/tests/workspace_graph_internals.rs @@ -0,0 +1,142 @@ +//! Unit tests for `workspace_graph` internal predicates that the +//! integration-style graph tests don't pin tightly enough: the +//! crate-rooted impl-path branch in `canonical_fn_name`, the +//! anchor-backed-concrete capability conjunction, and the +//! inherited-default-match guard chain. Each isolates one boolean so +//! the matching mutant dies. + +use crate::adapters::analyzers::architecture::call_parity_rule::anchor_index::AnchorInfo; +use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::workspace_index::WorkspaceTypeIndex; +use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::edge_rewrite::is_inherited_default_match; +use crate::adapters::analyzers::architecture::call_parity_rule::workspace_graph::{ + canonical_fn_name, CallGraph, +}; +use std::collections::{HashMap, HashSet}; + +// ── canonical_fn_name: crate-rooted impl path branch ──────────────────── + +#[test] +fn canonical_fn_name_prepends_file_module_for_relative_self_type() { + // A non-crate-rooted self type (`Some(["Foo"])`) must be prefixed with + // `crate` + the file's module segments. Pins `is_crate_rooted` against + // `-> true` (which would take the as-is arm and drop the prefix). + let got = canonical_fn_name( + "src/application/x.rs", + Some(&["Foo".to_string()]), + &[], + "method", + ); + assert_eq!(got, "crate::application::x::Foo::method"); +} + +#[test] +fn canonical_fn_name_uses_crate_rooted_self_type_as_is() { + // An already-crate-rooted self type is used verbatim — no file prefix. + // The positive control for `is_crate_rooted` (this arm is identical + // under the `-> true` mutant, so it pins the as-is path's correctness + // rather than the mutant). + let got = canonical_fn_name( + "src/application/x.rs", + Some(&["crate".to_string(), "foo".to_string(), "Bar".to_string()]), + &[], + "method", + ); + assert_eq!(got, "crate::foo::Bar::method"); +} + +// ── is_anchor_backed_concrete: capability AND containment ──────────────── + +fn graph_with_anchor(anchor: &str, info: AnchorInfo) -> CallGraph { + let mut anchors = HashMap::new(); + anchors.insert(anchor.to_string(), info); + CallGraph { + forward: HashMap::new(), + reverse: HashMap::new(), + layer_of: HashMap::new(), + trait_method_anchors: anchors, + } +} + +/// A target-capable anchor (visible trait declared in `application` +/// with a default body) whose overriding-impl canonicals are `impls`. +fn target_capable_anchor(impls: &[&str]) -> AnchorInfo { + AnchorInfo { + impl_layers: HashSet::new(), + impl_method_canonicals: impls.iter().map(|s| s.to_string()).collect(), + decl_layer: Some("application".to_string()), + has_default_body: true, + trait_visible: true, + location: None, + } +} + +#[test] +fn anchor_backed_concrete_requires_both_capability_and_containment() { + let concrete = "crate::application::logging::LoggingHandler::handle"; + let adapters = vec!["cli".to_string(), "mcp".to_string()]; + // Capability holds but the anchor does NOT list this concrete → false. + // Pins the `capability && contains(canonical)` conjunction against `||` + // (which would return true on capability alone). + let no_hit = graph_with_anchor("crate::ports::Handler::handle", target_capable_anchor(&[])); + assert!( + !no_hit.is_anchor_backed_concrete(concrete, "application", &adapters), + "capability without containment → false" + ); + // Both hold → true (positive control). + let hit = graph_with_anchor( + "crate::ports::Handler::handle", + target_capable_anchor(&[concrete]), + ); + assert!( + hit.is_anchor_backed_concrete(concrete, "application", &adapters), + "capability + containment → true" + ); +} + +// ── is_inherited_default_match: guard chain ───────────────────────────── + +/// Index where `crate::T::m` has a default body and `crate::Impl` is a +/// non-overriding impl of `crate::T` — the shape that makes a genuine +/// inherited-default match. +fn inherited_default_index() -> WorkspaceTypeIndex { + let mut idx = WorkspaceTypeIndex::new(); + idx.trait_methods + .insert("crate::T".to_string(), HashSet::from(["m".to_string()])); + idx.trait_methods_with_default_body + .insert(("crate::T".to_string(), "m".to_string())); + // Empty override-set for `crate::Impl` → `impl_overrides_method` is + // false (not the hand-built-index "assume override" default). + idx.trait_impl_overrides.insert( + "crate::T".to_string(), + HashMap::from([("crate::Impl".to_string(), HashSet::new())]), + ); + idx +} + +#[test] +fn inherited_default_match_false_when_impl_not_listed() { + // The impl_canon must appear in `impls`; an empty list short-circuits + // to false. Pins `is_inherited_default_match` against `-> true`. + let idx = inherited_default_index(); + assert!( + !is_inherited_default_match(&idx, "crate::T", &[], "crate::Impl", "m"), + "impl not in trait's impl list → false" + ); +} + +#[test] +fn inherited_default_match_true_for_non_overriding_default_impl() { + // Full match: impl listed, method on trait, default body, not + // overridden → true (positive control for the guard chain). + let idx = inherited_default_index(); + assert!( + is_inherited_default_match( + &idx, + "crate::T", + &["crate::Impl".to_string()], + "crate::Impl", + "m" + ), + "non-overriding default-body impl → true" + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/infer_call.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/infer_call.rs index 293998b3..0c1eaf36 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/infer_call.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/infer_call.rs @@ -229,3 +229,55 @@ fn test_method_call_unknown_method_is_none() { // No entry in method_returns for "bogus" on Session. assert!(infer(&f, "x.bogus()").is_none()); } + +// ── try_method_return: ≥3-segment type-qualified calls ─────────── + +#[test] +fn type_qualified_assoc_call_resolves_via_method_returns() { + // A 3+-segment `crate::app::Session::open()` call splits the last + // segment as the method and probes `method_returns` for the type + // prefix. Pins `try_method_return`'s `segs.len() < 2` guard against + // `>` (which would bail on the 4-segment path and return None). + let mut f = TypeInferFixture::new(); + f.index.insert_method_return( + "crate::app::Session", + "open", + CanonicalType::path(["crate", "app", "Session"]), + ); + let t = infer(&f, "crate::app::Session::open()").expect("3-seg assoc call resolved"); + assert_eq!(t, CanonicalType::path(["crate", "app", "Session"])); +} + +// ── lookup_trait_method_return: dyn-Trait receiver dispatch ─────── + +#[test] +fn trait_bound_receiver_resolves_via_impl_return() { + // A receiver typed as a trait bound dispatches `.handle()` to the + // first workspace impl's return type. Pins both + // `lookup_trait_method_return -> None` and its `!trait_has_method` + // guard (delete `!`) — either would lose the resolution. + let mut f = TypeInferFixture::new(); + f.bindings.insert( + "h", + CanonicalType::TraitBound(vec![vec![ + "crate".to_string(), + "app".to_string(), + "Handler".to_string(), + ]]), + ); + f.index.trait_methods.insert( + "crate::app::Handler".to_string(), + std::collections::HashSet::from(["handle".to_string()]), + ); + f.index.trait_impls.insert( + "crate::app::Handler".to_string(), + vec!["crate::app::LogHandler".to_string()], + ); + f.index.insert_method_return( + "crate::app::LogHandler", + "handle", + CanonicalType::path(["crate", "app", "Outcome"]), + ); + let t = infer(&f, "h.handle()").expect("trait-bound method dispatch resolved"); + assert_eq!(t, CanonicalType::path(["crate", "app", "Outcome"])); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/mod.rs index e1909301..dcad5503 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/mod.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/mod.rs @@ -5,5 +5,6 @@ mod infer_call; mod patterns_destructure; mod patterns_iterator; mod resolve; +mod resolve_internals; mod support; mod workspace_index; diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/patterns_destructure.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/patterns_destructure.rs index 891c7f92..d53bed34 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/patterns_destructure.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/patterns_destructure.rs @@ -276,3 +276,16 @@ fn test_or_pattern_uses_first_branch_bindings() { } // ── Nested patterns ────────────────────────────────────────────── + +#[test] +fn parenthesised_pattern_unwraps_to_inner_binding() { + // `(x)` is a parenthesised pattern; the collector must descend into it + // and bind the inner ident to the matched type. Pins the + // `Pat::Paren(p)` arm against deletion (which would drop the binding + // through the `_` fallback). + let f = TypeInferFixture::new(); + let b = bindings(&f, "(x)", CanonicalType::path(["crate", "app", "T"])); + assert_eq!(b.len(), 1, "paren pattern binds its inner ident: {b:?}"); + assert_eq!(b[0].0, "x"); + assert_eq!(b[0].1, CanonicalType::path(["crate", "app", "T"])); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve_internals.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve_internals.rs new file mode 100644 index 00000000..771e24db --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/resolve_internals.rs @@ -0,0 +1,233 @@ +//! Unit tests for resolver internal predicates that the integration +//! `resolve_type` tests don't pin tightly: marker-trait detection +//! (`resolve_marker`), wrapper-name decision (`resolve_wrapper`), bare- +//! `Self` substitution (`self_subst`), single-ident projection +//! (`resolve_alias`), the `Future` assoc-type guard, and the +//! recursion-depth increment. Each isolates one boolean/arithmetic op. + +use crate::adapters::analyzers::architecture::call_parity_rule::local_symbols::FileScope; +use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::canonical::CanonicalType; +use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::resolve::{ + resolve_type, ResolveContext, +}; +use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::resolve_marker::is_marker_trait; +use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::resolve_wrapper::identify_wrapper_name; +use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::self_subst::substitute_bare_self; +use crate::adapters::analyzers::architecture::call_parity_rule::type_infer::single_ident_of; +use crate::adapters::shared::use_tree::{AliasMap, ScopedAliasMap}; +use std::collections::{HashMap, HashSet}; + +struct Scope { + alias_map: AliasMap, + aliases_per_scope: ScopedAliasMap, + local_symbols: HashSet, + local_decl_scopes: HashMap>>, + crate_roots: HashSet, +} + +impl Scope { + fn new() -> Self { + Self { + alias_map: HashMap::new(), + aliases_per_scope: ScopedAliasMap::new(), + local_symbols: HashSet::new(), + local_decl_scopes: HashMap::new(), + crate_roots: HashSet::new(), + } + } + + fn file_scope(&self) -> FileScope<'_> { + FileScope { + path: "src/app/x.rs", + alias_map: &self.alias_map, + aliases_per_scope: &self.aliases_per_scope, + local_symbols: &self.local_symbols, + local_decl_scopes: &self.local_decl_scopes, + crate_root_modules: &self.crate_roots, + workspace_module_paths: None, + } + } +} + +fn ctx<'a>(file: &'a FileScope<'a>) -> ResolveContext<'a> { + ResolveContext { + file, + mod_stack: &[], + type_aliases: None, + transparent_wrappers: None, + workspace_files: None, + alias_param_subs: None, + generic_params: None, + reexports: None, + } +} + +fn path_of(src: &str) -> syn::Path { + syn::parse_str(src).expect("parse path") +} + +// ── resolve_marker::is_marker_trait ───────────────────────────────────── + +#[test] +fn bare_marker_trait_is_recognised() { + // A bare `Send` (single segment, hits the std prelude) is a marker. + // Pins `is_marker_trait -> false`, the `segs.len() == 1` `==`→`!=`, + // and the `single_segment ||` `||`→`&&` — all three would flip this + // to "not a marker". + let scope = Scope::new(); + let file = scope.file_scope(); + assert!( + is_marker_trait(&path_of("Send"), &ctx(&file)), + "bare `Send` is a std marker trait" + ); +} + +#[test] +fn bare_non_marker_trait_is_not_a_marker() { + // A bare non-marker name (`Handler`) is a real bound, not a marker. + // Pins the final `&& MARKER_TRAITS.contains` against `||` (which + // would call any single-segment path a marker). + let scope = Scope::new(); + let file = scope.file_scope(); + assert!( + !is_marker_trait(&path_of("Handler"), &ctx(&file)), + "bare `Handler` is a real bound" + ); +} + +// ── resolve_wrapper::identify_wrapper_name ────────────────────────────── + +#[test] +fn single_segment_non_wrapper_is_not_a_wrapper() { + // `Foo` (single segment, not in WRAPPER_NAMES) is not a wrapper. Pins + // `single && WRAPPER_NAMES.contains` against `||` (which would accept + // any single-segment name). `Arc` is the positive control. + let scope = Scope::new(); + let file = scope.file_scope(); + let c = ctx(&file); + assert_eq!( + identify_wrapper_name(&path_of("Foo"), "Foo", &c), + None, + "non-wrapper single ident → None" + ); + assert_eq!( + identify_wrapper_name(&path_of("Arc"), "Arc", &c).as_deref(), + Some("Arc"), + "Arc → wrapper" + ); +} + +#[test] +fn explicit_stdlib_non_wrapper_is_not_a_wrapper() { + // `std::Foo` reaches the explicit-stdlib branch; `Foo` isn't a + // wrapper name. Pins `explicit_stdlib && WRAPPER_NAMES.contains` + // against `||` (which would accept any std-prefixed path). + let scope = Scope::new(); + let file = scope.file_scope(); + assert_eq!( + identify_wrapper_name(&path_of("std::Foo"), "Foo", &ctx(&file)), + None, + "std-prefixed non-wrapper → None" + ); +} + +// ── self_subst::substitute_bare_self ──────────────────────────────────── + +fn render(ty: &syn::Type) -> String { + use quote::ToTokens; + ty.to_token_stream().to_string() +} + +#[test] +fn substitute_rewrites_bare_self_but_not_associated_self() { + // Bare `Self` is replaced with the impl segments; `Self::Output` (a + // multi-segment associated path) is left untouched. Pins the + // `qself.is_some() || segments.len() != 1` guard against `&&` (which + // would treat `Self::Output` as bare and drop `Output`). + let impl_segs = vec!["crate".to_string(), "app".to_string(), "Repo".to_string()]; + let bare: syn::Type = syn::parse_str("Self").unwrap(); + assert_eq!( + render(&substitute_bare_self(&bare, &impl_segs)), + render(&syn::parse_str::("crate::app::Repo").unwrap()), + "bare Self rewritten to impl path" + ); + let assoc: syn::Type = syn::parse_str("Self::Output").unwrap(); + assert!( + render(&substitute_bare_self(&assoc, &impl_segs)).contains("Output"), + "Self::Output keeps its associated segment: {}", + render(&substitute_bare_self(&assoc, &impl_segs)) + ); +} + +// ── resolve_alias::single_ident_of ────────────────────────────────────── + +fn type_path(src: &str) -> syn::TypePath { + match syn::parse_str::(src).expect("parse type") { + syn::Type::Path(tp) => tp, + _ => panic!("expected type path"), + } +} + +#[test] +fn single_ident_of_rejects_multi_segment_paths() { + // `a::b` is multi-segment → None; bare `T` → Some("T"). Pins the + // `qself.is_some() || segments.len() != 1` guard against `&&` (which + // would return `Some("a")` for the multi-segment path). + assert_eq!(single_ident_of(&type_path("a::b")), None, "multi-segment"); + assert_eq!( + single_ident_of(&type_path("T")).as_deref(), + Some("T"), + "single ident" + ); +} + +// ── resolve: future Output-assoc guard + recursion depth ──────────────── + +fn resolve_src(ty_src: &str) -> CanonicalType { + let scope = Scope::new(); + let file = scope.file_scope(); + resolve_type(&syn::parse_str(ty_src).expect("parse type"), &ctx(&file)) +} + +#[test] +fn future_requires_output_named_assoc_type() { + // `Future` resolves to `Future`; `Future` + // (non-`Output` assoc, no positional arg) is unresolved → Opaque. + // Pins the `a.ident == "Output"` match guard against `true` (which + // would pick `Item`'s type). + assert!( + matches!( + resolve_src("Future"), + CanonicalType::Future(_) + ), + "Output assoc → Future" + ); + assert_eq!( + resolve_src("Future"), + CanonicalType::Opaque, + "non-Output assoc with no positional arg → Opaque" + ); +} + +/// Count how many `Option` layers wrap the innermost type. +fn option_depth(mut ty: &CanonicalType) -> usize { + let mut n = 0; + while let CanonicalType::Option(inner) = ty { + n += 1; + ty = inner; + } + n +} + +#[test] +fn resolution_depth_is_capped() { + // Nesting deeper than MAX_RESOLVE_DEPTH (32) is truncated to Opaque. + // Pins `depth_guarded`'s `depth + 1` against `depth * 1` (= no + // increment, which would never hit the cap and resolve all 40 layers). + let nested = format!("{}i32{}", "Option<".repeat(40), ">".repeat(40)); + assert_eq!( + option_depth(&resolve_src(&nested)), + 32, + "Option nesting capped at MAX_RESOLVE_DEPTH" + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/mod.rs index 5b228e85..93a3497b 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/mod.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/mod.rs @@ -35,6 +35,7 @@ mod inline_mod_and_traits; mod leading_colon_and_disambiguation; mod method_and_fn_returns; mod turbofish_and_generics; +mod visitor_walks; pub(super) fn parse_file(src: &str) -> syn::File { syn::parse_str(src).expect("parse file") diff --git a/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/visitor_walks.rs b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/visitor_walks.rs new file mode 100644 index 00000000..1bc41e72 --- /dev/null +++ b/src/adapters/analyzers/architecture/call_parity_rule/type_infer/tests/workspace_index/visitor_walks.rs @@ -0,0 +1,150 @@ +//! Tests pinning the `Visit` walkers that populate `WorkspaceTypeIndex` +//! (alias / fn / method / trait collectors). Each isolates one survivor: +//! a `visit_* -> ()` (walk stops, item unrecorded), a `visit_item_mod -> +//! ()` (inline-module items unrecorded), the `||`→`&&` test-attr skip +//! (a `#[test]` item must NOT be indexed), and the alias generic-param +//! `GenericParam::Type` arm. + +use super::*; + +fn has_key_ending(index: &WorkspaceTypeIndex, suffix: &str) -> bool { + index.type_aliases.keys().any(|k| k.ends_with(suffix)) + || index.fn_returns.keys().any(|k| k.ends_with(suffix)) + || index.trait_methods.keys().any(|k| k.ends_with(suffix)) +} + +// ── alias collector (collect_from_file / visit_item_type / visit_item_mod) ── + +#[test] +fn type_alias_is_indexed_with_its_generic_params() { + // A generic type alias must be recorded with its type-param names. + // Pins `collect_from_file -> ()`, `visit_item_type -> ()`, and the + // `GenericParam::Type(t)` arm (deleting it would drop `T`). + let index = index_for( + &[("src/app/a.rs", "pub type Wrapped = Vec;")], + &["src/app/a.rs"], + ); + let entry = index + .type_aliases + .iter() + .find(|(k, _)| k.ends_with("::Wrapped")); + let (_, def) = entry.expect("type alias `Wrapped` indexed"); + assert_eq!(def.params, vec!["T".to_string()], "generic param recorded"); +} + +#[test] +fn type_alias_inside_inline_mod_is_indexed() { + // The alias collector must descend into inline modules. Pins + // `AliasCollector::visit_item_mod -> ()` (which would skip the body). + let index = index_for( + &[( + "src/app/a.rs", + "pub mod inner { pub type Buried = String; }", + )], + &["src/app/a.rs"], + ); + assert!( + index + .type_aliases + .keys() + .any(|k| k.contains("inner") && k.ends_with("::Buried")), + "alias inside `mod inner` indexed: {:?}", + index.type_aliases.keys().collect::>() + ); +} + +// ── fn collector (||→&& test-attr skip) ───────────────────────────────── + +#[test] +fn test_attributed_free_fn_is_not_indexed() { + // `has_cfg_test || has_test_attr` skips test fns from the return + // index. Pins `||`→`&&` (which would require BOTH attrs, indexing the + // `#[test]`-only fn). The plain fn is the positive control. + let index = index_for( + &[( + "src/app/a.rs", + "pub struct R;\n#[test]\nfn skipme() -> R { R }\npub fn keepme() -> R { R }", + )], + &["src/app/a.rs"], + ); + assert!( + index.fn_returns.keys().any(|k| k.ends_with("::keepme")), + "plain fn indexed: {:?}", + index.fn_returns.keys().collect::>() + ); + assert!( + !index.fn_returns.keys().any(|k| k.ends_with("::skipme")), + "#[test] fn must not be indexed: {:?}", + index.fn_returns.keys().collect::>() + ); +} + +// ── method collector (||→&& test-attr skip + visit_item_mod) ──────────── + +#[test] +fn test_attributed_method_is_not_indexed() { + // Same `||`→`&&` skip for impl methods. + let index = index_for( + &[( + "src/app/a.rs", + "pub struct S;\npub struct R;\nimpl S { #[test] fn skipm(&self) -> R { R } pub fn keepm(&self) -> R { R } }", + )], + &["src/app/a.rs"], + ); + let recv = index + .method_returns + .keys() + .find(|k| k.ends_with("::S")) + .expect("receiver S indexed"); + let methods = &index.method_returns[recv]; + assert!(methods.contains_key("keepm"), "plain method indexed"); + assert!( + !methods.contains_key("skipm"), + "#[test] method must not be indexed: {methods:?}" + ); +} + +#[test] +fn method_inside_inline_mod_is_indexed() { + // The method collector must descend into inline modules. Pins + // `MethodCollector::visit_item_mod -> ()`. + let index = index_for( + &[( + "src/app/a.rs", + "pub mod inner { pub struct S; pub struct R; impl S { pub fn m(&self) -> R { R } } }", + )], + &["src/app/a.rs"], + ); + assert!( + index + .method_returns + .keys() + .any(|k| k.contains("inner") && k.ends_with("::S")), + "method on type inside `mod inner` indexed: {:?}", + index.method_returns.keys().collect::>() + ); +} + +// ── trait collector (visit_item_mod) ──────────────────────────────────── + +#[test] +fn trait_inside_inline_mod_is_indexed() { + // The trait collector must descend into inline modules. Pins + // `TraitCollector::visit_item_mod -> ()`. + let index = index_for( + &[( + "src/app/a.rs", + "pub mod inner { pub trait Svc { fn handle(&self); } }", + )], + &["src/app/a.rs"], + ); + assert!( + has_key_ending(&index, "::Svc") + && index + .trait_methods + .keys() + .any(|k| k.contains("inner") && k.ends_with("::Svc")), + "trait inside `mod inner` indexed: {:?}", + index.trait_methods.keys().collect::>() + ); +} diff --git a/src/adapters/analyzers/architecture/call_parity_rule/workspace_graph/edge_rewrite.rs b/src/adapters/analyzers/architecture/call_parity_rule/workspace_graph/edge_rewrite.rs index 929bc8a0..5e62277d 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/workspace_graph/edge_rewrite.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/workspace_graph/edge_rewrite.rs @@ -97,7 +97,7 @@ fn inherited_default_anchor_for( /// `impl_canon` in its impl list, and the impl does NOT override the /// method. Extracted so `inherited_default_anchor_for` stays under /// the SRP cyclomatic budget after adding the ambiguity guard. -fn is_inherited_default_match( +pub(crate) fn is_inherited_default_match( type_index: &WorkspaceTypeIndex, trait_canon: &str, impls: &[String], diff --git a/src/adapters/analyzers/architecture/call_parity_rule/workspace_graph/mod.rs b/src/adapters/analyzers/architecture/call_parity_rule/workspace_graph/mod.rs index b9efbf39..2c6bbbab 100644 --- a/src/adapters/analyzers/architecture/call_parity_rule/workspace_graph/mod.rs +++ b/src/adapters/analyzers/architecture/call_parity_rule/workspace_graph/mod.rs @@ -19,7 +19,7 @@ //! file-local helpers — walking only pub fns would under-count delegation //! chains and trigger false positives in Check A. -mod edge_rewrite; +pub(crate) mod edge_rewrite; pub(crate) use edge_rewrite::apply_edge_rewrite; diff --git a/src/adapters/analyzers/architecture/compiled.rs b/src/adapters/analyzers/architecture/compiled.rs index 317b2b50..31a16db5 100644 --- a/src/adapters/analyzers/architecture/compiled.rs +++ b/src/adapters/analyzers/architecture/compiled.rs @@ -178,7 +178,7 @@ fn last_path_segment(path: &str) -> &str { /// Stage 3 starter-pack: prepend these common framework attribute-macro /// names so users don't need to list them in every rustqual.toml. The /// full set is `defaults ∪ user`. Operation. -fn build_transparent_macros(user: &[String]) -> HashSet { +pub(super) fn build_transparent_macros(user: &[String]) -> HashSet { const DEFAULTS: &[&str] = &[ "instrument", // tracing::instrument "async_trait", // async_trait::async_trait @@ -282,7 +282,7 @@ fn parse_unmatched_behavior(raw: &str) -> Result { /// runtime; users who want to match a hyphenated Cargo package name /// must supply the underscore form or a glob. /// Operation: pure predicate over the character set. -fn is_exact_crate_key(key: &str) -> bool { +pub(super) fn is_exact_crate_key(key: &str) -> bool { !key.is_empty() && key.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') } diff --git a/src/adapters/analyzers/architecture/forbidden_rule.rs b/src/adapters/analyzers/architecture/forbidden_rule.rs index 8f77f8b8..8352f76b 100644 --- a/src/adapters/analyzers/architecture/forbidden_rule.rs +++ b/src/adapters/analyzers/architecture/forbidden_rule.rs @@ -249,7 +249,7 @@ pub(crate) fn is_tie_break_winner( /// item lives inside `foo`'s own file, so crate-root candidates are /// not added. /// Operation: loop building candidate list, no own calls. -fn candidate_paths(inner: &[String]) -> Vec { +pub(super) fn candidate_paths(inner: &[String]) -> Vec { let mut candidates = Vec::new(); for len in (1..=inner.len()).rev() { let head = &inner[..len]; diff --git a/src/adapters/analyzers/architecture/matcher/tests/item_kind.rs b/src/adapters/analyzers/architecture/matcher/tests/item_kind.rs index a687c485..f179d9f8 100644 --- a/src/adapters/analyzers/architecture/matcher/tests/item_kind.rs +++ b/src/adapters/analyzers/architecture/matcher/tests/item_kind.rs @@ -273,3 +273,24 @@ fn unknown_kind_silently_ignored() { let hits = find(src, &["bogus_kind", "async_fn"]); assert_eq!(hits.len(), 1); } + +#[test] +fn top_level_cfg_test_items_detected_for_every_item_kind() { + // One #[cfg(test)] item of each non-mod kind that classify_top_level_non_mod + // handles. Each match arm projects exactly one hit, so a deleted arm drops + // the count below 6. + let src = r#" + #[cfg(test)] static S: u8 = 0; + #[cfg(test)] struct St; + #[cfg(test)] enum En { A } + #[cfg(test)] trait Tr {} + #[cfg(test)] type Ty = u8; + #[cfg(test)] use std::fmt; + "#; + let hits = find(src, &["top_level_cfg_test_item"]); + assert_eq!(hits.len(), 6, "all six item kinds classified: {hits:?}"); + let ns = names(&hits); + for name in ["S", "St", "En", "Tr", "Ty"] { + assert!(ns.contains(&name.to_string()), "{name} present: {ns:?}"); + } +} diff --git a/src/adapters/analyzers/architecture/tests/analyzer.rs b/src/adapters/analyzers/architecture/tests/analyzer.rs new file mode 100644 index 00000000..5492da71 --- /dev/null +++ b/src/adapters/analyzers/architecture/tests/analyzer.rs @@ -0,0 +1,232 @@ +//! Tests for the analyzer's hit→Finding projections + the public +//! `DimensionAnalyzer` surface. Each `Finding` field and rule-id arm is pinned +//! so a deleted field (→ Default) or a swapped rule_id is caught. +use crate::adapters::analyzers::architecture::analyzer::{ + forbidden_hit_to_finding, layer_hit_to_finding, +}; +use crate::adapters::analyzers::architecture::{MatchLocation, ViolationKind}; +use crate::domain::{Dimension, Severity}; + +fn loc(kind: ViolationKind) -> MatchLocation { + MatchLocation { + file: "src/a.rs".into(), + line: 7, + column: 3, + kind, + } +} + +#[test] +fn layer_hit_projects_every_finding_field() { + let f = layer_hit_to_finding(loc(ViolationKind::LayerViolation { + from_layer: "application".into(), + to_layer: "domain".into(), + imported_path: "crate::domain::X".into(), + })); + assert_eq!(f.file, "src/a.rs"); + assert_eq!(f.line, 7); + assert_eq!(f.column, 3); + assert_eq!(f.dimension, Dimension::Architecture); + assert_eq!(f.rule_id, "architecture/layer"); + assert_eq!(f.severity, Severity::High); + assert!(!f.message.is_empty(), "message rendered"); +} + +#[test] +fn unmatched_layer_hit_uses_unmatched_rule_id() { + let f = layer_hit_to_finding(loc(ViolationKind::UnmatchedLayer { + file: "src/a.rs".into(), + })); + assert_eq!( + f.rule_id, "architecture/layer/unmatched", + "unmatched-layer arm selects its own rule id" + ); +} + +#[test] +fn forbidden_hit_projects_every_finding_field() { + let f = forbidden_hit_to_finding(loc(ViolationKind::ForbiddenEdge { + reason: "adapters must not import app".into(), + imported_path: "crate::app::Y".into(), + })); + assert_eq!(f.file, "src/a.rs"); + assert_eq!(f.line, 7); + assert_eq!(f.column, 3); + assert_eq!(f.dimension, Dimension::Architecture); + assert_eq!(f.rule_id, "architecture/forbidden"); + assert_eq!(f.severity, Severity::High); + assert!( + f.message.contains("adapters must not import app"), + "forbidden message carries the reason: {}", + f.message + ); +} + +#[test] +fn dimension_name_is_architecture() { + use crate::adapters::analyzers::architecture::ArchitectureAnalyzer; + use crate::ports::DimensionAnalyzer; + assert_eq!(ArchitectureAnalyzer.dimension_name(), "architecture"); +} + +fn pattern( + allowed_in: Option>, + forbidden_in: Option>, +) -> crate::adapters::config::architecture::SymbolPattern { + crate::adapters::config::architecture::SymbolPattern { + name: "p".into(), + allowed_in, + forbidden_in, + except: vec![], + forbid_path_prefix: Some(vec!["x::".into()]), + forbid_method_call: None, + forbid_function_call: None, + forbid_macro_call: None, + forbid_item_kind: None, + forbid_derive: None, + forbid_glob_import: None, + regex: None, + reason: String::new(), + } +} + +#[test] +fn compile_pattern_scope_requires_exactly_one_of_allowed_forbidden() { + use crate::adapters::analyzers::architecture::analyzer::compile_pattern_scope; + // allowed_in only → AllowedIn scope (Some); forbidden_in only → ForbiddenIn + // (Some). Pins both match arms + the `build_globset` success path. + assert!( + compile_pattern_scope(&pattern(Some(vec!["src/**".into()]), None)).is_some(), + "allowed_in-only compiles" + ); + assert!( + compile_pattern_scope(&pattern(None, Some(vec!["src/**".into()]))).is_some(), + "forbidden_in-only compiles" + ); + // Neither / both → None (the XOR `_ => None`). + assert!( + compile_pattern_scope(&pattern(None, None)).is_none(), + "neither → None" + ); + assert!( + compile_pattern_scope(&pattern(Some(vec!["a".into()]), Some(vec!["b".into()]))).is_none(), + "both → None" + ); + // An invalid glob fails compilation (`build_globset` → None). + assert!( + compile_pattern_scope(&pattern(Some(vec!["[".into()]), None)).is_none(), + "invalid glob → None" + ); +} + +#[test] +fn pattern_scope_accepts_implements_forbidden_allowed_and_except() { + use crate::adapters::analyzers::architecture::analyzer::compile_pattern_scope; + // The scope-COMPILE test above only checks Some/None. This pins the actual + // `accepts()` decision — the spec's "where it fires" mechanic — which was + // otherwise untested (the `pattern()` helper always leaves `except` empty). + + // ForbiddenIn: fires INSIDE the forbidden paths, exempt outside. + let forbidden = + compile_pattern_scope(&pattern(None, Some(vec!["src/domain/**".into()]))).unwrap(); + assert!( + forbidden.accepts("src/domain/bad.rs"), + "ForbiddenIn fires inside its paths" + ); + assert!( + !forbidden.accepts("src/app/ok.rs"), + "ForbiddenIn exempt outside its paths" + ); + + // AllowedIn: the INVERSE — fires EVERYWHERE EXCEPT the allowed paths (the + // spec's "println! only in cli" / "syn:: only in adapters" semantics). + let allowed = compile_pattern_scope(&pattern(Some(vec!["src/cli/**".into()]), None)).unwrap(); + assert!( + !allowed.accepts("src/cli/main.rs"), + "AllowedIn exempt inside its paths" + ); + assert!( + allowed.accepts("src/domain/bad.rs"), + "AllowedIn fires outside its paths" + ); + + // `except` overrides both: a path in except is never matched, even inside + // forbidden_in. + let mut p = pattern(None, Some(vec!["src/domain/**".into()])); + p.except = vec!["src/domain/generated/**".into()]; + let scoped = compile_pattern_scope(&p).unwrap(); + assert!( + scoped.accepts("src/domain/bad.rs"), + "still fires in forbidden_in" + ); + assert!( + !scoped.accepts("src/domain/generated/gen.rs"), + "except exempts even inside forbidden_in" + ); +} + +fn two_layer_config() -> crate::config::ArchitectureConfig { + use crate::config::architecture::{ + ArchitectureLayersConfig, LayerPathsConfig, ReexportPointsConfig, + }; + use std::collections::HashMap; + let mut definitions = HashMap::new(); + definitions.insert( + "domain".into(), + LayerPathsConfig { + paths: vec!["src/domain/**".into()], + }, + ); + definitions.insert( + "adapter".into(), + LayerPathsConfig { + paths: vec!["src/adapters/**".into()], + }, + ); + let mut cfg = crate::config::ArchitectureConfig { + enabled: true, + ..Default::default() + }; + cfg.layers = ArchitectureLayersConfig { + order: vec!["domain".into(), "adapter".into()], + unmatched_behavior: "composition_root".into(), + definitions, + }; + cfg.reexport_points = ReexportPointsConfig { paths: vec![] }; + cfg +} + +#[test] +fn analyze_emits_findings_for_layer_violation_only_when_enabled() { + use crate::adapters::analyzers::architecture::ArchitectureAnalyzer; + use crate::ports::{AnalysisContext, DimensionAnalyzer, ParsedFile}; + let src = "use crate::adapters::X;"; + let files = vec![ParsedFile { + path: "src/domain/bad.rs".into(), + content: src.into(), + ast: syn::parse_file(src).unwrap(), + }]; + // Enabled: a domain file importing an adapter is an inner→outer layer + // violation → at least one finding (pins `analyze -> vec![]` and the + // `!arch.enabled` guard). + let mut config = crate::config::Config::default(); + config.architecture = two_layer_config(); + let ctx = AnalysisContext { + files: &files, + config: &config, + }; + assert!( + !ArchitectureAnalyzer.analyze(&ctx).is_empty(), + "enabled → finding" + ); + // Disabled: same input → no findings. + config.architecture.enabled = false; + let ctx = AnalysisContext { + files: &files, + config: &config, + }; + assert!( + ArchitectureAnalyzer.analyze(&ctx).is_empty(), + "disabled → empty" + ); +} diff --git a/src/adapters/analyzers/architecture/tests/compiled.rs b/src/adapters/analyzers/architecture/tests/compiled.rs index e8909f77..e404b3e2 100644 --- a/src/adapters/analyzers/architecture/tests/compiled.rs +++ b/src/adapters/analyzers/architecture/tests/compiled.rs @@ -410,3 +410,51 @@ fn test_layer_of_crate_path_resolves_crate_root_items() { "crate-root single-segment path must resolve to lib/main's layer" ); } + +#[test] +fn build_transparent_macros_unions_defaults_and_user() { + use crate::adapters::analyzers::architecture::compiled::build_transparent_macros; + let set = build_transparent_macros(&["my_crate::custom_macro".to_string(), " ".to_string()]); + assert!(set.contains("instrument"), "a default is present"); + assert!( + set.contains("custom_macro"), + "user macro's last segment added" + ); + // A blank/whitespace user entry trims to empty and is filtered out (`!is_empty`). + assert!(!set.contains(""), "empty entries filtered: {set:?}"); +} + +#[test] +fn is_exact_crate_key_accepts_alnum_underscore_only() { + use crate::adapters::analyzers::architecture::compiled::is_exact_crate_key; + assert!( + is_exact_crate_key("foo_bar2"), + "alnum + underscore is exact" + ); + assert!(!is_exact_crate_key("foo-bar"), "hyphen → not exact (glob)"); + assert!(!is_exact_crate_key(""), "empty → not exact"); +} + +#[test] +fn compile_includes_trait_contracts() { + use crate::config::architecture::TraitContract; + let mut cfg = cfg_with_layers(&[("domain", "src/domain/**")]); + cfg.trait_contracts = vec![TraitContract { + name: "no_async".into(), + scope: "src/ports/**".into(), + receiver_may_be: None, + required_param_type_contains: None, + forbidden_return_type_contains: None, + forbidden_error_variant_contains: None, + error_types: None, + methods_must_be_async: Some(false), + must_be_object_safe: None, + required_supertraits_contain: None, + }]; + let compiled = compile_architecture(&cfg).expect("compile"); + assert_eq!( + compiled.trait_contracts.len(), + 1, + "the trait contract is compiled (pins compile_trait_contracts != Ok(vec![]))" + ); +} diff --git a/src/adapters/analyzers/architecture/tests/explain.rs b/src/adapters/analyzers/architecture/tests/explain.rs index a70aee4d..8172c34a 100644 --- a/src/adapters/analyzers/architecture/tests/explain.rs +++ b/src/adapters/analyzers/architecture/tests/explain.rs @@ -6,7 +6,9 @@ //! asserted to keep the tests resilient to cosmetic tweaks. use crate::adapters::analyzers::architecture::compiled::CompiledArchitecture; -use crate::adapters::analyzers::architecture::explain::{explain_file, ExplainReport, ImportKind}; +use crate::adapters::analyzers::architecture::explain::{ + explain_file, ExplainReport, ImportEntry, ImportKind, +}; use crate::adapters::analyzers::architecture::forbidden_rule::CompiledForbiddenRule; use crate::adapters::analyzers::architecture::layer_rule::{LayerDefinitions, UnmatchedBehavior}; use globset::{Glob, GlobMatcher, GlobSet, GlobSetBuilder}; @@ -199,3 +201,91 @@ fn render_includes_violation_sections() { assert!(text.to_lowercase().contains("layer violation"), "{text}"); assert!(text.to_lowercase().contains("forbidden"), "{text}"); } + +use crate::adapters::analyzers::architecture::{MatchLocation, ViolationKind}; + +fn base_report() -> ExplainReport { + ExplainReport { + file: "src/x.rs".into(), + layer: None, + rank: None, + is_reexport: false, + imports: vec![], + layer_violations: vec![], + forbidden_violations: vec![], + } +} + +fn layer_violation() -> MatchLocation { + MatchLocation { + file: "src/x.rs".into(), + line: 5, + column: 0, + kind: ViolationKind::LayerViolation { + from_layer: "application".into(), + to_layer: "domain".into(), + imported_path: "crate::domain::Y".into(), + }, + } +} + +#[test] +fn header_shows_layer_and_rank() { + let mut r = base_report(); + r.layer = Some("domain".into()); + r.rank = Some(2); + let text = r.render(); + assert!(text.contains("Layer: domain (rank 2)"), "{text}"); +} + +#[test] +fn layer_violation_line_rendered_and_no_all_clear() { + let mut r = base_report(); + r.layer_violations = vec![layer_violation()]; + let text = r.render(); + assert!(text.contains("Layer violations:"), "section header: {text}"); + assert!( + text.contains("application") && text.contains("domain"), + "from/to layers + import in the line: {text}" + ); + assert!(text.contains("crate::domain::Y"), "imported path: {text}"); + // Violations present → the all-clear line must NOT appear (pins the `&&`). + assert!( + !text.contains("No architecture violations"), + "all-clear suppressed when violations exist: {text}" + ); +} + +#[test] +fn forbidden_violation_line_rendered() { + let mut r = base_report(); + r.forbidden_violations = vec![MatchLocation { + file: "src/x.rs".into(), + line: 9, + column: 0, + kind: ViolationKind::ForbiddenEdge { + reason: "no outward imports".into(), + imported_path: "crate::app::Z".into(), + }, + }]; + let text = r.render(); + assert!(text.contains("Forbidden rule violations:"), "{text}"); + assert!( + text.contains("crate::app::Z") || text.contains("no outward imports"), + "{text}" + ); +} + +#[test] +fn import_entry_renders_tail() { + let mut r = base_report(); + r.imports = vec![ImportEntry { + line: 3, + rendered: "use std::fmt;".into(), + kind: ImportKind::Ignored { + first_segment: "std".into(), + }, + }]; + let text = r.render(); + assert!(text.contains("ignored (std)"), "import tail: {text}"); +} diff --git a/src/adapters/analyzers/architecture/tests/forbidden_rule.rs b/src/adapters/analyzers/architecture/tests/forbidden_rule.rs index 516f0b65..3b4b3648 100644 --- a/src/adapters/analyzers/architecture/tests/forbidden_rule.rs +++ b/src/adapters/analyzers/architecture/tests/forbidden_rule.rs @@ -345,3 +345,49 @@ fn super_does_not_match_unrelated_rule() { )]; assert!(run(&fx, &rules).is_empty()); } + +#[test] +fn file_to_module_segments_treats_crate_roots_as_empty() { + use crate::adapters::analyzers::architecture::forbidden_rule::file_to_module_segments; + // Crate roots (lib.rs / main.rs) map to the empty module path; pins the + // `== "lib" || == "main"` guard against `&&`. + assert!(file_to_module_segments("src/lib.rs").is_empty(), "lib root"); + assert!( + file_to_module_segments("src/main.rs").is_empty(), + "main root" + ); + assert_eq!( + file_to_module_segments("src/foo/bar.rs"), + vec!["foo".to_string(), "bar".to_string()], + "normal module path" + ); +} + +#[test] +fn module_map_prefers_modern_file_over_legacy_mod_rs() { + use crate::adapters::analyzers::architecture::forbidden_rule::build_module_segs_to_path_map; + let ast = syn::parse_str::("fn f() {}").unwrap(); + // mod.rs FIRST, then the modern foo.rs — the modern form must win regardless + // of order (pins the `existing.ends_with("/mod.rs")` overwrite guard). + let files: Vec<(&str, &syn::File)> = vec![("src/foo/mod.rs", &ast), ("src/foo.rs", &ast)]; + let map = build_module_segs_to_path_map(&files); + assert_eq!( + map.get(&vec!["foo".to_string()]).copied(), + Some("src/foo.rs") + ); +} + +#[test] +fn candidate_paths_adds_crate_roots_only_for_single_segment() { + use crate::adapters::analyzers::architecture::forbidden_rule::candidate_paths; + let single = candidate_paths(&["foo".to_string()]); + assert!( + single.iter().any(|c| c == "src/lib.rs"), + "single segment → lib root" + ); + let nested = candidate_paths(&["foo".to_string(), "bar".to_string()]); + assert!( + !nested.iter().any(|c| c == "src/lib.rs"), + "nested path → no crate roots (pins `inner.len() == 1`)" + ); +} diff --git a/src/adapters/analyzers/architecture/tests/mod.rs b/src/adapters/analyzers/architecture/tests/mod.rs index 042085d2..4c76ba3d 100644 --- a/src/adapters/analyzers/architecture/tests/mod.rs +++ b/src/adapters/analyzers/architecture/tests/mod.rs @@ -1,6 +1,7 @@ // Module-level integration tests for the Architecture analyzer. // Matcher-specific unit tests live in matcher/tests/. +mod analyzer; mod call_parity_bench; mod call_parity_golden; mod compiled; diff --git a/src/adapters/analyzers/architecture/tests/rendering.rs b/src/adapters/analyzers/architecture/tests/rendering.rs index c4216fa4..1788dd30 100644 --- a/src/adapters/analyzers/architecture/tests/rendering.rs +++ b/src/adapters/analyzers/architecture/tests/rendering.rs @@ -95,3 +95,132 @@ fn missing_adapter_message_omits_hint_section_when_none() { "no hint must mean no hint section; got {msg:?}" ); } + +#[test] +fn multiplicity_mismatch_head_lists_per_adapter_counts() { + let kind = ViolationKind::CallParityMultiplicityMismatch { + target_fn: "handle".into(), + target_layer: "domain".into(), + counts_per_adapter: vec![("cli".into(), 1), ("http".into(), 2)], + }; + let msg = format_match_message(&kind, "call parity"); + assert!(msg.contains("divergent handler counts"), "{msg}"); + assert!(msg.contains("cli=1") && msg.contains("http=2"), "{msg}"); +} + +#[test] +fn multi_touchpoint_head_lists_touchpoints() { + let kind = ViolationKind::CallParityMultiTouchpoint { + fn_name: "dispatch".into(), + adapter_layer: "adapters".into(), + touchpoints: vec!["a".into(), "b".into()], + }; + let msg = format_match_message(&kind, "call parity"); + assert!(msg.contains("multiple target touchpoints"), "{msg}"); + assert!(msg.contains("adapters::dispatch"), "{msg}"); + assert!(msg.contains('a') && msg.contains('b'), "{msg}"); +} + +#[test] +fn item_kind_head_omits_empty_name() { + let named = format_match_message( + &ViolationKind::ItemKind { + kind: "struct", + name: "Foo".into(), + }, + "r", + ); + assert!(named.contains("struct Foo"), "named: {named}"); + let anon = format_match_message( + &ViolationKind::ItemKind { + kind: "struct", + name: String::new(), + }, + "r", + ); + assert!(anon.contains("struct"), "anon kind: {anon}"); + assert!( + !anon.contains("struct "), + "anonymous item omits the name: {anon}" + ); +} + +fn item_loc() -> crate::adapters::analyzers::architecture::MatchLocation { + crate::adapters::analyzers::architecture::MatchLocation { + file: "src/x.rs".into(), + line: 9, + column: 4, + kind: ViolationKind::ItemKind { + kind: "fn", + name: "bad".into(), + }, + } +} + +#[test] +fn match_to_finding_projects_every_field() { + use crate::adapters::analyzers::architecture::rendering::match_to_finding; + let pattern = crate::adapters::config::architecture::SymbolPattern { + name: "p".into(), + allowed_in: None, + forbidden_in: None, + except: vec![], + forbid_path_prefix: None, + forbid_method_call: None, + forbid_function_call: None, + forbid_macro_call: None, + forbid_item_kind: None, + forbid_derive: None, + forbid_glob_import: None, + regex: None, + reason: "no anon fns".into(), + }; + let f = match_to_finding(item_loc(), "architecture/pattern/x", &pattern); + assert_eq!(f.file, "src/x.rs"); + assert_eq!(f.line, 9); + assert_eq!(f.column, 4); + assert_eq!(f.dimension, crate::domain::Dimension::Architecture); + assert_eq!(f.rule_id, "architecture/pattern/x"); + assert_eq!(f.severity, crate::domain::Severity::Medium); + assert!( + f.message.contains("no anon fns"), + "reason in message: {}", + f.message + ); +} + +#[test] +fn build_architecture_finding_projects_every_field() { + use crate::adapters::analyzers::architecture::rendering::build_architecture_finding; + let f = build_architecture_finding( + item_loc(), + "architecture/layer".into(), + "reason text", + crate::domain::Severity::High, + ); + assert_eq!(f.file, "src/x.rs"); + assert_eq!(f.line, 9); + assert_eq!(f.column, 4); + assert_eq!(f.dimension, crate::domain::Dimension::Architecture); + assert_eq!(f.rule_id, "architecture/layer"); + assert_eq!(f.severity, crate::domain::Severity::High); +} + +#[test] +fn build_file_refs_maps_each_parsed_file() { + use crate::adapters::analyzers::architecture::rendering::build_file_refs; + use crate::ports::{AnalysisContext, ParsedFile}; + let config = crate::config::Config::default(); + let files = vec![ParsedFile { + path: "src/a.rs".into(), + content: "fn f() {}".into(), + ast: syn::parse_file("fn f() {}").unwrap(), + }]; + let ctx = AnalysisContext { + files: &files, + config: &config, + }; + let refs = build_file_refs(&ctx); + assert_eq!(refs.len(), 1, "one ref per parsed file"); + assert_eq!(refs[0].0, "src/a.rs"); +} diff --git a/src/adapters/analyzers/architecture/tests/trait_contract.rs b/src/adapters/analyzers/architecture/tests/trait_contract.rs index a286a8cc..d1714e6b 100644 --- a/src/adapters/analyzers/architecture/tests/trait_contract.rs +++ b/src/adapters/analyzers/architecture/tests/trait_contract.rs @@ -164,6 +164,43 @@ fn required_param_fires_when_none_of_the_params_match() { assert_eq!(checks(&hits), vec!["required_param"]); } +#[test] +fn required_param_flags_the_method_that_lacks_the_param_not_the_one_that_has_it() { + // The `!has_required` guard means the fn WITHOUT the param is flagged. + // Asserting on count alone can't catch a deleted `!` (it would flag the + // other method, keeping the count at 1) — pin the flagged method's + // identity via the detail message. + let mut rule = empty(); + rule.required_param_type_contains = Some("CancellationToken".into()); + let src = r#" + pub trait Svc { + fn with_ctx(&self, ctx: CancellationToken); + fn without(&self, path: String); + } + "#; + let hits = run("any.rs", src, &rule); + let details: Vec<&str> = hits + .iter() + .filter_map(|h| match &h.kind { + ViolationKind::TraitContract { + check: "required_param", + detail, + .. + } => Some(detail.as_str()), + _ => None, + }) + .collect(); + assert_eq!(details.len(), 1, "exactly one required_param hit: {hits:?}"); + assert!( + details[0].contains("without"), + "the method LACKING the param is flagged: {details:?}" + ); + assert!( + !details[0].contains("with_ctx"), + "the method that HAS the param is not flagged: {details:?}" + ); +} + // ── required_supertraits_contain ────────────────────────────────────── #[test] @@ -265,6 +302,27 @@ fn error_variant_substring_flagged_via_naming() { assert_eq!(checks(&hits), vec!["error_variant"]); } +#[test] +fn error_variant_check_inspects_the_named_enum_not_the_first_one() { + // `find_enum_in_file` must match the error enum BY NAME. A decoy enum + // declared first carries the forbidden `syn::` field; the method's + // actual error type (`MyError`, declared second) is clean. Pins the + // `e.ident == name` match guard against `true` (which would pick the + // first enum and wrongly flag it). + let mut rule = empty(); + rule.forbidden_error_variant_contains = vec!["syn::".into()]; + let src = r#" + pub enum DecoyError { Bad(syn::Error) } + pub enum MyError { Clean(String) } + pub trait Svc { fn f(&self) -> Result<(), MyError>; } + "#; + let hits = run("any.rs", src, &rule); + assert!( + checks(&hits).is_empty(), + "must inspect MyError (clean), not the first-declared DecoyError: {hits:?}" + ); +} + // ── combined: clean trait passes all checks ─────────────────────────── #[test] @@ -326,3 +384,42 @@ fn trait_in_nested_inline_module_is_checked() { "traits inside deeply nested inline modules must be checked" ); } + +#[test] +fn trait_contract_hit_to_finding_projects_rule_id_and_fields() { + use crate::adapters::analyzers::architecture::trait_contract_rule::hit_to_finding; + use crate::adapters::analyzers::architecture::{MatchLocation, ViolationKind}; + let hit = MatchLocation { + file: "src/ports/x.rs".into(), + line: 12, + column: 1, + kind: ViolationKind::TraitContract { + trait_name: "Repo".into(), + check: "receiver", + detail: "must take &self".into(), + }, + }; + let f = hit_to_finding(hit); + assert_eq!(f.file, "src/ports/x.rs"); + assert_eq!(f.line, 12); + assert_eq!(f.column, 1); + assert_eq!(f.dimension, crate::domain::Dimension::Architecture); + assert_eq!( + f.rule_id, "architecture/trait_contract/receiver", + "rule id embeds the check name (pins the TraitContract arm)" + ); + assert_eq!(f.severity, crate::domain::Severity::High); +} + +#[test] +fn render_type_collapses_path_colons() { + use crate::adapters::analyzers::architecture::trait_contract_rule::rendering::render_type; + let ty: syn::Type = syn::parse_str("std::fmt::Debug").unwrap(); + assert_eq!( + render_type(&ty), + "std::fmt::Debug", + "`::` closed up, no stray spaces" + ); + let generic: syn::Type = syn::parse_str("Vec").unwrap(); + assert_eq!(render_type(&generic), "Vec"); +} diff --git a/src/adapters/analyzers/architecture/trait_contract_rule/mod.rs b/src/adapters/analyzers/architecture/trait_contract_rule/mod.rs index ebde816d..de8a08c5 100644 --- a/src/adapters/analyzers/architecture/trait_contract_rule/mod.rs +++ b/src/adapters/analyzers/architecture/trait_contract_rule/mod.rs @@ -5,7 +5,7 @@ //! trait is defined; cross-file resolution is out of scope. mod checks; -mod rendering; +pub(crate) mod rendering; use crate::adapters::analyzers::architecture::rendering::{ build_architecture_finding, build_file_refs, @@ -123,7 +123,7 @@ pub fn collect_findings( /// Project a trait-contract hit to a domain `Finding`. /// Operation: rule_id selection + field copy. -fn hit_to_finding(hit: MatchLocation) -> Finding { +pub(super) fn hit_to_finding(hit: MatchLocation) -> Finding { let rule_id = match &hit.kind { ViolationKind::TraitContract { check, .. } => { format!("architecture/trait_contract/{check}") diff --git a/src/adapters/analyzers/architecture/trait_contract_rule/rendering.rs b/src/adapters/analyzers/architecture/trait_contract_rule/rendering.rs index 86a2352c..599db6e9 100644 --- a/src/adapters/analyzers/architecture/trait_contract_rule/rendering.rs +++ b/src/adapters/analyzers/architecture/trait_contract_rule/rendering.rs @@ -18,7 +18,7 @@ use quote::ToTokens; /// stay intact so keyword patterns like `"dyn Error"` or `"impl Trait"` /// match as written. /// Operation: token-stream stringification + targeted whitespace normalisation. -pub(super) fn render_type(ty: &syn::Type) -> String { +pub(crate) fn render_type(ty: &syn::Type) -> String { let mut tokens = proc_macro2::TokenStream::new(); ty.to_tokens(&mut tokens); normalise_rendering(&tokens.to_string()) diff --git a/src/adapters/analyzers/coupling/tests/integration.rs b/src/adapters/analyzers/coupling/tests/integration.rs new file mode 100644 index 00000000..342430e7 --- /dev/null +++ b/src/adapters/analyzers/coupling/tests/integration.rs @@ -0,0 +1,88 @@ +//! End-to-end `analyze_coupling` tests: real `use` statements → +//! graph → metrics → cycles → SDP. The unit-level mechanics live in +//! `root.rs` (graph/metrics/cycles) and `sdp.rs` (the SDP algorithm). + +use super::make_parsed; +use crate::adapters::analyzers::coupling::*; + +#[test] +fn test_analyze_coupling_integration() { + let parsed = make_parsed(vec![ + ("main.rs", "use crate::config::Config; fn main() {}"), + ("config.rs", "pub struct Config;"), + ("pipeline.rs", "use crate::config::Config; pub fn run() {}"), + ]); + let analysis = analyze_coupling(&parsed); + assert_eq!(analysis.metrics.len(), 3); + assert!(analysis.cycles.is_empty()); + + // config should have highest afferent coupling (2 dependents) + let config_metrics = analysis + .metrics + .iter() + .find(|m| m.module_name == "config") + .unwrap(); + assert_eq!(config_metrics.afferent, 2); + assert_eq!(config_metrics.efferent, 0); +} + +#[test] +fn test_analyze_coupling_with_cycle() { + let parsed = make_parsed(vec![ + ("a.rs", "use crate::b::Foo; pub struct Bar;"), + ("b.rs", "use crate::a::Bar; pub struct Foo;"), + ]); + let analysis = analyze_coupling(&parsed); + assert_eq!(analysis.cycles.len(), 1); + assert!(analysis.cycles[0].modules.contains(&"a".to_string())); + assert!(analysis.cycles[0].modules.contains(&"b".to_string())); +} + +#[test] +fn test_analyze_coupling_no_crate_deps() { + let parsed = make_parsed(vec![ + ("a.rs", "use std::collections::HashMap; fn f() {}"), + ("b.rs", "use serde::Deserialize; fn g() {}"), + ]); + let analysis = analyze_coupling(&parsed); + assert!(analysis.cycles.is_empty()); + for m in &analysis.metrics { + assert_eq!(m.afferent, 0); + assert_eq!(m.efferent, 0); + } +} + +#[test] +fn analyze_coupling_surfaces_sdp_violation_from_real_source() { + // End-to-end CP-002: real `use` statements build a graph where stable `a` + // (depended on by x,y; depends only on b) imports the unstable `b` (depends + // on p,q). The SDP check (via `populate_sdp_violations`, the pipeline's + // path) must surface the a→b inversion. The other coupling tests drive the + // SDP algorithm with hand-built `ModuleGraph`s; this pins the full + // source → graph → metrics → SDP composition. + let parsed = make_parsed(vec![ + ("a.rs", "use crate::b::B; pub struct A;"), + ("b.rs", "use crate::p::P; use crate::q::Q; pub struct B;"), + ("x.rs", "use crate::a::A; pub struct X;"), + ("y.rs", "use crate::a::A; pub struct Y;"), + ("p.rs", "pub struct P;"), + ("q.rs", "pub struct Q;"), + ]); + let mut analysis = analyze_coupling(&parsed); + assert!( + analysis.sdp_violations.is_empty(), + "sdp_violations is empty until populate_sdp_violations runs" + ); + populate_sdp_violations(&mut analysis); + let edge = analysis + .sdp_violations + .iter() + .find(|v| v.from_module == "a" && v.to_module == "b"); + let v = edge.expect("a→b SDP violation surfaced from source"); + assert!( + v.from_instability < v.to_instability, + "stable a (I={}) depends on less stable b (I={})", + v.from_instability, + v.to_instability + ); +} diff --git a/src/adapters/analyzers/coupling/tests/mod.rs b/src/adapters/analyzers/coupling/tests/mod.rs index 1c033468..c94bf87d 100644 --- a/src/adapters/analyzers/coupling/tests/mod.rs +++ b/src/adapters/analyzers/coupling/tests/mod.rs @@ -1,2 +1,16 @@ +mod integration; mod root; mod sdp; + +/// Parse a source string into a `syn::File` for graph-building tests. +pub(super) fn parse_code(code: &str) -> syn::File { + syn::parse_file(code).expect("Failed to parse test code") +} + +/// Build the `(path, source, ast)` triples the coupling analyzer consumes. +pub(super) fn make_parsed(files: Vec<(&str, &str)>) -> Vec<(String, String, syn::File)> { + files + .into_iter() + .map(|(path, code)| (path.to_string(), code.to_string(), parse_code(code))) + .collect() +} diff --git a/src/adapters/analyzers/coupling/tests/root.rs b/src/adapters/analyzers/coupling/tests/root.rs index 3733769f..b3e5f00c 100644 --- a/src/adapters/analyzers/coupling/tests/root.rs +++ b/src/adapters/analyzers/coupling/tests/root.rs @@ -1,16 +1,6 @@ +use super::make_parsed; use crate::adapters::analyzers::coupling::*; -fn parse_code(code: &str) -> syn::File { - syn::parse_file(code).expect("Failed to parse test code") -} - -fn make_parsed(files: Vec<(&str, &str)>) -> Vec<(String, String, syn::File)> { - files - .into_iter() - .map(|(path, code)| (path.to_string(), code.to_string(), parse_code(code))) - .collect() -} - /// Find module index by name in graph.modules. fn idx(graph: &ModuleGraph, name: &str) -> usize { graph @@ -98,15 +88,23 @@ fn test_build_graph_group_use() { #[test] fn test_build_graph_external_dep_ignored() { - let parsed = make_parsed(vec![( - "main.rs", - "use std::collections::HashMap; use serde::Deserialize; fn main() {}", - )]); + // `serde::config` collides with the local `config` module on its second + // segment. Only a `crate::`-prefixed path may create an edge, so the + // external import must still be ignored: a non-crate root short-circuits + // the dependency, length alone is not enough. + let parsed = make_parsed(vec![ + ( + "main.rs", + "use std::collections::HashMap; use serde::config::Opt; fn main() {}", + ), + ("config.rs", "pub struct Config;"), + ]); let graph = graph::build_module_graph(&parsed); let main_idx = idx(&graph, "main"); assert!( graph.forward[main_idx].is_empty(), - "External dependencies should be ignored" + "External dependencies must be ignored even when a path segment \ + collides with a local module name" ); } @@ -282,52 +280,3 @@ fn test_cycles_two_independent_cycles() { let cycles = cycles::detect_cycles(&graph); assert_eq!(cycles.len(), 2); } - -// ── analyze_coupling integration test ─────────────────────────── - -#[test] -fn test_analyze_coupling_integration() { - let parsed = make_parsed(vec![ - ("main.rs", "use crate::config::Config; fn main() {}"), - ("config.rs", "pub struct Config;"), - ("pipeline.rs", "use crate::config::Config; pub fn run() {}"), - ]); - let analysis = analyze_coupling(&parsed); - assert_eq!(analysis.metrics.len(), 3); - assert!(analysis.cycles.is_empty()); - - // config should have highest afferent coupling (2 dependents) - let config_metrics = analysis - .metrics - .iter() - .find(|m| m.module_name == "config") - .unwrap(); - assert_eq!(config_metrics.afferent, 2); - assert_eq!(config_metrics.efferent, 0); -} - -#[test] -fn test_analyze_coupling_with_cycle() { - let parsed = make_parsed(vec![ - ("a.rs", "use crate::b::Foo; pub struct Bar;"), - ("b.rs", "use crate::a::Bar; pub struct Foo;"), - ]); - let analysis = analyze_coupling(&parsed); - assert_eq!(analysis.cycles.len(), 1); - assert!(analysis.cycles[0].modules.contains(&"a".to_string())); - assert!(analysis.cycles[0].modules.contains(&"b".to_string())); -} - -#[test] -fn test_analyze_coupling_no_crate_deps() { - let parsed = make_parsed(vec![ - ("a.rs", "use std::collections::HashMap; fn f() {}"), - ("b.rs", "use serde::Deserialize; fn g() {}"), - ]); - let analysis = analyze_coupling(&parsed); - assert!(analysis.cycles.is_empty()); - for m in &analysis.metrics { - assert_eq!(m.afferent, 0); - assert_eq!(m.efferent, 0); - } -} diff --git a/src/adapters/analyzers/coupling/tests/sdp.rs b/src/adapters/analyzers/coupling/tests/sdp.rs index 242f7ba9..23c057fb 100644 --- a/src/adapters/analyzers/coupling/tests/sdp.rs +++ b/src/adapters/analyzers/coupling/tests/sdp.rs @@ -51,49 +51,72 @@ fn test_no_violations_all_same_instability() { } #[test] -fn test_violation_stable_depends_on_unstable() { - // A(stable) → B(unstable), C → A (makes A stable) - // C → A → B - // A: Ca=1, Ce=1, I=0.5 - // B: Ca=1, Ce=0, I=0.0 - // C: Ca=0, Ce=1, I=1.0 - // Edge C→A: C(1.0) → A(0.5) — C is unstable, depends on more stable A → no violation - // Edge A→B: A(0.5) → B(0.0) — A depends on more stable B → no violation - // No violations here. Let me construct a case where there IS a violation. +fn sdp_flags_stable_module_depending_on_unstable_one_with_exact_instabilities() { + // The canonical violation: stable `a` (Ca=2 via x,y; Ce=1 → b; I=1/3) + // depends on unstable `b` (Ca=1 via a; Ce=2 → p,q; I=2/3). The edge points + // stable → unstable, inverting SDP. Asserts the EXACT instabilities (not + // just `< 0.5` / `> 0.5`) so a metric-formula regression is caught here. + let graph = sdp_graph(); + let metrics = compute_coupling_metrics(&graph); + let violations = check_sdp(&graph, &metrics); + assert_eq!(violations.len(), 1, "exactly the a→b edge violates"); + let v = &violations[0]; + assert_eq!(v.from_module, "a"); + assert_eq!(v.to_module, "b"); + assert!( + v.from_instability < v.to_instability, + "stable from-module is less unstable than the to-module" + ); + assert!( + (v.from_instability - 1.0 / 3.0).abs() < 1e-9, + "from-instability ≈ 1/3, got {}", + v.from_instability + ); + assert!( + (v.to_instability - 2.0 / 3.0).abs() < 1e-9, + "to-instability ≈ 2/3, got {}", + v.to_instability + ); +} - // A: Ca=2, Ce=0, I=0.0 (very stable) - // B: Ca=0, Ce=2, I=1.0 (very unstable) - // A → B would be an SDP violation - // We need: X → A, Y → A (gives A Ca=2) - // B → P, B → Q (gives B Ce=2) - // A → B (the violating edge) +#[test] +fn sdp_collects_every_violating_edge_not_just_the_first() { + // One stable hub `a` (Ca=2 via x,y; Ce=2 → b,c; I=0.5) depends on TWO + // unstable modules b and c (each Ca=1, Ce=2 → leaves; I=2/3). Both a→b and + // a→c invert SDP, so the check must accumulate BOTH — not stop at the + // first. Pins the loop's collect-all behaviour. let graph = ModuleGraph { modules: vec![ "a".into(), "b".into(), + "c".into(), "x".into(), "y".into(), "p".into(), "q".into(), + "r".into(), + "s".into(), ], forward: vec![ - vec![1], // a → b - vec![4, 5], // b → p, b → q + vec![1, 2], // a → b, c + vec![5, 6], // b → p, q + vec![7, 8], // c → r, s vec![0], // x → a vec![0], // y → a vec![], // p vec![], // q + vec![], // r + vec![], // s ], }; let metrics = compute_coupling_metrics(&graph); - let violations = check_sdp(&graph, &metrics); - // A: Ca=2, Ce=1, I=1/3 ≈ 0.33 - // B: Ca=1, Ce=2, I=2/3 ≈ 0.67 - // A → B: 0.33 < 0.67 → violation - assert_eq!(violations.len(), 1); - assert_eq!(violations[0].from_module, "a"); - assert_eq!(violations[0].to_module, "b"); - assert!(violations[0].from_instability < violations[0].to_instability); + let mut violations = check_sdp(&graph, &metrics); + violations.sort_by(|l, r| l.to_module.cmp(&r.to_module)); + let edges: Vec<(&str, &str)> = violations + .iter() + .map(|v| (v.from_module.as_str(), v.to_module.as_str())) + .collect(); + assert_eq!(edges, vec![("a", "b"), ("a", "c")], "both edges collected"); } #[test] @@ -160,42 +183,9 @@ fn test_zero_violations_for_stable_leaves() { assert!(violations.is_empty()); } -#[test] -fn test_violation_details() { - // Make a clear violation: stable A depends on unstable B - // Setup: X→A, Y→A gives A high Ca - // B→P, B→Q gives B high Ce - // A→B is the violation - let graph = ModuleGraph { - modules: vec![ - "a".into(), - "b".into(), - "x".into(), - "y".into(), - "p".into(), - "q".into(), - ], - forward: vec![ - vec![1], // a → b - vec![4, 5], // b → p, q - vec![0], // x → a - vec![0], // y → a - vec![], // p - vec![], // q - ], - }; - let metrics = compute_coupling_metrics(&graph); - let violations = check_sdp(&graph, &metrics); - - assert_eq!(violations.len(), 1); - let v = &violations[0]; - assert_eq!(v.from_module, "a"); - assert_eq!(v.to_module, "b"); - // A: Ca=2, Ce=1, I≈0.33 - // B: Ca=1, Ce=2, I≈0.67 - assert!(v.from_instability < 0.5); - assert!(v.to_instability > 0.5); -} +// (Former `test_violation_details` folded into +// `sdp_flags_stable_module_depending_on_unstable_one_with_exact_instabilities` +// above — same fixture (`sdp_graph()`), stronger oracle.) #[test] fn sdp_violation_inherits_suppression_from_either_endpoint() { diff --git a/src/adapters/analyzers/dry/boilerplate/tests/root/bp001_to_005.rs b/src/adapters/analyzers/dry/boilerplate/tests/root/bp001_to_005.rs index 78fbc888..97f484d9 100644 --- a/src/adapters/analyzers/dry/boilerplate/tests/root/bp001_to_005.rs +++ b/src/adapters/analyzers/dry/boilerplate/tests/root/bp001_to_005.rs @@ -35,6 +35,44 @@ fn test_bp001_non_trivial_from_not_flagged() { ); } +#[test] +fn test_bp001_struct_literal_from_detected() { + // A `From` returning a struct literal with path fields is trivial; guards the + // `Expr::Struct` arm of the triviality check. + let code = + "struct W { a: i32 } impl From for W { fn from(a: i32) -> Self { Self { a } } }"; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-001"), + "a struct-literal From with path fields is trivial" + ); +} + +#[test] +fn test_bp001_struct_literal_with_rest_not_trivial() { + // `Self { a, ..Default::default() }` has a rest (`..`), so it is NOT trivial; + // guards the `s.rest.is_none() && …` conjunction. + let code = "struct W { a: i32 } impl From for W { fn from(a: i32) -> Self { Self { a, ..Default::default() } } }"; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-001"), + "a struct literal with `..rest` is not a trivial From" + ); +} + +#[test] +fn test_bp001_requires_method_named_from() { + // A single method NOT named `from` must not be treated as a From body; guards + // the `methods.len() != 1 || ident != "from"` short-circuit. + let code = + "struct W { a: i32 } impl From for W { fn convert(a: i32) -> Self { Self { a } } }"; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-001"), + "an impl From whose only method isn't `from` is not BP-001" + ); +} + // ── BP-002 ───────────────────────────────────────────────── #[test] @@ -208,3 +246,48 @@ fn test_bp005_custom_default_not_flagged() { "Default with custom value (42) should not be flagged" ); } + +#[test] +fn test_bp005_recognises_each_default_value_kind() { + // BP-005 fires only when *every* field is a default value, so each fixture's + // single field uses a distinct default-value kind: dropping that kind's arm + // in `is_default_value_expr` (or breaking its `==`) stops the impl flagging. + let cases = [ + ("float 0.0", "struct S { x: f64 } impl Default for S { fn default() -> Self { Self { x: 0.0 } } }"), + ("empty str", r#"struct S { x: String } impl Default for S { fn default() -> Self { Self { x: "" } } }"#), + ("None", "struct S { x: Option } impl Default for S { fn default() -> Self { Self { x: None } } }"), + ("empty vec!", "struct S { x: Vec } impl Default for S { fn default() -> Self { Self { x: vec![] } } }"), + ]; + for (label, code) in cases { + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-005"), + "default-value kind not recognised: {label}" + ); + } +} + +#[test] +fn test_bp005_reports_struct_name() { + // The finding carries the impl's self-type name; guards `self_type_of`. + let code = "struct Config { x: i32 } impl Default for Config { fn default() -> Self { Self { x: 0 } } }"; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + let bp005 = findings + .iter() + .find(|f| f.pattern_id == "BP-005") + .expect("BP-005 finding"); + assert_eq!(bp005.struct_name.as_deref(), Some("Config")); +} + +#[test] +fn test_bp005_requires_method_named_default() { + // A single method NOT named `default` must not be treated as a Default impl + // body. Guards the `methods.len() != 1 || ident != "default"` short-circuit. + let code = + "struct S { x: i32 } impl Default for S { fn not_default() -> Self { Self { x: 0 } } }"; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-005"), + "an impl Default whose only method isn't `default` is not BP-005" + ); +} diff --git a/src/adapters/analyzers/dry/boilerplate/tests/root/bp006_to_008.rs b/src/adapters/analyzers/dry/boilerplate/tests/root/bp006_to_008.rs index 6d0e317d..07fee082 100644 --- a/src/adapters/analyzers/dry/boilerplate/tests/root/bp006_to_008.rs +++ b/src/adapters/analyzers/dry/boilerplate/tests/root/bp006_to_008.rs @@ -229,3 +229,67 @@ fn test_bp008_no_clones_not_flagged() { "Struct construction without clones should not be flagged" ); } + +// ── BP-002 (trivial Display predicate edge cases) ────────── + +#[test] +fn test_bp002_writeln_display_detected() { + // A Display body using `writeln!` (not just `write!`) is still trivial; + // guards the `writeln` arm of `is_write_macro`. + let code = r#" + use std::fmt; + struct Name(String); + impl fmt::Display for Name { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + writeln!(f, "{}", self.0) + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-002"), + "a writeln!-based Display is trivial" + ); +} + +#[test] +fn test_bp002_requires_method_named_fmt() { + // A Display impl whose single method isn't `fmt` must not be treated as a + // Display body; guards the `methods.len() != 1 || ident != "fmt"` short-circuit. + let code = r#" + use std::fmt; + struct Name(String); + impl fmt::Display for Name { + fn render(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.0) + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-002"), + "an impl Display whose only method isn't `fmt` is not BP-002" + ); +} + +// ── BP-003 (setter branch) ───────────────────────────────── + +#[test] +fn test_bp003_setters_detected() { + // Three trivial setters (`fn set_x(&mut self, v) { self.x = v; }`) — 1 stmt, + // 2 inputs, self-field assignment — must trip BP-003. Guards the setter + // `stmts.len() == 1` and `inputs.len() == 2` checks. + let code = r#" + struct Config { a: i32, b: i32, c: i32 } + impl Config { + fn set_a(&mut self, v: i32) { self.a = v; } + fn set_b(&mut self, v: i32) { self.b = v; } + fn set_c(&mut self, v: i32) { self.c = v; } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-003"), + "three trivial setters should be detected" + ); +} diff --git a/src/adapters/analyzers/dry/boilerplate/tests/root/bp009_onward.rs b/src/adapters/analyzers/dry/boilerplate/tests/root/bp009_onward.rs index 6a19231b..b2888faa 100644 --- a/src/adapters/analyzers/dry/boilerplate/tests/root/bp009_onward.rs +++ b/src/adapters/analyzers/dry/boilerplate/tests/root/bp009_onward.rs @@ -186,3 +186,99 @@ fn test_disabled_boilerplate_returns_empty() { "No findings when no patterns are enabled" ); } + +// ── BP-006 position variants (let binding / impl method) ─── + +#[test] +fn test_bp006_match_in_let_binding_detected() { + // The repetitive match assigned via `let r = match …` must still be detected; + // guards the `Stmt::Local` arm of `check_repetitive_match`. + let code = r#" + enum Color { Red, Blue, Green, Yellow } + enum Shade { Red, Blue, Green, Yellow } + fn convert(c: Color) -> Shade { + let r = match c { + Color::Red => Shade::Red, + Color::Blue => Shade::Blue, + Color::Green => Shade::Green, + Color::Yellow => Shade::Yellow, + }; + r + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-006"), + "a repetitive match in a let binding is detected" + ); +} + +#[test] +fn test_bp006_match_in_impl_method_detected() { + // Guards the `Item::Impl` arm of `check_repetitive_match` (recursion into + // impl methods). + let code = r#" + enum Color { Red, Blue, Green, Yellow } + enum Shade { Red, Blue, Green, Yellow } + struct Conv; + impl Conv { + fn convert(&self, c: Color) -> Shade { + match c { + Color::Red => Shade::Red, + Color::Blue => Shade::Blue, + Color::Green => Shade::Green, + Color::Yellow => Shade::Yellow, + } + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-006"), + "a repetitive match in an impl method is detected" + ); +} + +// ── BP-008 / BP-009 position variants ────────────────────── + +#[test] +fn test_bp008_clone_heavy_in_let_binding_detected() { + // The clone-heavy construction bound via `let b = B {…}` must be detected; + // guards the `Stmt::Local` arm of `check_clone_heavy_conversion`. + let code = r#" + struct A { x: String, y: String, z: String } + struct B { x: String, y: String, z: String } + impl A { + fn to_b(&self) -> B { + let b = B { x: self.x.clone(), y: self.y.clone(), z: self.z.clone() }; + b + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-008"), + "a clone-heavy construction in a let binding is detected" + ); +} + +#[test] +fn test_bp009_overlapping_constructions_in_impl_method_detected() { + // Guards the `Item::Impl` arm of `check_repetitive_struct_update`. + let code = r#" + struct Config { host: String, port: u16, timeout: u64, retries: u32 } + struct Maker; + impl Maker { + fn make(&self) -> (Config, Config) { + let a = Config { host: "a".to_string(), port: 80, timeout: 30, retries: 3 }; + let b = Config { host: "b".to_string(), port: 80, timeout: 30, retries: 3 }; + (a, b) + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-009"), + "overlapping constructions in an impl method are detected" + ); +} diff --git a/src/adapters/analyzers/dry/boilerplate/tests/root/bp_predicates.rs b/src/adapters/analyzers/dry/boilerplate/tests/root/bp_predicates.rs new file mode 100644 index 00000000..d3cf3c21 --- /dev/null +++ b/src/adapters/analyzers/dry/boilerplate/tests/root/bp_predicates.rs @@ -0,0 +1,125 @@ +//! Predicate edge-case tests for the boilerplate detectors that the main +//! BP-NNN files (near the file-length cap) have no room for. Each pins a +//! specific guard/branch in a detector's recognition predicate. +use super::*; + +#[test] +fn test_bp004_builder_method_must_return_bare_self() { + // A builder method's second statement must be the bare `self` value. These + // methods assign a field but return `Self::new()` instead, so they are NOT + // builders — guards the `has_assign && returns_self_val` conjunction + // (turning it into `||` would accept them on the assignment alone). + let code = r#" + struct B { a: i32, b: i32, c: i32 } + impl B { + fn with_a(mut self, v: i32) -> Self { self.a = v; Self::new() } + fn with_b(mut self, v: i32) -> Self { self.b = v; Self::new() } + fn with_c(mut self, v: i32) -> Self { self.c = v; Self::new() } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-004"), + "methods that assign but do not return bare self are not builders" + ); +} + +#[test] +fn test_bp010_short_format_strings_not_collected() { + // Format strings shorter than the minimum length must not be collected, so + // repeating a short one (`"ab"`, len 4 < 5) does not trip BP-010. Guards the + // `starts_with('"') && s.len() >= MIN_FORMAT_STRING_LEN` conjunction. + let code = r#" + fn f() { + println!("ab"); + println!("ab"); + println!("ab"); + println!("ab"); + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-010"), + "short format strings (below the length minimum) must not be collected" + ); +} + +#[test] +fn test_bp009_low_field_overlap_not_flagged() { + // Two constructions of `Config` sharing only 1 of 3 field names → overlap + // ratio 1/3 < 0.5, below the threshold, so NOT flagged. Guards the + // `overlap / min_len >= MIN_OVERLAP_RATIO` division (a `*` would always pass). + let code = r#" + struct Config { a: i32, b: i32, c: i32, x: i32, y: i32 } + fn make() -> (Config, Config) { + let p = Config { a: 1, b: 2, c: 3 }; + let q = Config { a: 1, x: 2, y: 3 }; + (p, q) + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-009"), + "constructions with overlap ratio below 0.5 must not be flagged" + ); +} + +#[test] +fn test_bp007_from_impl_with_extra_method_not_counted() { + // An `impl From` is only an error-enum candidate when it has exactly ONE + // method named `from`. Three impls each with a second method must NOT be + // counted — guards the `methods.len() == 1 && ident == "from"` conjunction. + let code = r#" + enum E {} + impl From for E { fn from(x: i32) -> Self { E::from(0) } fn extra() {} } + impl From for E { fn from(x: u8) -> Self { E::from(0) } fn extra() {} } + impl From for E { fn from(x: u16) -> Self { E::from(0) } fn extra() {} } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-007"), + "From impls with a second method are not error-enum candidates" + ); +} + +#[test] +fn test_bp007_from_impl_with_non_expr_body_not_counted() { + // A candidate `from` body must be a single trailing expression. Three impls + // whose `from` body is a single `let` statement must NOT count — guards the + // `stmts.len() == 1 && matches!(Stmt::Expr(_, None))` conjunction. + let code = r#" + enum E {} + impl From for E { fn from(x: i32) -> Self { let _y = x; } } + impl From for E { fn from(x: u8) -> Self { let _y = x; } } + impl From for E { fn from(x: u16) -> Self { let _y = x; } } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + !findings.iter().any(|f| f.pattern_id == "BP-007"), + "From impls whose body is a let-statement are not trivial wrapping" + ); +} + +#[test] +fn test_bp006_tuple_struct_variant_arms_detected() { + // A repetitive enum→enum match whose arms are tuple-struct variant patterns + // (`Msg::A(_) => Out::A`) must be detected; guards the `Pat::TupleStruct` arm + // of `is_simple_enum_pattern`. + let code = r#" + enum Msg { A(i32), B(i32), C(i32), D(i32) } + enum Out { A, B, C, D } + fn convert(m: Msg) -> Out { + match m { + Msg::A(_) => Out::A, + Msg::B(_) => Out::B, + Msg::C(_) => Out::C, + Msg::D(_) => Out::D, + } + } + "#; + let findings = detect_boilerplate(&parse(code), &BoilerplateConfig::default()); + assert!( + findings.iter().any(|f| f.pattern_id == "BP-006"), + "a tuple-struct-variant enum mapping is detected" + ); +} diff --git a/src/adapters/analyzers/dry/boilerplate/tests/root/mod.rs b/src/adapters/analyzers/dry/boilerplate/tests/root/mod.rs index 1db5862b..d429cf1a 100644 --- a/src/adapters/analyzers/dry/boilerplate/tests/root/mod.rs +++ b/src/adapters/analyzers/dry/boilerplate/tests/root/mod.rs @@ -8,6 +8,7 @@ pub(super) use crate::config::sections::BoilerplateConfig; mod bp001_to_005; mod bp006_to_008; mod bp009_onward; +mod bp_predicates; pub(super) fn parse(code: &str) -> Vec<(String, String, syn::File)> { let syntax = syn::parse_file(code).expect("parse failed"); diff --git a/src/adapters/analyzers/dry/tests/dead_code.rs b/src/adapters/analyzers/dry/tests/dead_code.rs index 2d07bcfa..4947f382 100644 --- a/src/adapters/analyzers/dry/tests/dead_code.rs +++ b/src/adapters/analyzers/dry/tests/dead_code.rs @@ -1283,3 +1283,19 @@ fn helper_reached_via_trait_blanket_dispatch_is_not_dead_code() { warnings.iter().map(|w| (&w.function_name, &w.kind)).collect::>() ); } + +#[test] +fn test_only_called_fn_is_not_uncalled() { + // A production fn called only from tests is TestOnly, NOT Uncalled — guards + // the `!test_calls.contains(qualified)` term of `find_uncalled` (a `||` + // there would wrongly report it as uncalled). + let parsed = + parse("fn helper() { let _ = 1; } #[cfg(test)] mod tests { #[test] fn t() { helper(); } }"); + let warnings = dead_code_warnings(&parsed); + assert!( + !warnings + .iter() + .any(|w| w.function_name == "helper" && matches!(w.kind, DeadCodeKind::Uncalled)), + "a test-only fn must not be reported as Uncalled, got {warnings:?}" + ); +} diff --git a/src/adapters/analyzers/dry/tests/fragments.rs b/src/adapters/analyzers/dry/tests/fragments.rs index 49d3ad16..ac5bc407 100644 --- a/src/adapters/analyzers/dry/tests/fragments.rs +++ b/src/adapters/analyzers/dry/tests/fragments.rs @@ -438,3 +438,35 @@ fn test_detect_fragments_three_way() { "Three matching functions should produce at least 3 pair groups" ); } + +#[test] +fn fragment_entries_span_the_full_window() { + // Two functions share a 3-statement window, each statement on its own line. + // Every fragment entry must span from the first to the last statement line + // (end_line > start_line). Guards the `start + stmt_count - 1` end-index + // arithmetic in `merge_into_fragments` — a `+`/`/` there indexes past the + // window, collapsing the span to a single line. + let parsed = parse_multi(&[ + ( + "a.rs", + "fn foo() {\n let x = 1;\n let y = x + 2;\n let z = y * x;\n}\n", + ), + ( + "b.rs", + "fn bar() {\n let a = 1;\n let b = a + 2;\n let c = b * a;\n}\n", + ), + ]); + let groups = detect_fragments(&parsed, &low_threshold_config()); + assert!( + !groups.is_empty(), + "a shared 3-statement window is a fragment" + ); + for e in &groups[0].entries { + assert!( + e.end_line > e.start_line, + "fragment entry must span multiple lines, got {}..{}", + e.start_line, + e.end_line + ); + } +} diff --git a/src/adapters/analyzers/dry/tests/functions.rs b/src/adapters/analyzers/dry/tests/functions.rs index befbd28e..358fdcea 100644 --- a/src/adapters/analyzers/dry/tests/functions.rs +++ b/src/adapters/analyzers/dry/tests/functions.rs @@ -242,9 +242,34 @@ fn test_group_exact_duplicates_returns_remaining() { assert_eq!(remaining[0], 1); // index of b } +/// Count the `NearDuplicate` groups in `parsed` at the given similarity +/// threshold, plus the first one's similarity. Operation: filter + project. +fn near_dup_similarity( + parsed: &[(String, String, syn::File)], + threshold: f64, +) -> (usize, Option) { + let mut config = low_threshold_config(); + config.similarity_threshold = threshold; + let groups = detect_duplicates(parsed, &config); + let near: Vec = groups + .iter() + .filter_map(|g| match g.kind { + DuplicateKind::NearDuplicate { similarity } => Some(similarity), + _ => None, + }) + .collect(); + (near.len(), near.first().copied()) +} + #[test] -fn test_detect_near_duplicates_high_similarity() { - // Two functions with slight differences — should be near-duplicates +fn near_duplicate_detected_above_threshold_but_rejected_below_it() { + // `func_a`/`func_b` are token-identical except `+ 1` vs `- 1` (same token + // count → same bucket → comparable), forming a near- (not exact) + // duplicate. At a permissive threshold it IS flagged; raising the + // threshold strictly ABOVE the pair's measured similarity rejects it. + // Pins both halves of the spec's "deliberately strict" contract — the old + // version asserted similarity only INSIDE an `if detected`, so it passed + // vacuously when detection broke. let parsed = parse_multi(&[ ( "a.rs", @@ -255,22 +280,19 @@ fn test_detect_near_duplicates_high_similarity() { "fn func_b() { let x = 1; let y = x + 2; let z = y * x; let w = z - 1; }", ), ]); - let mut config = low_threshold_config(); - config.similarity_threshold = 0.80; - let groups = detect_duplicates(&parsed, &config); - // These have different hashes (+ vs -) but high Jaccard similarity - let near_groups: Vec<_> = groups - .iter() - .filter(|g| matches!(g.kind, DuplicateKind::NearDuplicate { .. })) - .collect(); - // Whether detected depends on bucketing — both have similar token counts - // The test verifies the mechanism works, even if thresholds vary - if !near_groups.is_empty() { - let DuplicateKind::NearDuplicate { similarity } = near_groups[0].kind else { - panic!("expected near duplicate"); - }; - assert!(similarity >= 0.80); - } + let (count, similarity) = near_dup_similarity(&parsed, 0.50); + assert_eq!(count, 1, "permissive threshold detects the near-duplicate"); + let similarity = similarity.unwrap(); + assert!( + (0.50..1.0).contains(&similarity), + "near (not exact) similarity in [0.50, 1.0): {similarity}" + ); + let strict = (similarity + 1.0) / 2.0; + let (strict_count, _) = near_dup_similarity(&parsed, strict); + assert_eq!( + strict_count, 0, + "threshold {strict} above similarity {similarity} rejects the pair" + ); } #[test] @@ -293,3 +315,25 @@ fn test_duplicate_entry_has_file_and_line() { assert!(!entry.name.is_empty()); } } + +#[test] +fn token_count_exactly_at_min_tokens_is_kept() { + // `let x = 1;` normalises to exactly 5 tokens. With `min_tokens = 5` it is + // at the boundary and must be KEPT (`tokens.len() < min_tokens` is false). + // Guards the `<` in `build_hash_entry` (a `<=` would drop it). + let config = DuplicatesConfig { + min_tokens: 5, + min_lines: 1, + ..DuplicatesConfig::default() + }; + let parsed = parse_multi(&[ + ("a.rs", "fn a() { let x = 1; }"), + ("b.rs", "fn b() { let y = 1; }"), + ]); + let groups = detect_duplicates(&parsed, &config); + assert_eq!( + groups.len(), + 1, + "bodies with exactly min_tokens tokens are kept and form a duplicate, got {groups:?}" + ); +} diff --git a/src/adapters/analyzers/dry/tests/match_patterns.rs b/src/adapters/analyzers/dry/tests/match_patterns.rs index ed557745..241e1c7d 100644 --- a/src/adapters/analyzers/dry/tests/match_patterns.rs +++ b/src/adapters/analyzers/dry/tests/match_patterns.rs @@ -184,3 +184,62 @@ fn test_group_requires_multiple_functions() { "3 instances even in same fn should be flagged" ); } + +#[test] +fn repeated_matches_in_impl_methods_are_qualified() { + // Three impl methods with identical match patterns form a group. Asserting + // the entries' file and `Type::method` qualified names pins several pieces + // at once: impl-method collection (`visit_impl_item_fn` / `visit_item_impl`), + // the Self-type `Type::Path` arm, `qualify_with_modules`, and `reset_for_file` + // setting the file path. + let code = r#" + enum E { A, B, C } + struct S; + impl S { + fn m1(&self, e: E) -> i32 { match e { E::A => 1, E::B => 2, E::C => 3 } } + fn m2(&self, e: E) -> i32 { match e { E::A => 1, E::B => 2, E::C => 3 } } + fn m3(&self, e: E) -> i32 { match e { E::A => 1, E::B => 2, E::C => 3 } } + } + "#; + let result = detect_repeated_matches(&parse(code)); + assert_eq!( + result.len(), + 1, + "three identical impl-method matches form one group" + ); + let entries = &result[0].entries; + assert!( + entries.iter().all(|e| e.file == "test.rs"), + "entries carry the reset file path, got {:?}", + entries.iter().map(|e| &e.file).collect::>() + ); + let mut names: Vec<&str> = entries.iter().map(|e| e.function_name.as_str()).collect(); + names.sort_unstable(); + assert_eq!( + names, + vec!["S::m1", "S::m2", "S::m3"], + "method names are qualified as `Type::method`" + ); +} + +#[test] +fn repeated_struct_variant_matches_carry_enum_name() { + // Struct-variant patterns (`E::A { .. }`) must yield the enum name; guards + // the `Pat::Struct` arm of `extract_enum_name`. + let code = r#" + enum E { A { x: i32 }, B { x: i32 }, C { x: i32 } } + fn f1(e: E) -> i32 { match e { E::A { .. } => 1, E::B { .. } => 2, E::C { .. } => 3 } } + fn f2(e: E) -> i32 { match e { E::A { .. } => 1, E::B { .. } => 2, E::C { .. } => 3 } } + fn f3(e: E) -> i32 { match e { E::A { .. } => 1, E::B { .. } => 2, E::C { .. } => 3 } } + "#; + let result = detect_repeated_matches(&parse(code)); + assert_eq!( + result.len(), + 1, + "three identical struct-variant matches form one group" + ); + assert_eq!( + result[0].enum_name, "E", + "the enum name is extracted from struct-variant patterns" + ); +} diff --git a/src/adapters/analyzers/dry/tests/wildcards.rs b/src/adapters/analyzers/dry/tests/wildcards.rs index 05c941b5..6fd037a8 100644 --- a/src/adapters/analyzers/dry/tests/wildcards.rs +++ b/src/adapters/analyzers/dry/tests/wildcards.rs @@ -198,3 +198,15 @@ fn test_pub_crate_use_reexport_excluded() { "pub(crate) use re-exports should be excluded" ); } + +#[test] +fn test_detects_wildcard_inside_module() { + // A `use x::*;` nested in an inline module must still be flagged; guards the + // `visit_item_mod` recursion in `WildcardCollector` against being a no-op. + let parsed = parse("mod inner { use crate::module::*; }"); + let warnings = detect_wildcard_imports(&parsed); + assert!( + !warnings.is_empty(), + "a wildcard import inside a module must be detected" + ); +} diff --git a/src/adapters/analyzers/iosp/tests/root/analysis_structure.rs b/src/adapters/analyzers/iosp/tests/root/analysis_structure.rs new file mode 100644 index 00000000..a2e9cec0 --- /dev/null +++ b/src/adapters/analyzers/iosp/tests/root/analysis_structure.rs @@ -0,0 +1,149 @@ +//! Whole-function analysis: effort-score arithmetic, severity boundary, +//! function-line count, for-loop/match delegation, nested-module recursion and +//! the `#[cfg(test)] impl` test flag. Shared helpers live in the parent module. +use super::*; + +#[test] +fn violation_effort_score_is_the_weighted_sum() { + // A Violation with 1 logic location, 1 own call and nesting depth 1 has + // effort = 1*1.0 + 1*1.5 + 1*2.0 = 4.5. Pins the whole weighted-sum formula + // (`build_function_analysis`), killing every `*`/`+` arithmetic mutant. + let a = raw_analysis_of("fn g() {} fn f() { if true { g(); } }", "f"); + assert_eq!(a.effort_score, Some(4.5), "effort = 1*1.0 + 1*1.5 + 1*2.0"); +} + +#[test] +fn violation_with_total_two_is_low_severity() { + // `compute_severity`: total (logic + calls) = 2 is NOT `> 2`, so it is Low, + // not Medium. Guards the `> SEVERITY_MEDIUM_THRESHOLD` boundary (`>=`). + let a = raw_analysis_of("fn g() {} fn f() { if true { g(); } }", "f"); + assert_eq!( + a.severity, + Some(Severity::Low), + "total == 2 is Low, not Medium" + ); +} + +#[test] +fn violation_with_total_five_is_medium_severity() { + // total = 4 logic + 1 call = 5, which is NOT `> 5`, so it is Medium, not + // High. Guards the `> SEVERITY_HIGH_THRESHOLD` boundary (`>` vs `>=`). + let a = raw_analysis_of( + "fn g() {} fn f() { if true {} if true {} if true {} if true {} g(); }", + "f", + ); + assert_eq!( + a.severity, + Some(Severity::Medium), + "total == 5 is Medium, not High" + ); +} + +#[test] +fn single_line_function_has_one_line_count() { + // `function_lines = close_line.saturating_sub(open_line) + 1`. A one-line + // body spans exactly 1 line; guards the `+ 1` (turning it into `* 1` gives + // 0). The `if` makes the body non-trivial so metrics are recorded. + let m = metrics_of("fn f() { if true { let _ = 1; } }"); + assert_eq!(m.function_lines, 1, "a single-line body is 1 line"); +} + +// --- for-loop / match delegation (visitor/mod.rs) ----------------------- +// A for-loop whose body only delegates (calls, possibly via `return`/parens) +// is dispatch, not logic, so it records no logic. Deleting a delegation arm +// makes the body "not delegation" → the loop wrongly counts as logic. + +#[test] +fn for_loop_with_return_delegation_is_not_logic() { + // `return g()` is delegation; guards the `Expr::Return` arm of + // `check_delegation_stack`. + let m = metrics_of("fn g() {} fn f() { for _ in 0..1 { return g(); } }"); + assert_eq!( + m.logic_count, 0, + "a return-delegating for body is not logic" + ); +} + +#[test] +fn for_loop_with_paren_delegation_is_not_logic() { + // `(g())` is delegation; guards the `Expr::Paren` arm of + // `check_delegation_stack`. + let m = metrics_of("fn g() {} fn f() { for _ in 0..1 { (g()); } }"); + assert_eq!(m.logic_count, 0, "a paren-delegating for body is not logic"); +} + +#[test] +fn match_with_block_arms_keeps_them_trivial() { + // Single-statement block arms (`=> { 0 }`) are trivial, so they don't add to + // cyclomatic complexity (base stays 1). Guards the `stmts.len() == 1` guard + // in `is_trivial_match_arm` (turning it false would count them). + let m = metrics_of("fn f(x: i32) -> i32 { match x { 1 => { 0 }, _ => { 1 } } }"); + assert_eq!( + m.cyclomatic_complexity, 1, + "single-statement block match arms are trivial" + ); +} + +// --- nested-module recursion (mod.rs analyze_mod) ----------------------- +// Items inside nested modules must still be analysed and appear in the results. +// Deleting a recursion arm drops them entirely. + +#[test] +fn impl_method_in_nested_module_is_analysed() { + // Guards the `Item::Impl` arm of `analyze_mod`. + let names = analysed_names("mod inner { struct S; impl S { fn m(&self) {} } }"); + assert!(names.iter().any(|n| n == "m"), "got {names:?}"); +} + +#[test] +fn trait_method_in_nested_module_is_analysed() { + // Guards the `Item::Trait` arm of `analyze_mod`. + let names = analysed_names("mod inner { trait T { fn m(&self) {} } }"); + assert!(names.iter().any(|n| n == "m"), "got {names:?}"); +} + +#[test] +fn function_in_doubly_nested_module_is_analysed() { + // Guards the `Item::Mod` arm of `analyze_mod` (recursion into deeper mods). + let names = analysed_names("mod inner { mod deeper { fn m() {} } }"); + assert!(names.iter().any(|n| n == "m"), "got {names:?}"); +} + +// --- cfg(test) impl marks methods as test code ------------------------- +// `file_in_test || has_cfg_test(impl.attrs)` (and the `mod_is_test || …` +// mirror) — a `#[cfg(test)] impl` in production code marks its methods test, +// even though the file/module itself is not test. `struct Keep` stops the file +// being whole-file-classified, so the per-impl `||` is what's exercised. + +#[test] +fn method_in_top_level_cfg_test_impl_is_marked_test() { + // Guards `analyze_file`'s Impl-arm `file_in_test || has_cfg_test(&i.attrs)`. + let m = analysis_of( + "struct Keep; struct S; #[cfg(test)] impl S { fn m(&self) {} }", + "m", + ); + assert!(m.is_test, "a method in a #[cfg(test)] impl is test code"); +} + +#[test] +fn default_method_in_top_level_cfg_test_trait_is_marked_test() { + // Guards `analyze_file`'s Trait-arm `file_in_test || has_cfg_test(&t.attrs)`. + let m = analysis_of("struct Keep; #[cfg(test)] trait T { fn m(&self) {} }", "m"); + assert!( + m.is_test, + "a default method in a #[cfg(test)] trait is test code" + ); +} + +#[test] +fn method_in_modular_cfg_test_impl_is_marked_test() { + // Guards `analyze_mod`'s `mod_is_test || has_cfg_test(&i.attrs)`. + let m = analysis_of( + "struct Keep; struct S; mod inner { #[cfg(test)] impl super::S { fn m(&self) {} } }", + "m", + ); + assert!( + m.is_test, + "a method in a nested #[cfg(test)] impl is test code" + ); +} diff --git a/src/adapters/analyzers/iosp/tests/root/dispatch_and_getters.rs b/src/adapters/analyzers/iosp/tests/root/dispatch_and_getters.rs index 6e89eae9..fd42875d 100644 --- a/src/adapters/analyzers/iosp/tests/root/dispatch_and_getters.rs +++ b/src/adapters/analyzers/iosp/tests/root/dispatch_and_getters.rs @@ -1,5 +1,19 @@ use super::*; +/// A pure match-dispatch fn (every arm is a single delegation). Shared by the +/// classification test and the "complexity is still tracked" test — two +/// distinct contracts on the same canonical shape. +const MATCH_DISPATCH: &str = r#" + fn call_a() {} + fn call_b() {} + fn dispatch(x: i32) { + match x { + 0 => call_a(), + _ => call_b(), + } + } +"#; + #[test] fn test_trivial_self_getter_not_violation() { let code = r#" @@ -110,17 +124,7 @@ fn test_for_loop_delegation_not_violation() { #[test] fn test_match_dispatch_is_integration() { - let code = r#" - fn call_a() {} - fn call_b() {} - fn dispatch(x: i32) { - match x { - 0 => call_a(), - _ => call_b(), - } - } - "#; - let results = parse_and_analyze(code); + let results = parse_and_analyze(MATCH_DISPATCH); let f = results.iter().find(|r| r.name == "dispatch").unwrap(); assert_eq!( f.classification, @@ -199,24 +203,10 @@ fn test_match_with_guard_is_violation() { #[test] fn test_match_dispatch_complexity_still_tracked() { - let code = r#" - fn call_a() {} - fn call_b() {} - fn dispatch(x: i32) { - match x { - 0 => call_a(), - _ => call_b(), - } - } - "#; - let results = parse_and_analyze(code); + // Leniency reclassifies the match as orchestration but must NOT zero out + // the cognitive complexity — the match arms are still decision points. + let results = parse_and_analyze(MATCH_DISPATCH); let f = results.iter().find(|r| r.name == "dispatch").unwrap(); - assert_eq!( - f.classification, - Classification::Integration, - "Match dispatch should be Integration, got {:?}", - f.classification - ); assert!( f.complexity.as_ref().unwrap().cognitive_complexity >= 1, "Complexity should still be tracked for dispatch match" diff --git a/src/adapters/analyzers/iosp/tests/root/metrics_exact.rs b/src/adapters/analyzers/iosp/tests/root/metrics_exact.rs new file mode 100644 index 00000000..6d2fc637 --- /dev/null +++ b/src/adapters/analyzers/iosp/tests/root/metrics_exact.rs @@ -0,0 +1,171 @@ +//! Per-construct metric assertions for `BodyVisitor`. Each fixture isolates a +//! single construct so the relevant counter is driven from its base — counters +//! base at 0 (a `> 0` check kills `*=` / arm-deletion, and `-=` underflow +//! panics), while cyclomatic bases at 1 so it needs an exact check. Shared +//! helpers (`metrics_of`, …) live in the parent module. +use super::*; + +// Cyclomatic complexity starts at 1 (the base path), so each loop must take it +// to exactly 2 — an exact check is needed because `1 *= 1` stays 1 (a `> 0` +// check would not notice the lost increment). + +#[test] +fn for_loop_increments_cyclomatic() { + assert_eq!( + metrics_of("fn f() { for _ in 0..2 { let _ = (); } }").cyclomatic_complexity, + 2 + ); +} + +#[test] +fn while_loop_increments_cyclomatic() { + assert_eq!( + metrics_of("fn f() { while false { let _ = (); } }").cyclomatic_complexity, + 2 + ); +} + +#[test] +fn loop_increments_cyclomatic() { + assert_eq!( + metrics_of("fn f() { loop { break; } }").cyclomatic_complexity, + 2 + ); +} + +#[test] +fn and_after_or_increments_cognitive() { + // `a && b || c` = `(a && b) || c`: the outer Or remembers `is_and = false`, + // then its left child `&&` differs → one cognitive jump on the *And* branch. + // (The mirror Or branch is unreachable — an Or can never be visited while + // the remembered op is And, since that needs a parenthesised Or as a `&&` + // operand and the paren resets the tracker — so it is an equivalent mutant.) + let m = metrics_of("fn f(a: bool, b: bool, c: bool) -> bool { a && b || c }"); + assert!( + m.cognitive_complexity > 0, + "an alternating && after an || is a cognitive jump, got {}", + m.cognitive_complexity + ); +} + +// The counters below sit on `BodyVisitor`, which only runs for *non-trivial* +// bodies (`is_trivial_body` short-circuits single-expression getters). Each +// fixture wraps the construct in an `if` so the visitor runs and `complexity` +// is `Some`, without otherwise touching the counter under test. + +#[test] +fn unsafe_block_counted() { + assert!(metrics_of("fn f(x: bool) { if x { unsafe { let _ = 1; } } }").unsafe_blocks > 0); +} + +// The macros below are written in *expression* position (block tail, no +// trailing `;`): a `panic!();` statement is a `Stmt::Macro`, but the visitor's +// macro arm fires on `Expr::Macro`, which is the tail-expression form. + +#[test] +fn panic_macro_counted() { + assert!(metrics_of(r#"fn f(x: bool) { if x { panic!("boom") } }"#).panic_count > 0); +} + +#[test] +fn unreachable_macro_counted_as_panic() { + assert!(metrics_of("fn f(x: bool) { if x { unreachable!() } }").panic_count > 0); +} + +#[test] +fn todo_macro_counted() { + assert!(metrics_of("fn f(x: bool) { if x { todo!() } }").todo_count > 0); +} + +#[test] +fn unwrap_counted() { + assert!( + metrics_of("fn f(o: Option, x: bool) -> i32 { if x { o.unwrap() } else { 0 } }") + .unwrap_count + > 0 + ); +} + +#[test] +fn expect_counted() { + assert!( + metrics_of(r#"fn f(o: Option, x: bool) -> i32 { if x { o.expect("e") } else { 0 } }"#) + .expect_count + > 0 + ); +} + +#[test] +fn comparison_counts_as_logic() { + // Guards the comparison match arm (`==`/`!=`/`<`/…) of the logic detector. + assert!(metrics_of("fn f(a: i32, b: i32) -> bool { a == b }").logic_count > 0); +} + +#[test] +fn bitwise_counts_as_logic() { + // Guards the bitwise match arm (`&`/`|`/`^`/`<<`/`>>`). + assert!(metrics_of("fn f(a: i32, b: i32) -> i32 { a & b }").logic_count > 0); +} + +#[test] +fn float_literal_is_a_magic_number() { + // Guards the `Lit::Float` arm of magic-number detection. + assert!( + !metrics_of("fn f(x: bool) { if x { let _ = 3.14; } }") + .magic_numbers + .is_empty(), + "a bare float literal is a magic number" + ); +} + +#[test] +fn negative_float_literal_records_signed_value() { + // `-3.14` is handled as a unit by the unary-negation arm, recording the + // signed value. Guards that arm's `Lit::Float` case (deleting it would let + // the inner `3.14` be recorded unsigned instead). + let m = metrics_of("fn f(x: bool) { if x { let _ = -3.14; } }"); + assert!( + m.magic_numbers.iter().any(|n| n.value == "-3.14"), + "a negative float literal records its signed value, got {:?}", + m.magic_numbers + ); +} + +#[test] +fn non_negation_unary_on_int_records_unsigned_value() { + // `!5` is a *non-negation* unary, so the negative-literal fast path must NOT + // claim it — the inner `5` is recorded unsigned. Guards the + // `matches!(op, UnOp::Neg(_))` match guard against firing on every unary. + let m = metrics_of("fn f(x: bool) { if x { let _ = !5; } }"); + assert!( + m.magic_numbers.iter().any(|n| n.value == "5"), + "a `!` unary is not a negative literal; inner value stays unsigned, got {:?}", + m.magic_numbers + ); +} + +#[test] +fn const_context_resets_after_const_item() { + // A `const`/`static` item suppresses magic numbers in its value, but the + // suppression must be *popped* afterwards so a later literal is still + // flagged. Guards the `in_const_context -= 1` restore in + // `visit_item_const`/`visit_item_static`. + let m = metrics_of("fn f(x: bool) { if x { const K: i32 = 42; let _ = 99; } }"); + assert!( + m.magic_numbers.iter().any(|n| n.value == "99"), + "the literal after a const item must still be a magic number" + ); + assert!( + !m.magic_numbers.iter().any(|n| n.value == "42"), + "the const's own value is suppressed" + ); +} + +#[test] +fn static_context_resets_after_static_item() { + let m = metrics_of("fn f(x: bool) { if x { static S: i32 = 42; let _ = 99; } }"); + assert!( + m.magic_numbers.iter().any(|n| n.value == "99"), + "the literal after a static item must still be a magic number" + ); +} diff --git a/src/adapters/analyzers/iosp/tests/root/mod.rs b/src/adapters/analyzers/iosp/tests/root/mod.rs index 554206ee..4995c0d4 100644 --- a/src/adapters/analyzers/iosp/tests/root/mod.rs +++ b/src/adapters/analyzers/iosp/tests/root/mod.rs @@ -7,12 +7,15 @@ pub(super) use crate::adapters::analyzers::iosp::scope::ProjectScope; pub(super) use crate::adapters::analyzers::iosp::*; pub(super) use crate::config::Config; +mod analysis_structure; mod classification_exact; mod classification_predicate; mod classify_basics; mod complexity_and_metadata; mod dispatch_and_getters; mod is_test; +mod metrics_exact; +mod own_call_resolution; mod own_calls_a; mod own_calls_b; @@ -64,11 +67,44 @@ pub(super) fn classify_cfg(code: &str, fn_name: &str, config: &Config) -> Classi /// Whether `fn_name` in `code` is classified as test code (`is_test`). pub(super) fn is_test_of(code: &str, fn_name: &str) -> bool { + analysis_of(code, fn_name).is_test +} + +/// Full analysis of function `name` in `code` (with leaf reclassification). +pub(super) fn analysis_of(code: &str, name: &str) -> FunctionAnalysis { parse_and_analyze(code) .into_iter() - .find(|f| f.name == fn_name) - .unwrap_or_else(|| panic!("fn {fn_name} not found")) - .is_test + .find(|r| r.name == name) + .unwrap_or_else(|| panic!("fn {name} not found")) +} + +/// Raw analysis of `name` without leaf reclassification, so a genuine Violation +/// keeps its `Violation` classification (and its `effort_score`/`severity`). +pub(super) fn raw_analysis_of(code: &str, name: &str) -> FunctionAnalysis { + parse_and_analyze_with_config(code, &Config::default()) + .into_iter() + .find(|r| r.name == name) + .unwrap_or_else(|| panic!("fn {name} not found")) +} + +/// Complexity metrics of the single function `f` in `code`. +pub(super) fn metrics_of(code: &str) -> ComplexityMetrics { + analysis_of(code, "f") + .complexity + .expect("f should have complexity metrics") +} + +/// Own-call targets recorded for function `name` in `code`. +pub(super) fn own_calls_of(code: &str, name: &str) -> Vec { + analysis_of(code, name).own_calls +} + +/// Names of all analysed functions in `code`. +pub(super) fn analysed_names(code: &str) -> Vec { + parse_and_analyze(code) + .into_iter() + .map(|r| r.name) + .collect() } // (label, code, fn_name, expected) — Integration = orchestrates own calls only; diff --git a/src/adapters/analyzers/iosp/tests/root/own_call_resolution.rs b/src/adapters/analyzers/iosp/tests/root/own_call_resolution.rs new file mode 100644 index 00000000..d4223b62 --- /dev/null +++ b/src/adapters/analyzers/iosp/tests/root/own_call_resolution.rs @@ -0,0 +1,195 @@ +//! Own-call recording: lenient nested contexts, recursion, iterator skip, +//! receiver type resolution, and trivial-self-getter exclusion. Each fixture +//! has `f` call something; whether it is recorded as an own call reveals the +//! decision under test. Shared helpers live in the parent module. +use super::*; + +#[test] +fn async_block_body_is_lenient() { + // An own call inside an `async` block is skipped (lenient, like a closure) + // under the default config — guards the `Expr::Async` arm that enters + // lenient mode. + let calls = own_calls_of("fn g() {} fn f() { let _ = async { g() }; }", "f"); + assert!( + calls.is_empty(), + "calls inside async are lenient, got {calls:?}" + ); +} + +#[test] +fn async_depth_pops_after_block() { + // After an `async` block the leniency must be popped, so a following own + // call is still counted — guards the `async_block_depth -= 1` restore. + let calls = own_calls_of("fn g() {} fn f() { let _ = async {}; g(); }", "f"); + assert!( + !calls.is_empty(), + "an own call after an async block must still count, got {calls:?}" + ); +} + +#[test] +fn non_iterator_own_method_call_is_counted() { + // A non-iterator own method call must be recorded as an own call. Guards the + // `is_iterator && !strict_iterator_chains` skip condition. + let calls = own_calls_of( + "struct S; impl S { fn helper(&self) {} } fn f(s: S) { s.helper(); let _ = 0; }", + "f", + ); + assert!( + calls.iter().any(|c| c.contains("helper")), + "a non-iterator own method call is an own call, got {calls:?}" + ); +} + +#[test] +fn recursive_own_method_call_is_counted_when_recursion_disallowed() { + // With `allow_recursion = false` (default), a self-recursive own method call + // is still an own call: `allow_recursion && is_recursive` short-circuits to + // false. Turning `&&` into `||` would skip recursive calls. + let calls = own_calls_of( + "struct S; impl S { fn f(&self) -> i32 { let _ = 0; self.f() } }", + "f", + ); + assert!( + calls.iter().any(|c| c.contains("f")), + "a recursive own method call counts when recursion is disallowed, got {calls:?}" + ); +} + +// --- receiver type resolution ------------------------------------------- +// `foo` is a method of `A`; resolving the receiver's type distinguishes a call +// on a `B` value (not own) from the name-only fallback (which would accept it). + +#[test] +fn receiver_of_wrong_type_is_not_an_own_call() { + // Guards `extract_simple_type` (Path arm / `-> None`) and + // `resolve_receiver_type`'s non-self Path arm. + let calls = own_calls_of( + "struct A; struct B; impl A { fn foo(&self) {} fn f(&self, b: B) { b.foo(); let _ = 0; } }", + "f", + ); + assert!( + calls.is_empty(), + "a method call on a wrong-typed receiver is not an own call, got {calls:?}" + ); +} + +#[test] +fn self_receiver_resolves_to_parent_type_only() { + // In `B::f`, `self.foo()` resolves to `B` (no `foo`), so it is not an own + // call — guards the `is_ident("self")` arm of `resolve_receiver_type`. + let calls = own_calls_of( + "struct A; impl A { fn foo(&self) {} } struct B; impl B { fn f(&self) { self.foo(); let _ = 0; } }", + "f", + ); + assert!( + calls.is_empty(), + "self.foo() resolves to the parent type only, got {calls:?}" + ); +} + +#[test] +fn reference_typed_receiver_is_resolved() { + // A `&B` parameter must resolve to `B` (references are unwrapped). Guards the + // `Type::Reference` arm of `extract_simple_type`. + let calls = own_calls_of( + "struct A; struct B; impl A { fn foo(&self) {} fn f(&self, b: &B) { b.foo(); let _ = 0; } }", + "f", + ); + assert!( + calls.is_empty(), + "a &B receiver resolves to B; A::foo on it is not an own call, got {calls:?}" + ); +} + +// --- trivial self-getter detection (scope.rs) --------------------------- +// A method recognised as a trivial self-getter is added to `trivial_methods` +// and excluded from own-call counting. Each fixture has `f` call `g`; whether +// `g` counts as an own call of `f` reveals whether `g` was classified trivial. + +#[test] +fn method_with_extra_param_is_not_a_trivial_getter() { + // `has_trivial_self_signature`: a method with a non-self parameter is not a + // trivial getter, so the call to it counts. Guards `has_receiver && + // typed_count == 0` (→ true, and `&&` → `||`). + let calls = own_calls_of( + "struct S { x: i32 } impl S { fn g(&self, n: i32) -> i32 { self.x } fn f(&self) -> i32 { self.g(1) } }", + "f", + ); + assert!( + calls.iter().any(|c| c.contains("g")), + "a call to a non-trivial (extra-param) method is an own call, got {calls:?}" + ); +} + +#[test] +fn cast_accessor_body_is_a_trivial_getter() { + // `self.x as f64` is a trivial accessor; guards the `Expr::Cast` arm. + let calls = own_calls_of( + "struct S { x: i32 } impl S { fn g(&self) -> f64 { self.x as f64 } fn f(&self) -> f64 { self.g() } }", + "f", + ); + assert!( + calls.is_empty(), + "a cast-accessor getter call is not an own call, got {calls:?}" + ); +} + +#[test] +fn unary_accessor_body_is_a_trivial_getter() { + // `-self.x` is a trivial accessor; guards the `Expr::Unary` arm. + let calls = own_calls_of( + "struct S { x: i32 } impl S { fn g(&self) -> i32 { -self.x } fn f(&self) -> i32 { self.g() } }", + "f", + ); + assert!( + calls.is_empty(), + "a unary-accessor getter call is not an own call, got {calls:?}" + ); +} + +#[test] +fn paren_accessor_body_is_a_trivial_getter() { + // `(self.x)` is a trivial accessor; guards the `Expr::Paren` arm. + let calls = own_calls_of( + "struct S { x: i32 } impl S { fn g(&self) -> i32 { (self.x) } fn f(&self) -> i32 { self.g() } }", + "f", + ); + assert!( + calls.is_empty(), + "a paren-accessor getter call is not an own call, got {calls:?}" + ); +} + +#[test] +fn non_get_one_arg_method_breaks_trivial_accessor() { + // Only a no-arg stdlib accessor or `get` with a trivial arg is trivial. A + // one-arg non-`get` call (`self.items.bar(0)`) makes the body non-trivial, + // so the getter is NOT trivial. Guards the `args.len() != 1 || method != + // "get"` early-out. + let calls = own_calls_of( + "struct S { items: Vec } impl S { fn g(&self) -> i32 { self.items.bar(0) } fn f(&self) -> i32 { self.g() } }", + "f", + ); + assert!( + calls.iter().any(|c| c.contains("g")), + "a one-arg non-get call is not a trivial accessor, so g is an own call, got {calls:?}" + ); +} + +#[test] +fn get_with_non_self_path_arg_breaks_trivial_accessor() { + // `self.items.get(IDX)` — the `get` argument is a non-self path (a const), + // which is not a trivial arg, so the body is not a trivial accessor and the + // getter counts. `g` takes no extra parameter (so its *signature* is trivial) + // — the body check is therefore decisive. Guards the `is_ident("self")` arg + // guard against accepting any path. + let calls = own_calls_of( + "const IDX: usize = 0; struct S { items: Vec } impl S { fn g(&self) -> i32 { self.items.get(IDX) } fn f(&self) -> i32 { self.g() } }", + "f", + ); + assert!( + calls.iter().any(|c| c.contains("g")), + "get(non_self_path) is not a trivial accessor, so g is an own call, got {calls:?}" + ); +} diff --git a/src/adapters/analyzers/srp/tests/cohesion/scoring.rs b/src/adapters/analyzers/srp/tests/cohesion/scoring.rs index a08a40ef..d9be380e 100644 --- a/src/adapters/analyzers/srp/tests/cohesion/scoring.rs +++ b/src/adapters/analyzers/srp/tests/cohesion/scoring.rs @@ -100,3 +100,49 @@ fn test_composite_score_lcom4_one_is_zero() { let score_incohesive = compute_composite_score(3, 5, 5, 2, &config); assert!(score_incohesive > score_cohesive); } + +#[test] +fn test_composite_score_exact_value() { + // Pin the whole formula to one exact number so every arithmetic step is + // observable. With threshold-range 4 and distinct weights: + // lcom4_norm = (3-1)/4 = 0.5 → 0.4 * 0.5 = 0.20 + // field_norm = 1/4 = 0.25 → 0.3 * 0.25 = 0.075 + // method_norm = 5/10 = 0.5 → 0.2 * 0.5 = 0.10 + // fan_out_norm= 1/5 = 0.2 → 0.1 * 0.2 = 0.02 + // composite = 0.395 + let config = SrpConfig { + lcom4_threshold: 5, + max_fields: 4, + max_methods: 10, + max_fan_out: 5, + weights: [0.4, 0.3, 0.2, 0.1], + ..SrpConfig::default() + }; + let score = compute_composite_score(3, 1, 5, 1, &config); + assert!( + (score - 0.395).abs() < 1e-9, + "expected composite 0.395, got {score}" + ); +} + +#[test] +fn test_composite_score_zero_cap_ratio() { + // A misconfigured `max_fields == 0` must treat zero count as 0.0 and any + // non-zero count as fully penalised (1.0) — guards `normalised_ratio`'s + // `value == 0` branch. Weight only the field term so it drives the score. + let config = SrpConfig { + max_fields: 0, + weights: [0.0, 1.0, 0.0, 0.0], + ..SrpConfig::default() + }; + assert_eq!( + compute_composite_score(0, 0, 0, 0, &config), + 0.0, + "zero count under a zero cap is unpenalised" + ); + assert_eq!( + compute_composite_score(0, 2, 0, 0, &config), + 1.0, + "non-zero count under a zero cap is fully penalised" + ); +} diff --git a/src/adapters/analyzers/srp/tests/cohesion/warnings.rs b/src/adapters/analyzers/srp/tests/cohesion/warnings.rs index 20bc7bd0..d4c70af1 100644 --- a/src/adapters/analyzers/srp/tests/cohesion/warnings.rs +++ b/src/adapters/analyzers/srp/tests/cohesion/warnings.rs @@ -111,5 +111,53 @@ fn test_build_struct_warnings_triggers_for_incohesive() { !warnings.is_empty(), "Incohesive god object should trigger SRP warning" ); - assert_eq!(warnings[0].struct_name, "GodObject"); + let w = &warnings[0]; + assert_eq!(w.struct_name, "GodObject"); + // The spec's core SRP-001 contract is the NAMED disjoint clusters, not just + // "this struct warned". The 7 field-groups (db / cache / logger+metrics / + // router+handler / auth+config / buffer+queue / pool+state) are disjoint, so + // the warning must surface lcom4=7 AND name all 7 clusters with the right + // members — otherwise the "split into these types" refactor isn't mechanical. + assert_eq!(w.lcom4, 7, "seven disjoint field-groups → 7 clusters"); + assert_eq!( + w.clusters.len(), + w.lcom4, + "every cluster is named in the warning" + ); + let db = w + .clusters + .iter() + .find(|c| c.fields.contains(&"db".to_string())) + .expect("a db responsibility cluster is named"); + let mut db_methods = db.methods.clone(); + db_methods.sort(); + assert_eq!( + db_methods, + vec!["read_db", "write_db"], + "the db cluster groups exactly its own methods" + ); +} + +#[test] +fn test_build_struct_warnings_two_methods_analysed_not_skipped() { + // Exactly 2 methods is the boundary where LCOM4 becomes defined, so the + // skip guard must be `len < 2` — `== 2` or `<= 2` would wrongly drop it. + // `smell_threshold = 0.0` makes any analysed struct warn, isolating the + // skip decision from the score. + let structs = vec![make_struct("Pair", &["a", "b"])]; + let methods = vec![ + make_method("use_a", "Pair", &["a"], &[]), + make_method("use_b", "Pair", &["b"], &[]), + ]; + let config = SrpConfig { + smell_threshold: 0.0, + ..SrpConfig::default() + }; + let warnings = build_struct_warnings(&structs, &methods, &config); + assert_eq!( + warnings.len(), + 1, + "a 2-method struct must be analysed, not skipped" + ); + assert_eq!(warnings[0].struct_name, "Pair"); } diff --git a/src/adapters/analyzers/srp/tests/module/production_lines.rs b/src/adapters/analyzers/srp/tests/module/production_lines.rs index fc3010bc..b61b78d7 100644 --- a/src/adapters/analyzers/srp/tests/module/production_lines.rs +++ b/src/adapters/analyzers/srp/tests/module/production_lines.rs @@ -131,6 +131,20 @@ fn test_count_production_lines_nested_block_closes_properly() { assert_eq!(count_production_lines(source), 1); } +#[test] +fn test_count_production_lines_skips_line_with_two_block_comments() { + // Two block comments separated by whitespace on one line is still a + // comment line: the inter-comment space at depth 0 must not be counted as + // code (guards the `!c.is_whitespace()` match guard against firing on + // whitespace). + let source = "fn foo() {}\n/* a */ /* b */\nfn bar() {}\n"; + assert_eq!( + count_production_lines(source), + 2, + "a whitespace-separated double block comment is not production code" + ); +} + #[test] fn test_count_production_lines_empty() { assert_eq!(count_production_lines(""), 0); diff --git a/src/adapters/analyzers/srp/tests/root.rs b/src/adapters/analyzers/srp/tests/root.rs index ba13daaa..e875b933 100644 --- a/src/adapters/analyzers/srp/tests/root.rs +++ b/src/adapters/analyzers/srp/tests/root.rs @@ -80,6 +80,20 @@ fn collect_methods(parsed: &[(String, String, syn::File)]) -> Vec Vec { + let parsed = vec![(path.to_string(), code.to_string(), parse_file(code))]; + analyze_srp( + &parsed, + &SrpConfig::default(), + &std::collections::HashMap::new(), + (300, 800), + ) + .struct_warnings +} + #[test] fn test_struct_collector_named_fields() { let code = "struct Foo { x: i32, y: String }"; @@ -210,14 +224,9 @@ fn test_analyze_srp_cohesive_struct() { fn reset(&mut self) { self.count = 0; } } "#; - let syntax = parse_file(code); - let parsed = vec![("test.rs".to_string(), code.to_string(), syntax)]; - let config = SrpConfig::default(); - let call_graph = std::collections::HashMap::new(); - let analysis = analyze_srp(&parsed, &config, &call_graph, (300, 800)); // Fully cohesive struct → no warning assert!( - analysis.struct_warnings.is_empty(), + struct_warnings_for("test.rs", code).is_empty(), "Cohesive struct should not trigger SRP warning" ); } @@ -248,3 +257,41 @@ fn test_analyze_srp_returns_empty_param_warnings() { let analysis = analyze_srp(&parsed, &config, &call_graph, (300, 800)); assert!(analysis.param_warnings.is_empty()); } + +#[test] +fn test_analyze_srp_god_struct_fires_in_test_file() { + // SRP-001 (god-struct cohesion) deliberately applies to TEST code too: a + // god-fixture wiring up auth + db + caching + routing in one struct is a + // real smell, and the "independent #[test] fns are the file's purpose" + // rationale that makes the MODULE cluster-check production-only does NOT + // excuse it. Only `analyze_module_srp` skips test files; the struct-level + // check is intentionally NOT gated on cfg_test_files (production thresholds, + // no separate `[tests]` knob — `// qual:allow(srp)` covers rare fixtures). + // The `#![cfg(test)]` inner attr marks this a whole test file, so this pins + // the struct warning still fires there. + let code = r#" + #![cfg(test)] + struct GodFixture { + db: u8, cache: u8, logger: u8, metrics: u8, config: u8, state: u8, + buffer: u8, queue: u8, pool: u8, handler: u8, router: u8, auth: u8, + } + impl GodFixture { + fn read_db(&self) { query(self.db); } + fn write_db(&mut self) { commit(self.db); } + fn read_cache(&self) { get_key(self.cache); } + fn write_cache(&mut self) { set_key(self.cache); } + fn log_info(&self) { format_log(self.logger); } + fn log_error(&self) { format_log(self.logger); inc(self.metrics); } + fn route(&self) { dispatch(self.router, self.handler); } + fn authenticate(&self) { verify(self.auth, self.config); } + fn flush(&mut self) { drain(self.buffer, self.queue); } + fn manage_pool(&mut self) { alloc(self.pool, self.state); } + } + "#; + assert!( + struct_warnings_for("tests/fixtures.rs", code) + .iter() + .any(|w| w.struct_name == "GodFixture"), + "struct SRP-001 must fire on a god-struct even in a test file" + ); +} diff --git a/src/adapters/analyzers/structural/deh.rs b/src/adapters/analyzers/structural/deh.rs index f5b453d2..50bd07eb 100644 --- a/src/adapters/analyzers/structural/deh.rs +++ b/src/adapters/analyzers/structural/deh.rs @@ -5,6 +5,8 @@ use syn::visit::Visit; use crate::config::StructuralConfig; use crate::findings::Dimension; +use crate::adapters::shared::cfg_test::has_test_attr; + use super::{has_cfg_test_attr, StructuralWarning, StructuralWarningKind}; /// Downcast method names that indicate broken polymorphism. @@ -13,7 +15,11 @@ const DOWNCAST_METHODS: &[&str] = &["downcast_ref", "downcast_mut", "downcast"]; /// Detect downcast escape hatches: use of Any::downcast_*. /// Test code is skipped: a file in `cfg_test_files` (integration-test dir, /// `#![cfg(test)]`, or `#[cfg(test)] mod` chain) starts `in_test = true`; -/// inline `#[cfg(test)] mod` blocks are handled per-item. +/// inline `#[cfg(test)] mod` blocks and a function's own `#[test]` / +/// `#[cfg(test)]` attributes are handled per-item (the latter covers the +/// synthetic `#[test]` fns the macro-expansion pre-pass emits for +/// `quickcheck!` / `proptest!` properties, whose original `#[cfg(test)]` +/// wrapper is gone). /// Operation: iterates parsed files, walks expressions for downcast calls. pub(crate) fn detect_deh( warnings: &mut Vec, @@ -51,6 +57,15 @@ impl<'ast, 'a> Visit<'ast> for DowncastVisitor<'a> { self.in_test = was_in_test; } + fn visit_item_fn(&mut self, node: &'ast syn::ItemFn) { + let was_in_test = self.in_test; + if has_test_attr(&node.attrs) || has_cfg_test_attr(&node.attrs) { + self.in_test = true; + } + syn::visit::visit_item_fn(self, node); + self.in_test = was_in_test; + } + fn visit_expr_method_call(&mut self, node: &'ast syn::ExprMethodCall) { if !self.in_test { let method_name = node.method.to_string(); diff --git a/src/adapters/analyzers/structural/tests/btc.rs b/src/adapters/analyzers/structural/tests/btc.rs index fa08c44c..e9c6da04 100644 --- a/src/adapters/analyzers/structural/tests/btc.rs +++ b/src/adapters/analyzers/structural/tests/btc.rs @@ -55,6 +55,22 @@ fn test_inherent_impl_not_flagged() { assert!(w.is_empty()); } +#[test] +fn test_default_default_body_not_treated_as_stub() { + // BTC stub forms are the panic-style macros only — `todo!`, + // `unimplemented!`, `panic!("not implemented")` (see `is_stub_body` and + // `book/function-quality.md`). A method whose body is `Default::default()` + // is frequently a genuine implementation, so it is intentionally NOT a stub. + // Pin that contract so any future change to flag it is deliberate. + let w = detect_in( + "trait Foo { fn bar(&self) -> i32; } impl Foo for M { fn bar(&self) -> i32 { Default::default() } } struct M;", + ); + assert!( + w.is_empty(), + "a Default::default() body is not treated as a BTC stub" + ); +} + #[test] fn test_empty_impl_not_flagged() { let w = detect_in("trait Foo {} impl Foo for MyType {} struct MyType;"); @@ -68,6 +84,31 @@ fn test_partial_stub_flags_only_stubs() { assert_eq!(w[0].name, "a"); } +#[test] +fn stub_impl_in_non_test_module_flagged() { + // A stub trait impl nested in a regular (non-test) module must still be + // found — guards the recursion guard against never descending / descending + // only into test modules. + let w = detect_in( + "mod inner { trait Foo { fn bar(&self); } impl Foo for MyType { fn bar(&self) { todo!() } } struct MyType; }", + ); + assert_eq!(w.len(), 1, "stub impl in a non-test module must be flagged"); +} + +#[test] +fn stub_impl_in_inline_cfg_test_module_excluded() { + // The same stub inside `#[cfg(test)] mod` must be skipped. `struct Keep` + // stops the file being whole-file-classified as test code, so the inline + // `!has_cfg_test_attr` guard is the thing under test. + let w = detect_in( + "struct Keep; #[cfg(test)] mod tests { trait Foo { fn bar(&self); } impl Foo for MyType { fn bar(&self) { todo!() } } struct MyType; }", + ); + assert!( + w.is_empty(), + "stub impl in a #[cfg(test)] mod must be excluded" + ); +} + #[test] fn test_disabled_check() { let syntax = syn::parse_file( diff --git a/src/adapters/analyzers/structural/tests/deh.rs b/src/adapters/analyzers/structural/tests/deh.rs index 9de3e482..2249bcdc 100644 --- a/src/adapters/analyzers/structural/tests/deh.rs +++ b/src/adapters/analyzers/structural/tests/deh.rs @@ -51,6 +51,66 @@ fn downcast_in_cfg_test_companion_file_excluded() { ); } +#[test] +fn downcast_in_test_fn_excluded() { + // A `#[test]` fn is test code regardless of its enclosing module/file cfg + // state — its body's downcast is a legitimate test escape hatch. This is + // also the shape the macro-expansion pre-pass emits for `quickcheck!` / + // `proptest!` properties (params dropped, `#[test]` added) once the macro's + // own `#[cfg(test)]` wrapper is gone, so DEH must honour the function's own + // test attribute, not just module/file cfg. + let w = detect_in("#[test] fn prop() { a.downcast_ref::(); }"); + assert!( + w.is_empty(), + "a #[test] fn body must be excluded from DEH: {} warning(s)", + w.len() + ); +} + +#[test] +fn downcast_in_cfg_test_fn_excluded() { + // A function carrying its own `#[cfg(test)]` (not inside a `#[cfg(test)] + // mod`) is test code too — honour fn-level cfg, mirroring the module case. + let w = detect_in("#[cfg(test)] fn helper() { a.downcast_ref::(); }"); + assert!(w.is_empty(), "a #[cfg(test)] fn body must be excluded"); +} + +#[test] +fn downcast_in_expanded_quickcheck_property_excluded() { + // End-to-end regression guard: a `#[cfg(test)] quickcheck! { … }` is + // surfaced by the macro-expansion pre-pass as a synthetic `#[test] fn` + // with the macro's `#[cfg(test)]` wrapper dropped. DEH must still skip the + // body because the generated fn carries `#[test]` — otherwise expansion + // flips a test body into apparent production code. + use crate::adapters::shared::macro_expansion::expand_test_macros; + let src = + "#[cfg(test)] quickcheck! { fn prop(x: u8) -> bool { x.downcast_ref::().is_some() } }"; + let mut parsed = vec![( + "lib.rs".to_string(), + src.to_string(), + syn::parse_file(src).expect("test source"), + )]; + expand_test_macros(&mut parsed); + let config = StructuralConfig::default(); + let cfg_test_files = std::collections::HashSet::new(); + let mut warnings = Vec::new(); + detect_deh(&mut warnings, &parsed, &config, &cfg_test_files); + assert!( + warnings.is_empty(), + "expanded #[test] property body must be excluded from DEH: {warnings:?}" + ); +} + +#[test] +fn downcast_in_non_test_module_flagged() { + // A downcast nested in a regular (non-test) module must be flagged: the + // visitor has to descend into the module (and keep `in_test = false`). + // Guards `visit_item_mod` against being turned into a no-op (which would + // also drop the recursion). + let w = detect_in("mod inner { fn foo(a: &dyn std::any::Any) { a.downcast_ref::(); } }"); + assert_eq!(w.len(), 1, "downcast in a non-test module must be flagged"); +} + #[test] fn test_disabled_check() { let syntax = syn::parse_file("fn foo(a: &dyn std::any::Any) { a.downcast_ref::(); }") diff --git a/src/adapters/analyzers/structural/tests/iet.rs b/src/adapters/analyzers/structural/tests/iet.rs index a13af827..b330c523 100644 --- a/src/adapters/analyzers/structural/tests/iet.rs +++ b/src/adapters/analyzers/structural/tests/iet.rs @@ -89,3 +89,18 @@ fn test_cfg_test_module_excluded() { let w = detect_in("#[cfg(test)] mod tests { pub fn a() -> Result<(), String> { Ok(()) } pub fn b() -> Result { Ok(1) } }"); assert!(w.is_empty()); } + +#[test] +fn inconsistent_error_types_across_non_test_module_flagged() { + // One conflicting error type lives in a regular (non-test) module; the + // collector must descend into it — guards the module-recursion guard + // against being skipped (otherwise only one error type is seen). + let w = detect_in( + "pub fn a() -> Result<(), String> { Ok(()) } mod inner { pub fn b() -> Result { Ok(1) } }", + ); + assert_eq!( + w.len(), + 1, + "an error type inside a non-test module must be collected" + ); +} diff --git a/src/adapters/analyzers/structural/tests/nms.rs b/src/adapters/analyzers/structural/tests/nms.rs index 8e0ca104..690b0fde 100644 --- a/src/adapters/analyzers/structural/tests/nms.rs +++ b/src/adapters/analyzers/structural/tests/nms.rs @@ -83,3 +83,94 @@ fn test_indexed_field_method_call_not_flagged() { "self.items[i].push(v) should be recognized as mutation" ); } + +#[test] +fn test_assign_to_local_still_flagged() { + // Assigning to a *local* (not `self`) is not a self-mutation, so a method + // that only reads self is still needless-mut — guards `is_self_target` / + // the `Expr::Assign` guard against treating every assignment as self-write. + let w = detect_in( + "struct S { x: i32 } impl S { fn f(&mut self) -> i32 { let mut y = 0; y = self.x; y } }", + ); + assert_eq!(w.len(), 1, "assigning a local is not a self-mutation"); +} + +#[test] +fn test_non_assign_binary_on_self_still_flagged() { + // `self.x > 0` is a comparison, not a compound assignment — it does not + // mutate self. Guards `is_compound_assign` and the `&&` in the binary arm. + let w = detect_in("struct S { x: i32 } impl S { fn f(&mut self) -> bool { self.x > 0 } }"); + assert_eq!(w.len(), 1, "a comparison on self.x is not a mutation"); +} + +#[test] +fn test_immutable_self_reference_still_flagged() { + // `&self.x` is an *immutable* borrow — not a mutation. Guards the + // `r.mutability.is_some() && is_self_target(...)` reference arm. + let w = + detect_in("struct S { x: i32 } impl S { fn f(&mut self) -> i32 { let r = &self.x; *r } }"); + assert_eq!(w.len(), 1, "an immutable &self.x borrow is not a mutation"); +} + +#[test] +fn test_method_call_on_local_still_flagged() { + // A method call on a *local* (not self) is not a self-mutation. Guards + // `is_self_field` / `is_self_path` / `is_self_indexed_field` against + // treating any method-call receiver as self. + let w = detect_in( + "struct S { x: i32 } impl S { fn f(&mut self) -> i32 { let v = String::new(); v.len(); self.x } }", + ); + assert_eq!( + w.len(), + 1, + "a method call on a local is not a self-mutation" + ); +} + +#[test] +fn test_bare_self_reference_still_flagged() { + // `self` referenced only as a bare path (passed to a fn) still counts as a + // self-reference — guards the `Expr::Path` arm of `is_self_ref`. + let w = detect_in("struct S; impl S { fn f(&mut self) { take(self); } }"); + assert_eq!(w.len(), 1, "a bare `self` argument is a self-reference"); +} + +#[test] +fn test_non_self_path_not_referenced_as_self() { + // A non-`self` path (`x`) must NOT be mistaken for a self-reference; + // without a self-reference NMS defers to SLM. Guards the `== \"self\"` + // check in `is_self_ref`. + let w = detect_in("struct S; impl S { fn f(&mut self) { let x = 1; let _ = x; } }"); + assert!( + w.is_empty(), + "a non-self local path is not a self-reference" + ); +} + +#[test] +fn needless_mut_self_in_non_test_module_flagged() { + // The inherent-method collector must descend into regular (non-test) + // modules — guards the `!has_cfg_test_attr` recursion guard in + // `visit_item_methods` against never descending / only into test modules. + let w = + detect_in("mod inner { struct S { x: i32 } impl S { fn f(&mut self) -> i32 { self.x } } }"); + assert_eq!( + w.len(), + 1, + "needless &mut self in a non-test module must be flagged" + ); +} + +#[test] +fn needless_mut_self_in_inline_cfg_test_module_excluded() { + // The same inside `#[cfg(test)] mod` must be skipped. `fn keep` keeps the + // file from being whole-file-classified as test code, so the inline guard + // is the thing under test. + let w = detect_in( + "fn keep() {} #[cfg(test)] mod tests { struct S { x: i32 } impl S { fn f(&mut self) -> i32 { self.x } } }", + ); + assert!( + w.is_empty(), + "needless &mut self in a #[cfg(test)] mod must be excluded" + ); +} diff --git a/src/adapters/analyzers/structural/tests/sit.rs b/src/adapters/analyzers/structural/tests/sit.rs index 2c474e28..bcc850e2 100644 --- a/src/adapters/analyzers/structural/tests/sit.rs +++ b/src/adapters/analyzers/structural/tests/sit.rs @@ -62,6 +62,22 @@ fn test_zero_impls_not_flagged() { assert!(w.is_empty()); } +#[test] +fn single_impl_in_non_test_module_collected() { + // The metadata collector must descend into regular (non-test) modules: an + // impl living in `mod inner` must still count toward the trait's impl set + // so SIT sees the single implementor. Guards the metadata-recursion guard + // in `collect_item_metadata` against being skipped. + let w = detect_from( + "trait Drawable { fn draw(&self); } mod inner { struct Circle; impl super::Drawable for Circle { fn draw(&self) {} } }", + ); + assert_eq!( + w.len(), + 1, + "an impl inside a non-test module must be collected into the metadata" + ); +} + #[test] fn test_disabled_check() { let syntax = diff --git a/src/adapters/analyzers/tq/assertions.rs b/src/adapters/analyzers/tq/assertions.rs index 9a9fe12a..22746ace 100644 --- a/src/adapters/analyzers/tq/assertions.rs +++ b/src/adapters/analyzers/tq/assertions.rs @@ -34,7 +34,8 @@ pub(crate) fn detect_assertion_free_tests( visitor.visit_block(&test_fn.body); if !(visitor.has_assertion || (test_fn.should_panic && visitor.has_panic) - || visitor.has_call) + || visitor.has_call + || test_fn.returns_bool) { warnings.push(TqWarning { file: path.clone(), @@ -55,6 +56,9 @@ struct TestFnInfo { line: usize, body: syn::Block, should_panic: bool, + /// Return type is `bool` — a quickcheck-style property whose boolean + /// verdict is its oracle (see `is_bool_return`). + returns_bool: bool, } /// Collects `#[test]` functions from a file. @@ -82,6 +86,7 @@ impl<'ast> Visit<'ast> for TestFunctionCollector { line, body: (*node.block).clone(), should_panic: has_should_panic_attr(&node.attrs), + returns_bool: is_bool_return(&node.sig.output), }); } syn::visit::visit_item_fn(self, node); @@ -161,3 +166,19 @@ use crate::adapters::shared::cfg_test::{has_cfg_test, has_test_attr}; fn has_should_panic_attr(attrs: &[syn::Attribute]) -> bool { attrs.iter().any(|a| a.path().is_ident("should_panic")) } + +/// True if the function returns `bool` — a quickcheck-style property whose +/// boolean verdict IS its assertion. The macro-expansion pre-pass surfaces +/// `quickcheck! { fn p(x: T) -> bool { … } }` as a synthetic `#[test] fn p() +/// -> bool { … }` with its params dropped, so a body like `{ x < 100 }` carries +/// no assertion macro or call — the returned bool is the oracle quickcheck +/// checks across every generated input. A plain `#[test]` cannot return `bool` +/// (it would not compile), so this signal is quickcheck-specific and safe. +/// Operation: return-type path inspection. +fn is_bool_return(output: &syn::ReturnType) -> bool { + let syn::ReturnType::Type(_, ty) = output else { + return false; + }; + matches!(&**ty, syn::Type::Path(tp) + if tp.path.segments.last().is_some_and(|s| s.ident == "bool")) +} diff --git a/src/adapters/analyzers/tq/tests/assertions.rs b/src/adapters/analyzers/tq/tests/assertions.rs index 6e871ec0..0840d783 100644 --- a/src/adapters/analyzers/tq/tests/assertions.rs +++ b/src/adapters/analyzers/tq/tests/assertions.rs @@ -147,6 +147,46 @@ fn test_prop_assert_no_warning() { ); } +#[test] +fn quickcheck_bool_property_no_warning() { + // The macro-expansion pre-pass surfaces `quickcheck! { fn p(x: u8) -> bool + // { x < 100 } }` as a synthetic `#[test] fn p() -> bool { x < 100 }` (params + // dropped). The boolean RETURN is the property's oracle — quickcheck checks + // it holds for every generated input — so a bare-boolean body with no + // assertion macro and no call must NOT be flagged TQ-001 assertion-free. + let warnings = parse_and_detect( + r#" + #[cfg(test)] + mod tests { + #[test] + fn small() -> bool { x < 100 } + } + "#, + ); + assert!( + warnings.is_empty(), + "a `-> bool` property's boolean return is its assertion: {warnings:?}" + ); +} + +#[test] +fn unit_return_without_assertion_still_warns() { + // Guard the `-> bool` leniency above: it must be specific to a boolean + // oracle. A normal unit-returning test with no assertion/call is still a + // TQ-001 NoAssertion — the bool exemption must not leak to `()` tests. + let warnings = parse_and_detect( + r#" + #[cfg(test)] + mod tests { + #[test] + fn nothing() { let _x = 1 < 2; } + } + "#, + ); + assert_eq!(warnings.len(), 1); + assert_eq!(warnings[0].kind, TqWarningKind::NoAssertion); +} + #[test] fn test_assert_ne_no_warning() { let warnings = parse_and_detect( @@ -196,9 +236,12 @@ fn test_assert_prefixed_custom_macro_no_warning() { #[test] fn test_extra_assertion_macro_config() { - let extras = vec!["verify".to_string()]; - let warnings = parse_and_detect_with_extras( - r#" + // The config must MATTER: `verify!` is not a built-in assertion (no + // `assert`/`debug_assert` prefix), so without the extras it triggers + // TQ-001; only the `extra_assertion_macros = ["verify"]` config makes it + // count. Asserting only the configured-on case would pass even if every + // macro were blanket-accepted — pin both sides. + let source = r#" #[cfg(test)] mod tests { #[test] @@ -206,9 +249,17 @@ fn test_extra_assertion_macro_config() { verify!(result.is_ok()); } } - "#, - &extras, + "#; + let without = parse_and_detect(source); + assert_eq!( + without.len(), + 1, + "verify! is NOT a built-in assertion → TQ-001 without the config" ); + assert_eq!(without[0].kind, TqWarningKind::NoAssertion); + + let extras = vec!["verify".to_string()]; + let warnings = parse_and_detect_with_extras(source, &extras); assert!( warnings.is_empty(), "verify! in extra_assertion_macros should be recognized" @@ -252,3 +303,98 @@ fn test_multiple_tests_mixed() { assert_eq!(warnings.len(), 1); assert_eq!(warnings[0].function_name, "test_bad"); } + +#[test] +fn non_assertion_macro_alone_emits_warning() { + // A non-assertion macro (`println!`) is not an assertion and is not a call, + // so a test whose only statement is one must still be flagged — guards + // `is_assertion_macro` against blanket-accepting every macro. + let warnings = parse_and_detect( + r#" + #[cfg(test)] + mod tests { + #[test] + fn test_something() { + println!("hi"); + } + } + "#, + ); + assert_eq!(warnings.len(), 1); + assert_eq!(warnings[0].kind, TqWarningKind::NoAssertion); +} + +#[test] +fn expression_position_assertion_no_warning() { + // An assertion in *expression* position (`let _ = assert_eq!(…)`) is an + // `Expr::Macro`, not a `Stmt::Macro` — exercises `visit_expr_macro`. + let warnings = parse_and_detect( + r#" + #[cfg(test)] + mod tests { + #[test] + fn test_something() { + let _ = assert_eq!(1, 1); + } + } + "#, + ); + assert!(warnings.is_empty()); +} + +#[test] +fn should_panic_with_expression_position_panic_no_warning() { + // A `panic!` in expression position drives the `== "panic"` check inside + // `visit_expr_macro`; combined with `#[should_panic]` it is a valid oracle. + let warnings = parse_and_detect( + r#" + #[cfg(test)] + mod tests { + #[test] + #[should_panic] + fn test_something() { + let _ = panic!("boom"); + } + } + "#, + ); + assert!(warnings.is_empty()); +} + +#[test] +fn method_call_only_no_warning() { + // A test whose only effect is a *method* call (no free-function call, no + // assertion) is still exercising code — guards `visit_expr_method_call`. + let warnings = parse_and_detect( + r#" + #[cfg(test)] + mod tests { + #[test] + fn test_something() { + 1u32.count_ones(); + } + } + "#, + ); + assert!(warnings.is_empty()); +} + +#[test] +fn panic_without_should_panic_attr_emits_warning() { + // A `panic!` only counts as an oracle when the test is `#[should_panic]`. + // Without that attribute, a panic-only test has no real assertion and must + // be flagged — guards `has_should_panic_attr` against returning `true`. + let warnings = parse_and_detect( + r#" + #[cfg(test)] + mod tests { + #[test] + fn test_something() { + panic!("boom"); + } + } + "#, + ); + assert_eq!(warnings.len(), 1); + assert_eq!(warnings[0].kind, TqWarningKind::NoAssertion); +} diff --git a/src/adapters/analyzers/tq/tests/lcov.rs b/src/adapters/analyzers/tq/tests/lcov.rs index 95818cb6..1476dd76 100644 --- a/src/adapters/analyzers/tq/tests/lcov.rs +++ b/src/adapters/analyzers/tq/tests/lcov.rs @@ -82,3 +82,21 @@ fn test_parse_zero_hit_function() { Some(&0) ); } + +#[test] +fn test_parse_unknown_line_within_record_does_not_split() { + // `LF:1` matches none of SF/FNDA/DA and is not `end_of_record`, so it must + // be ignored *while a file is open* — a record is closed only on a real + // `end_of_record`, never merely because a file is currently open. Both line + // hits must land in the single `src/lib.rs` record. + let (_tmp, path) = write_lcov("SF:src/lib.rs\nDA:1,1\nLF:1\nDA:2,1\nend_of_record\n"); + let result = parse_lcov(&path).unwrap(); + assert_eq!( + result.len(), + 1, + "an unknown mid-record line must not open a new record" + ); + let data = &result["src/lib.rs"]; + assert_eq!(data.line_hits.get(&1), Some(&1)); + assert_eq!(data.line_hits.get(&2), Some(&1)); +} diff --git a/src/adapters/analyzers/tq/tests/sut.rs b/src/adapters/analyzers/tq/tests/sut.rs index 0cacb7d1..ee5b016a 100644 --- a/src/adapters/analyzers/tq/tests/sut.rs +++ b/src/adapters/analyzers/tq/tests/sut.rs @@ -20,17 +20,27 @@ fn make_declared(name: &str, is_test: bool) -> DeclaredFunction { } } -fn parse_and_detect(source: &str, declared: &[DeclaredFunction]) -> Vec { +/// Run SUT detection over `source` against an explicit `scope_source` and +/// `reaches` set. The single arrange shared by every SUT test. +fn detect_in( + source: &str, + declared: &[DeclaredFunction], + scope_source: &str, + reaches: &[&str], +) -> Vec { let syntax = syn::parse_file(source).expect("test source"); let parsed = vec![("test.rs".to_string(), source.to_string(), syntax)]; - let scope_source = "fn prod_fn() {} fn helper() {}"; let scope_syntax = syn::parse_file(scope_source).expect("scope source"); let scope_refs = vec![("lib.rs", &scope_syntax)]; let scope = ProjectScope::from_files(&scope_refs); - let reaches_prod = HashSet::new(); + let reaches_prod: HashSet = reaches.iter().map(|s| s.to_string()).collect(); detect_no_sut_tests(&parsed, &scope, declared, &reaches_prod) } +fn parse_and_detect(source: &str, declared: &[DeclaredFunction]) -> Vec { + detect_in(source, declared, "fn prod_fn() {} fn helper() {}", &[]) +} + #[test] fn test_calls_prod_function_no_warning() { let declared = vec![make_declared("prod_fn", false)]; @@ -112,20 +122,17 @@ fn test_associated_function_call_recognized_as_sut() { // as a SUT call — there's no `new`-specific path, so a constructor and a // plain static method exercise the same recognition. let declared = vec![make_declared("new", false)]; - let scope_source = "struct MyType {} impl MyType { fn new() -> Self { MyType {} } }"; - let scope_syntax = syn::parse_file(scope_source).expect("scope source"); - let scope_refs = vec![("lib.rs", &scope_syntax)]; - let scope = ProjectScope::from_files(&scope_refs); - let source = r#" + let warnings = detect_in( + r#" #[test] fn test_constructor() { let x = MyType::new(); } - "#; - let syntax = syn::parse_file(source).expect("test source"); - let parsed = vec![("test.rs".to_string(), source.to_string(), syntax)]; - let reaches_prod = HashSet::new(); - let warnings = detect_no_sut_tests(&parsed, &scope, &declared, &reaches_prod); + "#, + &declared, + "struct MyType {} impl MyType { fn new() -> Self { MyType {} } }", + &[], + ); assert!( warnings.is_empty(), "MyType::new() should be recognized as SUT call" @@ -135,23 +142,63 @@ fn test_associated_function_call_recognized_as_sut() { #[test] fn test_transitive_sut_via_helper() { let declared = vec![make_declared("prod_fn", false)]; - let scope_source = "fn prod_fn() {}"; - let scope_syntax = syn::parse_file(scope_source).expect("scope source"); - let scope_refs = vec![("lib.rs", &scope_syntax)]; - let scope = ProjectScope::from_files(&scope_refs); - let source = r#" + let warnings = detect_in( + r#" #[test] fn test_via_helper() { my_helper(); } - "#; - let syntax = syn::parse_file(source).expect("test source"); - let parsed = vec![("test.rs".to_string(), source.to_string(), syntax)]; - // my_helper transitively reaches prod_fn - let reaches_prod: HashSet = ["my_helper".to_string()].into(); - let warnings = detect_no_sut_tests(&parsed, &scope, &declared, &reaches_prod); + "#, + &declared, + "fn prod_fn() {}", + &["my_helper"], + ); assert!( warnings.is_empty(), "my_helper transitively calls prod code" ); } + +#[test] +fn calls_prod_fn_known_only_via_declared_set() { + // `prod_only` is a production fn (declared, not a test) that is absent from + // the parsed scope, so recognition must come from the declared-name set + // alone — guarding the `!f.is_test` filter and the first `||` branch. + let declared = vec![make_declared("prod_only", false)]; + let warnings = detect_in( + r#" + #[test] + fn test_it() { + prod_only(); + } + "#, + &declared, + "fn unrelated() {}", + &[], + ); + assert!( + warnings.is_empty(), + "a call to a declared production fn is a SUT call" + ); +} + +#[test] +fn calls_fn_known_only_via_scope_functions() { + // `scope_fn` is in the analysed scope but NOT in the declared set; the + // scope-functions branch alone must recognise it as exercising the SUT. + let warnings = detect_in( + r#" + #[test] + fn test_it() { + scope_fn(); + } + "#, + &[], + "fn scope_fn() {}", + &[], + ); + assert!( + warnings.is_empty(), + "a call to an in-scope function is a SUT call" + ); +} diff --git a/src/adapters/analyzers/tq/tests/untested.rs b/src/adapters/analyzers/tq/tests/untested.rs index 68f7f75a..25fc59e2 100644 --- a/src/adapters/analyzers/tq/tests/untested.rs +++ b/src/adapters/analyzers/tq/tests/untested.rs @@ -1,5 +1,6 @@ use crate::adapters::analyzers::dry::dead_code::DeadCodeWarning; use crate::adapters::analyzers::dry::DeclaredFunction; +use crate::adapters::analyzers::tq::build_reaches_prod_set; use crate::adapters::analyzers::tq::untested::*; use crate::adapters::analyzers::tq::{TqWarning, TqWarningKind}; use crate::config::Config; @@ -217,3 +218,29 @@ fn test_empty_call_graph_falls_back_to_direct() { assert_eq!(warnings.len(), 1); assert_eq!(warnings[0].function_name, "b"); } + +#[test] +fn build_reaches_prod_set_seeds_prod_and_walks_callers_backward() { + // call graph: test_a → helper → prod_fn. Backward BFS from the production + // seed must reach helper (calls prod_fn) and test_a (calls helper). + let mut call_graph: HashMap> = HashMap::new(); + call_graph.insert("helper".to_string(), vec!["prod_fn".to_string()]); + call_graph.insert("test_a".to_string(), vec!["helper".to_string()]); + // `lonely_test` reaches no production code; the `!is_test` seed filter must + // keep it out of the set. + let declared = vec![ + make_declared("prod_fn", false), + make_declared("lonely_test", true), + ]; + let reaches = build_reaches_prod_set(&call_graph, &declared); + assert!(reaches.contains("prod_fn"), "production fn seeds the set"); + assert!(reaches.contains("helper"), "helper calls prod_fn"); + assert!( + reaches.contains("test_a"), + "test_a transitively reaches prod via helper" + ); + assert!( + !reaches.contains("lonely_test"), + "a test fn reaching no prod code is excluded from the seed" + ); +} diff --git a/src/adapters/config/init.rs b/src/adapters/config/init.rs index d40a45af..448390ba 100644 --- a/src/adapters/config/init.rs +++ b/src/adapters/config/init.rs @@ -190,6 +190,17 @@ enabled = true # Optional: path to LCOV coverage file for TQ-004/TQ-005 checks. # coverage_file = "lcov.info" +# ── Test-Code Thresholds ─────────────────────────────────────────────── +# A curated subset of checks also runs on test code: DRY-001/004/005, LONG_FN +# (function length), SRP file-length, and the god-struct check (SRP-001). Each +# key below overrides the matching production threshold FOR TEST CODE ONLY; an +# unset key inherits the production value. Which checks apply is fixed. + +[tests] +# max_function_lines = 60 # overrides [complexity].max_function_lines +# file_length_baseline = 300 # overrides [srp].file_length_baseline +# file_length_ceiling = 600 # overrides [srp].file_length_ceiling + # ── Quality Score Weights ────────────────────────────────────────────── # Weights for each dimension in the overall quality score. # Must sum to approximately 1.0. @@ -308,6 +319,16 @@ check_sdp = true enabled = true # coverage_file = "lcov.info" +# ── Test-Code Thresholds ─────────────────────────────────────────────── +# A curated subset of checks also runs on test code (DRY-001/004/005, LONG_FN, +# SRP file-length, god-struct SRP-001). Each key overrides the matching +# production threshold FOR TEST CODE ONLY; unset = inherit production. + +[tests] +# max_function_lines = 60 # overrides [complexity].max_function_lines +# file_length_baseline = 300 # overrides [srp].file_length_baseline +# file_length_ceiling = 600 # overrides [srp].file_length_ceiling + # ── Quality Score Weights ────────────────────────────────────────────── # Must sum to approximately 1.0. diff --git a/src/adapters/config/sections.rs b/src/adapters/config/sections.rs index 506d0430..6f751f93 100644 --- a/src/adapters/config/sections.rs +++ b/src/adapters/config/sections.rs @@ -200,10 +200,14 @@ impl Default for SrpConfig { /// /// rustqual applies a curated subset of checks to test code — DRY-001/004/005 /// (duplicate fns / fragments / repeated matches), LONG_FN (function length), -/// and SRP size (file/module length, method count). The remaining checks stay -/// test-exempt: ERROR_HANDLING, MAGIC_NUMBER, IOSP, DRY-002 dead code, DRY-003 -/// wildcard imports, Coupling, and all Structural detectors. **This split is -/// fixed — only the thresholds below are configurable.** +/// and SRP file-length (SRP_MODULE). The god-struct check (SRP-001) also fires +/// on test structs — a god-fixture is a real smell — but at production +/// thresholds, with no separate test knob (`// qual:allow(srp)` covers the rare +/// legitimate fixture). The remaining checks stay test-exempt: ERROR_HANDLING, +/// MAGIC_NUMBER, IOSP, DRY-002 dead code, DRY-003 wildcard imports, Coupling, +/// all Structural detectors, and the SRP *module*-cohesion (independent-cluster) +/// check — a test file's independent `#[test]` fns are its purpose, not a smell. +/// **This split is fixed — only the thresholds below are configurable.** /// /// Each field overrides the matching production threshold *for test code /// only*. The default is `None`, meaning the production value is inherited — @@ -218,8 +222,6 @@ pub struct TestsConfig { pub file_length_baseline: Option, /// Overrides `[srp].file_length_ceiling` for test files. pub file_length_ceiling: Option, - /// Overrides `[srp].max_methods` for test impls / inherent blocks. - pub max_methods: Option, } /// Configuration for coupling analysis. diff --git a/src/adapters/config/tests/init.rs b/src/adapters/config/tests/init.rs index e76389e7..ff353125 100644 --- a/src/adapters/config/tests/init.rs +++ b/src/adapters/config/tests/init.rs @@ -48,6 +48,7 @@ fn test_generate_default_config_contents() { assert!(content.contains("[boilerplate]")); assert!(content.contains("[srp]")); assert!(content.contains("[coupling]")); + assert!(content.contains("[tests]")); assert!(content.contains("max_suppression_ratio")); assert!(content.contains("fail_on_warnings")); assert!(content.contains("[weights]")); @@ -120,4 +121,5 @@ fn test_generate_tailored_config_includes_metrics_comments() { assert!(content.contains("100 function(s)")); assert!(content.contains("current max: 10")); assert!(content.contains("current max: 8")); + assert!(content.contains("[tests]")); } diff --git a/src/adapters/config/tests/sections.rs b/src/adapters/config/tests/sections.rs index 48426f9c..627c7da4 100644 --- a/src/adapters/config/tests/sections.rs +++ b/src/adapters/config/tests/sections.rs @@ -98,7 +98,6 @@ fn test_tests_config_defaults_inherit_production() { assert_eq!(c.max_function_lines, None); assert_eq!(c.file_length_baseline, None); assert_eq!(c.file_length_ceiling, None); - assert_eq!(c.max_methods, None); } #[test] @@ -107,13 +106,11 @@ fn test_tests_config_deserialize_overrides() { max_function_lines = 120 file_length_baseline = 500 file_length_ceiling = 1200 - max_methods = 40 "#; let c: TestsConfig = toml::from_str(toml_str).unwrap(); assert_eq!(c.max_function_lines, Some(120)); assert_eq!(c.file_length_baseline, Some(500)); assert_eq!(c.file_length_ceiling, Some(1200)); - assert_eq!(c.max_methods, Some(40)); } #[test] diff --git a/src/adapters/report/baseline.rs b/src/adapters/report/baseline.rs index 2c6f0d09..617724b2 100644 --- a/src/adapters/report/baseline.rs +++ b/src/adapters/report/baseline.rs @@ -103,13 +103,13 @@ pub fn create_baseline(results: &[FunctionAnalysis], summary: &Summary) -> Strin .unwrap_or_else(|e| format!("{{\"error\":\"baseline serialization failed: {e}\"}}")) } -/// Print v2-specific deltas: TQ warnings, findings, and quality score. -/// Returns true if quality score regressed. -/// Operation: data extraction, comparison, and display logic; own call hidden in closure. -fn print_v2_deltas(raw: &serde_json::Value, summary: &Summary) -> bool { - let show_delta = |label: &str, old_pct: f64, new_pct: f64| { - print_score_delta(label, old_pct, new_pct); - }; +/// Build the v2-specific delta lines (TQ warnings, quality score) plus the +/// regression flag (quality score dropped). Pure so the TQ sum, the +/// `* PERCENTAGE_MULTIPLIER` scaling, and the regression comparison are +/// observable in tests rather than buried in stdout. +/// Operation: data extraction + comparison; own call hidden in closure. +pub(super) fn v2_delta_lines(raw: &serde_json::Value, summary: &Summary) -> (Vec, bool) { + let fmt = |label: &str, old_pct: f64, new_pct: f64| format_score_delta(label, old_pct, new_pct); let tq_keys = [ "tq_no_assertion_warnings", "tq_no_sut_warnings", @@ -123,91 +123,108 @@ fn print_v2_deltas(raw: &serde_json::Value, summary: &Summary) -> bool { + summary.tq_untested_warnings + summary.tq_uncovered_warnings + summary.tq_untested_logic_warnings; - println!( - " TQ warnings: {} \u{2192} {} ({:+})", - old_tq, - new_tq, - new_tq as i64 - old_tq as i64 - ); let old_quality = raw["quality_score"].as_f64().unwrap_or(0.0); - show_delta( - "Quality", - old_quality * PERCENTAGE_MULTIPLIER, - summary.quality_score * PERCENTAGE_MULTIPLIER, - ); - summary.quality_score - old_quality < 0.0 + let lines = vec![ + format!( + " TQ warnings: {} \u{2192} {} ({:+})", + old_tq, + new_tq, + new_tq as i64 - old_tq as i64 + ), + fmt( + "Quality", + old_quality * PERCENTAGE_MULTIPLIER, + summary.quality_score * PERCENTAGE_MULTIPLIER, + ), + ]; + (lines, summary.quality_score - old_quality < 0.0) } -/// Compare current results against a baseline and print delta. -/// Returns true if there was a regression (quality score decreased). -/// Supports v1 (IOSP-only) and v2 (full quality score) baseline formats. -/// Operation: comparison and display logic. Own calls hidden in closures. -pub fn print_comparison( - baseline_content: &str, - _results: &[FunctionAnalysis], - summary: &Summary, -) -> bool { - let show_delta = |label: &str, old_pct: f64, new_pct: f64| { - print_score_delta(label, old_pct, new_pct); - }; - let v2_deltas = |r: &serde_json::Value, s: &Summary| print_v2_deltas(r, s); +/// Build all baseline-comparison lines plus the regression flag, given the +/// already-parsed baseline JSON. Pure so the violation/finding deltas, the +/// IOSP scaling, and the v1/v2 regression branch are observable in tests. +/// Operation: comparison + display logic; own calls hidden in closures. +pub(super) fn comparison_lines(raw: &serde_json::Value, summary: &Summary) -> (Vec, bool) { + let fmt = |label: &str, old_pct: f64, new_pct: f64| format_score_delta(label, old_pct, new_pct); + let v2 = |r: &serde_json::Value, s: &Summary| v2_delta_lines(r, s); let findings = |s: &Summary| s.total_findings(); - let raw: serde_json::Value = match serde_json::from_str(baseline_content) { - Ok(v) => v, - Err(e) => { - eprintln!("Error parsing baseline: {e}"); - return false; - } - }; let is_v2 = raw.get("version").and_then(|v| v.as_u64()).unwrap_or(0) >= 2; - println!( - "\n{}", - "\u{2550}\u{2550}\u{2550} Baseline Comparison \u{2550}\u{2550}\u{2550}".bold() - ); let old_iosp = raw["iosp_score"].as_f64().unwrap_or(0.0); let old_violations = raw["violations"].as_u64().unwrap_or(0) as usize; let violation_delta = summary.violations as i64 - old_violations as i64; - println!( - " Violations: {} \u{2192} {} ({:+})", - old_violations, summary.violations, violation_delta - ); + let mut lines = vec![ + format!( + "\n{}", + "\u{2550}\u{2550}\u{2550} Baseline Comparison \u{2550}\u{2550}\u{2550}".bold() + ), + format!( + " Violations: {} \u{2192} {} ({:+})", + old_violations, summary.violations, violation_delta + ), + ]; if is_v2 { let old_findings = raw["total_findings"].as_u64().unwrap_or(0) as usize; let finding_delta = findings(summary) as i64 - old_findings as i64; - println!( + lines.push(format!( " Findings: {} \u{2192} {} ({:+})", old_findings, findings(summary), finding_delta - ); + )); } - show_delta( + lines.push(fmt( "IOSP Score", old_iosp * PERCENTAGE_MULTIPLIER, summary.iosp_score * PERCENTAGE_MULTIPLIER, - ); - if is_v2 { - v2_deltas(&raw, summary) + )); + let regressed = if is_v2 { + let (v2_lines, reg) = v2(raw, summary); + lines.extend(v2_lines); + reg } else { summary.iosp_score - old_iosp < 0.0 - } + }; + (lines, regressed) +} + +/// Compare current results against a baseline and print delta. +/// Returns true if there was a regression (quality score decreased). +/// Supports v1 (IOSP-only) and v2 (full quality score) baseline formats. +/// Integration: parse, then delegate line-building to `comparison_lines`. +pub fn print_comparison( + baseline_content: &str, + _results: &[FunctionAnalysis], + summary: &Summary, +) -> bool { + let raw: serde_json::Value = match serde_json::from_str(baseline_content) { + Ok(v) => v, + Err(e) => { + eprintln!("Error parsing baseline: {e}"); + return false; + } + }; + let (lines, regressed) = comparison_lines(&raw, summary); + lines.iter().for_each(|l| println!("{l}")); + regressed } -/// Print a labeled score delta line with colored arrow. +/// Build a labeled score-delta line: up-arrow (green) when the score rose, +/// down-arrow (red) when it fell, `(unchanged)` when equal. Pure so the +/// direction branch and the `new - old` delta are observable in tests. /// Operation: conditional formatting logic, no own calls. -fn print_score_delta(label: &str, old_pct: f64, new_pct: f64) { +pub(super) fn format_score_delta(label: &str, old_pct: f64, new_pct: f64) -> String { let delta = new_pct - old_pct; if delta > 0.0 { - println!( + format!( " {label}: {old_pct:.1}% \u{2192} {new_pct:.1}% ({})", format!("\u{2191} {:.1}%", delta).green() - ); + ) } else if delta < 0.0 { - println!( + format!( " {label}: {old_pct:.1}% \u{2192} {new_pct:.1}% ({})", format!("\u{2193} {:.1}%", delta.abs()).red() - ); + ) } else { - println!(" {label}: {new_pct:.1}% (unchanged)"); + format!(" {label}: {new_pct:.1}% (unchanged)") } } diff --git a/src/adapters/report/html/tests/complexity.rs b/src/adapters/report/html/tests/complexity.rs new file mode 100644 index 00000000..a18057b7 --- /dev/null +++ b/src/adapters/report/html/tests/complexity.rs @@ -0,0 +1,155 @@ +//! HTML complexity section: the flagged-key membership filter +//! (`matches_any_flagged`) and the `!suppressed && !complexity_suppressed` +//! row filter that decide which function rows are rendered. +use crate::report::html::complexity::format_complexity_section; +use crate::report::html::views::{ + HtmlComplexityDataView, HtmlComplexityFunctionRow, HtmlComplexityKey, HtmlComplexityView, +}; + +fn row(name: &str, line: usize, suppressed: bool) -> HtmlComplexityFunctionRow { + HtmlComplexityFunctionRow { + qualified_name: name.into(), + file: "a.rs".into(), + line, + cognitive: 20, + cyclomatic: 12, + max_nesting: 5, + function_lines: 80, + issue_summary: "magic: 42".into(), + suppressed, + complexity_suppressed: false, + } +} + +#[test] +fn complexity_section_renders_only_flagged_unsuppressed_rows() { + let finding_view = HtmlComplexityView { + flagged_keys: vec![HtmlComplexityKey { + file: "a.rs".into(), + line: 5, + is_magic_number: false, + }], + }; + let data_view = HtmlComplexityDataView { + functions: vec![ + row("shown_fn", 5, false), // flagged (a.rs:5) + not suppressed → shown + row("other_line_fn", 99, false), // a.rs:99 not in flagged keys → hidden + row("suppressed_fn", 5, true), // flagged but suppressed → hidden + ], + }; + let html = format_complexity_section(&finding_view, &data_view); + assert!( + html.contains("Complexity \u{2014} 1 Warning"), + "one warning: {html}" + ); + assert!( + html.contains("shown_fn"), + "flagged unsuppressed row shown: {html}" + ); + assert!( + !html.contains("other_line_fn"), + "non-flagged line excluded (matches_any_flagged file&&line): {html}" + ); + assert!( + !html.contains("suppressed_fn"), + "suppressed row excluded: {html}" + ); +} + +#[test] +fn complexity_magic_number_key_flags_whole_file_regardless_of_line() { + // A magic-number key (is_magic_number = true) matches any line in the file. + let finding_view = HtmlComplexityView { + flagged_keys: vec![HtmlComplexityKey { + file: "a.rs".into(), + line: 1, + is_magic_number: true, + }], + }; + let data_view = HtmlComplexityDataView { + functions: vec![row("magic_fn", 42, false)], + }; + let html = format_complexity_section(&finding_view, &data_view); + assert!( + html.contains("magic_fn"), + "magic-number key flags the whole file (line ignored): {html}" + ); +} + +fn metrics_with( + unsafe_blocks: usize, + unwrap_count: usize, + magic: bool, +) -> crate::domain::analysis_data::ComplexityMetricsRecord { + crate::domain::analysis_data::ComplexityMetricsRecord { + cognitive_complexity: 0, + cyclomatic_complexity: 0, + max_nesting: 0, + function_lines: 0, + unsafe_blocks, + unwrap_count, + expect_count: 0, + panic_count: 0, + todo_count: 0, + logic_count: 0, + call_count: 0, + hotspots: vec![], + magic_numbers: if magic { + vec![crate::domain::analysis_data::MagicNumberOccurrence { + line: 7, + value: "42".into(), + }] + } else { + vec![] + }, + logic_occurrences: vec![], + } +} + +fn frec_with( + metrics: crate::domain::analysis_data::ComplexityMetricsRecord, +) -> crate::domain::analysis_data::FunctionRecord { + crate::domain::analysis_data::FunctionRecord { + name: "f".into(), + file: "a.rs".into(), + line: 1, + qualified_name: "f".into(), + parent_type: None, + classification: crate::domain::analysis_data::FunctionClassification::Operation, + severity: None, + complexity: Some(metrics), + parameter_count: 0, + own_calls: vec![], + is_trait_impl: false, + is_test: false, + effort_score: None, + suppressed: false, + complexity_suppressed: false, + } +} + +#[test] +fn build_issue_summary_lists_magic_unsafe_and_error_handling() { + use crate::report::html::complexity::build_complexity_data_view; + let view = build_complexity_data_view(&[frec_with(metrics_with(2, 3, true))]); + let summary = &view.functions[0].issue_summary; + assert!(summary.contains("magic"), "magic numbers: {summary}"); + assert!( + summary.contains("2 unsafe"), + "unsafe blocks (`> 0`): {summary}" + ); + assert!( + summary.contains("3unwrap"), + "error-handling count (`> 0` + `!empty`): {summary}" + ); +} + +#[test] +fn build_issue_summary_em_dash_when_clean() { + use crate::report::html::complexity::build_complexity_data_view; + let view = build_complexity_data_view(&[frec_with(metrics_with(0, 0, false))]); + assert_eq!( + view.functions[0].issue_summary, "\u{2014}", + "no issues → em-dash" + ); +} diff --git a/src/adapters/report/html/tests/dashboard.rs b/src/adapters/report/html/tests/dashboard.rs new file mode 100644 index 00000000..61237982 --- /dev/null +++ b/src/adapters/report/html/tests/dashboard.rs @@ -0,0 +1,52 @@ +//! HTML dashboard: the quality-score percentage (`* PERCENTAGE_MULTIPLIER`) and +//! the score→color thresholds (`>= 0.8` green, `>= 0.5` yellow). +use crate::ports::Reporter; +use crate::report::html::HtmlReporter; +use crate::report::{AnalysisResult, Summary}; + +fn render_dashboard(quality: f64, dimension_scores: [f64; 7]) -> String { + let mut summary = Summary { + total: 100, + quality_score: quality, + ..Default::default() + }; + summary.dimension_scores = dimension_scores; + let analysis = AnalysisResult { + results: vec![], + summary, + findings: crate::domain::AnalysisFindings::default(), + data: crate::domain::AnalysisData::default(), + }; + HtmlReporter { + summary: &analysis.summary, + } + .render(&analysis.findings, &analysis.data) +} + +/// The score-badge's `style="background:"` — the ONLY place `color()`'s +/// output is observable (a literal `color:#48bb78` cell appears elsewhere +/// unconditionally, so plain `contains("#48bb78")` is useless). +fn badge_background(quality: f64) -> String { + let html = render_dashboard(quality, [1.0; 7]); + let marker = "score-badge\" style=\"background:"; + let start = html.find(marker).expect("score badge element") + marker.len(); + html[start..start + 7].to_string() +} + +#[test] +fn dashboard_quality_badge_color_by_threshold() { + // The badge background is colored from the quality score: >= 0.8 green, + // >= 0.5 yellow, else red. Each threshold boundary pins one `>=`. + assert_eq!(badge_background(0.8), "#48bb78", "0.8 → green (>= 0.8)"); + assert_eq!(badge_background(0.5), "#ecc94b", "0.5 → yellow (>= 0.5)"); + assert_eq!(badge_background(0.3), "#f56565", "0.3 → red (else)"); +} + +#[test] +fn dashboard_score_percentage() { + // quality 0.8 → "80.0%" pins `pct = v * PERCENTAGE_MULTIPLIER`. + assert!( + render_dashboard(0.8, [1.0; 7]).contains("80.0%"), + "quality percentage (* MULTIPLIER)" + ); +} diff --git a/src/adapters/report/html/tests/dry.rs b/src/adapters/report/html/tests/dry.rs new file mode 100644 index 00000000..5b39cf44 --- /dev/null +++ b/src/adapters/report/html/tests/dry.rs @@ -0,0 +1,74 @@ +//! HTML DRY section rendering: the finding-total `+` sum across the six +//! categories and each per-category table/group builder. +use crate::adapters::report::projections::dry::{ + BoilerplateRow, DeadCodeRow, DryGroupRow, ParticipantRow, WildcardRow, +}; +use crate::report::html::dry::format_dry_section; +use crate::report::html::views::HtmlDryView; + +fn group(kind: &str, fname: &str) -> DryGroupRow { + DryGroupRow { + kind_label: kind.into(), + participants: vec![ParticipantRow { + function_name: fname.into(), + file: "lib.rs".into(), + line: 1, + }], + } +} + +#[test] +fn dry_section_total_and_every_category_table() { + // One entry in each of the six categories → total 6 (pins the five `+`). + let view = HtmlDryView { + duplicate_groups: vec![group("Exact", "dupfn")], + fragment_groups: vec![group("3", "fragfn")], + repeated_match_groups: vec![group("E", "repfn")], + dead_code: vec![DeadCodeRow { + qualified_name: "deadfn".into(), + kind_tag: "uncalled", + file: "d.rs".into(), + line: 2, + suggestion: "remove".into(), + }], + boilerplate: vec![BoilerplateRow { + pattern_id: "BP-001".into(), + struct_name: "Foo".into(), + file: "b.rs".into(), + line: 3, + message: "boiler".into(), + suggestion: "derive".into(), + }], + wildcards: vec![WildcardRow { + module_path: "m::*".into(), + file: "w.rs".into(), + line: 5, + }], + }; + let html = format_dry_section(&view); + assert!( + html.contains("DRY \u{2014} 6 Findings"), + "total header: {html}" + ); + assert!(html.contains("dupfn"), "duplicate group: {html}"); + assert!(html.contains("fragfn"), "fragment group: {html}"); + assert!(html.contains("repfn"), "repeated-match group: {html}"); + assert!(html.contains("deadfn"), "dead-code table: {html}"); + assert!(html.contains("BP-001"), "boilerplate table: {html}"); + assert!(html.contains("m::*"), "wildcard table: {html}"); +} + +#[test] +fn dry_section_empty_state() { + let view = HtmlDryView { + duplicate_groups: vec![], + fragment_groups: vec![], + repeated_match_groups: vec![], + dead_code: vec![], + boilerplate: vec![], + wildcards: vec![], + }; + let html = format_dry_section(&view); + assert!(html.contains("DRY \u{2014} 0 Findings"), "{html}"); + assert!(html.contains("No DRY issues found"), "{html}"); +} diff --git a/src/adapters/report/html/tests/iosp.rs b/src/adapters/report/html/tests/iosp.rs new file mode 100644 index 00000000..3a8fc329 --- /dev/null +++ b/src/adapters/report/html/tests/iosp.rs @@ -0,0 +1,76 @@ +//! HTML IOSP section: the violation-row filter (`!suppressed && classification +//! == Violation`) and the finding↔function join (`file == … && line == …`). +use crate::domain::analysis_data::{FunctionClassification, FunctionRecord}; +use crate::report::html::iosp::{build_iosp_data_view, format_iosp_section}; +use crate::report::html::views::{HtmlIospFindingRow, HtmlIospView}; +use crate::report::Summary; + +fn record(classification: FunctionClassification, suppressed: bool) -> FunctionRecord { + FunctionRecord { + name: "f".into(), + file: "a.rs".into(), + line: 5, + qualified_name: "viol_fn".into(), + parent_type: None, + classification, + severity: Some(crate::domain::Severity::High), + complexity: None, + parameter_count: 0, + own_calls: vec![], + is_trait_impl: false, + is_test: false, + effort_score: None, + suppressed, + complexity_suppressed: false, + } +} + +#[test] +fn build_iosp_data_view_keeps_only_unsuppressed_violations() { + // Operation (non-violation) and suppressed violation rows are dropped; pins + // `!suppressed && classification == Violation`. + assert!( + build_iosp_data_view(&[record(FunctionClassification::Operation, false)]) + .violations + .is_empty(), + "non-violation excluded" + ); + assert!( + build_iosp_data_view(&[record(FunctionClassification::Violation, true)]) + .violations + .is_empty(), + "suppressed violation excluded" + ); + assert_eq!( + build_iosp_data_view(&[record(FunctionClassification::Violation, false)]) + .violations + .len(), + 1, + "unsuppressed violation kept" + ); +} + +#[test] +fn iosp_section_join_requires_exact_file_and_line() { + // The violation row is at a.rs:5; a finding at a.rs:99 must NOT join (pins + // the `file == … && line == …` match), leaving the logic/calls cells empty. + let data = build_iosp_data_view(&[record(FunctionClassification::Violation, false)]); + let findings = HtmlIospView { + findings: vec![HtmlIospFindingRow { + file: "a.rs".into(), + line: 99, + logic_summary: "LOGIC_MARKER".into(), + call_summary: "CALL_MARKER".into(), + }], + }; + let summary = Summary { + violations: 1, + ..Default::default() + }; + let html = format_iosp_section(&findings, &data, &summary); + assert!(html.contains("viol_fn"), "violation row rendered: {html}"); + assert!( + !html.contains("LOGIC_MARKER"), + "line mismatch → finding does not join: {html}" + ); +} diff --git a/src/adapters/report/html/tests/mod.rs b/src/adapters/report/html/tests/mod.rs index 6ee09e6a..b7868cb9 100644 --- a/src/adapters/report/html/tests/mod.rs +++ b/src/adapters/report/html/tests/mod.rs @@ -1 +1,7 @@ +mod complexity; +mod dashboard; +mod dry; +mod iosp; mod root; +mod sections; +mod srp_tables; diff --git a/src/adapters/report/html/tests/sections.rs b/src/adapters/report/html/tests/sections.rs new file mode 100644 index 00000000..92731f53 --- /dev/null +++ b/src/adapters/report/html/tests/sections.rs @@ -0,0 +1,98 @@ +//! HTML rendering tests for the Coupling, Structural, and Test-Quality +//! sections — each `format_*_subsection`/`format_*` builder must reach the +//! output, and the structural warning-total `+` and `&&` guards are pinned. +use crate::adapters::report::projections::coupling::SdpViolationRow; +use crate::adapters::report::projections::srp::StructuralRow; +use crate::adapters::report::projections::tq::TqRow; +use crate::report::html::coupling::format_coupling_section; +use crate::report::html::structural_table::format_structural_section; +use crate::report::html::tq_table::format_tq_section; +use crate::report::html::views::{ + HtmlCouplingDataView, HtmlCouplingModuleRow, HtmlCouplingView, HtmlTqView, +}; + +fn srow(code: &str, name: &str) -> StructuralRow { + StructuralRow { + code: code.into(), + name: name.into(), + detail: "detail".into(), + file: "s.rs".into(), + line: 4, + } +} + +#[test] +fn coupling_section_renders_cycles_sdp_and_modules() { + let view = HtmlCouplingView { + cycle_paths: vec![vec!["cyc_alpha".into(), "cyc_beta".into()]], + sdp_violations: vec![SdpViolationRow { + from: "sdp_from".into(), + from_instability: 0.2, + to: "sdp_to".into(), + to_instability: 0.8, + }], + structural_rows: vec![], + }; + let data = HtmlCouplingDataView { + modules: vec![HtmlCouplingModuleRow { + name: "mod_node".into(), + afferent: 1, + efferent: 9, + instability: 0.9, + suppressed: false, + }], + }; + let html = format_coupling_section(&view, &data); + assert!(html.contains("1 Module, 1 Cycle"), "header: {html}"); + assert!(html.contains("mod_node"), "module subsection: {html}"); + assert!( + html.contains("sdp_from") && html.contains("sdp_to"), + "sdp subsection: {html}" + ); + assert!( + html.contains("cyc_alpha") && html.contains("cyc_beta"), + "cycle subsection: {html}" + ); +} + +#[test] +fn structural_section_total_and_rows() { + // 1 SRP + 1 Coupling row = 2 warnings; the header sum pins the `+`. + let html = format_structural_section(&[srow("SLM", "Foo")], &[srow("OI", "Bar")]); + assert!(html.contains("2 Warning"), "total header: {html}"); + assert!( + html.contains("SLM") && html.contains("Foo"), + "srp row: {html}" + ); + assert!( + html.contains("OI") && html.contains("Bar"), + "coupling row: {html}" + ); + // An SRP-only set still renders its row (pins the all-empty `&&` guard) and + // pluralizes "Warning" via `count == 1` (one row → singular). + let srp_only = format_structural_section(&[srow("BTC", "Trait")], &[]); + assert!(srp_only.contains("BTC"), "srp-only renders: {srp_only}"); + assert!( + srp_only.contains("1 Warning<"), + "single row → singular 'Warning' (pins `count == 1`): {srp_only}" + ); + // Both empty → no warning rows. + let empty = format_structural_section(&[], &[]); + assert!(empty.contains("No structural warnings"), "empty: {empty}"); +} + +#[test] +fn tq_section_renders_row() { + let view = HtmlTqView { + warnings: vec![TqRow { + function_name: "test_it".into(), + file: "t.rs".into(), + line: 9, + display_label: "no assertion", + detail: String::new(), + }], + }; + let html = format_tq_section(&view); + assert!(html.contains("test_it"), "tq row: {html}"); + assert!(html.contains("no assertion"), "tq label: {html}"); +} diff --git a/src/adapters/report/html/tests/srp_tables.rs b/src/adapters/report/html/tests/srp_tables.rs new file mode 100644 index 00000000..f75c4cda --- /dev/null +++ b/src/adapters/report/html/tests/srp_tables.rs @@ -0,0 +1,76 @@ +//! HTML SRP sub-table rendering tests: the warning-total header arithmetic, +//! each sub-table builder, and the `independent_clusters > 0` cluster cell. +use crate::adapters::report::projections::srp::{SrpModuleRow, SrpParamRow, SrpStructRow}; +use crate::report::html::srp_tables::format_srp_section; +use crate::report::html::views::HtmlSrpView; + +fn struct_row() -> SrpStructRow { + SrpStructRow { + struct_name: "BigStruct".into(), + file: "s.rs".into(), + line: 3, + lcom4: 4, + field_count: 9, + method_count: 7, + fan_out: 2, + } +} + +fn module_row(independent_clusters: usize) -> SrpModuleRow { + SrpModuleRow { + module: "big_mod".into(), + file: "m.rs".into(), + production_lines: 900, + independent_clusters, + cluster_names: vec![], + } +} + +fn param_row() -> SrpParamRow { + SrpParamRow { + function_name: "wide_fn".into(), + file: "p.rs".into(), + line: 8, + parameter_count: 7, + } +} + +#[test] +fn srp_section_total_header_and_subtables() { + // 1 struct + 2 module + 1 param = 4 warnings; the header sum pins the two `+`. + let view = HtmlSrpView { + struct_warnings: vec![struct_row()], + module_warnings: vec![module_row(2), module_row(0)], + param_warnings: vec![param_row()], + structural_rows: vec![], + }; + let html = format_srp_section(&view); + assert!( + html.contains("SRP \u{2014} 4 Warnings"), + "total header: {html}" + ); + // Each sub-table renders its row content (pins the `-> String` builders). + assert!(html.contains("BigStruct"), "struct row: {html}"); + assert!(html.contains("big_mod"), "module row: {html}"); + assert!(html.contains("wide_fn"), "param row: {html}"); + // Cluster cell: clusters>0 → "N clusters", clusters==0 → em-dash. Pins `> 0` + // against `>=` (a zero-cluster module must NOT render "0 clusters"). + assert!(html.contains("2 clusters"), "non-zero clusters: {html}"); + assert!( + !html.contains("0 clusters"), + "zero clusters → em-dash, not '0 clusters': {html}" + ); +} + +#[test] +fn srp_section_empty_states_when_no_warnings() { + let view = HtmlSrpView { + struct_warnings: vec![], + module_warnings: vec![], + param_warnings: vec![], + structural_rows: vec![], + }; + let html = format_srp_section(&view); + assert!(html.contains("SRP \u{2014} 0 Warnings"), "{html}"); + assert!(html.contains("No SRP warnings"), "empty state: {html}"); +} diff --git a/src/adapters/report/sarif/tests/mappers.rs b/src/adapters/report/sarif/tests/mappers.rs new file mode 100644 index 00000000..b911cfff --- /dev/null +++ b/src/adapters/report/sarif/tests/mappers.rs @@ -0,0 +1,194 @@ +//! Tests for the SARIF rule-id mappers (`*_rule`) and the `helpUri` guard. +//! Each finding kind / structural code maps to a fixed rule id; asserting the +//! exact id pins every match arm and the `-> ""`/"xyzzy" body replacements. +use crate::domain::findings::{ + ComplexityFindingKind, CouplingFinding, CouplingFindingDetails, CouplingFindingKind, + DryFinding, DryFindingDetails, DryFindingKind, SrpFinding, SrpFindingDetails, SrpFindingKind, + TqFindingKind, +}; +use crate::domain::{Dimension, Finding, Severity}; +use crate::report::sarif::rules::*; + +fn common(dim: Dimension) -> Finding { + Finding { + file: "x.rs".into(), + line: 1, + column: 0, + dimension: dim, + rule_id: "r".into(), + message: "m".into(), + severity: Severity::Medium, + suppressed: false, + } +} + +fn dry(kind: DryFindingKind, details: DryFindingDetails) -> DryFinding { + DryFinding { + common: common(Dimension::Dry), + kind, + details, + } +} + +fn srp(kind: SrpFindingKind, details: SrpFindingDetails) -> SrpFinding { + SrpFinding { + common: common(Dimension::Srp), + kind, + details, + } +} + +#[test] +fn complexity_rule_maps_each_kind() { + use ComplexityFindingKind::*; + let cases = [ + (Cognitive, "CX-001"), + (Cyclomatic, "CX-002"), + (MagicNumber, "CX-003"), + (FunctionLength, "CX-004"), + (NestingDepth, "CX-005"), + (Unsafe, "CX-006"), + (ErrorHandling, "A20"), + ]; + for (kind, want) in cases { + assert_eq!(complexity_rule(kind), want, "{kind:?}"); + } +} + +#[test] +fn dry_rule_maps_each_kind() { + let dup = dry( + DryFindingKind::DuplicateExact, + DryFindingDetails::DeadCode { + qualified_name: String::new(), + suggestion: None, + }, + ); + assert_eq!(dry_rule(&dup), "DRY-001"); + let dead = dry( + DryFindingKind::DeadCodeUncalled, + DryFindingDetails::DeadCode { + qualified_name: String::new(), + suggestion: None, + }, + ); + assert_eq!(dry_rule(&dead), "DRY-002"); + let frag = dry( + DryFindingKind::Fragment, + DryFindingDetails::DeadCode { + qualified_name: String::new(), + suggestion: None, + }, + ); + assert_eq!(dry_rule(&frag), "DRY-003"); + let bp = dry( + DryFindingKind::Boilerplate, + DryFindingDetails::Boilerplate { + pattern_id: "BP-007".into(), + struct_name: None, + suggestion: String::new(), + }, + ); + assert_eq!(dry_rule(&bp), "BP-007", "boilerplate uses its pattern_id"); +} + +#[test] +fn srp_rule_maps_each_kind_and_structural_codes() { + assert_eq!( + srp_rule(&srp( + SrpFindingKind::StructCohesion, + SrpFindingDetails::ParameterCount { + function_name: String::new(), + parameter_count: 0, + }, + )), + "SRP-001" + ); + assert_eq!( + srp_rule(&srp( + SrpFindingKind::ModuleLength, + SrpFindingDetails::ParameterCount { + function_name: String::new(), + parameter_count: 0, + }, + )), + "SRP-002" + ); + assert_eq!( + srp_rule(&srp( + SrpFindingKind::ParameterCount, + SrpFindingDetails::ParameterCount { + function_name: String::new(), + parameter_count: 0, + }, + )), + "SRP-003" + ); + // Structural → structural_rule(code): each code maps to itself. + for code in ["BTC", "SLM", "NMS", "OI", "SIT", "DEH", "IET"] { + let f = srp( + SrpFindingKind::Structural, + SrpFindingDetails::Structural { + item_name: "I".into(), + code: code.into(), + detail: "d".into(), + }, + ); + assert_eq!(srp_rule(&f), code, "structural code {code}"); + } +} + +#[test] +fn coupling_rule_maps_each_detail() { + let cpl = |details| CouplingFinding { + common: common(Dimension::Coupling), + kind: CouplingFindingKind::Structural, + details, + }; + assert_eq!( + coupling_rule(&cpl(CouplingFindingDetails::Cycle { modules: vec![] })), + "CP-001" + ); + assert_eq!( + coupling_rule(&cpl(CouplingFindingDetails::SdpViolation { + from_module: String::new(), + to_module: String::new(), + from_instability: 0.0, + to_instability: 0.0, + })), + "CP-002" + ); + assert_eq!( + coupling_rule(&cpl(CouplingFindingDetails::ThresholdExceeded { + module_name: String::new(), + afferent: 0, + efferent: 0, + instability: 0.0, + })), + "CP-003" + ); + assert_eq!( + coupling_rule(&cpl(CouplingFindingDetails::Structural { + item_name: String::new(), + code: "DEH".into(), + detail: String::new(), + })), + "DEH" + ); +} + +#[test] +fn tq_rule_maps_kinds_and_help_uri_only_on_iosp() { + assert_eq!(tq_rule(&TqFindingKind::NoAssertion), "TQ-001"); + // The `id == "iosp/violation"` guard adds a helpUri to exactly that rule. + let rules = sarif_rules(); + let with_help = |id: &str| { + rules + .iter() + .find(|r| r["id"] == id) + .map(|r| r.get("helpUri").is_some()) + .unwrap_or(false) + }; + assert!(with_help("iosp/violation"), "iosp rule carries helpUri"); + assert!(!with_help("CX-001"), "non-iosp rules have no helpUri"); +} diff --git a/src/adapters/report/sarif/tests/mod.rs b/src/adapters/report/sarif/tests/mod.rs index d75876c8..6655c27d 100644 --- a/src/adapters/report/sarif/tests/mod.rs +++ b/src/adapters/report/sarif/tests/mod.rs @@ -1,2 +1,3 @@ +mod mappers; mod root; mod rules; diff --git a/src/adapters/report/sarif/tests/rules.rs b/src/adapters/report/sarif/tests/rules.rs index b202c4c7..7209ec46 100644 --- a/src/adapters/report/sarif/tests/rules.rs +++ b/src/adapters/report/sarif/tests/rules.rs @@ -1,6 +1,7 @@ use crate::domain::findings::{ - ArchitectureFinding, CouplingFinding, CouplingFindingDetails, CouplingFindingKind, DryFinding, - DryFindingDetails, DryFindingKind, IospFinding, SrpFinding, SrpFindingDetails, SrpFindingKind, + ArchitectureFinding, ComplexityFinding, ComplexityFindingKind, CouplingFinding, + CouplingFindingDetails, CouplingFindingKind, DryFinding, DryFindingDetails, DryFindingKind, + IospFinding, SrpFinding, SrpFindingDetails, SrpFindingKind, TqFinding, TqFindingKind, }; use crate::domain::{AnalysisData, AnalysisFindings, Finding, Severity}; use crate::report::sarif::build_sarif_value; @@ -161,3 +162,124 @@ fn every_emitted_rule_id_is_registered_in_rules_table() { "IOSP findings must emit canonical rule_id `iosp/violation`" ); } + +fn cxf(kind: ComplexityFindingKind, suppressed: bool) -> ComplexityFinding { + let mut common = dim_finding(crate::findings::Dimension::Complexity, "cx"); + common.suppressed = suppressed; + ComplexityFinding { + common, + kind, + metric_value: 0, + threshold: 0, + hotspot: None, + } +} + +fn tqf(kind: TqFindingKind, suppressed: bool) -> TqFinding { + let mut common = dim_finding(crate::findings::Dimension::TestQuality, "tq"); + common.suppressed = suppressed; + TqFinding { + common, + kind, + function_name: "t".into(), + uncovered_lines: None, + } +} + +fn drf(kind: DryFindingKind, suppressed: bool) -> DryFinding { + let mut common = dim_finding(crate::findings::Dimension::Dry, "dry"); + common.suppressed = suppressed; + DryFinding { + common, + kind, + details: DryFindingDetails::DeadCode { + qualified_name: String::new(), + suggestion: None, + }, + } +} + +fn cpf(details: CouplingFindingDetails, suppressed: bool) -> CouplingFinding { + let mut common = dim_finding(crate::findings::Dimension::Coupling, "cp"); + common.suppressed = suppressed; + CouplingFinding { + common, + kind: CouplingFindingKind::Structural, + details, + } +} + +#[test] +fn sarif_results_exclude_suppressed_findings_and_emit_ratio() { + // Each dimension carries one unsuppressed + one suppressed finding with + // distinct rule ids. Only the unsuppressed ids reach the results array + // (pins the five `!suppressed` filters), and an exceeded suppression ratio + // emits the SUP-001 result (pins `suppression_ratio_result`). + let findings = AnalysisFindings { + complexity: vec![ + cxf(ComplexityFindingKind::Cognitive, false), + cxf(ComplexityFindingKind::Unsafe, true), + ], + dry: vec![ + drf(DryFindingKind::DuplicateExact, false), + drf(DryFindingKind::DeadCodeUncalled, true), + ], + srp: vec![ + srp_kind(SrpFindingKind::StructCohesion, false), + srp_kind(SrpFindingKind::ParameterCount, true), + ], + coupling: vec![ + cpf(CouplingFindingDetails::Cycle { modules: vec![] }, false), + cpf( + CouplingFindingDetails::ThresholdExceeded { + module_name: String::new(), + afferent: 0, + efferent: 0, + instability: 0.0, + }, + true, + ), + ], + test_quality: vec![ + tqf(TqFindingKind::NoAssertion, false), + tqf(TqFindingKind::Uncovered, true), + ], + ..Default::default() + }; + let mut analysis = make_analysis_for(findings); + analysis.summary.suppression_ratio_exceeded = true; + let value = build_sarif_value(&analysis); + let emitted: HashSet = value["runs"][0]["results"] + .as_array() + .expect("results") + .iter() + .filter_map(|r| r["ruleId"].as_str().map(str::to_string)) + .collect(); + for present in [ + "CX-001", "DRY-001", "SRP-001", "CP-001", "TQ-001", "SUP-001", + ] { + assert!( + emitted.contains(present), + "{present} must be emitted: {emitted:?}" + ); + } + for absent in ["CX-006", "DRY-002", "SRP-003", "CP-003"] { + assert!( + !emitted.contains(absent), + "suppressed {absent} must be excluded: {emitted:?}" + ); + } +} + +fn srp_kind(kind: SrpFindingKind, suppressed: bool) -> SrpFinding { + let mut common = dim_finding(crate::findings::Dimension::Srp, "srp"); + common.suppressed = suppressed; + SrpFinding { + common, + kind, + details: SrpFindingDetails::ParameterCount { + function_name: String::new(), + parameter_count: 0, + }, + } +} diff --git a/src/adapters/report/suggestions.rs b/src/adapters/report/suggestions.rs index a57d529a..16a14bf8 100644 --- a/src/adapters/report/suggestions.rs +++ b/src/adapters/report/suggestions.rs @@ -2,70 +2,94 @@ use colored::Colorize; use crate::adapters::analyzers::iosp::{Classification, FunctionAnalysis}; -/// Print refactoring suggestions for violation functions. -/// Integration: filters violations and delegates per-function suggestions. -pub fn print_suggestions(results: &[FunctionAnalysis]) { - let violations: Vec<_> = results - .iter() - .filter(|f| !f.suppressed && matches!(f.classification, Classification::Violation { .. })) - .collect(); +/// Logic kind constants for pattern matching without boolean chains. +const CONDITIONAL_KINDS: &[&str] = &["if", "match"]; +const LOOP_KINDS: &[&str] = &["for", "while", "loop"]; - if violations.is_empty() { - return; - } +/// A refactoring suggestion for one violation function: its name + line plus +/// the (headline, follow-up) message pairs that apply. +pub(crate) struct FunctionSuggestion { + pub qualified_name: String, + pub line: usize, + pub messages: Vec<(&'static str, &'static str)>, +} - println!("\n{}", "═══ Refactoring Suggestions ═══".bold()); - violations +/// Build the refactoring suggestions for every unsuppressed violation. Pure so +/// the violation filter and the per-function branch logic are observable in +/// tests rather than buried in stdout. +/// Operation: filter + per-function projection (own call hidden in closure). +pub(crate) fn collect_suggestions(results: &[FunctionAnalysis]) -> Vec { + let lines = |f: &FunctionAnalysis| suggestion_messages(f); + results .iter() - .for_each(|func| print_function_suggestion(func)); + .filter(|f| !f.suppressed && matches!(f.classification, Classification::Violation { .. })) + .map(|f| FunctionSuggestion { + qualified_name: f.qualified_name.clone(), + line: f.line, + messages: lines(f), + }) + .collect() } -/// Logic kind constants for pattern matching without boolean chains. -const CONDITIONAL_KINDS: &[&str] = &["if", "match"]; -const LOOP_KINDS: &[&str] = &["for", "while", "loop"]; - -/// Print a refactoring suggestion for a single violation function. -/// Operation: pattern matching logic, no own function calls. -fn print_function_suggestion(func: &FunctionAnalysis) { +/// The (headline, follow-up) suggestion messages that apply to a violation: +/// conditional+calls → extract condition, loop+calls → iterator chain, and +/// pure logic with neither → extract the logic. Pure. +/// Operation: pattern-matching logic, no own calls. +pub(crate) fn suggestion_messages(func: &FunctionAnalysis) -> Vec<(&'static str, &'static str)> { let Classification::Violation { logic_locations, call_locations, .. } = &func.classification else { - return; + return vec![]; }; - - println!("\n {} (line {})", func.qualified_name.bold(), func.line); - let has_conditional = logic_locations .iter() .any(|l| CONDITIONAL_KINDS.contains(&l.kind.as_str())); let has_loop = logic_locations .iter() .any(|l| LOOP_KINDS.contains(&l.kind.as_str())); - - if has_conditional && !call_locations.is_empty() { - println!( - " {} Extract the condition logic into a separate operation,", - "→".cyan() - ); - println!(" then call it from a pure integration function."); + let has_calls = !call_locations.is_empty(); + let mut out = Vec::new(); + if has_conditional && has_calls { + out.push(( + "Extract the condition logic into a separate operation,", + "then call it from a pure integration function.", + )); } - - if has_loop && !call_locations.is_empty() { - println!( - " {} Consider using an iterator chain instead of a loop with calls,", - "→".cyan() - ); - println!(" or extract the loop body into a separate operation."); + if has_loop && has_calls { + out.push(( + "Consider using an iterator chain instead of a loop with calls,", + "or extract the loop body into a separate operation.", + )); } - if !has_conditional && !has_loop { - println!( - " {} Extract the logic (arithmetic/comparisons) into a helper operation,", - "→".cyan() - ); - println!(" keeping this function as a pure integration."); + out.push(( + "Extract the logic (arithmetic/comparisons) into a helper operation,", + "keeping this function as a pure integration.", + )); } + out +} + +/// Print refactoring suggestions for violation functions. +/// Integration: collects suggestions, then prints each. +pub fn print_suggestions(results: &[FunctionAnalysis]) { + let suggestions = collect_suggestions(results); + suggestions + .first() + .into_iter() + .for_each(|_| println!("\n{}", "═══ Refactoring Suggestions ═══".bold())); + suggestions.iter().for_each(print_function_suggestion); +} + +/// Print one function's suggestion block. +/// Integration: prints header + each message line via closures. +fn print_function_suggestion(s: &FunctionSuggestion) { + println!("\n {} (line {})", s.qualified_name.bold(), s.line); + s.messages.iter().for_each(|(headline, follow_up)| { + println!(" {} {headline}", "→".cyan()); + println!(" {follow_up}"); + }); } diff --git a/src/adapters/report/tests/ai/details.rs b/src/adapters/report/tests/ai/details.rs new file mode 100644 index 00000000..c5177465 --- /dev/null +++ b/src/adapters/report/tests/ai/details.rs @@ -0,0 +1,152 @@ +//! AI detail-formatter edge cases: the partner-location filters in +//! `dry_category_detail` (self-link exclusion via `!(file == && line ==)`) and +//! the `independent_clusters > max` cluster clause in `srp_category_detail`. +use super::*; + +fn dry_detail(f: DryFinding) -> String { + let config = Config::default(); + let data = crate::domain::AnalysisData::default(); + let rows = make_reporter(&config, &data).build_dry(&[f]); + let entries: Vec = rows.into_iter().map(format_dry_entry).collect(); + entries[0]["detail"].as_str().unwrap().to_string() +} + +fn dry_common() -> Finding { + Finding { + file: "src/a.rs".into(), + line: 10, + column: 0, + dimension: crate::findings::Dimension::Dry, + rule_id: "r".into(), + message: "x".into(), + severity: crate::domain::Severity::Medium, + suppressed: false, + } +} + +fn participant(file: &str, line: usize) -> DuplicateParticipant { + DuplicateParticipant { + function_name: "p".into(), + file: file.into(), + line, + } +} + +fn frag_participant(file: &str, line: usize) -> crate::domain::findings::FragmentParticipant { + crate::domain::findings::FragmentParticipant { + function_name: "p".into(), + file: file.into(), + line, + end_line: line + 3, + } +} + +#[test] +fn duplicate_keeps_same_file_different_line_partner() { + // A partner in the SAME file but a different line is a real partner; the + // self-link (same file AND line) is excluded. Pins the `&&` (an `||` would + // drop the same-file partner too). + let detail = dry_detail(DryFinding { + common: dry_common(), + kind: DryFindingKind::DuplicateExact, + details: DryFindingDetails::Duplicate { + participants: vec![participant("src/a.rs", 10), participant("src/a.rs", 99)], + similarity: None, + }, + }); + assert!( + detail.contains("src/a.rs:99"), + "same-file partner kept: {detail}" + ); +} + +#[test] +fn fragment_excludes_self_and_keeps_other_partners() { + // Fragment partner filter: self (a.rs:10) excluded, same-file-other-line + // (a.rs:99) and other-file (b.rs:20) kept. Pins the `!`, the two `==`, and + // the `&&` of `!(p.file == f.file && p.line == f.line)`. + let detail = dry_detail(DryFinding { + common: dry_common(), + kind: DryFindingKind::Fragment, + details: DryFindingDetails::Fragment { + participants: vec![ + frag_participant("src/a.rs", 10), + frag_participant("src/a.rs", 99), + frag_participant("src/b.rs", 20), + ], + statement_count: 4, + }, + }); + assert!( + detail.contains("src/a.rs:99"), + "same-file partner kept: {detail}" + ); + assert!( + detail.contains("src/b.rs:20"), + "other-file partner kept: {detail}" + ); + assert!( + !detail.contains("src/a.rs:10"), + "self-link excluded: {detail}" + ); +} + +#[test] +fn srp_module_cluster_clause_pins_greater_than_max() { + let mut config = Config::default(); + config.srp.max_independent_clusters = 2; + let data = crate::domain::AnalysisData::default(); + let module = |clusters: usize| SrpFinding { + common: Finding { + file: "m.rs".into(), + line: 1, + column: 0, + dimension: crate::findings::Dimension::Srp, + rule_id: "srp/module".into(), + message: "x".into(), + severity: crate::domain::Severity::Medium, + suppressed: false, + }, + kind: SrpFindingKind::ModuleLength, + details: SrpFindingDetails::ModuleLength { + module: "m".into(), + production_lines: 900, + independent_clusters: clusters, + cluster_names: vec![], + length_score: 0.0, + }, + }; + let detail = |clusters| { + let rows = make_reporter(&config, &data).build_srp(&[module(clusters)]); + let entries: Vec = rows + .into_iter() + .map(|r| format_srp_entry(r, &config)) + .collect(); + entries[0]["detail"].as_str().unwrap().to_string() + }; + assert!( + detail(3).contains("independent clusters"), + "3 > 2 → clause shown" + ); + assert!( + !detail(2).contains("independent clusters"), + "2 not > 2 → clause hidden (pins `>` vs `>=`)" + ); +} + +#[test] +fn iosp_function_name_requires_exact_line_match() { + // A function record at lib.rs:40 must NOT resolve an IOSP finding at + // lib.rs:99 (same file, different line). Pins `fr.file == file && fr.line == + // line` against `&&`→`||`, which would mis-resolve on file alone. + let mut data = crate::domain::AnalysisData::default(); + data.functions.push(violation_record("src/lib.rs", 40)); + let f = iosp_finding("src/lib.rs", 99); + let config = Config::default(); + let rows = make_reporter(&config, &data).build_iosp(&[f]); + let entries: Vec = rows.into_iter().map(format_iosp_entry).collect(); + assert_ne!( + entries[0]["fn"], "MyType::bad_fn", + "line mismatch must not resolve the function name" + ); +} diff --git a/src/adapters/report/tests/ai/dimension_entries_a.rs b/src/adapters/report/tests/ai/dimension_entries_a.rs index 92f3e2a1..5b262acd 100644 --- a/src/adapters/report/tests/ai/dimension_entries_a.rs +++ b/src/adapters/report/tests/ai/dimension_entries_a.rs @@ -44,40 +44,9 @@ fn build_iosp_emits_violation_with_logic_and_call_lines() { #[test] fn build_iosp_resolves_function_name_via_data() { - use crate::domain::analysis_data::FunctionClassification; let mut data = crate::domain::AnalysisData::default(); - data.functions.push(FunctionRecord { - name: "bad_fn".into(), - file: "src/lib.rs".into(), - line: 40, - qualified_name: "MyType::bad_fn".into(), - parent_type: Some("MyType".into()), - classification: FunctionClassification::Violation, - severity: Some(crate::domain::Severity::Medium), - complexity: None, - parameter_count: 0, - own_calls: vec![], - is_trait_impl: false, - is_test: false, - effort_score: None, - suppressed: false, - complexity_suppressed: false, - }); - let f = IospFinding { - common: Finding { - file: "src/lib.rs".into(), - line: 40, - column: 0, - dimension: crate::findings::Dimension::Iosp, - rule_id: "iosp/violation".into(), - message: "x".into(), - severity: crate::domain::Severity::Medium, - suppressed: false, - }, - logic_locations: vec![], - call_locations: vec![], - effort_score: None, - }; + data.functions.push(violation_record("src/lib.rs", 40)); + let f = iosp_finding("src/lib.rs", 40); let config = Config::default(); let reporter = make_reporter(&config, &data); let rows = reporter.build_iosp(&[f]); diff --git a/src/adapters/report/tests/ai/mod.rs b/src/adapters/report/tests/ai/mod.rs index f89a0071..185396a9 100644 --- a/src/adapters/report/tests/ai/mod.rs +++ b/src/adapters/report/tests/ai/mod.rs @@ -26,6 +26,7 @@ pub(super) use crate::report::AnalysisResult; pub(super) use serde_json::Value; mod build_ai_value_shape; +mod details; mod dimension_entries_a; mod dimension_entries_b; mod smoke_and_orphan; @@ -79,3 +80,44 @@ pub(super) fn make_reporter<'a>( format: AiOutputFormat::Json, } } + +/// A Violation `FunctionRecord` for the IOSP function-name-resolution tests. +pub(super) fn violation_record(file: &str, line: usize) -> FunctionRecord { + use crate::domain::analysis_data::FunctionClassification; + FunctionRecord { + name: "bad_fn".into(), + file: file.into(), + line, + qualified_name: "MyType::bad_fn".into(), + parent_type: Some("MyType".into()), + classification: FunctionClassification::Violation, + severity: Some(crate::domain::Severity::Medium), + complexity: None, + parameter_count: 0, + own_calls: vec![], + is_trait_impl: false, + is_test: false, + effort_score: None, + suppressed: false, + complexity_suppressed: false, + } +} + +/// An IOSP violation `Finding` at `file:line` with no logic/call locations. +pub(super) fn iosp_finding(file: &str, line: usize) -> IospFinding { + IospFinding { + common: Finding { + file: file.into(), + line, + column: 0, + dimension: crate::findings::Dimension::Iosp, + rule_id: "iosp/violation".into(), + message: "x".into(), + severity: crate::domain::Severity::Medium, + suppressed: false, + }, + logic_locations: vec![], + call_locations: vec![], + effort_score: None, + } +} diff --git a/src/adapters/report/tests/baseline.rs b/src/adapters/report/tests/baseline.rs index 52efd94b..deba2ab8 100644 --- a/src/adapters/report/tests/baseline.rs +++ b/src/adapters/report/tests/baseline.rs @@ -206,3 +206,94 @@ fn test_baseline_v2_regression_by_quality_score() { let regressed = compare(&ab(Classification::Operation), &ab(violation("if", "x"))); assert!(regressed, "Quality score regression should be detected"); } + +#[test] +fn test_format_score_delta_direction_and_magnitude() { + use crate::report::baseline::format_score_delta; + // Rose: up-arrow + the exact delta magnitude. Pins `new - old` (a `+`/`/` + // would change the printed magnitude) and the `delta > 0.0` branch. + let up = format_score_delta("Quality", 80.0, 90.0); + assert!(up.contains('\u{2191}'), "score rise shows ↑: {up}"); + assert!(up.contains("10.0%"), "delta magnitude is 10.0%: {up}"); + // Fell: down-arrow + abs magnitude. Pins the `delta < 0.0` branch. + let down = format_score_delta("Quality", 90.0, 80.0); + assert!(down.contains('\u{2193}'), "score drop shows ↓: {down}"); + assert!(down.contains("10.0%"), "abs delta is 10.0%: {down}"); + // Equal: the unchanged branch (no arrow). + let same = format_score_delta("Quality", 50.0, 50.0); + assert!( + same.contains("unchanged"), + "equal scores are unchanged: {same}" + ); + assert!( + !same.contains('\u{2191}') && !same.contains('\u{2193}'), + "unchanged shows no arrow: {same}" + ); +} + +#[test] +fn test_comparison_lines_pins_deltas_and_regression() { + use crate::report::baseline::comparison_lines; + // v2 baseline: iosp 0.5, violations 2, total_findings 3, quality 0.8, 1 TQ. + let raw = serde_json::json!({ + "version": 2, + "iosp_score": 0.5, + "violations": 2, + "total_findings": 3, + "quality_score": 0.8, + "tq_no_assertion_warnings": 1 + }); + // Current: violations 5 (Δ+3), all 5 TQ kinds = 1 (Σ5, Δ+4), + // total_findings = 5 + 5 = 10 (Δ+7), iosp 0.6, quality 0.7 (regressed). + let summary = Summary { + violations: 5, + iosp_score: 0.6, + quality_score: 0.7, + tq_no_assertion_warnings: 1, + tq_no_sut_warnings: 1, + tq_untested_warnings: 1, + tq_uncovered_warnings: 1, + tq_untested_logic_warnings: 1, + ..Summary::default() + }; + let (lines, regressed) = comparison_lines(&raw, &summary); + let joined = lines.join("\n"); + assert!(joined.contains("(+3)"), "violation delta +3: {joined}"); + assert!(joined.contains("(+7)"), "finding delta +7: {joined}"); + assert!( + joined.contains("(+4)"), + "TQ delta +4 (Σ pins the 5-field sum): {joined}" + ); + assert!( + joined.contains("50.0%"), + "old IOSP 0.5 → 50.0% (pins *MULTIPLIER): {joined}" + ); + assert!(joined.contains("60.0%"), "new IOSP 0.6 → 60.0%: {joined}"); + assert!( + joined.contains("80.0%"), + "old quality 0.8 → 80.0%: {joined}" + ); + assert!( + joined.contains("70.0%"), + "new quality 0.7 → 70.0%: {joined}" + ); + assert!(regressed, "quality 0.7 < baseline 0.8 → regressed"); +} + +#[test] +fn test_comparison_lines_v1_skips_findings_line() { + use crate::report::baseline::comparison_lines; + // A v1 baseline (no version) has no Findings line and regresses on IOSP only. + let raw = serde_json::json!({"iosp_score": 0.9, "violations": 0}); + let summary = Summary { + iosp_score: 0.8, + ..Summary::default() + }; + let (lines, regressed) = comparison_lines(&raw, &summary); + let joined = lines.join("\n"); + assert!( + !joined.contains("Findings:"), + "v1 has no findings line: {joined}" + ); + assert!(regressed, "v1 IOSP 0.8 < 0.9 → regressed"); +} diff --git a/src/adapters/report/tests/dot.rs b/src/adapters/report/tests/dot.rs index de2e53e2..7a0e17ce 100644 --- a/src/adapters/report/tests/dot.rs +++ b/src/adapters/report/tests/dot.rs @@ -161,3 +161,20 @@ fn dot_reporter_intentionally_omits_orphan_rendering() { "dot reporter must NOT render orphan reason text, got:\n{out}" ); } + +#[test] +fn dot_nodes_use_classification_specific_fill_colors() { + // Each classification maps to its own fill/font color pair; pins + // `classification_colours` against a constant/blank tuple. + let data = data_with(vec![ + make_record("i_fn", FunctionClassification::Integration), + make_record("o_fn", FunctionClassification::Operation), + make_record("t_fn", FunctionClassification::Trivial), + make_record("v_fn", FunctionClassification::Violation), + ]); + let out = DotReporter.render(&AnalysisFindings::default(), &data); + assert!(out.contains("#c8e6c9"), "integration fill: {out}"); + assert!(out.contains("#bbdefb"), "operation fill: {out}"); + assert!(out.contains("#f5f5f5"), "trivial fill: {out}"); + assert!(out.contains("#ffcdd2"), "violation fill: {out}"); +} diff --git a/src/adapters/report/tests/findings_list_categories.rs b/src/adapters/report/tests/findings_list_categories.rs new file mode 100644 index 00000000..0b3a9f40 --- /dev/null +++ b/src/adapters/report/tests/findings_list_categories.rs @@ -0,0 +1,323 @@ +//! Per-kind (category, detail) mapping tests for the findings-list reporter, +//! exercised through the public `collect_all_findings`. Each finding kind must +//! produce its exact category + detail string — pinning the match arms and +//! `-> ""`/"xyzzy" body replacements in `categories.rs`. +use crate::domain::findings::{ + ComplexityFinding, ComplexityFindingKind, DryFinding, DryFindingDetails, DryFindingKind, + SrpFinding, SrpFindingDetails, SrpFindingKind, +}; +use crate::domain::{AnalysisData, AnalysisFindings, Dimension, Finding, Severity}; +use crate::report::findings_list::{collect_all_findings, FindingEntry}; +use crate::report::{AnalysisResult, Summary}; + +fn common(dim: Dimension) -> Finding { + Finding { + file: "lib.rs".into(), + line: 3, + column: 0, + dimension: dim, + rule_id: "r".into(), + message: "the magic number here".into(), + severity: Severity::Medium, + suppressed: false, + } +} + +fn collect(findings: AnalysisFindings) -> Vec { + collect_all_findings(&AnalysisResult { + results: vec![], + summary: Summary::default(), + findings, + data: AnalysisData::default(), + }) +} + +fn one_dry(kind: DryFindingKind, details: DryFindingDetails) -> FindingEntry { + let f = DryFinding { + common: common(Dimension::Dry), + kind, + details, + }; + collect(AnalysisFindings { + dry: vec![f], + ..Default::default() + }) + .into_iter() + .next() + .expect("one dry entry") +} + +fn one_srp(kind: SrpFindingKind, details: SrpFindingDetails) -> FindingEntry { + let f = SrpFinding { + common: common(Dimension::Srp), + kind, + details, + }; + collect(AnalysisFindings { + srp: vec![f], + ..Default::default() + }) + .into_iter() + .next() + .expect("one srp entry") +} + +fn one_complexity(kind: ComplexityFindingKind, metric_value: usize) -> FindingEntry { + let f = ComplexityFinding { + common: common(Dimension::Complexity), + kind, + metric_value, + threshold: 0, + hotspot: None, + }; + collect(AnalysisFindings { + complexity: vec![f], + ..Default::default() + }) + .into_iter() + .next() + .expect("one complexity entry") +} + +type DryCase = ( + DryFindingKind, + DryFindingDetails, + &'static str, + &'static str, +); + +fn dry_cases() -> Vec { + vec![ + ( + DryFindingKind::DuplicateSimilar, + DryFindingDetails::Duplicate { + participants: vec![], + similarity: Some(0.9), + }, + "DUPLICATE", + "similar", + ), + ( + DryFindingKind::Fragment, + DryFindingDetails::Fragment { + participants: vec![], + statement_count: 3, + }, + "FRAGMENT", + "3 stmts", + ), + ( + DryFindingKind::DeadCodeUncalled, + DryFindingDetails::DeadCode { + qualified_name: "ghost".into(), + suggestion: None, + }, + "DEAD_CODE", + "ghost", + ), + ( + DryFindingKind::DeadCodeTestOnly, + DryFindingDetails::DeadCode { + qualified_name: "ghost".into(), + suggestion: None, + }, + "DEAD_CODE", + "testonly ghost", + ), + ( + DryFindingKind::Wildcard, + DryFindingDetails::Wildcard { + module_path: "m::*".into(), + }, + "WILDCARD", + "m::*", + ), + ( + DryFindingKind::Boilerplate, + DryFindingDetails::Boilerplate { + pattern_id: "BP-007".into(), + struct_name: None, + suggestion: "x".into(), + }, + "BOILERPLATE", + "BP-007", + ), + ( + DryFindingKind::RepeatedMatch, + DryFindingDetails::RepeatedMatch { + enum_name: "Color".into(), + participants: vec![], + }, + "REPEATED_MATCH", + "Color", + ), + ] +} + +#[test] +fn dry_category_and_detail_per_kind() { + for (kind, details, cat, detail) in dry_cases() { + let e = one_dry(kind, details); + assert_eq!(e.category, cat, "{kind:?} category"); + assert_eq!(e.detail, detail, "{kind:?} detail"); + } +} + +#[test] +fn srp_category_and_detail_per_kind() { + let struct_e = one_srp( + SrpFindingKind::StructCohesion, + SrpFindingDetails::StructCohesion { + struct_name: "Big".into(), + lcom4: 4, + field_count: 9, + method_count: 7, + fan_out: 2, + composite_score: 0.0, + clusters: vec![], + }, + ); + assert_eq!( + (struct_e.category, struct_e.detail.as_str()), + ("SRP_STRUCT", "Big: LCOM4=4") + ); + let module_e = one_srp( + SrpFindingKind::ModuleLength, + SrpFindingDetails::ModuleLength { + module: "m".into(), + production_lines: 900, + independent_clusters: 0, + cluster_names: vec![], + length_score: 0.0, + }, + ); + assert_eq!( + (module_e.category, module_e.detail.as_str()), + ("SRP_MODULE", "900 lines") + ); + let param_e = one_srp( + SrpFindingKind::ParameterCount, + SrpFindingDetails::ParameterCount { + function_name: "f".into(), + parameter_count: 7, + }, + ); + assert_eq!( + (param_e.category, param_e.detail.as_str()), + ("SRP_PARAMS", "7 params") + ); + let struct_code = one_srp( + SrpFindingKind::Structural, + SrpFindingDetails::Structural { + item_name: "I".into(), + code: "SLM".into(), + detail: "d".into(), + }, + ); + assert_eq!( + (struct_code.category, struct_code.detail.as_str()), + ("SRP_STRUCTURAL", "SLM") + ); +} + +#[test] +fn complexity_detail_per_kind() { + use ComplexityFindingKind::*; + assert_eq!(one_complexity(Cognitive, 10).detail, "complexity 10"); + assert_eq!(one_complexity(NestingDepth, 5).detail, "depth 5"); + assert_eq!(one_complexity(FunctionLength, 80).detail, "80 lines"); + assert_eq!(one_complexity(Unsafe, 2).detail, "2 blocks"); + assert_eq!(one_complexity(ErrorHandling, 0).detail, "unwrap/panic/todo"); +} + +#[test] +fn srp_build_drops_suppressed() { + // A suppressed SRP finding produces no entry — pins build_srp's `!suppressed` + // filter and its `-> vec![]` replacement (the unsuppressed one still emits). + let mut suppressed = SrpFinding { + common: common(Dimension::Srp), + kind: SrpFindingKind::ParameterCount, + details: SrpFindingDetails::ParameterCount { + function_name: "f".into(), + parameter_count: 7, + }, + }; + suppressed.common.suppressed = true; + let entries = collect(AnalysisFindings { + srp: vec![suppressed], + ..Default::default() + }); + assert!( + !entries.iter().any(|e| e.category.starts_with("SRP")), + "suppressed SRP finding excluded: {entries:?}" + ); +} + +fn frec( + file: &str, + line: usize, + qualified_name: &str, +) -> crate::domain::analysis_data::FunctionRecord { + crate::domain::analysis_data::FunctionRecord { + name: qualified_name.into(), + file: file.into(), + line, + qualified_name: qualified_name.into(), + parent_type: None, + classification: crate::domain::analysis_data::FunctionClassification::Operation, + severity: None, + complexity: None, + parameter_count: 0, + own_calls: vec![], + is_trait_impl: false, + is_test: false, + effort_score: None, + suppressed: false, + complexity_suppressed: false, + } +} + +fn cog_entry_with_functions( + functions: Vec, +) -> FindingEntry { + let f = ComplexityFinding { + common: common(Dimension::Complexity), + kind: ComplexityFindingKind::Cognitive, + metric_value: 10, + threshold: 0, + hotspot: None, + }; + collect_all_findings(&AnalysisResult { + results: vec![], + summary: Summary::default(), + findings: AnalysisFindings { + complexity: vec![f], + ..Default::default() + }, + data: AnalysisData { + functions, + ..Default::default() + }, + }) + .into_iter() + .next() + .expect("one entry") +} + +#[test] +fn function_name_at_requires_exact_file_and_line_match() { + // The finding sits at lib.rs:3. An exact-match record supplies its name; + // records that differ in file OR line must not match (pins the + // `fr.file == file && fr.line == line` lookup against `&&`→`||` / `==`→`!=`). + let exact = cog_entry_with_functions(vec![frec("lib.rs", 3, "right_fn")]); + assert_eq!(exact.function_name, "right_fn", "exact match supplies name"); + + let mismatched = cog_entry_with_functions(vec![ + frec("lib.rs", 99, "wrong_line"), + frec("other.rs", 3, "wrong_file"), + ]); + assert_eq!( + mismatched.function_name, "", + "no record matches both file and line → empty name" + ); +} diff --git a/src/adapters/report/tests/github/messages.rs b/src/adapters/report/tests/github/messages.rs new file mode 100644 index 00000000..9f27d3ef --- /dev/null +++ b/src/adapters/report/tests/github/messages.rs @@ -0,0 +1,214 @@ +//! Per-dimension GitHub annotation *message* tests — the detail-match arms in +//! `format_{dry,srp,coupling}_message`, `complexity_level`, and the `located` +//! no-location branch that the smoke tests don't reach. +use super::*; +use crate::domain::findings::{ + ComplexityFinding, ComplexityFindingKind, CouplingFinding, CouplingFindingDetails, + CouplingFindingKind, DryFinding, DryFindingDetails, DryFindingKind, DuplicateParticipant, + FragmentParticipant, SrpFinding, SrpFindingDetails, SrpFindingKind, TqFinding, TqFindingKind, +}; +use crate::domain::{Dimension, Severity}; + +fn common(dim: Dimension, file: &str, suppressed: bool) -> Finding { + Finding { + file: file.into(), + line: 5, + column: 0, + dimension: dim, + rule_id: "r".into(), + message: "fallback".into(), + severity: Severity::Medium, + suppressed, + } +} + +fn dry(kind: DryFindingKind, details: DryFindingDetails) -> DryFinding { + DryFinding { + common: common(Dimension::Dry, "d.rs", false), + kind, + details, + } +} + +#[test] +fn dry_messages_per_kind_and_suppressed_dropped() { + let dup = dry( + DryFindingKind::DuplicateExact, + DryFindingDetails::Duplicate { + participants: vec![DuplicateParticipant { + function_name: "dupfn".into(), + file: "d.rs".into(), + line: 1, + }], + similarity: None, + }, + ); + let frag = dry( + DryFindingKind::Fragment, + DryFindingDetails::Fragment { + participants: vec![FragmentParticipant { + function_name: "fragfn".into(), + file: "f.rs".into(), + line: 2, + end_line: 6, + }], + statement_count: 4, + }, + ); + let mut suppressed = dup.clone(); + suppressed.common.suppressed = true; + let out = render_dry_chunk(&[dup, frag, suppressed]); + assert!(out.contains("Duplicate functions: dupfn"), "{out}"); + assert!( + out.contains("Duplicate fragment (4 stmts): fragfn"), + "{out}" + ); + // Only two rows rendered (suppressed dropped): two annotation lines. + assert_eq!(out.lines().count(), 2, "suppressed dropped: {out}"); +} + +fn srp(kind: SrpFindingKind, details: SrpFindingDetails) -> SrpFinding { + SrpFinding { + common: common(Dimension::Srp, "s.rs", false), + kind, + details, + } +} + +#[test] +fn srp_messages_per_kind() { + let out = render_srp_chunk(&[ + srp( + SrpFindingKind::StructCohesion, + SrpFindingDetails::StructCohesion { + struct_name: "Big".into(), + lcom4: 4, + field_count: 9, + method_count: 7, + fan_out: 2, + composite_score: 0.0, + clusters: vec![], + }, + ), + srp( + SrpFindingKind::ModuleLength, + SrpFindingDetails::ModuleLength { + module: "big_mod".into(), + production_lines: 900, + independent_clusters: 3, + cluster_names: vec![], + length_score: 0.0, + }, + ), + srp( + SrpFindingKind::ParameterCount, + SrpFindingDetails::ParameterCount { + function_name: "f".into(), + parameter_count: 7, + }, + ), + ]); + assert!( + out.contains("SRP cohesion: Big has LCOM4=4, methods=7"), + "{out}" + ); + assert!( + out.contains("SRP module length: big_mod has 900 lines"), + "module length message: {out}" + ); + assert!(out.contains("'f' has 7 parameters"), "{out}"); +} + +fn cpl(details: CouplingFindingDetails, file: &str) -> CouplingFinding { + CouplingFinding { + common: common(Dimension::Coupling, file, false), + kind: CouplingFindingKind::Structural, + details, + } +} + +#[test] +fn coupling_messages_and_cycle_has_no_file_location() { + // A cycle finding carries an empty file → `located` emits the no-location + // form `::level::msg` (pins `file.is_empty() || line == 0`). + let out = render_coupling_chunk(&[ + cpl( + CouplingFindingDetails::Cycle { + modules: vec!["a".into(), "b".into()], + }, + "", + ), + cpl( + CouplingFindingDetails::SdpViolation { + from_module: "x".into(), + to_module: "y".into(), + from_instability: 0.2, + to_instability: 0.8, + }, + "c.rs", + ), + cpl( + CouplingFindingDetails::ThresholdExceeded { + module_name: "hot_mod".into(), + afferent: 1, + efferent: 9, + instability: 0.9, + }, + "t.rs", + ), + ]); + assert!(out.contains("Coupling cycle: a → b"), "{out}"); + assert!( + out.contains("::warning::Coupling cycle"), + "no-location form: {out}" + ); + assert!(out.contains("SDP violation: x"), "{out}"); + assert!(out.contains("file=c.rs"), "located form for SDP: {out}"); + assert!( + out.contains("Coupling threshold exceeded: hot_mod"), + "threshold message: {out}" + ); +} + +#[test] +fn complexity_level_maps_kind_to_annotation_level() { + // Threshold breaches → ::notice, smells → ::warning (pins complexity_level). + let cx = |kind| ComplexityFinding { + common: common(Dimension::Complexity, "c.rs", false), + kind, + metric_value: 10, + threshold: 5, + hotspot: None, + }; + let cog = cx(ComplexityFindingKind::Cognitive); + let magic = cx(ComplexityFindingKind::MagicNumber); + assert!( + render_complexity_chunk(&[cog]).contains("::notice"), + "cognitive → notice" + ); + assert!( + render_complexity_chunk(&[magic]).contains("::warning"), + "magic → warning" + ); +} + +#[test] +fn tq_view_drops_suppressed_rows() { + let live = TqFinding { + common: common(Dimension::TestQuality, "live.rs", false), + kind: TqFindingKind::NoAssertion, + function_name: "t".into(), + uncovered_lines: None, + }; + let mut suppressed = live.clone(); + suppressed.common.file = "supp.rs".into(); + suppressed.common.suppressed = true; + let out = render_tq_chunk(&[live, suppressed]); + // The live row is emitted, the suppressed one dropped — distinct files so a + // deleted `!suppressed` (which would keep the suppressed one) is caught. + assert!(out.contains("file=live.rs"), "live row emitted: {out}"); + assert!( + !out.contains("file=supp.rs"), + "suppressed row dropped: {out}" + ); +} diff --git a/src/adapters/report/tests/github/mod.rs b/src/adapters/report/tests/github/mod.rs index 61148fe8..7832ac8c 100644 --- a/src/adapters/report/tests/github/mod.rs +++ b/src/adapters/report/tests/github/mod.rs @@ -19,6 +19,7 @@ pub(super) use crate::report::github::*; pub(super) use crate::report::{AnalysisResult, Summary}; mod annotations; +mod messages; mod rendering; // Wrappers that preserve the test API: take a finding slice, return diff --git a/src/adapters/report/tests/json/functions.rs b/src/adapters/report/tests/json/functions.rs new file mode 100644 index 00000000..60b70192 --- /dev/null +++ b/src/adapters/report/tests/json/functions.rs @@ -0,0 +1,83 @@ +//! JSON per-function violation-location tests. `violation_locations` attaches +//! an IOSP finding's logic/call locations to a function record only when both +//! file AND line match — pins the `file == … && line == …` lookup. +use super::*; +use crate::domain::analysis_data::{FunctionClassification, FunctionRecord}; +use crate::domain::findings::{IospFinding, LogicLocation}; +use crate::domain::{AnalysisData, AnalysisFindings, Dimension, Finding, Severity}; +use crate::report::{AnalysisResult, Summary}; + +fn finding_at(file: &str, line: usize) -> Finding { + Finding { + file: file.into(), + line, + column: 0, + dimension: Dimension::Iosp, + rule_id: "iosp/violation".into(), + message: "m".into(), + severity: Severity::High, + suppressed: false, + } +} + +fn violation_record(file: &str, line: usize, name: &str) -> FunctionRecord { + FunctionRecord { + name: name.into(), + file: file.into(), + line, + qualified_name: name.into(), + parent_type: None, + classification: FunctionClassification::Violation, + severity: Some(Severity::High), + complexity: None, + parameter_count: 0, + own_calls: vec![], + is_trait_impl: false, + is_test: false, + effort_score: None, + suppressed: false, + complexity_suppressed: false, + } +} + +fn function_entry(func_line: usize, iosp_line: usize) -> serde_json::Value { + let iosp = IospFinding { + common: finding_at("test.rs", iosp_line), + logic_locations: vec![LogicLocation { + kind: "if".into(), + line: 1, + }], + call_locations: vec![], + effort_score: None, + }; + let analysis = AnalysisResult { + results: vec![], + summary: Summary::default(), + findings: AnalysisFindings { + iosp: vec![iosp], + ..Default::default() + }, + data: AnalysisData { + functions: vec![violation_record("test.rs", func_line, "viol")], + ..Default::default() + }, + }; + function_named(&json_value(&analysis), "viol").clone() +} + +#[test] +fn violation_locations_attach_only_on_exact_line_match() { + // Same file + same line → the IOSP finding's logic location is attached. + let matched = function_entry(5, 5); + assert_eq!( + matched["logic"].as_array().map(Vec::len), + Some(1), + "matching file+line attaches logic: {matched}" + ); + // Same file but a different line → no attachment (pins the `&&`). + let mismatched = function_entry(5, 99); + assert!( + mismatched["logic"].as_array().is_none_or(|a| a.is_empty()), + "line mismatch → no logic locations: {mismatched}" + ); +} diff --git a/src/adapters/report/tests/json/mod.rs b/src/adapters/report/tests/json/mod.rs index b8c45095..82d58fe2 100644 --- a/src/adapters/report/tests/json/mod.rs +++ b/src/adapters/report/tests/json/mod.rs @@ -9,6 +9,8 @@ pub(super) use crate::adapters::report::test_support::{make_analysis, make_resul pub(super) use crate::report::json::*; pub(super) use crate::report::AnalysisResult; +mod functions; +mod sections; mod srp_complexity_severity; mod summary_fields_and_orphan; mod violations_and_dups; diff --git a/src/adapters/report/tests/json/sections.rs b/src/adapters/report/tests/json/sections.rs new file mode 100644 index 00000000..88acc6c8 --- /dev/null +++ b/src/adapters/report/tests/json/sections.rs @@ -0,0 +1,290 @@ +//! JSON-envelope section tests: every per-category `build_*` and its +//! `JsonChunk` field must reach the serialized output, and the `compose` +//! coupling/srp `None`-when-empty guards must keep a populated section. +use super::*; +use crate::domain::analysis_data::ModuleCouplingRecord; +use crate::domain::findings::{ + ArchitectureFinding, CouplingFinding, CouplingFindingDetails, CouplingFindingKind, DryFinding, + DryFindingDetails, DryFindingKind, DuplicateParticipant, FragmentParticipant, SrpFinding, + SrpFindingDetails, SrpFindingKind, TqFinding, TqFindingKind, +}; +use crate::domain::{AnalysisData, AnalysisFindings, Dimension, Finding, Severity}; +use crate::report::{AnalysisResult, Summary}; + +fn common(dim: Dimension) -> Finding { + Finding { + file: "lib.rs".into(), + line: 3, + column: 0, + dimension: dim, + rule_id: "r".into(), + message: "m".into(), + severity: Severity::Medium, + suppressed: false, + } +} + +fn dry(kind: DryFindingKind, details: DryFindingDetails) -> DryFinding { + DryFinding { + common: common(Dimension::Dry), + kind, + details, + } +} + +fn srp(kind: SrpFindingKind, details: SrpFindingDetails) -> SrpFinding { + SrpFinding { + common: common(Dimension::Srp), + kind, + details, + } +} + +fn cpl(details: CouplingFindingDetails) -> CouplingFinding { + CouplingFinding { + common: common(Dimension::Coupling), + kind: CouplingFindingKind::Structural, + details, + } +} + +fn analysis_with(findings: AnalysisFindings, data: AnalysisData) -> AnalysisResult { + AnalysisResult { + results: vec![], + summary: Summary::default(), + findings, + data, + } +} + +fn all_dry() -> Vec { + vec![ + dry( + DryFindingKind::DuplicateExact, + DryFindingDetails::Duplicate { + participants: vec![DuplicateParticipant { + function_name: "d".into(), + file: "lib.rs".into(), + line: 1, + }], + similarity: None, + }, + ), + dry( + DryFindingKind::DeadCodeUncalled, + DryFindingDetails::DeadCode { + qualified_name: "dead".into(), + suggestion: None, + }, + ), + dry( + DryFindingKind::Wildcard, + DryFindingDetails::Wildcard { + module_path: "m::*".into(), + }, + ), + dry( + DryFindingKind::Boilerplate, + DryFindingDetails::Boilerplate { + pattern_id: "BP-001".into(), + struct_name: None, + suggestion: "s".into(), + }, + ), + dry( + DryFindingKind::Fragment, + DryFindingDetails::Fragment { + participants: vec![FragmentParticipant { + function_name: "frag".into(), + file: "lib.rs".into(), + line: 2, + end_line: 6, + }], + statement_count: 4, + }, + ), + ] +} + +fn structural_srp() -> SrpFinding { + srp( + SrpFindingKind::Structural, + SrpFindingDetails::Structural { + item_name: "Foo".into(), + code: "SLM".into(), + detail: "d".into(), + }, + ) +} + +fn rich_findings() -> AnalysisFindings { + AnalysisFindings { + dry: all_dry(), + srp: vec![ + srp( + SrpFindingKind::ParameterCount, + SrpFindingDetails::ParameterCount { + function_name: "f".into(), + parameter_count: 7, + }, + ), + structural_srp(), + ], + coupling: vec![ + cpl(CouplingFindingDetails::Cycle { + modules: vec!["a".into(), "b".into()], + }), + cpl(CouplingFindingDetails::SdpViolation { + from_module: "x".into(), + to_module: "y".into(), + from_instability: 0.2, + to_instability: 0.8, + }), + cpl(CouplingFindingDetails::Structural { + item_name: "Baz".into(), + code: "DEH".into(), + detail: "downcast".into(), + }), + ], + test_quality: vec![TqFinding { + common: common(Dimension::TestQuality), + kind: TqFindingKind::NoAssertion, + function_name: "t".into(), + uncovered_lines: None, + }], + architecture: vec![ArchitectureFinding { + common: common(Dimension::Architecture), + }], + ..Default::default() + } +} + +fn one_module() -> AnalysisData { + AnalysisData { + modules: vec![ModuleCouplingRecord { + module_name: "modA".into(), + afferent: 1, + efferent: 9, + instability: 0.9, + incoming: vec![], + outgoing: vec![], + suppressed: false, + warning: true, + }], + ..Default::default() + } +} + +fn nonempty(v: &serde_json::Value, key: &str) -> bool { + !v[key].as_array().unwrap_or(&vec![]).is_empty() +} + +#[test] +fn json_envelope_contains_every_populated_section() { + let v = json_value(&analysis_with(rich_findings(), one_module())); + for key in [ + "dead_code", + "wildcard_warnings", + "boilerplate", + "duplicates", + "fragments", + "tq_warnings", + "structural_warnings", + "architecture_findings", + ] { + assert!(nonempty(&v, key), "section {key} missing: {v}"); + } + assert!(nonempty(&v["srp"], "param_warnings"), "srp param: {v}"); + // Both the SRP-side (build_srp) and Coupling-side structural rows reach the + // envelope — pins each chunk's `structural` field against deletion. + let structural = v["structural_warnings"].to_string(); + assert!( + structural.contains("SLM"), + "srp structural (build_srp field): {v}" + ); + assert!(structural.contains("DEH"), "coupling structural: {v}"); + let coupling = &v["coupling"]; + for key in ["modules", "cycles", "sdp_violations"] { + assert!(nonempty(coupling, key), "coupling.{key} missing: {v}"); + } + // The cycle carries its real module names — pins build_cycles against + // `vec![vec![]]`/`vec![vec!["xyzzy"]]` body replacements. + assert_eq!( + coupling["cycles"][0][0], "a", + "cycle modules preserved: {v}" + ); + assert_eq!(coupling["cycles"][0][1], "b", "{v}"); +} + +#[test] +fn coupling_section_present_with_only_a_cycle() { + // `compose` keeps the coupling section when ANY of modules/cycles is + // populated. A cycle-only analysis (no modules) pins the + // `modules.is_empty() && cycles.is_empty()` guard against `||`. + let findings = AnalysisFindings { + coupling: vec![cpl(CouplingFindingDetails::Cycle { + modules: vec!["a".into()], + })], + ..Default::default() + }; + let v = json_value(&analysis_with(findings, AnalysisData::default())); + assert!( + !v["coupling"].is_null(), + "cycle-only keeps coupling section: {v}" + ); +} + +#[test] +fn srp_section_present_with_only_a_struct_warning() { + // Same for SRP: a struct-only analysis keeps the section (pins the + // `srp_struct.is_empty() && srp_module.is_empty() && srp_param.is_empty()` + // guard against `||`). + let findings = AnalysisFindings { + srp: vec![srp( + SrpFindingKind::StructCohesion, + SrpFindingDetails::StructCohesion { + struct_name: "Big".into(), + lcom4: 4, + field_count: 9, + method_count: 7, + fan_out: 2, + composite_score: 0.0, + clusters: vec![], + }, + )], + ..Default::default() + }; + let v = json_value(&analysis_with(findings, AnalysisData::default())); + assert!(!v["srp"].is_null(), "struct-only keeps srp section: {v}"); +} + +#[test] +fn suppressed_findings_excluded_from_json() { + // Marking every finding suppressed empties the suppressible arrays — pins the + // `!suppressed` filters in build_dead_code/fragments/wildcards/boilerplate/ + // sdp_violations/structural. + let mut f = rich_findings(); + f.dry.iter_mut().for_each(|d| d.common.suppressed = true); + f.coupling + .iter_mut() + .for_each(|c| c.common.suppressed = true); + f.srp.iter_mut().for_each(|s| s.common.suppressed = true); + // A module keeps the coupling section present so sdp_violations is an + // (empty) array rather than the section collapsing to null. + let v = json_value(&analysis_with(f, one_module())); + for key in ["dead_code", "fragments", "wildcard_warnings", "boilerplate"] { + assert!( + !nonempty(&v, key), + "{key} must be empty when suppressed: {v}" + ); + } + assert!( + !nonempty(&v, "structural_warnings"), + "structural suppressed: {v}" + ); + let sdp = &v["coupling"]["sdp_violations"]; + assert!( + sdp.is_null() || sdp.as_array().unwrap().is_empty(), + "sdp suppressed: {v}" + ); +} diff --git a/src/adapters/report/tests/mod.rs b/src/adapters/report/tests/mod.rs index 70a2b47d..0a406b74 100644 --- a/src/adapters/report/tests/mod.rs +++ b/src/adapters/report/tests/mod.rs @@ -2,8 +2,10 @@ mod ai; mod baseline; mod dot; mod findings_list; +mod findings_list_categories; mod github; mod json; mod projections_dry; +mod projections_extra; mod root; mod suggestions; diff --git a/src/adapters/report/tests/projections_dry.rs b/src/adapters/report/tests/projections_dry.rs index c073ad79..48aee21c 100644 --- a/src/adapters/report/tests/projections_dry.rs +++ b/src/adapters/report/tests/projections_dry.rs @@ -94,3 +94,94 @@ fn split_dry_findings_collapses_duplicate_repeated_match_group_emissions() { buckets.repeated_match_groups.len(), ); } + +fn dead_code_finding(name: &str, suppressed: bool) -> DryFinding { + let mut common = dry_common(1); + common.suppressed = suppressed; + DryFinding { + common, + kind: DryFindingKind::DeadCodeUncalled, + details: DryFindingDetails::DeadCode { + qualified_name: name.into(), + suggestion: Some("remove".into()), + }, + } +} + +#[test] +fn dead_code_boilerplate_wildcard_buckets_built_and_drop_suppressed() { + let findings = vec![ + dead_code_finding("dead_fn", false), + dead_code_finding("suppressed_dead", true), + DryFinding { + common: dry_common(2), + kind: DryFindingKind::Boilerplate, + details: DryFindingDetails::Boilerplate { + pattern_id: "BP-001".into(), + struct_name: Some("Foo".into()), + suggestion: "derive".into(), + }, + }, + DryFinding { + common: dry_common(3), + kind: DryFindingKind::Wildcard, + details: DryFindingDetails::Wildcard { + module_path: "foo::*".into(), + }, + }, + ]; + let b = split_dry_findings(&findings); + assert_eq!( + b.dead_code.len(), + 1, + "suppressed dead-code dropped (`!suppressed`)" + ); + assert_eq!(b.dead_code[0].qualified_name, "dead_fn"); + assert_eq!(b.boilerplate.len(), 1); + assert_eq!(b.boilerplate[0].pattern_id, "BP-001"); + assert_eq!(b.wildcards.len(), 1); + assert_eq!(b.wildcards[0].module_path, "foo::*"); +} + +#[test] +fn duplicate_and_fragment_groups_carry_participants() { + use crate::domain::findings::{DuplicateParticipant, FragmentParticipant}; + let findings = vec![ + DryFinding { + common: dry_common(1), + kind: DryFindingKind::DuplicateExact, + details: DryFindingDetails::Duplicate { + participants: vec![DuplicateParticipant { + function_name: "dup_a".into(), + file: "lib.rs".into(), + line: 5, + }], + similarity: None, + }, + }, + DryFinding { + common: dry_common(2), + kind: DryFindingKind::Fragment, + details: DryFindingDetails::Fragment { + participants: vec![FragmentParticipant { + function_name: "frag_a".into(), + file: "lib.rs".into(), + line: 10, + end_line: 14, + }], + statement_count: 4, + }, + }, + ]; + let b = split_dry_findings(&findings); + assert_eq!(b.duplicate_groups.len(), 1); + assert!(b.duplicate_groups[0] + .participants + .iter() + .any(|p| p.function_name == "dup_a")); + assert_eq!(b.fragment_groups.len(), 1); + assert!(b.fragment_groups[0] + .participants + .iter() + .any(|p| p.function_name == "frag_a")); +} diff --git a/src/adapters/report/tests/projections_extra.rs b/src/adapters/report/tests/projections_extra.rs new file mode 100644 index 00000000..7711b608 --- /dev/null +++ b/src/adapters/report/tests/projections_extra.rs @@ -0,0 +1,185 @@ +//! Tests for the shared Coupling / SRP / TQ projections (`split_*_findings`, +//! `project_tq_rows`). Each pins the per-kind match arms, the `!suppressed` +//! filters, and the detail builders against no-op / arm-deletion mutations. +use crate::adapters::report::projections::coupling::split_coupling_findings; +use crate::adapters::report::projections::srp::split_srp_findings; +use crate::adapters::report::projections::tq::project_tq_rows; +use crate::domain::findings::{ + CouplingFinding, CouplingFindingDetails, CouplingFindingKind, SrpFinding, SrpFindingDetails, + SrpFindingKind, TqFinding, TqFindingKind, +}; +use crate::domain::{Dimension, Finding, Severity}; + +fn common(dim: Dimension, line: usize, suppressed: bool) -> Finding { + Finding { + file: "lib.rs".into(), + line, + column: 0, + dimension: dim, + rule_id: "r".into(), + message: "m".into(), + severity: Severity::Medium, + suppressed, + } +} + +fn cpl( + kind: CouplingFindingKind, + details: CouplingFindingDetails, + suppressed: bool, +) -> CouplingFinding { + CouplingFinding { + common: common(Dimension::Coupling, 1, suppressed), + kind, + details, + } +} + +fn sdp(from: &str, suppressed: bool) -> CouplingFinding { + cpl( + CouplingFindingKind::SdpViolation, + CouplingFindingDetails::SdpViolation { + from_module: from.into(), + to_module: "dep".into(), + from_instability: 0.2, + to_instability: 0.8, + }, + suppressed, + ) +} + +fn structural(code: &str, suppressed: bool) -> CouplingFinding { + cpl( + CouplingFindingKind::Structural, + CouplingFindingDetails::Structural { + item_name: "I".into(), + code: code.into(), + detail: "d".into(), + }, + suppressed, + ) +} + +#[test] +fn coupling_split_buckets_cycles_always_sdp_and_structural_filtered() { + let findings = vec![ + cpl( + CouplingFindingKind::Cycle, + CouplingFindingDetails::Cycle { + modules: vec!["a".into(), "b".into()], + }, + false, + ), + sdp("live", false), + sdp("quiet", true), + structural("OI", false), + structural("SIT", true), + ]; + let b = split_coupling_findings(&findings); + assert_eq!( + b.cycle_paths.len(), + 1, + "cycle bucket (arm + always-included)" + ); + assert_eq!( + b.sdp_violations.len(), + 1, + "suppressed SDP filtered (`!suppressed`)" + ); + assert_eq!(b.sdp_violations[0].from, "live"); + assert_eq!(b.structural_rows.len(), 1); + assert_eq!(b.structural_rows[0].code, "OI"); +} + +fn srp(kind: SrpFindingKind, details: SrpFindingDetails) -> SrpFinding { + SrpFinding { + common: common(Dimension::Srp, 1, false), + kind, + details, + } +} + +#[test] +fn srp_split_buckets_each_kind_and_drops_suppressed() { + let struct_f = srp( + SrpFindingKind::StructCohesion, + SrpFindingDetails::StructCohesion { + struct_name: "Big".into(), + lcom4: 4, + field_count: 9, + method_count: 7, + fan_out: 2, + composite_score: 0.5, + clusters: vec![], + }, + ); + let module_f = srp( + SrpFindingKind::ModuleLength, + SrpFindingDetails::ModuleLength { + module: "m".into(), + production_lines: 900, + independent_clusters: 2, + cluster_names: vec![], + length_score: 0.0, + }, + ); + let param_f = srp( + SrpFindingKind::ParameterCount, + SrpFindingDetails::ParameterCount { + function_name: "f".into(), + parameter_count: 7, + }, + ); + let structural_f = srp( + SrpFindingKind::Structural, + SrpFindingDetails::Structural { + item_name: "Foo::bar".into(), + code: "SLM".into(), + detail: "selfless".into(), + }, + ); + let mut suppressed_struct = struct_f.clone(); + suppressed_struct.common.suppressed = true; + let b = split_srp_findings(&[struct_f, module_f, param_f, structural_f, suppressed_struct]); + assert_eq!(b.struct_warnings.len(), 1, "suppressed struct dropped"); + assert_eq!(b.struct_warnings[0].struct_name, "Big"); + assert_eq!(b.module_warnings.len(), 1); + assert_eq!(b.module_warnings[0].module, "m"); + assert_eq!(b.param_warnings.len(), 1); + assert_eq!(b.param_warnings[0].function_name, "f"); + assert_eq!(b.structural_rows.len(), 1, "structural arm projected"); + assert_eq!(b.structural_rows[0].code, "SLM"); +} + +fn tq( + line: usize, + kind: TqFindingKind, + name: &str, + uncovered: Option>, +) -> TqFinding { + TqFinding { + common: common(Dimension::TestQuality, line, false), + kind, + function_name: name.into(), + uncovered_lines: uncovered, + } +} + +#[test] +fn tq_rows_drop_suppressed_and_untested_logic_lists_uncovered() { + let logic = tq( + 1, + TqFindingKind::UntestedLogic, + "t1", + Some(vec![("if".into(), 5)]), + ); + let plain = tq(2, TqFindingKind::NoAssertion, "t2", None); + let mut suppressed = plain.clone(); + suppressed.common.suppressed = true; + let rows = project_tq_rows(&[logic, plain, suppressed]); + assert_eq!(rows.len(), 2, "suppressed dropped (`!suppressed`)"); + let lr = rows.iter().find(|r| r.function_name == "t1").unwrap(); + assert_eq!(lr.detail, "if at line 5", "UntestedLogic detail text"); + let pr = rows.iter().find(|r| r.function_name == "t2").unwrap(); + assert!(pr.detail.is_empty(), "non-logic kinds have no detail"); +} diff --git a/src/adapters/report/tests/root/quality_score.rs b/src/adapters/report/tests/root/quality_score.rs index 75acd28d..76c079da 100644 --- a/src/adapters/report/tests/root/quality_score.rs +++ b/src/adapters/report/tests/root/quality_score.rs @@ -120,6 +120,145 @@ fn test_score_all_violations_is_near_zero() { ); } +#[test] +fn compute_quality_score_pins_every_dimension_deficit() { + // Each dimension's deficit is `1 - (sum_of_its_findings / total).min(1)`. + // With total = 100 and one finding in every contributing field, each + // dimension score is an exact, distinct value. Asserting all seven pins + // every `+` in the per-dimension sums, the `coupling_cycles * 2` weight, the + // `/ total` divisions, and the leading `1.0 -` — any of those mutations + // shifts the corresponding score off its expected value. + let mut summary = Summary { + total: 100, + iosp_score: 0.80, + // complexity: 6 fields → 6 + complexity_warnings: 1, + magic_number_warnings: 1, + nesting_depth_warnings: 1, + function_length_warnings: 1, + unsafe_warnings: 1, + error_handling_warnings: 1, + // dry: 6 fields → 6 + duplicate_groups: 1, + fragment_groups: 1, + dead_code_warnings: 1, + boilerplate_warnings: 1, + wildcard_import_warnings: 1, + repeated_match_groups: 1, + // srp: 4 fields → 4 + srp_struct_warnings: 1, + srp_module_warnings: 1, + srp_param_warnings: 1, + structural_srp_warnings: 1, + // coupling: 1 + 1*2 + 1 + 1 = 5 + coupling_warnings: 1, + coupling_cycles: 1, + sdp_violations: 1, + structural_coupling_warnings: 1, + // tq: 5 fields → 5 + tq_no_assertion_warnings: 1, + tq_no_sut_warnings: 1, + tq_untested_warnings: 1, + tq_uncovered_warnings: 1, + tq_untested_logic_warnings: 1, + // architecture → 1 + architecture_warnings: 1, + ..Default::default() + }; + summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); + let expected = [0.80, 0.94, 0.94, 0.96, 0.95, 0.95, 0.99]; + for (i, want) in expected.iter().enumerate() { + assert!( + (summary.dimension_scores[i] - want).abs() < 1e-9, + "dimension_scores[{i}] = {} want {want}", + summary.dimension_scores[i] + ); + } +} + +#[test] +fn compute_quality_score_zero_weights_collapse_to_zero() { + // With every weight zero, `active_dims` is 0, so the `active_dims > 0.0` + // guard falls to `scale = 1.0` and the score is `1 - 1*(1 - 0) = 0`. + // Flipping that guard to `>=` would take `scale = active_dims = 0.0`, + // yielding 1.0 — caught by asserting exactly 0.0. + let mut summary = Summary { + total: 100, + iosp_score: 0.9, + ..Default::default() + }; + summary.compute_quality_score(&[0.0; 7]); + assert!( + summary.quality_score.abs() < 1e-12, + "all-zero weights → score 0, got {}", + summary.quality_score + ); +} + +#[test] +fn compute_quality_score_epsilon_weight_is_inactive() { + // A weight of exactly `f64::EPSILON` is *not* an active dimension + // (`w > f64::EPSILON` is false). With two real weights of 0.5 the scale is + // 2; counting the epsilon weight as active (the `>`→`>=` mutation) would + // make it 3 and pull the score from 0.90 to 0.85. + let mut summary = Summary { + total: 100, + iosp_score: 0.9, + ..Default::default() + }; + let mut weights = [0.0; 7]; + weights[0] = 0.5; + weights[1] = 0.5; + weights[2] = f64::EPSILON; + summary.compute_quality_score(&weights); + // dimension_scores = [0.9, 1, 1, ...]; weighted_avg = 0.9*0.5 + 1*0.5 ≈ 0.95; + // scale = 2 → 1 - 2*(1 - 0.95) = 0.90. + assert!( + (summary.quality_score - 0.90).abs() < 1e-9, + "epsilon weight must not count as active (scale 2 → 0.90), got {}", + summary.quality_score + ); +} + +#[test] +fn total_findings_sums_every_contributing_field() { + // Every one of the 28 finding-count fields set to 1 → total 28. With all + // fields non-zero, any `+`→`-`/`*` in the sum changes the result, so the + // exact assertion pins the whole `total_findings` chain. + let summary = Summary { + violations: 1, + complexity_warnings: 1, + magic_number_warnings: 1, + nesting_depth_warnings: 1, + function_length_warnings: 1, + unsafe_warnings: 1, + error_handling_warnings: 1, + duplicate_groups: 1, + fragment_groups: 1, + dead_code_warnings: 1, + boilerplate_warnings: 1, + srp_struct_warnings: 1, + srp_module_warnings: 1, + srp_param_warnings: 1, + wildcard_import_warnings: 1, + repeated_match_groups: 1, + coupling_warnings: 1, + coupling_cycles: 1, + sdp_violations: 1, + tq_no_assertion_warnings: 1, + tq_no_sut_warnings: 1, + tq_untested_warnings: 1, + tq_uncovered_warnings: 1, + tq_untested_logic_warnings: 1, + structural_srp_warnings: 1, + structural_coupling_warnings: 1, + architecture_warnings: 1, + orphan_suppressions: 1, + ..Summary::default() + }; + assert_eq!(summary.total_findings(), 28); +} + #[test] fn test_total_findings() { let summary = Summary { diff --git a/src/adapters/report/tests/suggestions.rs b/src/adapters/report/tests/suggestions.rs index f101c95a..b0abdc3a 100644 --- a/src/adapters/report/tests/suggestions.rs +++ b/src/adapters/report/tests/suggestions.rs @@ -93,3 +93,92 @@ fn test_print_suggestions_suppressed_skipped() { let results = vec![func]; print_suggestions(&results); } + +fn violation(logic_kind: &str, with_calls: bool) -> FunctionAnalysis { + make_result( + "v", + Classification::Violation { + has_logic: true, + has_own_calls: with_calls, + logic_locations: vec![LogicOccurrence { + kind: logic_kind.into(), + line: 1, + }], + call_locations: if with_calls { + vec![CallOccurrence { + name: "helper".into(), + line: 2, + }] + } else { + vec![] + }, + }, + ) +} + +#[test] +fn suggestion_messages_pick_branch_by_logic_kind_and_calls() { + assert!( + suggestion_messages(&violation("if", true))[0] + .0 + .contains("Extract the condition"), + "conditional + calls → condition suggestion" + ); + assert!( + suggestion_messages(&violation("for", true))[0] + .0 + .contains("iterator chain"), + "loop + calls → iterator suggestion" + ); + // Pure logic (no conditional/loop) → the generic extract-logic suggestion, + // regardless of calls. + assert!( + suggestion_messages(&violation("let", false))[0] + .0 + .contains("Extract the logic"), + "no conditional/loop → extract-logic suggestion" + ); + // A conditional WITHOUT calls yields no condition suggestion (pins the + // condition branch's `&& has_calls`). + assert!( + suggestion_messages(&violation("if", false)) + .iter() + .all(|(h, _)| !h.contains("Extract the condition")), + "conditional without calls → no condition suggestion" + ); + // A loop WITHOUT calls yields no iterator suggestion (pins the loop + // branch's `&& has_calls`). + assert!( + suggestion_messages(&violation("for", false)) + .iter() + .all(|(h, _)| !h.contains("iterator chain")), + "loop without calls → no iterator suggestion" + ); + // A conditional (has_conditional = true) suppresses the generic + // extract-logic line — pins the `!has_conditional && !has_loop`. + assert!( + suggestion_messages(&violation("if", true)) + .iter() + .all(|(h, _)| !h.contains("Extract the logic")), + "a conditional present → no extract-logic suggestion" + ); +} + +#[test] +fn collect_suggestions_filters_to_unsuppressed_violations() { + let mut suppressed = violation("if", true); + suppressed.qualified_name = "supp_fn".into(); + suppressed.suppressed = true; + let mut live = violation("if", true); + live.qualified_name = "live_fn".into(); + let results = vec![ + live, + make_result("op", Classification::Operation), + suppressed, + ]; + let suggestions = collect_suggestions(&results); + // Only the unsuppressed violation survives; pins `!suppressed` (a deleted `!` + // would keep the suppressed one and drop the live one). + assert_eq!(suggestions.len(), 1, "only the unsuppressed violation"); + assert_eq!(suggestions[0].qualified_name, "live_fn"); +} diff --git a/src/adapters/report/text/mod.rs b/src/adapters/report/text/mod.rs index 073750d8..3524dacb 100644 --- a/src/adapters/report/text/mod.rs +++ b/src/adapters/report/text/mod.rs @@ -143,7 +143,7 @@ impl<'a> ReporterImpl for TextReporter<'a> { } /// Format the findings list with heading. -fn format_findings_list(entries: &[FindingEntry]) -> String { +pub(super) fn format_findings_list(entries: &[FindingEntry]) -> String { if entries.is_empty() { return String::new(); } diff --git a/src/adapters/report/text/tests/coupling.rs b/src/adapters/report/text/tests/coupling.rs new file mode 100644 index 00000000..432b665c --- /dev/null +++ b/src/adapters/report/text/tests/coupling.rs @@ -0,0 +1,87 @@ +//! Rendering tests for the text Coupling section. A verbose render with a +//! warning module, a cycle, an SDP violation, and incoming/outgoing edges pins +//! every `push_*` sub-section; a non-verbose render pins the `verbose && !…` +//! detail guards and the cycle-status line. +use crate::adapters::report::projections::coupling::SdpViolationRow; +use crate::report::text::coupling::format_coupling_section; +use crate::report::text::views::{CouplingTableView, CouplingView, ModuleRow}; + +fn module(name: &str, warning: bool) -> ModuleRow { + ModuleRow { + name: name.into(), + afferent: 1, + efferent: 9, + instability: 0.9, + suppressed: false, + warning, + incoming: vec!["up".into()], + outgoing: vec!["down".into()], + } +} + +fn view_with_cycle() -> CouplingView { + CouplingView { + cycle_paths: vec![vec!["a".into(), "b".into()]], + sdp_violations: vec![SdpViolationRow { + from: "x".into(), + from_instability: 0.2, + to: "y".into(), + to_instability: 0.8, + }], + structural_rows: vec![], + } +} + +#[test] +fn coupling_verbose_renders_header_cycle_sdp_legend_and_module_edges() { + let view = view_with_cycle(); + let table = CouplingTableView { + modules: vec![module("modA", true)], + }; + let out = format_coupling_section(&view, &table, true); + assert!(out.contains("Modules analyzed: 1"), "verbose header: {out}"); + assert!(out.contains("Circular dependency: a → b"), "cycle: {out}"); + assert!(out.contains("SDP violation: x"), "sdp: {out}"); + assert!(out.contains("Incoming"), "legend: {out}"); + assert!(out.contains("modA"), "module row: {out}"); + assert!(out.contains("exceeds threshold"), "warning tag: {out}"); + assert!( + out.contains("→ depends on:") && out.contains("down"), + "outgoing: {out}" + ); + assert!( + out.contains("← used by:") && out.contains("up"), + "incoming: {out}" + ); + assert!( + !out.contains("No circular dependencies"), + "cycle present → no all-clear line: {out}" + ); +} + +#[test] +fn coupling_non_verbose_hides_edges_and_shows_all_clear() { + // No cycles, non-verbose: the compact table header shows, per-module + // incoming/outgoing detail is hidden (pins `verbose && !…`), and the + // all-clear cycle status line is emitted. + let view = CouplingView { + cycle_paths: vec![], + sdp_violations: vec![], + structural_rows: vec![], + }; + let table = CouplingTableView { + modules: vec![module("modB", false)], + }; + let out = format_coupling_section(&view, &table, false); + assert!(out.contains("Instability"), "compact table header: {out}"); + assert!(out.contains("modB"), "module row: {out}"); + assert!( + !out.contains("depends on"), + "edges hidden non-verbose: {out}" + ); + assert!(!out.contains("used by"), "edges hidden non-verbose: {out}"); + assert!( + out.contains("No circular dependencies"), + "no cycles → all-clear line: {out}" + ); +} diff --git a/src/adapters/report/text/tests/dry.rs b/src/adapters/report/text/tests/dry.rs new file mode 100644 index 00000000..9805f993 --- /dev/null +++ b/src/adapters/report/text/tests/dry.rs @@ -0,0 +1,97 @@ +//! Rendering tests for the text DRY section. A single-populated-category view +//! both renders that category's content (pinning each `push_*` against a no-op) +//! and flips the all-empty early-return guard (pinning each `&&` → `||`). +use crate::adapters::report::projections::dry::{ + BoilerplateRow, DeadCodeRow, DryGroupRow, ParticipantRow, WildcardRow, +}; +use crate::report::text::dry::format_dry_section; +use crate::report::text::views::DryView; + +fn empty_view() -> DryView { + DryView { + duplicate_groups: vec![], + fragment_groups: vec![], + dead_code: vec![], + boilerplate: vec![], + wildcards: vec![], + repeated_match_groups: vec![], + } +} + +fn group(kind: &str, fname: &str, file: &str, line: usize) -> DryGroupRow { + DryGroupRow { + kind_label: kind.into(), + participants: vec![ParticipantRow { + function_name: fname.into(), + file: file.into(), + line, + }], + } +} + +#[test] +fn dry_group_categories_render_with_participants() { + let mut v = empty_view(); + v.duplicate_groups = vec![group("Exact", "dupfn", "d.rs", 1)]; + let out = format_dry_section(&v); + assert!(out.contains("Exact duplicate"), "exact label (`==`): {out}"); + assert!(out.contains("dupfn (d.rs:1)"), "participant row: {out}"); + + let mut v = empty_view(); + v.fragment_groups = vec![group("3", "fragfn", "f.rs", 2)]; + let out = format_dry_section(&v); + assert!(out.contains("Fragment 1: 3 matching"), "{out}"); + assert!(out.contains("fragfn (f.rs:2)"), "{out}"); + + let mut v = empty_view(); + v.repeated_match_groups = vec![group("E", "repfn", "r.rs", 6)]; + let out = format_dry_section(&v); + assert!(out.contains("Repeated match [E]"), "{out}"); + assert!(out.contains("repfn (r.rs:6)"), "{out}"); +} + +#[test] +fn dry_dead_code_boilerplate_wildcard_render() { + let mut v = empty_view(); + v.dead_code = vec![DeadCodeRow { + qualified_name: "deadfn".into(), + kind_tag: "uncalled", + file: "x.rs".into(), + line: 3, + suggestion: "remove it".into(), + }]; + assert!( + format_dry_section(&v).contains("deadfn [uncalled]"), + "dead code row" + ); + + let mut v = empty_view(); + v.boilerplate = vec![BoilerplateRow { + pattern_id: "BP-001".into(), + struct_name: "Foo".into(), + file: "b.rs".into(), + line: 4, + message: "boilerplate msg".into(), + suggestion: "sug".into(), + }]; + assert!( + format_dry_section(&v).contains("[BP-001] Foo"), + "boilerplate row" + ); + + let mut v = empty_view(); + v.wildcards = vec![WildcardRow { + module_path: "foo::*".into(), + file: "w.rs".into(), + line: 5, + }]; + assert!( + format_dry_section(&v).contains("Wildcard import: foo::*"), + "wildcard row" + ); +} + +#[test] +fn dry_section_empty_when_no_findings() { + assert!(format_dry_section(&empty_view()).is_empty()); +} diff --git a/src/adapters/report/text/tests/files.rs b/src/adapters/report/text/tests/files.rs new file mode 100644 index 00000000..d8fe8963 --- /dev/null +++ b/src/adapters/report/text/tests/files.rs @@ -0,0 +1,205 @@ +//! Rendering tests for the verbose per-file listing (`format_files_section`). +//! Asserting on the rendered string pins the file-visibility filter, the +//! verbose match guards, the violation detail lines, and the complexity / +//! warning formatting that the existing smoke tests don't reach. +use crate::adapters::analyzers::iosp::{ + Classification, ComplexityMetrics, FunctionAnalysis, MagicNumberOccurrence, Severity, +}; +use crate::adapters::report::test_support::{make_result, violation}; +use crate::report::text::files::format_files_section; + +/// An unsuppressed Violation `v` with an effort score and High severity. +fn violation_fn() -> FunctionAnalysis { + let mut f = make_result("v", violation("if", "helper")); + f.severity = Some(Severity::High); + f.effort_score = Some(3.5); + f +} + +/// An Operation with full complexity metrics and every complexity warning set. +fn warned_operation() -> FunctionAnalysis { + let mut f = make_result("op", Classification::Operation); + f.complexity = Some(ComplexityMetrics { + logic_count: 3, + call_count: 0, + max_nesting: 0, + cognitive_complexity: 20, + cyclomatic_complexity: 12, + function_lines: 80, + unsafe_blocks: 2, + unwrap_count: 2, + magic_numbers: vec![MagicNumberOccurrence { + line: 4, + value: "42".into(), + }], + ..Default::default() + }); + f.cognitive_warning = true; + f.nesting_depth_warning = true; + f.function_length_warning = true; + f.unsafe_warning = true; + f.error_handling_warning = true; + f +} + +#[test] +fn violation_entry_shows_logic_calls_effort_and_severity() { + // A file with one unsuppressed violation is shown even non-verbose, with its + // logic/call locations and effort. Pins has_violations and the + // `!logic_locations.is_empty()` / `!call_locations.is_empty()` guards. + let out = format_files_section(&[violation_fn()], false); + assert!(out.contains("VIOLATION"), "{out}"); + assert!(out.contains("[HIGH]"), "severity tag: {out}"); + assert!( + out.contains("Logic:") && out.contains("if"), + "logic line: {out}" + ); + assert!( + out.contains("Calls:") && out.contains("helper"), + "calls line: {out}" + ); + assert!( + out.contains("Effort:") && out.contains("3.5"), + "effort line: {out}" + ); +} + +#[test] +fn non_verbose_hides_clean_files_but_verbose_shows_them() { + // A clean (unsuppressed, non-violation) Operation file is skipped without + // --verbose and shown with it. Pins the `!verbose && !has_violations && + // !has_suppressed` skip and the per-arm `verbose` match guards. + let op = make_result("clean_op", Classification::Operation); + assert!( + format_files_section(std::slice::from_ref(&op), false).is_empty(), + "clean file hidden without --verbose" + ); + let verbose = format_files_section(&[op], true); + assert!( + verbose.contains("OPERATION"), + "shown with --verbose: {verbose}" + ); + assert!(verbose.contains("clean_op"), "{verbose}"); +} + +#[test] +fn suppressed_function_keeps_its_file_visible() { + // A file whose only function is suppressed is still shown (has_suppressed), + // pinning the `!has_suppressed` term of the skip condition. + let mut f = make_result("hidden", Classification::Operation); + f.suppressed = true; + let out = format_files_section(&[f], false); + assert!( + out.contains("test.rs"), + "suppressed-only file header shown: {out}" + ); +} + +#[test] +fn complexity_details_and_warnings_render() { + // Verbose render of an Operation with metrics + warnings. Pins the + // `logic>0 || call>0 || nesting>0` complexity-line guard, the magic-number + // emptiness check, the unsafe singular/plural `== 1`, and the error-handling + // `count > 0` filter. + let out = format_files_section(&[warned_operation()], true); + assert!(out.contains("logic=3"), "complexity line: {out}"); + assert!(out.contains("cognitive complexity 20"), "{out}"); + assert!(out.contains("magic numbers:"), "magic numbers msg: {out}"); + assert!( + out.contains("2 unsafe blocks"), + "plural unsafe (== 1 → else 's'): {out}" + ); + assert!( + out.contains("error handling:") && out.contains("2 unwrap"), + "error msg: {out}" + ); + assert!(out.contains("nesting depth"), "{out}"); + assert!(out.contains("function length 80 lines"), "{out}"); +} + +#[test] +fn complexity_line_hidden_when_all_metrics_zero() { + // With logic/call/nesting all zero the "Complexity:" detail line is not + // emitted. Pins the `> 0` comparisons against `==`/`<` (which would emit it). + let mut f = make_result("zero", Classification::Operation); + f.complexity = Some(ComplexityMetrics::default()); + let out = format_files_section(&[f], true); + assert!(out.contains("OPERATION"), "{out}"); + assert!( + !out.contains("logic="), + "no complexity line when all zero: {out}" + ); +} + +#[test] +fn non_verbose_violation_file_hides_non_violation_entries() { + // A file shown because of a violation still hides its Integration/Operation/ + // Trivial functions when non-verbose (each arm is `verbose`-guarded). + let out = format_files_section( + &[ + violation_fn(), + make_result("integ_fn", Classification::Integration), + make_result("op_fn", Classification::Operation), + make_result("triv_fn", Classification::Trivial), + ], + false, + ); + assert!(out.contains("VIOLATION"), "violation shown: {out}"); + for hidden in ["integ_fn", "op_fn", "triv_fn"] { + assert!( + !out.contains(hidden), + "{hidden} hidden non-verbose (pins its `verbose` match guard): {out}" + ); + } +} + +fn op_with_metrics(name: &str, m: ComplexityMetrics) -> FunctionAnalysis { + let mut f = make_result(name, Classification::Operation); + f.complexity = Some(m); + f +} + +#[test] +fn complexity_line_shown_for_calls_or_nesting_alone() { + // The "Complexity:" line shows if ANY of logic/calls/nesting is > 0. Isolating + // calls (then nesting) pins each `> 0` against `<` and the `||` chain. + let calls_only = op_with_metrics( + "calls_fn", + ComplexityMetrics { + call_count: 2, + ..Default::default() + }, + ); + assert!( + format_files_section(&[calls_only], true).contains("calls=2"), + "calls-only → complexity line shown" + ); + let nesting_only = op_with_metrics( + "nest_fn", + ComplexityMetrics { + max_nesting: 2, + ..Default::default() + }, + ); + assert!( + format_files_section(&[nesting_only], true).contains("nesting=2"), + "nesting-only → complexity line shown" + ); +} + +#[test] +fn error_handling_lists_only_nonzero_counts() { + // Only non-zero error-handling counts appear (pins `*count > 0` vs `>=`). + let f = op_with_metrics( + "err_fn", + ComplexityMetrics { + unwrap_count: 2, + ..Default::default() + }, + ); + let mut f = f; + f.error_handling_warning = true; + let out = format_files_section(&[f], true); + assert!(out.contains("2 unwrap"), "unwrap listed: {out}"); + assert!(!out.contains("0 expect"), "zero counts not listed: {out}"); +} diff --git a/src/adapters/report/text/tests/mod.rs b/src/adapters/report/text/tests/mod.rs index 6ee09e6a..0dc4fa8a 100644 --- a/src/adapters/report/text/tests/mod.rs +++ b/src/adapters/report/text/tests/mod.rs @@ -1 +1,7 @@ +mod coupling; +mod dry; +mod files; mod root; +mod sections; +mod srp; +mod summary; diff --git a/src/adapters/report/text/tests/sections.rs b/src/adapters/report/text/tests/sections.rs new file mode 100644 index 00000000..380420e9 --- /dev/null +++ b/src/adapters/report/text/tests/sections.rs @@ -0,0 +1,118 @@ +//! Rendering tests for the smaller text sections: cross-dimension Structural, +//! Architecture (view projection + section), Test Quality rows, and the +//! findings-list heading. +use crate::adapters::report::projections::srp::StructuralRow; +use crate::adapters::report::projections::tq::TqRow; +use crate::domain::findings::ArchitectureFinding; +use crate::domain::{Dimension, Finding, Severity}; +use crate::report::findings_list::FindingEntry; +use crate::report::text::architecture::{build_architecture_view, format_architecture_section}; +use crate::report::text::format_findings_list; +use crate::report::text::structural::format_structural_section; +use crate::report::text::tq::format_tq_section; +use crate::report::text::views::{ArchitectureView, TqView}; + +fn srow(code: &str, name: &str) -> StructuralRow { + StructuralRow { + code: code.into(), + name: name.into(), + detail: "detail text".into(), + file: "s.rs".into(), + line: 7, + } +} + +#[test] +fn structural_section_renders_either_side_and_is_empty_when_both_empty() { + // An SRP-only set renders (pins `srp.is_empty() && coupling.is_empty()` + // against `||`, which would early-return on the empty coupling side), and + // the row content pins the `-> String::new()`/"xyzzy" body replacements. + let out = format_structural_section(&[srow("SLM", "Foo::bar")], &[]); + assert!(out.contains("SLM"), "{out}"); + assert!(out.contains("Foo::bar (s.rs:7)"), "{out}"); + assert!(out.contains("detail text"), "{out}"); + // Coupling-only side also renders. + let out = format_structural_section(&[], &[srow("OI", "Baz")]); + assert!(out.contains("OI") && out.contains("Baz"), "{out}"); + // Both empty → nothing. + assert!(format_structural_section(&[], &[]).is_empty()); +} + +fn arch_finding(file: &str, suppressed: bool) -> ArchitectureFinding { + ArchitectureFinding { + common: Finding { + file: file.into(), + line: 5, + column: 0, + dimension: Dimension::Architecture, + rule_id: "architecture/layer".into(), + message: "layer violation".into(), + severity: Severity::Medium, + suppressed, + }, + } +} + +#[test] +fn architecture_view_drops_suppressed_and_section_renders_rows() { + // build_architecture_view keeps only unsuppressed findings (pins the `!`), + // and the section renders each with a singular/plural heading. + let view = build_architecture_view(&[ + arch_finding("keep.rs", false), + arch_finding("drop.rs", true), + ]); + assert_eq!(view.findings.len(), 1, "suppressed finding dropped"); + let out = format_architecture_section(&view); + assert!(out.contains("1 Finding"), "singular heading: {out}"); + assert!(out.contains("keep.rs"), "{out}"); + assert!(out.contains("architecture/layer"), "{out}"); + assert!(!out.contains("drop.rs"), "suppressed row absent: {out}"); + // Empty view → empty output. + assert!(format_architecture_section(&ArchitectureView { findings: vec![] }).is_empty()); +} + +#[test] +fn tq_section_renders_row_with_detail() { + // A TQ row with a non-empty detail renders both the main line and the detail + // sub-line. Pins `push_tq_row` (no-op) and the `!detail.is_empty()` guard. + let view = TqView { + warnings: vec![TqRow { + function_name: "test_it".into(), + file: "t.rs".into(), + line: 9, + display_label: "no assertion", + detail: "missing assert".into(), + }], + }; + let out = format_tq_section(&view); + assert!(out.contains("test_it (t.rs:9)"), "{out}"); + assert!(out.contains("no assertion"), "{out}"); + assert!(out.contains("missing assert"), "detail sub-line: {out}"); +} + +#[test] +fn findings_list_heading_pluralizes_and_lists_entries() { + // Two entries → plural "2 Findings" heading and each entry line. Pins + // format_findings_list against the `-> String::new()`/"xyzzy" replacements. + let entries = vec![ + FindingEntry { + file: "a.rs".into(), + line: 1, + category: "COGNITIVE", + detail: String::new(), + function_name: "fa".into(), + }, + FindingEntry { + file: "b.rs".into(), + line: 2, + category: "DUPLICATE", + detail: String::new(), + function_name: "fb".into(), + }, + ]; + let out = format_findings_list(&entries); + assert!(out.contains("2 Findings"), "plural heading: {out}"); + assert!(out.contains("a.rs:1") && out.contains("COGNITIVE"), "{out}"); + assert!(out.contains("b.rs:2") && out.contains("DUPLICATE"), "{out}"); + assert!(format_findings_list(&[]).is_empty()); +} diff --git a/src/adapters/report/text/tests/srp.rs b/src/adapters/report/text/tests/srp.rs new file mode 100644 index 00000000..9a9d05ba --- /dev/null +++ b/src/adapters/report/text/tests/srp.rs @@ -0,0 +1,84 @@ +//! Rendering tests for the text SRP section. Single-populated-category views +//! pin each `push_*` (no-op) and the all-empty `&&` early-return guard; the +//! module rows additionally pin the `production_lines > 0` / +//! `independent_clusters > 0` sub-guards. +use crate::adapters::report::projections::srp::{SrpModuleRow, SrpParamRow, SrpStructRow}; +use crate::report::text::srp::format_srp_section; +use crate::report::text::views::SrpView; + +fn empty_view() -> SrpView { + SrpView { + struct_warnings: vec![], + module_warnings: vec![], + param_warnings: vec![], + structural_rows: vec![], + } +} + +#[test] +fn srp_struct_and_param_rows_render() { + let mut v = empty_view(); + v.struct_warnings = vec![SrpStructRow { + struct_name: "Big".into(), + file: "s.rs".into(), + line: 3, + lcom4: 4, + field_count: 9, + method_count: 7, + fan_out: 2, + }]; + let out = format_srp_section(&v); + assert!(out.contains("Big (s.rs:3)"), "{out}"); + assert!(out.contains("LCOM4=4"), "{out}"); + + let mut v = empty_view(); + v.param_warnings = vec![SrpParamRow { + function_name: "big_fn".into(), + file: "p.rs".into(), + line: 8, + parameter_count: 7, + }]; + let out = format_srp_section(&v); + assert!(out.contains("big_fn (p.rs:8)"), "{out}"); + assert!(out.contains("7 parameters"), "{out}"); +} + +#[test] +fn srp_module_rows_show_only_nonzero_lines_and_clusters() { + // One module with positive lines + clusters renders both detail lines and the + // cluster names; a second module with zero of each renders nothing. Pins the + // `production_lines > 0` and `independent_clusters > 0` guards. + let mut v = empty_view(); + v.module_warnings = vec![ + SrpModuleRow { + module: "big".into(), + file: "m.rs".into(), + production_lines: 900, + independent_clusters: 2, + cluster_names: vec!["a, b".into()], + }, + SrpModuleRow { + module: "small".into(), + file: "m2.rs".into(), + production_lines: 0, + independent_clusters: 0, + cluster_names: vec![], + }, + ]; + let out = format_srp_section(&v); + assert!(out.contains("big — 900 production lines"), "{out}"); + assert!( + out.contains("big — 2 independent function clusters"), + "{out}" + ); + assert!(out.contains("Cluster 1: [a, b]"), "{out}"); + assert!( + !out.contains("small —"), + "zero module renders no detail: {out}" + ); +} + +#[test] +fn srp_section_empty_when_no_findings() { + assert!(format_srp_section(&empty_view()).is_empty()); +} diff --git a/src/adapters/report/text/tests/summary.rs b/src/adapters/report/text/tests/summary.rs new file mode 100644 index 00000000..2338f30a --- /dev/null +++ b/src/adapters/report/text/tests/summary.rs @@ -0,0 +1,257 @@ +//! Rendering tests for the text summary section. `format_summary_section` +//! orchestrates the header, per-dimension scores (with inline finding +//! locations), suppression lines, and the pass/fail footer; asserting on the +//! rendered string pins the arithmetic, thresholds, and category mapping that +//! coarse "contains 'quality'" smoke tests miss. +use crate::adapters::report::text::summary::format_summary_section; +use crate::report::findings_list::FindingEntry; +use crate::report::Summary; + +fn entry(file: &str, line: usize, category: &'static str, function_name: &str) -> FindingEntry { + FindingEntry { + file: file.into(), + line, + category, + detail: String::new(), + function_name: function_name.into(), + } +} + +/// A summary with one finding in every dimension + a violation (7 findings, +/// ≤ 10 so inline locations show), exact dimension_scores, and suppressions — +/// rendered with one matching `FindingEntry` per dimension category. +fn rich_render() -> String { + let mut summary = Summary { + total: 100, + integrations: 40, + operations: 50, + trivial: 9, + violations: 1, + complexity_warnings: 1, + duplicate_groups: 1, + srp_struct_warnings: 1, + coupling_warnings: 1, + tq_no_assertion_warnings: 1, + architecture_warnings: 1, + suppressed: 2, + all_suppressions: 3, + suppression_ratio_exceeded: true, + ..Default::default() + }; + summary.dimension_scores = [0.50, 0.60, 0.70, 0.80, 0.90, 0.95, 0.99]; + let findings = vec![ + entry("cx.rs", 11, "COGNITIVE", "cx_fn"), + entry("dry.rs", 22, "DUPLICATE", "dry_fn"), + entry("srp.rs", 33, "SRP_STRUCT", "srp_fn"), + entry("cp.rs", 44, "COUPLING", "cp_fn"), + entry("tq.rs", 55, "TQ_NO_ASSERT", "tq_fn"), + entry("arch.rs", 66, "ARCHITECTURE", "arch_fn"), + ]; + format_summary_section(&summary, &findings) +} + +#[test] +fn format_summary_section_header_shows_counts_score_and_iosp_detail() { + let out = rich_render(); + assert!(out.contains("Functions: 100"), "{out}"); + assert!(out.contains("7 findings"), "plural finding count: {out}"); + assert!( + out.contains("40I, 50O, 9T, 1 violation)"), + "IOSP detail with singular violation (pins `violations == 1`): {out}" + ); + assert!( + !out.contains("All quality checks passed"), + "footer must not show with findings: {out}" + ); +} + +#[test] +fn format_summary_section_shows_each_dimension_score_and_label() { + let out = rich_render(); + // Exact percentages pin pct * MULTIPLIER. + assert!(out.contains("50.0%"), "IOSP 0.50 → 50.0%: {out}"); + assert!(out.contains("60.0%"), "Complexity 0.60 → 60.0%: {out}"); + assert!(out.contains("99.0%"), "Architecture 0.99 → 99.0%: {out}"); + // Every label present pins build_dimensions != empty/default. + for label in [ + "Complexity:", + "DRY:", + "SRP:", + "Coupling:", + "Test Quality:", + "Architecture:", + ] { + assert!( + out.contains(label), + "dimension label {label} missing: {out}" + ); + } +} + +#[test] +fn format_summary_section_maps_each_category_to_its_dimension_locations() { + // One inline location per dimension proves the dimension_categories arms map + // each category to the right dimension. + let out = rich_render(); + for loc in [ + "cx.rs:11", + "dry.rs:22", + "srp.rs:33", + "cp.rs:44", + "tq.rs:55", + "arch.rs:66", + ] { + assert!(out.contains(loc), "inline location {loc} missing: {out}"); + } +} + +#[test] +fn format_summary_section_renders_suppression_lines() { + let out = rich_render(); + assert!(out.contains("Suppressed: 2"), "suppressed count: {out}"); + assert!(out.contains("All allows: 3"), "all-allows count: {out}"); + assert!(out.contains("ratio exceeds"), "ratio warning: {out}"); +} + +#[test] +fn format_summary_section_clean_shows_pass_footer_and_no_finding_count() { + // Zero findings: header omits the finding count, and the pass footer shows. + let mut summary = Summary { + total: 10, + integrations: 5, + operations: 5, + ..Default::default() + }; + summary.dimension_scores = [1.0; 7]; + let out = format_summary_section(&summary, &[]); + assert!( + out.contains("All quality checks passed"), + "clean run shows the pass footer: {out}" + ); + assert!( + !out.contains("finding"), + "clean header omits the finding count: {out}" + ); + // No violations → IOSP detail without a violation clause. + assert!(out.contains("5I, 5O, 0T"), "{out}"); + assert!(!out.contains("violation"), "no violation clause: {out}"); +} + +#[test] +fn format_summary_section_detail_lists_only_nonzero_counts() { + // Within a dimension only non-zero finding counts are listed (the `*c > 0` + // filter). complexity_warnings = 2, the rest of Complexity's fields 0. + let mut summary = Summary { + total: 100, + complexity_warnings: 2, + ..Default::default() + }; + summary.dimension_scores = [1.0, 0.5, 1.0, 1.0, 1.0, 1.0, 1.0]; + let out = format_summary_section(&summary, &[]); + assert!(out.contains("2 complexity"), "non-zero count listed: {out}"); + assert!( + !out.contains("magic numbers"), + "zero-count categories are not listed: {out}" + ); +} + +#[test] +fn format_summary_section_hides_inline_locations_above_threshold() { + // With more than INLINE_LOCATION_THRESHOLD (10) findings, inline `→` location + // lines are suppressed even though findings exist. Pins the `<=` threshold. + let mut summary = Summary { + total: 100, + complexity_warnings: 11, + ..Default::default() + }; + summary.dimension_scores = [1.0, 0.4, 1.0, 1.0, 1.0, 1.0, 1.0]; + let findings = vec![entry("cx.rs", 7, "COGNITIVE", "cx_fn")]; + let out = format_summary_section(&summary, &findings); + assert!(out.contains("11 complexity"), "count still shown: {out}"); + assert!( + !out.contains("cx.rs:7"), + "inline locations hidden above the threshold: {out}" + ); +} + +fn clean(total: usize) -> Summary { + let mut s = Summary { + total, + ..Default::default() + }; + s.dimension_scores = [1.0; 7]; + s +} + +#[test] +fn summary_suppression_lines_only_for_nonzero_counts() { + // suppressed = 0 → no "Suppressed:" line; all_suppressions = 3 → shown. + // Pins the `> 0` guards against `>=` (which would print a "… 0" line). + let mut s = clean(10); + s.suppressed = 0; + s.all_suppressions = 3; + let out = format_summary_section(&s, &[]); + assert!( + !out.contains("Suppressed:"), + "0 suppressed → no line: {out}" + ); + assert!(out.contains("All allows: 3"), "all-allows shown: {out}"); + + let mut s2 = clean(10); + s2.suppressed = 0; + s2.all_suppressions = 0; + let out2 = format_summary_section(&s2, &[]); + assert!( + !out2.contains("All allows:"), + "0 all-allows → no line: {out2}" + ); + assert!(!out2.contains("Suppressed:"), "{out2}"); +} + +#[test] +fn summary_inline_location_skips_empty_file_findings() { + // An inline location is shown only for a finding with a non-empty file AND a + // matching dimension category. A complexity finding with an empty file must + // NOT produce a `→ :line` line — pins `dim_cats.contains && !file.is_empty()`. + let mut s = clean(100); + s.complexity_warnings = 1; + s.dimension_scores = [1.0, 0.5, 1.0, 1.0, 1.0, 1.0, 1.0]; + let findings = vec![entry("", 7, "COGNITIVE", "ghost_fn")]; + let out = format_summary_section(&s, &findings); + assert!(out.contains("1 complexity"), "count shown: {out}"); + assert!( + !out.contains("ghost_fn"), + "empty-file finding has no inline location: {out}" + ); +} + +/// True if a blank line immediately precedes the first line containing `needle`. +fn blank_line_before(out: &str, needle: &str) -> bool { + let lines: Vec<&str> = out.lines().collect(); + lines + .iter() + .position(|l| l.contains(needle)) + .is_some_and(|i| i > 0 && lines[i - 1].trim().is_empty()) +} + +#[test] +fn summary_suppression_section_preceded_by_blank_line() { + // The suppression section is separated from the dimension scores by a blank + // line (the `suppressed > 0 || all_suppressions > 0` guard). Pins the `||` + // and the `> 0` comparisons: with exactly one count non-zero, dropping the + // guard (`&&`, or `>`→`<`/`==`) removes the separator. + let mut s = clean(10); + s.suppressed = 2; + s.all_suppressions = 0; + assert!( + blank_line_before(&format_summary_section(&s, &[]), "Suppressed:"), + "blank line before the suppressed-count line" + ); + let mut s2 = clean(10); + s2.suppressed = 0; + s2.all_suppressions = 3; + assert!( + blank_line_before(&format_summary_section(&s2, &[]), "All allows:"), + "blank line before the all-allows line" + ); +} diff --git a/src/app/architecture.rs b/src/app/architecture.rs index 49c6eac0..fee1c29e 100644 --- a/src/app/architecture.rs +++ b/src/app/architecture.rs @@ -28,7 +28,7 @@ pub(super) fn collect_architecture_findings( summary: &mut Summary, ) -> Vec { let mut findings = run_architecture_dimension(parsed, config, suppression_lines); - summary.architecture_warnings = findings.iter().filter(|f| !f.suppressed).count(); + summary.architecture_warnings = count_architecture_warnings(&findings); findings.sort_by(|a, b| { a.file .cmp(&b.file) @@ -38,6 +38,12 @@ pub(super) fn collect_architecture_findings( findings } +/// Count the findings that remain active (not suppressed) for the summary. +/// Operation: filter + count. +pub(super) fn count_architecture_warnings(findings: &[Finding]) -> usize { + findings.iter().filter(|f| !f.suppressed).count() +} + /// Run every port-based dimension analyzer and return their findings with /// file-level suppressions applied. /// Integration: delegates context construction, analyzer dispatch, suppression marking. @@ -72,7 +78,7 @@ fn run_architecture_dimension( /// `qual:allow(architecture)` for one helper would silence unrelated /// call-parity, layer, or forbidden-edge findings elsewhere in the /// same file. Operation: per-finding lookup over the suppression map. -fn mark_architecture_suppressions( +pub(super) fn mark_architecture_suppressions( findings: &mut [Finding], suppression_lines: &HashMap>, ) { diff --git a/src/app/exit_gates.rs b/src/app/exit_gates.rs index f429274c..facc7e50 100644 --- a/src/app/exit_gates.rs +++ b/src/app/exit_gates.rs @@ -21,17 +21,27 @@ pub(crate) fn apply_exit_gates(cli: &Cli, config: &Config, summary: &Summary) -> } /// Emit a stderr warning when the suppression ratio exceeds the configured max. -/// Operation: conditional formatting. +/// Integration: delegates the message to `suppression_ratio_warning`. fn warn_suppression_ratio(summary: &Summary, max_ratio: f64) { + suppression_ratio_warning(summary, max_ratio) + .into_iter() + .for_each(|msg| eprintln!("{msg}")); +} + +/// Build the suppression-ratio warning message, or `None` when the ratio gate +/// didn't trip (not exceeded, or no functions analysed). Pure so the gate logic +/// is observable in tests rather than buried in a stderr side effect. +/// Operation: conditional formatting. +pub(crate) fn suppression_ratio_warning(summary: &Summary, max_ratio: f64) -> Option { if !summary.suppression_ratio_exceeded || summary.total == 0 { - return; + return None; } - eprintln!( + Some(format!( "Warning: {} suppression(s) found ({:.1}% of functions, max: {:.1}%)", summary.all_suppressions, summary.all_suppressions as f64 / summary.total as f64 * PERCENTAGE_MULTIPLIER, max_ratio * PERCENTAGE_MULTIPLIER, - ); + )) } /// Return Err(1) iff `--fail-on-warnings` is set and the diff --git a/src/app/pipeline.rs b/src/app/pipeline.rs index 0e7fdc53..e462c94c 100644 --- a/src/app/pipeline.rs +++ b/src/app/pipeline.rs @@ -173,6 +173,8 @@ fn finalize_summary( } /// Run a full analysis pipeline on a set of files and produce output. +/// Returns the `AnalysisResult` it printed, so callers (and tests) can observe +/// the orchestration's product rather than only its stdout side effect. /// Integration: orchestrates read_and_parse_files, run_analysis, output_results. pub(crate) fn analyze_and_output( path: &Path, @@ -180,11 +182,12 @@ pub(crate) fn analyze_and_output( output_format: &crate::cli::OutputFormat, verbose: bool, suggestions: bool, -) { +) -> AnalysisResult { let files = collect_filtered_files(path, config); let parsed = read_and_parse_files(&files, path); let analysis = run_analysis(parsed, config); output_results(&analysis, output_format, verbose, suggestions, config); + analysis } /// Output results in the requested format. diff --git a/src/app/tests/architecture.rs b/src/app/tests/architecture.rs new file mode 100644 index 00000000..d955ecff --- /dev/null +++ b/src/app/tests/architecture.rs @@ -0,0 +1,71 @@ +//! `app::architecture` glue: window-scoped suppression marking and the +//! summary warning count. Built on hand-constructed `Finding`s so the +//! port-based analyzer doesn't need to run. +use crate::app::architecture::{count_architecture_warnings, mark_architecture_suppressions}; +use crate::domain::{Dimension, Finding, Severity}; +use std::collections::HashMap; + +fn arch_finding(line: usize, suppressed: bool) -> Finding { + Finding { + file: "src/x.rs".into(), + line, + column: 0, + dimension: Dimension::Architecture, + rule_id: "architecture/layer".into(), + message: String::new(), + severity: Severity::Medium, + suppressed, + } +} + +fn marker(line: usize, dim: Dimension) -> HashMap> { + [( + "src/x.rs".to_string(), + vec![crate::findings::Suppression { + line, + dimensions: vec![dim], + reason: None, + }], + )] + .into() +} + +#[test] +fn architecture_marker_in_window_suppresses_finding() { + // A `qual:allow(architecture)` at line 5 covers a finding at line 6 (within + // ANNOTATION_WINDOW). Pins `mark_architecture_suppressions` against being a + // no-op (`-> ()`), which would leave the finding active. + let mut findings = vec![arch_finding(6, false)]; + mark_architecture_suppressions(&mut findings, &marker(5, Dimension::Architecture)); + assert!( + findings[0].suppressed, + "an in-window architecture marker must suppress the finding" + ); +} + +#[test] +fn architecture_marker_must_cover_the_architecture_dimension() { + // A marker in the window but covering a *different* dimension must not + // suppress an architecture finding. Pins the `covers(Architecture) && + // is_within_window` filter against `&&`→`||` (which would suppress on + // window proximity alone). + let mut findings = vec![arch_finding(6, false)]; + mark_architecture_suppressions(&mut findings, &marker(5, Dimension::Complexity)); + assert!( + !findings[0].suppressed, + "an in-window marker for another dimension must not suppress architecture" + ); +} + +#[test] +fn count_architecture_warnings_excludes_suppressed() { + // Two active + one suppressed → 2. The asymmetric counts pin the + // `!suppressed` filter: deleting the `!` would count the one suppressed + // finding instead (1 ≠ 2). + let findings = vec![ + arch_finding(1, false), + arch_finding(2, false), + arch_finding(3, true), + ]; + assert_eq!(count_architecture_warnings(&findings), 2); +} diff --git a/src/app/tests/gates.rs b/src/app/tests/gates.rs new file mode 100644 index 00000000..298c43ae --- /dev/null +++ b/src/app/tests/gates.rs @@ -0,0 +1,181 @@ +//! `app::exit_gates` + `app::setup` use-case tests: the suppression-ratio +//! warning builder, the per-gate `Result` checks, the composed +//! `apply_exit_gates` stack, and config-load error mapping. Split out of +//! `run.rs` to keep both test files under the test-file length baseline. +use crate::app::exit_gates::{ + apply_exit_gates, check_default_fail, check_fail_on_warnings, check_min_quality_score, + check_quality_gates, suppression_ratio_warning, +}; +use crate::cli::Cli; +use crate::config::Config; +use clap::Parser; + +#[test] +fn test_check_fail_on_warnings_passes_when_no_warnings() { + let mut config = Config::default(); + config.fail_on_warnings = true; + let summary = crate::report::Summary { + total: 10, + ..Default::default() + }; + assert!(check_fail_on_warnings(&config, &summary).is_ok()); +} + +#[test] +fn test_check_fail_on_warnings_passes_when_disabled() { + let config = Config::default(); // fail_on_warnings = false + let summary = crate::report::Summary { + total: 10, + suppression_ratio_exceeded: true, + ..Default::default() + }; + assert!(check_fail_on_warnings(&config, &summary).is_ok()); +} + +#[test] +fn test_check_fail_on_warnings_exits_when_triggered() { + let mut config = Config::default(); + config.fail_on_warnings = true; + let summary = crate::report::Summary { + total: 10, + suppression_ratio_exceeded: true, + ..Default::default() + }; + assert_eq!(check_fail_on_warnings(&config, &summary), Err(1)); +} + +#[test] +fn test_min_quality_score_cli_parse() { + let cli = Cli::parse_from(["test", "--min-quality-score", "80.0"]); + assert!((cli.min_quality_score.unwrap() - 80.0).abs() < f64::EPSILON); +} + +#[test] +fn test_check_quality_gates_passes() { + let cli = Cli::parse_from(["test", "--min-quality-score", "50.0"]); + let mut summary = crate::report::Summary { + total: 10, + iosp_score: 1.0, + ..Default::default() + }; + summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); + assert!(check_quality_gates(&cli, &summary).is_ok()); +} + +#[test] +fn test_check_min_quality_score_below_threshold() { + let mut summary = crate::report::Summary { + total: 10, + ..Default::default() + }; + summary.quality_score = 0.5; + assert_eq!(check_min_quality_score(90.0, &summary), Err(1)); +} + +#[test] +fn test_check_min_quality_score_above_threshold() { + let mut summary = crate::report::Summary { + total: 10, + ..Default::default() + }; + summary.quality_score = 0.95; + assert!(check_min_quality_score(90.0, &summary).is_ok()); +} + +#[test] +fn test_check_quality_gates_below_threshold() { + let cli = Cli::parse_from(["test", "--min-quality-score", "90.0"]); + let summary = crate::report::Summary { + total: 10, + quality_score: 0.5, + ..Default::default() + }; + assert_eq!(check_quality_gates(&cli, &summary), Err(1)); +} + +#[test] +fn test_check_quality_gates_no_gate_set() { + let cli = Cli::parse_from(["test"]); + let summary = crate::report::Summary { + total: 10, + ..Default::default() + }; + assert!(check_quality_gates(&cli, &summary).is_ok()); +} + +#[test] +fn test_check_min_quality_score_exactly_at_threshold_passes() { + // The gate fails only *below* the floor; exactly at it passes. Pins the + // `actual < min_score` comparison against `<=` (which would reject 80==80). + let mut summary = crate::report::Summary { + total: 10, + ..Default::default() + }; + summary.quality_score = 0.8; // 80.0% after the percentage multiplier + assert!( + check_min_quality_score(80.0, &summary).is_ok(), + "score exactly at the floor must pass" + ); +} + +#[test] +fn test_apply_exit_gates_returns_err_on_findings() { + // End-to-end: a clean config + a summary carrying findings must make the + // composed gate stack return Err(1) (via check_default_fail). Pins + // `apply_exit_gates` against being replaced by `Ok(())`. + let cli = Cli::parse_from(["test"]); + let config = Config::default(); + let summary = crate::report::Summary { + total: 10, + violations: 3, + ..Default::default() + }; + assert_eq!(apply_exit_gates(&cli, &config, &summary), Err(1)); +} + +#[test] +fn test_suppression_ratio_warning_message_gating() { + // The pure message builder returns Some only when the ratio is exceeded and + // at least one function was analysed. The three rows pin every clause of the + // `!exceeded || total == 0` guard: delete-`!`, `||`→`&&`, and `==`→`!=`. + // (exceeded, total, expect_message) + let cases = [(true, 10, true), (false, 10, false), (true, 0, false)]; + for (exceeded, total, expect) in cases { + let summary = crate::report::Summary { + total, + all_suppressions: 4, + suppression_ratio_exceeded: exceeded, + ..Default::default() + }; + assert_eq!( + suppression_ratio_warning(&summary, 0.1).is_some(), + expect, + "exceeded={exceeded} total={total}" + ); + } +} + +#[test] +fn test_setup_config_missing_explicit_file_returns_exit_code_2() { + // An explicit `--config` path that doesn't exist flows through + // `load_explicit_config` → `report_config_error`, which prints to stderr + // and maps to exit code 2. Pins `report_config_error`'s `2` (vs 0/-1/1) and + // `load_explicit_config` against returning `Ok(Default::default())`. + let cli = Cli::parse_from(["test", "--config", "/no/such/rustqual.toml"]); + assert_eq!(crate::app::setup::setup_config(&cli).err(), Some(2)); +} + +#[test] +fn test_check_default_fail_with_findings() { + assert_eq!(check_default_fail(false, 5), Err(1)); +} + +#[test] +fn test_check_default_fail_no_fail_mode() { + assert!(check_default_fail(true, 5).is_ok()); +} + +#[test] +fn test_check_default_fail_no_findings() { + assert!(check_default_fail(false, 0).is_ok()); +} diff --git a/src/app/tests/metrics/counters.rs b/src/app/tests/metrics/counters.rs new file mode 100644 index 00000000..12d2d789 --- /dev/null +++ b/src/app/tests/metrics/counters.rs @@ -0,0 +1,296 @@ +//! Per-dimension warning/violation counters in `app::metrics`. Each fixture +//! puts a metric/warning exactly at a threshold (or splits suppressed vs not) +//! so the comparison / `||` / `!` mutations in the counting logic flip the +//! asserted total. +use super::*; +use crate::adapters::analyzers::coupling::{CouplingAnalysis, CouplingMetrics, ModuleGraph}; +use crate::config::sections::CouplingConfig; + +fn coupling_config() -> CouplingConfig { + CouplingConfig { + max_instability: 0.5, + max_fan_in: 5, + max_fan_out: 5, + ..CouplingConfig::default() + } +} + +fn metric(afferent: usize, efferent: usize, instability: f64) -> CouplingMetrics { + CouplingMetrics { + module_name: "m".to_string(), + afferent, + efferent, + instability, + incoming: vec![], + outgoing: vec![], + suppressed: false, + warning: false, + } +} + +fn coupling_warnings(metrics: Vec) -> usize { + let mut analysis = CouplingAnalysis { + metrics, + cycles: vec![], + sdp_violations: vec![], + graph: ModuleGraph::default(), + }; + let config = coupling_config(); + let mut summary = Summary::from_results(&[]); + count_coupling_warnings(Some(&mut analysis), &config, &mut summary); + summary.coupling_warnings +} + +#[test] +fn coupling_afferent_exactly_at_threshold_does_not_warn() { + // afferent == max_fan_in (5) is NOT over the threshold. Guards the + // `m.afferent > config.max_fan_in` comparison (`>` vs `>=`/`==`). + assert_eq!(coupling_warnings(vec![metric(5, 0, 0.0)]), 0); +} + +#[test] +fn coupling_afferent_above_threshold_warns() { + // afferent above the cap warns even though efferent is below it — guards the + // `|| m.efferent > max_fan_out` disjunction against becoming `&&`. + assert_eq!(coupling_warnings(vec![metric(6, 0, 0.0)]), 1); +} + +#[test] +fn coupling_efferent_exactly_at_threshold_does_not_warn() { + // efferent == max_fan_out (5) is NOT over the threshold. + assert_eq!(coupling_warnings(vec![metric(0, 5, 0.0)]), 0); +} + +#[test] +fn coupling_efferent_above_threshold_warns() { + assert_eq!(coupling_warnings(vec![metric(0, 6, 0.0)]), 1); +} + +#[test] +fn coupling_instability_exactly_at_threshold_does_not_warn() { + // instability == max_instability (0.5) is NOT over the threshold. Guards the + // `m.instability > config.max_instability` comparison. + assert_eq!(coupling_warnings(vec![metric(1, 0, 0.5)]), 0); +} + +#[test] +fn coupling_instability_above_threshold_warns() { + assert_eq!(coupling_warnings(vec![metric(1, 0, 0.6)]), 1); +} + +#[test] +fn compute_coupling_returns_some_when_enabled() { + // With coupling enabled (default), `compute_coupling` returns Some — guards + // the `!config.coupling.enabled` early-return. + let analysis = compute_coupling(&[], &crate::config::Config::default()); + assert!(analysis.is_some(), "coupling analysis runs when enabled"); +} + +#[test] +fn count_srp_warnings_counts_unsuppressed_struct_warnings() { + // Guards `count_srp_warnings` against being a no-op: one unsuppressed struct + // warning must surface as `summary.srp_struct_warnings == 1`. + let mut srp = make_srp(); + srp.struct_warnings + .push(crate::adapters::analyzers::srp::SrpWarning { + struct_name: "S".to_string(), + file: "test.rs".to_string(), + line: 1, + lcom4: 2, + field_count: 3, + method_count: 4, + fan_out: 1, + composite_score: 0.9, + clusters: vec![], + suppressed: false, + }); + let mut summary = Summary::from_results(&[]); + count_srp_warnings(Some(&srp), &mut summary); + assert_eq!(summary.srp_struct_warnings, 1); +} + +#[test] +fn count_sdp_violations_excludes_suppressed_with_distinct_counts() { + // Two suppressed + one unsuppressed → exactly 1 counted. Distinct counts + // (1 vs 2) so deleting the `!` (counting suppressed instead) is observable. + use crate::adapters::analyzers::coupling::sdp::SdpViolation; + let sdp = |suppressed: bool| SdpViolation { + from_module: "a".into(), + to_module: "b".into(), + from_instability: 0.2, + to_instability: 0.8, + suppressed, + }; + let analysis = CouplingAnalysis { + metrics: vec![], + cycles: vec![], + sdp_violations: vec![sdp(true), sdp(true), sdp(false)], + graph: ModuleGraph::default(), + }; + let config = CouplingConfig::default(); + let mut summary = Summary::from_results(&[]); + count_sdp_violations(Some(&analysis), &config, &mut summary); + assert_eq!( + summary.sdp_violations, 1, + "only the one unsuppressed violation counts" + ); +} + +// ── DRY finding counts + wildcard suppression window ────────── + +use crate::adapters::analyzers::dry::wildcards::WildcardImportWarning; +use crate::findings::Dimension; +use std::collections::HashMap; + +fn sups_at(line: usize, dim: Dimension) -> HashMap> { + [( + "test.rs".to_string(), + vec![Suppression { + line, + dimensions: vec![dim], + reason: None, + }], + )] + .into() +} + +fn wildcard_suppressed(w_line: usize, sup_line: usize, dim: Dimension) -> bool { + let mut warnings = vec![WildcardImportWarning { + file: "test.rs".to_string(), + line: w_line, + module_path: "crate::x::*".to_string(), + suppressed: false, + }]; + mark_wildcard_suppressions(&mut warnings, &sups_at(sup_line, dim)); + warnings[0].suppressed +} + +#[test] +fn wildcard_suppression_same_line_suppresses() { + // sup.line == w.line is within the window; guards the `sup.line <= w.line` + // bound (`<=` vs `>`). + assert!(wildcard_suppressed(5, 5, Dimension::Dry)); +} + +#[test] +fn wildcard_suppression_one_line_above_suppresses() { + // diff 1 == WILDCARD window; guards the `w.line - sup.line <= window` bound + // and the subtraction (a `/` would give 2/1=2 > 1, a `+` 2+1=3 > 1). + assert!(wildcard_suppressed(2, 1, Dimension::Dry)); +} + +#[test] +fn wildcard_suppression_two_lines_above_does_not_suppress() { + // diff 2 > window 1 → not suppressed. + assert!(!wildcard_suppressed(3, 1, Dimension::Dry)); +} + +#[test] +fn wildcard_suppression_below_warning_does_not_suppress() { + // A suppression *below* the warning must not apply; guards the first `&&` + // (an `||` would evaluate `w.line - sup.line` and underflow, or wrongly + // suppress). + assert!(!wildcard_suppressed(2, 5, Dimension::Dry)); +} + +#[test] +fn wildcard_suppression_wrong_dimension_does_not_suppress() { + // In-window but covering a different dimension → not suppressed; guards the + // `&& sup.covers(dry_dim)` conjunction. + assert!(!wildcard_suppressed(5, 5, Dimension::Complexity)); +} + +fn one_entry_dup(suppressed: bool) -> DuplicateGroup { + DuplicateGroup { + entries: vec![DuplicateEntry { + name: "a".into(), + qualified_name: "a".into(), + file: "test.rs".into(), + line: 1, + }], + kind: DuplicateKind::Exact, + suppressed, + } +} + +fn one_entry_frag(suppressed: bool) -> FragmentGroup { + FragmentGroup { + entries: vec![FragmentEntry { + function_name: "f".into(), + qualified_name: "f".into(), + file: "test.rs".into(), + start_line: 1, + end_line: 3, + }], + statement_count: 3, + suppressed, + } +} + +fn one_bp(suppressed: bool) -> BoilerplateFind { + BoilerplateFind { + pattern_id: "BP-001".into(), + file: "test.rs".into(), + line: 1, + struct_name: None, + description: String::new(), + suggestion: String::new(), + suppressed, + } +} + +fn one_wildcard(suppressed: bool) -> WildcardImportWarning { + WildcardImportWarning { + file: "test.rs".into(), + line: 1, + module_path: "crate::x::*".into(), + suppressed, + } +} + +fn one_entry_rep(suppressed: bool) -> RepeatedMatchGroup { + RepeatedMatchGroup { + enum_name: "E".into(), + entries: vec![RepeatedMatchEntry { + file: "test.rs".into(), + line: 1, + function_name: "h".into(), + arm_count: 4, + }], + suppressed, + } +} + +#[test] +fn count_dry_findings_counts_only_unsuppressed() { + // Each DRY vector has 2 unsuppressed + 1 suppressed; the summary must report + // 2 (not 1, not 0). Guards the `!g.suppressed` filters and the function + // against being a no-op. + let dry = DryResults { + duplicates: vec![ + one_entry_dup(false), + one_entry_dup(false), + one_entry_dup(true), + ], + dead_code: vec![], + fragments: vec![ + one_entry_frag(false), + one_entry_frag(false), + one_entry_frag(true), + ], + boilerplate: vec![one_bp(false), one_bp(false), one_bp(true)], + wildcard_warnings: vec![one_wildcard(false), one_wildcard(false), one_wildcard(true)], + }; + let repeated = vec![ + one_entry_rep(false), + one_entry_rep(false), + one_entry_rep(true), + ]; + let mut summary = Summary::from_results(&[]); + count_dry_findings(&dry, &repeated, &mut summary); + assert_eq!(summary.duplicate_groups, 2, "duplicates"); + assert_eq!(summary.fragment_groups, 2, "fragments"); + assert_eq!(summary.boilerplate_warnings, 2, "boilerplate"); + assert_eq!(summary.wildcard_import_warnings, 2, "wildcards"); + assert_eq!(summary.repeated_match_groups, 2, "repeated matches"); +} diff --git a/src/app/tests/metrics/dry_detection.rs b/src/app/tests/metrics/dry_detection.rs new file mode 100644 index 00000000..2d4c59ee --- /dev/null +++ b/src/app/tests/metrics/dry_detection.rs @@ -0,0 +1,56 @@ +//! `run_dry_detection` per-detector enable guards. Each closure has an inner +//! `if !config. { return vec![]; }` short-circuit; deleting the `!` would +//! run the detector when the flag is off. +use super::*; + +fn parse(code: &str) -> Vec<(String, String, syn::File)> { + vec![( + "test.rs".to_string(), + code.to_string(), + syn::parse_file(code).expect("parse failed"), + )] +} + +fn run_dry(config: &crate::config::Config, code: &str) -> DryResults { + let parsed = parse(code); + let sups = std::collections::HashMap::new(); + let api = std::collections::HashMap::new(); + let test_helper = std::collections::HashMap::new(); + let annotation_lines = AnnotationLines { + api: &api, + test_helper: &test_helper, + }; + let cfg_test_files = std::collections::HashSet::new(); + run_dry_detection(&parsed, config, &sups, &annotation_lines, &cfg_test_files) +} + +#[test] +fn dead_code_detection_skipped_when_disabled() { + // With `detect_dead_code = false` an uncalled fn must NOT be reported; + // guards the `if !c.duplicates.detect_dead_code` short-circuit. + let mut config = crate::config::Config::default(); + config.duplicates.detect_dead_code = false; + config.compile(); + let dry = run_dry(&config, "fn unused() { let _ = 1; }"); + assert!( + dry.dead_code.is_empty(), + "no dead-code warnings when detect_dead_code is off, got {:?}", + dry.dead_code + ); +} + +#[test] +fn wildcard_detection_skipped_when_duplicates_disabled() { + // `detect_wildcard_imports` stays on but `duplicates.enabled = false`, so the + // wildcard closure's `if !c.duplicates.enabled` must short-circuit to empty; + // guards that `!`. + let mut config = crate::config::Config::default(); + config.duplicates.enabled = false; + config.compile(); + let dry = run_dry(&config, "use crate::foo::*;"); + assert!( + dry.wildcard_warnings.is_empty(), + "no wildcard warnings when duplicates is disabled, got {:?}", + dry.wildcard_warnings + ); +} diff --git a/src/app/tests/metrics/mod.rs b/src/app/tests/metrics/mod.rs index 2caa2b79..61a0a2a4 100644 --- a/src/app/tests/metrics/mod.rs +++ b/src/app/tests/metrics/mod.rs @@ -21,7 +21,10 @@ pub(super) use crate::config::sections::SrpConfig; pub(super) use crate::findings::Suppression; pub(super) use crate::report::Summary; +mod counters; +mod dry_detection; mod param_warnings; +mod srp_suppression; mod suppression; pub(super) fn make_func(name: &str, param_count: usize, trait_impl: bool) -> FunctionAnalysis { diff --git a/src/app/tests/metrics/srp_suppression.rs b/src/app/tests/metrics/srp_suppression.rs new file mode 100644 index 00000000..b10fcbec --- /dev/null +++ b/src/app/tests/metrics/srp_suppression.rs @@ -0,0 +1,87 @@ +//! `mark_srp_suppressions` proximity window (SRP_STRUCT_PARAM = 5). Struct and +//! param warnings share the same `sup.line <= w.line && w.line - sup.line <= +//! WINDOW && sup.covers(srp)` logic; the cases below put a suppression at each +//! boundary so the `&&` / `-` / comparison mutations flip the verdict. +use super::*; +use crate::adapters::analyzers::srp::{ParamSrpWarning, SrpWarning}; +use crate::findings::Dimension; +use std::collections::HashMap; + +fn srp_sups(line: usize, dim: Dimension) -> HashMap> { + [( + "test.rs".to_string(), + vec![Suppression { + line, + dimensions: vec![dim], + reason: None, + }], + )] + .into() +} + +fn struct_warning(line: usize) -> SrpWarning { + SrpWarning { + struct_name: "S".to_string(), + file: "test.rs".to_string(), + line, + lcom4: 2, + field_count: 3, + method_count: 4, + fan_out: 1, + composite_score: 0.9, + clusters: vec![], + suppressed: false, + } +} + +fn srp_struct_suppressed(w_line: usize, sup_line: usize, dim: Dimension) -> bool { + let mut srp = make_srp(); + srp.struct_warnings.push(struct_warning(w_line)); + mark_srp_suppressions(Some(&mut srp), &srp_sups(sup_line, dim)); + srp.struct_warnings[0].suppressed +} + +fn srp_param_suppressed(w_line: usize, sup_line: usize, dim: Dimension) -> bool { + let mut srp = make_srp(); + srp.param_warnings.push(ParamSrpWarning { + function_name: "f".to_string(), + file: "test.rs".to_string(), + line: w_line, + parameter_count: 6, + suppressed: false, + }); + mark_srp_suppressions(Some(&mut srp), &srp_sups(sup_line, dim)); + srp.param_warnings[0].suppressed +} + +/// `(warning_line, suppression_line, dimension, expected_suppressed)`. +const WINDOW_CASES: &[(usize, usize, Dimension, bool)] = &[ + (5, 5, Dimension::Srp, true), // same line — in window + (6, 1, Dimension::Srp, true), // diff 5 == window + (7, 1, Dimension::Srp, false), // diff 6 > window + (5, 5, Dimension::Complexity, false), // in window but wrong dimension + (10, 2, Dimension::Srp, false), // diff 8 > window (kills `-`→`/`: 10/2=5≤5) + (2, 5, Dimension::Srp, false), // suppression below the warning +]; + +#[test] +fn srp_struct_suppression_respects_window_and_dimension() { + for &(w, sup, dim, exp) in WINDOW_CASES { + assert_eq!( + srp_struct_suppressed(w, sup, dim), + exp, + "struct w={w} sup={sup} dim={dim:?}" + ); + } +} + +#[test] +fn srp_param_suppression_respects_window_and_dimension() { + for &(w, sup, dim, exp) in WINDOW_CASES { + assert_eq!( + srp_param_suppressed(w, sup, dim), + exp, + "param w={w} sup={sup} dim={dim:?}" + ); + } +} diff --git a/src/app/tests/metrics/suppression.rs b/src/app/tests/metrics/suppression.rs index a04e6ae1..b15be876 100644 --- a/src/app/tests/metrics/suppression.rs +++ b/src/app/tests/metrics/suppression.rs @@ -125,6 +125,89 @@ fn test_inverse_annotation_suppresses_duplicate() { ); } +#[test] +fn dry_suppression_must_cover_the_dry_dimension() { + // A marker in the line window but covering a *different* dimension must not + // suppress a DRY group. Pins the `is_within_window && covers(dry)` filter + // against `&&`→`||` (which would suppress on window alone). + use crate::adapters::analyzers::dry::functions::{ + DuplicateEntry, DuplicateGroup, DuplicateKind, + }; + let mut groups = vec![DuplicateGroup { + entries: vec![DuplicateEntry { + name: "foo".into(), + qualified_name: "foo".into(), + file: "test.rs".into(), + line: 5, + }], + kind: DuplicateKind::Exact, + suppressed: false, + }]; + // Marker on line 4 (in window of entry line 5) but covering Complexity. + let sups: std::collections::HashMap> = [( + "test.rs".to_string(), + vec![Suppression { + line: 4, + dimensions: vec![crate::findings::Dimension::Complexity], + reason: None, + }], + )] + .into(); + mark_dry_suppressions(&mut groups, &sups); + assert!( + !groups[0].suppressed, + "an in-window marker for another dimension must not suppress DRY" + ); +} + +/// Build a single near-duplicate group `[as_str@as_line, parse@15]` and mark it +/// against a `qual:inverse(parse)` annotation at `inv_line`. +fn inverse_suppressed(inv_line: usize, as_line: usize) -> bool { + use crate::adapters::analyzers::dry::functions::{ + DuplicateEntry, DuplicateGroup, DuplicateKind, + }; + let mut groups = vec![DuplicateGroup { + entries: vec![ + DuplicateEntry { + name: "as_str".into(), + qualified_name: "Foo::as_str".into(), + file: "test.rs".into(), + line: as_line, + }, + DuplicateEntry { + name: "parse".into(), + qualified_name: "Foo::parse".into(), + file: "test.rs".into(), + line: 15, + }, + ], + kind: DuplicateKind::NearDuplicate { similarity: 0.91 }, + suppressed: false, + }]; + let inverse_lines: std::collections::HashMap> = + [("test.rs".to_string(), vec![(inv_line, "parse".to_string())])].into(); + mark_inverse_suppressions(&mut groups, &inverse_lines); + groups[0].suppressed +} + +#[test] +fn inverse_suppression_window_boundaries() { + // The inverse window is `line <= entry.line && entry.line - line <= WINDOW` + // (WINDOW = 3). Annotation at line 1: + // - entry at line 4 → diff exactly 3 → suppressed (pins `<=`→`>` and the + // `entry.line - line` subtraction against `-`→`/`: 4/1=4 > 3). + // - entry at line 10 → diff 9 → not suppressed (pins `&&`→`||`, which would + // suppress on the `line <= entry.line` half alone). + assert!( + inverse_suppressed(1, 4), + "inverse pair at the window edge (diff 3) is suppressed" + ); + assert!( + !inverse_suppressed(1, 10), + "inverse pair outside the window (diff 9) is not suppressed" + ); +} + #[test] fn test_inverse_annotation_must_target_group_member() { use crate::adapters::analyzers::dry::functions::{ diff --git a/src/app/tests/mod.rs b/src/app/tests/mod.rs index df0d7372..e77816b8 100644 --- a/src/app/tests/mod.rs +++ b/src/app/tests/mod.rs @@ -1,5 +1,29 @@ mod analyze_codebase; +mod architecture; +mod gates; mod metrics; mod pipeline; +mod projection; +mod projection_secondary; mod run; +mod structural_metrics; +mod tq_metrics; mod warnings; + +/// One `test.rs` suppression at `line` covering `dim`. Shared by the per-pass +/// suppression-window tests (each pass's `mark_*_suppressions` is itself a +/// near-clone of the others). +pub(super) fn one_suppression( + line: usize, + dim: crate::findings::Dimension, +) -> std::collections::HashMap> { + [( + "test.rs".to_string(), + vec![crate::findings::Suppression { + line, + dimensions: vec![dim], + reason: None, + }], + )] + .into() +} diff --git a/src/app/tests/pipeline.rs b/src/app/tests/pipeline.rs index d72a9198..766fa15d 100644 --- a/src/app/tests/pipeline.rs +++ b/src/app/tests/pipeline.rs @@ -3,7 +3,7 @@ use crate::adapters::source::filesystem::{ collect_filtered_files, collect_rust_files, collect_suppression_lines, read_and_parse_files, }; use crate::app::metrics::{count_coupling_warnings, mark_coupling_suppressions}; -use crate::app::pipeline::{output_results, run_analysis}; +use crate::app::pipeline::{analyze_and_output, output_results, run_analysis}; use crate::app::warnings::{check_suppression_ratio, count_all_suppressions}; use crate::config::Config; use crate::findings::Suppression; @@ -705,3 +705,31 @@ fn test_run_analysis_findings_architecture_field_present() { assert!(analysis.findings.architecture.is_empty()); let _len: usize = analysis.findings.architecture.len(); } + +#[test] +fn test_analyze_and_output_returns_analyzed_functions() { + // `analyze_and_output` orchestrates collect → parse → analyze → print and + // returns the `AnalysisResult` it printed. Asserting the returned analysis + // contains the fixture's functions pins the orchestration against being + // replaced by a no-op (the four delegated calls being skipped). + let tmp = test_dir(); + fs::write( + tmp.path().join("lib.rs"), + "fn alpha() {}\nfn beta() { alpha(); }\n", + ) + .unwrap(); + let mut config = Config::default(); + config.compile(); + let analysis = analyze_and_output( + tmp.path(), + &config, + &crate::cli::OutputFormat::Text, + false, + false, + ); + assert!( + analysis.results.iter().any(|f| f.name == "alpha"), + "returned analysis must carry the fixture's functions, got {:?}", + analysis.results.iter().map(|f| &f.name).collect::>() + ); +} diff --git a/src/app/tests/projection.rs b/src/app/tests/projection.rs new file mode 100644 index 00000000..e2e95910 --- /dev/null +++ b/src/app/tests/projection.rs @@ -0,0 +1,101 @@ +//! `app::projection` — analysis structs → typed domain findings. The flag/field +//! mutations (`fn → vec![]`, dropped arms, count arithmetic, dimension `==`) are +//! observed by asserting the projected findings. +use crate::adapters::analyzers::iosp::{ + ComplexityHotspot, ComplexityMetrics, FunctionAnalysis, MagicNumberOccurrence, +}; +use crate::app::projection::{project_architecture, project_complexity}; +use crate::config::Config; +use crate::domain::findings::ComplexityFindingKind; +use crate::domain::{Dimension, Finding}; + +fn func(metrics: ComplexityMetrics) -> FunctionAnalysis { + super::warnings::make_func_with_metrics(metrics) +} + +#[test] +fn project_complexity_emits_cognitive_finding() { + // Guards `push_metric_threshold` against being a no-op. + let mut f = func(ComplexityMetrics { + cognitive_complexity: 10, + ..Default::default() + }); + f.cognitive_warning = true; + let findings = project_complexity(&[f], &Config::default()); + assert!(findings + .iter() + .any(|x| matches!(x.kind, ComplexityFindingKind::Cognitive) && x.metric_value == 10)); +} + +#[test] +fn project_complexity_error_handling_sums_all_counts() { + // metric_value = unwrap + expect + panic + todo = 4; guards `error_handling_count` + // (the `+` arithmetic and the `-> 0`/`-> 1` replacements). + let mut f = func(ComplexityMetrics { + unwrap_count: 1, + expect_count: 1, + panic_count: 1, + todo_count: 1, + ..Default::default() + }); + f.error_handling_warning = true; + let findings = project_complexity(&[f], &Config::default()); + let eh = findings + .iter() + .find(|x| matches!(x.kind, ComplexityFindingKind::ErrorHandling)) + .expect("error-handling finding"); + assert_eq!(eh.metric_value, 4, "1 + 1 + 1 + 1"); +} + +#[test] +fn project_complexity_nesting_carries_hotspot() { + // Guards `nesting_hotspot` against returning None. + let mut f = func(ComplexityMetrics { + max_nesting: 5, + hotspots: vec![ComplexityHotspot { + line: 3, + nesting_depth: 5, + construct: "if".to_string(), + }], + ..Default::default() + }); + f.nesting_depth_warning = true; + let findings = project_complexity(&[f], &Config::default()); + let nd = findings + .iter() + .find(|x| matches!(x.kind, ComplexityFindingKind::NestingDepth)) + .expect("nesting finding"); + assert!(nd.hotspot.is_some(), "nesting finding carries its hotspot"); +} + +#[test] +fn project_complexity_emits_magic_number_findings() { + // Guards `push_magic_number_findings` against being a no-op. + let f = func(ComplexityMetrics { + magic_numbers: vec![MagicNumberOccurrence { + line: 1, + value: "42".to_string(), + }], + ..Default::default() + }); + let findings = project_complexity(&[f], &Config::default()); + assert!(findings + .iter() + .any(|x| matches!(x.kind, ComplexityFindingKind::MagicNumber))); +} + +#[test] +fn project_architecture_wraps_each_legacy_finding() { + // Guards `project_architecture` against returning an empty vec. + let legacy = vec![Finding { + dimension: Dimension::Architecture, + rule_id: "architecture/forbidden_edge".to_string(), + ..Default::default() + }]; + let findings = project_architecture(&legacy); + assert_eq!( + findings.len(), + 1, + "each legacy finding becomes one ArchitectureFinding" + ); +} diff --git a/src/app/tests/projection_secondary.rs b/src/app/tests/projection_secondary.rs new file mode 100644 index 00000000..ef83ff44 --- /dev/null +++ b/src/app/tests/projection_secondary.rs @@ -0,0 +1,189 @@ +//! `app::projection` for the secondary passes (coupling, SRP, structural, +//! data, DRY). Pins the filter predicates (`warning && !suppressed`, the +//! `dimension ==` selectors), the structural rule-id prefix (`srp`/`coupling` +//! match arms), and the per-group projection helpers against `-> vec![]`. +use crate::adapters::analyzers::coupling::{CouplingAnalysis, CouplingMetrics}; +use crate::adapters::analyzers::dry::fragments::{FragmentEntry, FragmentGroup}; +use crate::adapters::analyzers::dry::match_patterns::{RepeatedMatchEntry, RepeatedMatchGroup}; +use crate::adapters::analyzers::structural::{ + StructuralAnalysis, StructuralWarning, StructuralWarningKind, +}; +use crate::app::projection::{project_coupling, project_data, project_dry, project_srp}; +use crate::app::secondary::SecondaryResults; +use crate::domain::findings::{CouplingFindingKind, DryFindingKind, SrpFindingKind}; +use crate::findings::Dimension; + +fn metric(name: &str, warning: bool, suppressed: bool) -> CouplingMetrics { + CouplingMetrics { + module_name: name.into(), + afferent: 1, + efferent: 9, + instability: 0.9, + incoming: vec![], + outgoing: vec![], + suppressed, + warning, + } +} + +fn coupling_with(metrics: Vec) -> CouplingAnalysis { + CouplingAnalysis { + metrics, + cycles: vec![], + sdp_violations: vec![], + graph: Default::default(), + } +} + +fn structural_warning(dim: Dimension, kind: StructuralWarningKind) -> StructuralAnalysis { + StructuralAnalysis { + warnings: vec![StructuralWarning { + file: "src/x.rs".into(), + line: 10, + name: "Foo".into(), + kind, + dimension: dim, + suppressed: false, + }], + } +} + +#[test] +fn project_coupling_threshold_filter_is_warning_and_not_suppressed() { + // Only a metric that is `warning && !suppressed` becomes a ThresholdExceeded + // finding. A second, non-warning metric must be dropped — pinning the + // `warning && !suppressed` filter (`&&`→`||` would admit it, deleting `!` + // would reject the live one). + let coupling = coupling_with(vec![ + metric("live", true, false), + metric("quiet", false, false), + ]); + let breaches = project_coupling(Some(&coupling), None) + .into_iter() + .filter(|f| matches!(f.kind, CouplingFindingKind::ThresholdExceeded)) + .count(); + assert_eq!( + breaches, 1, + "only the warning, unsuppressed metric breaches" + ); +} + +#[test] +fn project_coupling_takes_only_coupling_dimension_structural_warnings() { + // A structural warning carrying `dimension == Coupling` projects into a + // Structural coupling finding with a `coupling/structural/...` rule id. + // Pins the `w.dimension == Coupling` selector and the `Coupling` match arm + // in `structural_pieces`. + let structural = structural_warning( + Dimension::Coupling, + StructuralWarningKind::DowncastEscapeHatch, + ); + let findings = project_coupling(None, Some(&structural)); + let s = findings + .iter() + .find(|f| matches!(f.kind, CouplingFindingKind::Structural)) + .expect("structural coupling finding"); + assert!( + s.common.rule_id.starts_with("coupling/structural/"), + "rule_id keyed by the Coupling arm, got {}", + s.common.rule_id + ); +} + +#[test] +fn project_srp_takes_only_srp_dimension_structural_warnings() { + // Mirror for SRP: a `dimension == Srp` structural warning projects into a + // Structural SRP finding with a `srp/structural/...` rule id. Pins the + // `w.dimension == Srp` selector and the `Srp` match arm. + let structural = structural_warning(Dimension::Srp, StructuralWarningKind::SelflessMethod); + let findings = project_srp(None, Some(&structural)); + let s = findings + .iter() + .find(|f| matches!(f.kind, SrpFindingKind::Structural)) + .expect("structural srp finding"); + assert!( + s.common.rule_id.starts_with("srp/structural/"), + "rule_id keyed by the Srp arm, got {}", + s.common.rule_id + ); +} + +#[test] +fn project_data_emits_one_module_record_per_metric() { + // Guards `project_modules` against `-> vec![]`. + let coupling = coupling_with(vec![metric("m", true, false)]); + let data = project_data(&[], Some(&coupling)); + assert_eq!(data.modules.len(), 1, "one ModuleCouplingRecord per metric"); +} + +fn empty_secondary() -> SecondaryResults { + SecondaryResults { + coupling: None, + duplicates: vec![], + dead_code: vec![], + fragments: vec![], + boilerplate: vec![], + wildcard_warnings: vec![], + repeated_matches: vec![], + srp: None, + tq: None, + structural: None, + } +} + +#[test] +fn project_dry_emits_fragment_and_repeated_match_findings() { + // Guards `project_fragment_group` and `project_repeated_match_group` against + // `-> vec![]`. A fragment group with two entries and a repeated-match group + // with two entries each project one finding per entry. + let mut secondary = empty_secondary(); + secondary.fragments = vec![FragmentGroup { + entries: vec![ + FragmentEntry { + function_name: "a".into(), + qualified_name: "m::a".into(), + file: "src/x.rs".into(), + start_line: 1, + end_line: 8, + }, + FragmentEntry { + function_name: "b".into(), + qualified_name: "m::b".into(), + file: "src/x.rs".into(), + start_line: 20, + end_line: 27, + }, + ], + statement_count: 6, + suppressed: false, + }]; + secondary.repeated_matches = vec![RepeatedMatchGroup { + enum_name: "E".into(), + entries: vec![ + RepeatedMatchEntry { + file: "src/x.rs".into(), + line: 3, + function_name: "f".into(), + arm_count: 4, + }, + RepeatedMatchEntry { + file: "src/x.rs".into(), + line: 40, + function_name: "g".into(), + arm_count: 4, + }, + ], + suppressed: false, + }]; + let findings = project_dry(&secondary); + let fragments = findings + .iter() + .filter(|f| matches!(f.kind, DryFindingKind::Fragment)) + .count(); + let repeated = findings + .iter() + .filter(|f| matches!(f.kind, DryFindingKind::RepeatedMatch)) + .count(); + assert_eq!(fragments, 2, "one fragment finding per entry"); + assert_eq!(repeated, 2, "one repeated-match finding per entry"); +} diff --git a/src/app/tests/run.rs b/src/app/tests/run.rs index 78d501f6..9ac80a2c 100644 --- a/src/app/tests/run.rs +++ b/src/app/tests/run.rs @@ -1,6 +1,3 @@ -use crate::app::exit_gates::{ - check_default_fail, check_fail_on_warnings, check_min_quality_score, check_quality_gates, -}; use crate::app::setup::apply_cli_overrides; use crate::cli::{Cli, OutputFormat}; use crate::config::{self, Config}; @@ -150,116 +147,6 @@ fn test_fail_on_warnings_config_default() { assert!(!config.fail_on_warnings); } -// ── Gate function tests (Result-based) ───────────────────── - -#[test] -fn test_check_fail_on_warnings_passes_when_no_warnings() { - let mut config = Config::default(); - config.fail_on_warnings = true; - let summary = crate::report::Summary { - total: 10, - ..Default::default() - }; - assert!(check_fail_on_warnings(&config, &summary).is_ok()); -} - -#[test] -fn test_check_fail_on_warnings_passes_when_disabled() { - let config = Config::default(); // fail_on_warnings = false - let summary = crate::report::Summary { - total: 10, - suppression_ratio_exceeded: true, - ..Default::default() - }; - assert!(check_fail_on_warnings(&config, &summary).is_ok()); -} - -#[test] -fn test_check_fail_on_warnings_exits_when_triggered() { - let mut config = Config::default(); - config.fail_on_warnings = true; - let summary = crate::report::Summary { - total: 10, - suppression_ratio_exceeded: true, - ..Default::default() - }; - assert_eq!(check_fail_on_warnings(&config, &summary), Err(1)); -} - -#[test] -fn test_min_quality_score_cli_parse() { - let cli = Cli::parse_from(["test", "--min-quality-score", "80.0"]); - assert!((cli.min_quality_score.unwrap() - 80.0).abs() < f64::EPSILON); -} - -#[test] -fn test_check_quality_gates_passes() { - let cli = Cli::parse_from(["test", "--min-quality-score", "50.0"]); - let mut summary = crate::report::Summary { - total: 10, - iosp_score: 1.0, - ..Default::default() - }; - summary.compute_quality_score(&crate::config::sections::DEFAULT_QUALITY_WEIGHTS); - assert!(check_quality_gates(&cli, &summary).is_ok()); -} - -#[test] -fn test_check_min_quality_score_below_threshold() { - let mut summary = crate::report::Summary { - total: 10, - ..Default::default() - }; - summary.quality_score = 0.5; - assert_eq!(check_min_quality_score(90.0, &summary), Err(1)); -} - -#[test] -fn test_check_min_quality_score_above_threshold() { - let mut summary = crate::report::Summary { - total: 10, - ..Default::default() - }; - summary.quality_score = 0.95; - assert!(check_min_quality_score(90.0, &summary).is_ok()); -} - -#[test] -fn test_check_quality_gates_below_threshold() { - let cli = Cli::parse_from(["test", "--min-quality-score", "90.0"]); - let summary = crate::report::Summary { - total: 10, - quality_score: 0.5, - ..Default::default() - }; - assert_eq!(check_quality_gates(&cli, &summary), Err(1)); -} - -#[test] -fn test_check_quality_gates_no_gate_set() { - let cli = Cli::parse_from(["test"]); - let summary = crate::report::Summary { - total: 10, - ..Default::default() - }; - assert!(check_quality_gates(&cli, &summary).is_ok()); -} - -#[test] -fn test_check_default_fail_with_findings() { - assert_eq!(check_default_fail(false, 5), Err(1)); -} - -#[test] -fn test_check_default_fail_no_fail_mode() { - assert!(check_default_fail(true, 5).is_ok()); -} - -#[test] -fn test_check_default_fail_no_findings() { - assert!(check_default_fail(false, 0).is_ok()); -} - #[test] fn test_determine_output_format_explicit() { let cli = Cli::parse_from(["test", "--format", "json"]); diff --git a/src/app/tests/structural_metrics.rs b/src/app/tests/structural_metrics.rs new file mode 100644 index 00000000..1eb8403b --- /dev/null +++ b/src/app/tests/structural_metrics.rs @@ -0,0 +1,72 @@ +//! `app::structural_metrics` — enable guard, suppression window (STRUCTURAL = 5) +//! and per-dimension warning counting. +use crate::adapters::analyzers::structural::{ + StructuralAnalysis, StructuralWarning, StructuralWarningKind, +}; +use crate::app::structural_metrics::*; +use crate::config::Config; +use crate::findings::Dimension; +use crate::report::Summary; + +fn warning(line: usize, dim: Dimension, suppressed: bool) -> StructuralWarning { + StructuralWarning { + file: "test.rs".to_string(), + line, + name: "m".to_string(), + kind: StructuralWarningKind::SelflessMethod, + dimension: dim, + suppressed, + } +} + +#[test] +fn compute_structural_returns_some_when_enabled() { + // Guards the `!config.structural.enabled` early-return. + assert!(compute_structural(&[], &Config::default()).is_some()); +} + +fn struct_suppressed(w_line: usize, sup_line: usize, w_dim: Dimension, sup_dim: Dimension) -> bool { + let mut analysis = StructuralAnalysis { + warnings: vec![warning(w_line, w_dim, false)], + }; + let sups = super::one_suppression(sup_line, sup_dim); + mark_structural_suppressions(Some(&mut analysis), &sups); + analysis.warnings[0].suppressed +} + +#[test] +fn structural_suppression_window_and_dimension() { + let s = Dimension::Srp; + // same line, in window + assert!(struct_suppressed(5, 5, s, s)); + // diff 5 == STRUCTURAL window + assert!(struct_suppressed(6, 1, s, s)); + // diff 6 > window + assert!(!struct_suppressed(7, 1, s, s)); + // in window but covers a different dimension (kills the `&& covers`) + assert!(!struct_suppressed(5, 5, s, Dimension::Complexity)); + // diff 8 > window — kills `w.line - sup.line` `-`→`/` (10/2=5 ≤ 5) + assert!(!struct_suppressed(10, 2, s, s)); + // suppression below the warning (kills the leading `&&` / underflow) + assert!(!struct_suppressed(2, 5, s, s)); +} + +#[test] +fn count_structural_warnings_splits_by_dimension() { + // SRP: 2 unsuppressed + 1 suppressed → 2. Coupling: 1 unsuppressed + 1 + // suppressed → 1. Distinct counts pin the `!suppressed` filter, both match + // arms and their `+= 1`, and the function against being a no-op. + let analysis = StructuralAnalysis { + warnings: vec![ + warning(1, Dimension::Srp, false), + warning(2, Dimension::Srp, false), + warning(3, Dimension::Srp, true), + warning(4, Dimension::Coupling, false), + warning(5, Dimension::Coupling, true), + ], + }; + let mut summary = Summary::from_results(&[]); + count_structural_warnings(Some(&analysis), &mut summary); + assert_eq!(summary.structural_srp_warnings, 2); + assert_eq!(summary.structural_coupling_warnings, 1); +} diff --git a/src/app/tests/tq_metrics.rs b/src/app/tests/tq_metrics.rs new file mode 100644 index 00000000..93c22abb --- /dev/null +++ b/src/app/tests/tq_metrics.rs @@ -0,0 +1,63 @@ +//! `app::tq_metrics` — suppression window (TQ = 5) and per-kind warning counting. +use crate::adapters::analyzers::tq::{TqAnalysis, TqWarning, TqWarningKind}; +use crate::app::tq_metrics::*; +use crate::findings::Dimension; +use crate::report::Summary; + +fn warning(line: usize, kind: TqWarningKind, suppressed: bool) -> TqWarning { + TqWarning { + file: "test.rs".to_string(), + line, + function_name: "t".to_string(), + kind, + suppressed, + } +} + +fn tq_suppressed(w_line: usize, sup_line: usize, dim: Dimension) -> bool { + let mut tq = TqAnalysis { + warnings: vec![warning(w_line, TqWarningKind::NoAssertion, false)], + }; + let sups = super::one_suppression(sup_line, dim); + mark_tq_suppressions(Some(&mut tq), &sups); + tq.warnings[0].suppressed +} + +#[test] +fn tq_suppression_window_and_dimension() { + let t = Dimension::TestQuality; + assert!(tq_suppressed(5, 5, t)); // same line + assert!(tq_suppressed(6, 1, t)); // diff 5 == TQ window + assert!(!tq_suppressed(7, 1, t)); // diff 6 > window + assert!(!tq_suppressed(5, 5, Dimension::Complexity)); // wrong dimension + assert!(!tq_suppressed(10, 2, t)); // diff 8 > window (kills `-`→`/`: 10/2=5≤5) + assert!(!tq_suppressed(2, 5, t)); // below the warning +} + +#[test] +fn count_tq_warnings_splits_by_kind() { + // One unsuppressed warning of each kind → each summary counter is 1. Pins + // the per-kind `+= 1` (a `*=`/`-=` would give 0) and the no-op mutant. + let tq = TqAnalysis { + warnings: vec![ + warning(1, TqWarningKind::NoAssertion, false), + warning(2, TqWarningKind::NoSut, false), + warning(3, TqWarningKind::Untested, false), + warning(4, TqWarningKind::Uncovered, false), + warning( + 5, + TqWarningKind::UntestedLogic { + uncovered_lines: vec![("test.rs".to_string(), 5)], + }, + false, + ), + ], + }; + let mut summary = Summary::from_results(&[]); + count_tq_warnings(Some(&tq), &mut summary); + assert_eq!(summary.tq_no_assertion_warnings, 1); + assert_eq!(summary.tq_no_sut_warnings, 1); + assert_eq!(summary.tq_untested_warnings, 1); + assert_eq!(summary.tq_uncovered_warnings, 1); + assert_eq!(summary.tq_untested_logic_warnings, 1); +} diff --git a/src/app/tests/warnings/complexity_flags.rs b/src/app/tests/warnings/complexity_flags.rs new file mode 100644 index 00000000..52aa48c8 --- /dev/null +++ b/src/app/tests/warnings/complexity_flags.rs @@ -0,0 +1,96 @@ +//! `apply_complexity_warnings` threshold flags. Metrics are placed exactly at +//! or one over `max_cognitive`/`max_cyclomatic` (both set to 5) so the `>` +//! comparisons, the `||` between them, and the `+=` counters all flip. +use super::*; +use crate::adapters::analyzers::iosp::MagicNumberOccurrence; + +fn cx_config(max_cognitive: usize, max_cyclomatic: usize) -> Config { + let mut c = Config::default(); + c.complexity.max_cognitive = max_cognitive; + c.complexity.max_cyclomatic = max_cyclomatic; + c +} + +/// `(cognitive_warning, cyclomatic_warning, complexity_warnings, magic_warnings)`. +fn apply_cx(metrics: ComplexityMetrics, config: &Config) -> (bool, bool, usize, usize) { + let mut fa = make_func_with_metrics(metrics); + let mut summary = Summary::from_results(&[]); + apply_complexity_warnings(std::slice::from_mut(&mut fa), config, &mut summary); + ( + fa.cognitive_warning, + fa.cyclomatic_warning, + summary.complexity_warnings, + summary.magic_number_warnings, + ) +} + +#[test] +fn complexity_exactly_at_threshold_does_not_warn() { + // cognitive == max AND cyclomatic == max → neither over → no warning. + let m = ComplexityMetrics { + cognitive_complexity: 5, + cyclomatic_complexity: 5, + ..Default::default() + }; + assert_eq!(apply_cx(m, &cx_config(5, 5)), (false, false, 0, 0)); +} + +#[test] +fn cognitive_over_threshold_warns_alone() { + // cognitive over, cyclomatic at threshold → cognitive_warning only, counted + // once. Guards the `||` (an `&&` would need both over) and the `+= 1`. + let m = ComplexityMetrics { + cognitive_complexity: 6, + cyclomatic_complexity: 5, + ..Default::default() + }; + assert_eq!(apply_cx(m, &cx_config(5, 5)), (true, false, 1, 0)); +} + +#[test] +fn cyclomatic_over_threshold_warns_alone() { + let m = ComplexityMetrics { + cognitive_complexity: 5, + cyclomatic_complexity: 6, + ..Default::default() + }; + assert_eq!(apply_cx(m, &cx_config(5, 5)), (false, true, 1, 0)); +} + +#[test] +fn magic_numbers_are_summed() { + // A non-test function's magic numbers are added to the summary; guards the + // `magic_number_warnings += m.magic_numbers.len()`. + let m = ComplexityMetrics { + magic_numbers: vec![ + MagicNumberOccurrence { + line: 1, + value: "42".into(), + }, + MagicNumberOccurrence { + line: 2, + value: "7".into(), + }, + MagicNumberOccurrence { + line: 3, + value: "13".into(), + }, + ], + ..Default::default() + }; + assert_eq!(apply_cx(m, &cx_config(5, 5)).3, 3); +} + +#[test] +fn disabled_complexity_emits_no_warnings() { + // With complexity disabled the pass is a no-op even for wildly-over metrics; + // guards the `!config.complexity.enabled` early-return. + let mut config = cx_config(5, 5); + config.complexity.enabled = false; + let m = ComplexityMetrics { + cognitive_complexity: 99, + cyclomatic_complexity: 99, + ..Default::default() + }; + assert_eq!(apply_cx(m, &config), (false, false, 0, 0)); +} diff --git a/src/app/tests/warnings/exclude_and_error_handling.rs b/src/app/tests/warnings/exclude_and_error_handling.rs index 4e22d23c..f7f9172a 100644 --- a/src/app/tests/warnings/exclude_and_error_handling.rs +++ b/src/app/tests/warnings/exclude_and_error_handling.rs @@ -69,6 +69,26 @@ fn test_error_handling_flagged_for_non_test_fn() { assert_eq!(summary.error_handling_warnings, 1); } +#[test] +fn test_error_handling_flagged_for_lone_panic() { + // A non-test fn whose only error-handling signal is a `panic!` (unwrap = 0) + // is still flagged. With unwrap = 0 the `unwrap_count + panic_count` term in + // `has_error_handling_issue` is `0 + 1`; a `+`→`-` mutation underflows (usize + // panic) and a `+`→`*` collapses it to 0 — both caught by this assertion, + // complementing the unwrap-led case above. + let config = Config::default(); + let mut summary = Summary::default(); + let mut fa = make_func_with_metrics(ComplexityMetrics { + panic_count: 1, + ..Default::default() + }); + fa.is_test = false; + let mut results = vec![fa]; + apply_extended_warnings(&mut results, &config, &mut summary, &HashMap::new()); + assert!(results[0].error_handling_warning); + assert_eq!(summary.error_handling_warnings, 1); +} + #[test] fn test_unsafe_suppressed_by_allow_annotation() { let config = Config::default(); diff --git a/src/app/tests/warnings/flag_application.rs b/src/app/tests/warnings/flag_application.rs new file mode 100644 index 00000000..e0aa575f --- /dev/null +++ b/src/app/tests/warnings/flag_application.rs @@ -0,0 +1,70 @@ +//! `apply_file_suppressions` (IOSP/Complexity proximity window = 3) and +//! `apply_recursive_annotations` (drop self-calls). Fixtures place a +//! suppression at a window boundary / wrong dimension, and a recursive marker +//! over a function whose own-calls include its own name & qualified name. +use super::*; +use crate::adapters::analyzers::iosp::ComplexityMetrics; +use crate::findings::{Dimension, Suppression}; + +/// `(suppressed, complexity_suppressed)` for a function at `fa_line` with a +/// single suppression at `sup_line` covering `dim`. +fn file_suppressed(fa_line: usize, sup_line: usize, dim: Dimension) -> (bool, bool) { + let mut fa = make_func_with_metrics(ComplexityMetrics::default()); + fa.line = fa_line; + let sup = Suppression { + line: sup_line, + dimensions: vec![dim], + reason: None, + }; + apply_file_suppressions(&mut fa, &[sup]); + (fa.suppressed, fa.complexity_suppressed) +} + +#[test] +fn iosp_suppression_on_same_line_suppresses_iosp_only() { + // An IOSP suppression in window marks `suppressed` (kills the outer `||`→`&&` + // and the `is_adjacent && covers_iosp` conjunction) but NOT + // `complexity_suppressed` (kills the complexity arm's `&&`→`||`). + assert_eq!(file_suppressed(5, 5, Dimension::Iosp), (true, false)); +} + +#[test] +fn complexity_suppression_on_same_line_suppresses_complexity_only() { + assert_eq!(file_suppressed(5, 5, Dimension::Complexity), (false, true)); +} + +#[test] +fn suppression_at_window_edge_applies() { + // diff 3 == window → adjacent. + assert_eq!(file_suppressed(5, 2, Dimension::Iosp), (true, false)); +} + +#[test] +fn suppression_just_outside_window_does_not_apply() { + // fa.line 6, sup.line 2 → diff 4 > window 3 → not adjacent. Guards the + // `fa.line - s.line` subtraction (a `/` gives 6/2=3 ≤ 3 and would apply). + assert_eq!(file_suppressed(6, 2, Dimension::Iosp), (false, false)); +} + +#[test] +fn suppression_below_function_does_not_apply() { + // sup.line 5 > fa.line 2 → not adjacent (and the `&&` short-circuits before + // the subtraction underflows). + assert_eq!(file_suppressed(2, 5, Dimension::Iosp), (false, false)); +} + +#[test] +fn recursive_annotation_drops_self_calls_only() { + // A `qual:recursive`-marked fn (name `f`, qualified `Foo::f`) keeps only the + // non-self call. Guards `call != self_name && call != qualified` against the + // `!=`→`==` and `&&`→`||` mutations (each would keep a self-call). + let mut fa = make_func_with_metrics(ComplexityMetrics::default()); + fa.name = "f".to_string(); + fa.qualified_name = "Foo::f".to_string(); + fa.line = 7; + fa.own_calls = vec!["f".to_string(), "Foo::f".to_string(), "other".to_string()]; + let recursive_lines: HashMap> = + [("test.rs".to_string(), HashSet::from([7]))].into(); + apply_recursive_annotations(std::slice::from_mut(&mut fa), &recursive_lines); + assert_eq!(fa.own_calls, vec!["other".to_string()]); +} diff --git a/src/app/tests/warnings/mod.rs b/src/app/tests/warnings/mod.rs index c060f82d..4a4a88fb 100644 --- a/src/app/tests/warnings/mod.rs +++ b/src/app/tests/warnings/mod.rs @@ -13,10 +13,14 @@ pub(super) use crate::config::Config; pub(super) use crate::report::Summary; pub(super) use std::collections::{HashMap, HashSet}; +mod complexity_flags; mod exclude_and_error_handling; mod extended_warnings; +mod flag_application; mod orphan_basics_and_suppression; +mod orphan_complexity_thresholds; mod orphan_dry_and_disabled; +mod orphan_mod_internals; mod orphan_module_tq_arch; mod orphan_support; pub(super) use orphan_support::*; diff --git a/src/app/tests/warnings/orphan_complexity_thresholds.rs b/src/app/tests/warnings/orphan_complexity_thresholds.rs new file mode 100644 index 00000000..7ce19f01 --- /dev/null +++ b/src/app/tests/warnings/orphan_complexity_thresholds.rs @@ -0,0 +1,82 @@ +//! Orphan detection at the exact complexity thresholds. A `qual:allow(complexity)` +//! marker over a function whose metric is *exactly* at the cap suppresses +//! nothing (the warning fires only when *over* the cap) → it is an orphan. +//! A `>`→`>=` mutation in the `exceeds_*` predicates would make `would_trigger` +//! true and wrongly clear the orphan. +use super::*; +use crate::adapters::analyzers::iosp::ComplexityMetrics; + +#[test] +fn complexity_marker_at_exact_threshold_is_orphan() { + // Defaults: cognitive 15, cyclomatic 10, nesting 4, length 60. + let cases = [ + ( + "cognitive", + ComplexityMetrics { + cognitive_complexity: 15, + ..Default::default() + }, + ), + ( + "cyclomatic", + ComplexityMetrics { + cyclomatic_complexity: 10, + ..Default::default() + }, + ), + ( + "nesting", + ComplexityMetrics { + max_nesting: 4, + ..Default::default() + }, + ), + ( + "length", + ComplexityMetrics { + function_lines: 60, + ..Default::default() + }, + ), + ]; + for (label, m) in cases { + let orphans = complexity_sup_orphans(5, 6, m); + assert!( + !orphans.is_empty(), + "case {label}: a marker over an exactly-at-threshold fn suppresses nothing → orphan" + ); + } +} + +#[test] +fn error_handling_marker_is_not_orphan() { + // A non-test fn that triggers error-handling makes the marker valid (not + // orphan). Two single-count fixtures pin every `+` in the + // `unwrap + panic + todo + expect.min(threshold)` sum: a lone `panic` + // exercises the left `+`s, and a lone `expect` (threshold 1 under the + // default `allow_expect=false`) exercises the trailing `+ expect.min`. + // Any `+`→`*` collapses the live term to 0 (→ orphan); any `+`→`-` + // underflows (→ panic). Either way the empty assertion catches it. + let cases = [ + ( + "panic", + ComplexityMetrics { + panic_count: 1, + ..Default::default() + }, + ), + ( + "expect", + ComplexityMetrics { + expect_count: 1, + ..Default::default() + }, + ), + ]; + for (label, m) in cases { + assert!( + complexity_sup_orphans(5, 6, m).is_empty(), + "case {label}: a non-test fn error-handling count is a target the marker suppresses" + ); + } +} diff --git a/src/app/tests/warnings/orphan_mod_internals.rs b/src/app/tests/warnings/orphan_mod_internals.rs new file mode 100644 index 00000000..e04141a7 --- /dev/null +++ b/src/app/tests/warnings/orphan_mod_internals.rs @@ -0,0 +1,175 @@ +//! Internal predicates of the orphan detector (`app::orphan_suppressions::mod`) +//! that the higher-level orphan tests don't pin: the coupling-only +//! `is_verifiable` branch, the DRY enable-guard truth table, architecture +//! in-window matching, the invalid-marker projection, and the `is_test` +//! short-circuits in `push_magic_numbers` / `exceeds_error_handling`. +use super::*; +use crate::adapters::analyzers::iosp::{ComplexityMetrics, MagicNumberOccurrence}; +use crate::adapters::suppression::qual_allow::InvalidQualAllow; +use crate::findings::{Dimension, Suppression}; + +/// One marker on `file` at `line` covering `dims`. +fn marker(file: &str, line: usize, dims: &[Dimension]) -> HashMap> { + let mut sups = HashMap::new(); + sups.insert( + file.to_string(), + vec![Suppression { + line, + dimensions: dims.to_vec(), + reason: None, + }], + ); + sups +} + +fn run( + sups: &HashMap>, + analysis: &crate::report::AnalysisResult, + config: &Config, +) -> usize { + crate::app::orphan_suppressions::detect_orphan_suppressions( + sups, + &std::collections::HashMap::new(), + analysis, + config, + ) + .len() +} + +#[test] +fn coupling_only_marker_is_verifiable_when_a_coupling_finding_exists() { + // A coupling-only marker is verifiable iff the file has a line-anchored + // Coupling finding. Here the only coupling finding is out of window, so the + // marker is a verifiable-but-unmatched orphan. The `p.dim == Coupling` + // probe flipped to `!=` would make the file look like it has no coupling + // anchor → marker skipped → 0. Asserting 1 pins the `==`. + let sups = marker("src/foo.rs", 1, &[Dimension::Coupling]); + let mut analysis = empty_analysis(); + analysis + .findings + .coupling + .push(make_structural_coupling_finding("src/foo.rs", 500)); + assert_eq!( + run(&sups, &analysis, &Config::default()), + 1, + "coupling-only marker with an out-of-window coupling finding is a verifiable orphan" + ); +} + +#[test] +fn dry_enable_guard_truth_table() { + // `collect_dry_positions` returns early only when BOTH duplicates and + // boilerplate are disabled. A matchable DRY finding sits one line below the + // marker (wildcard window = 1). (dup_enabled, bp_enabled, expected_orphans): + // both off → no positions → orphan; either on → position matches → not. + // Kills `&&`→`||` (the one-on rows) and either `!` deletion (the both-off row). + let cases = [(false, false, 1), (true, false, 0), (false, true, 0)]; + for (dup, bp, expected) in cases { + let sups = marker("src/foo.rs", 6, &[Dimension::Dry]); + let mut analysis = empty_analysis(); + analysis + .findings + .dry + .push(make_dry_wildcard_finding("src/foo.rs", 7)); + let mut config = Config::default(); + config.duplicates.enabled = dup; + config.boilerplate.enabled = bp; + config.compile(); + assert_eq!( + run(&sups, &analysis, &config), + expected, + "dup={dup} bp={bp}: dry enable-guard" + ); + } +} + +#[test] +fn architecture_marker_in_window_is_not_orphan() { + // An architecture finding two lines below the marker (DEFAULT window = 3) is + // matched → not orphan. A `collect_architecture_positions` that drops the + // position (body replaced, or the `enabled` guard inverted) would leave the + // marker unmatched → orphan. Asserting 0 pins the collection. + let sups = marker("src/foo.rs", 1, &[Dimension::Architecture]); + let mut analysis = empty_analysis(); + analysis + .findings + .architecture + .push(make_architecture_finding("src/foo.rs", 3)); + let mut config = Config::default(); + config.architecture.enabled = true; + assert_eq!( + run(&sups, &analysis, &config), + 0, + "architecture marker matching an in-window finding must not be orphan" + ); +} + +#[test] +fn invalid_marker_surfaces_as_orphan() { + // A malformed `qual:allow(...)` (typo'd dimension) suppresses nothing but + // must surface so the author sees the stale marker. Pins + // `invalid_marker_orphans` against being replaced by an empty vec. + let invalid: HashMap> = [( + "src/foo.rs".to_string(), + vec![(5, InvalidQualAllow::UnknownDimensions("srp_params".into()))], + )] + .into(); + let analysis = empty_analysis(); + let orphans = crate::app::orphan_suppressions::detect_orphan_suppressions( + &HashMap::new(), + &invalid, + &analysis, + &Config::default(), + ); + assert_eq!( + orphans.len(), + 1, + "invalid marker must surface as one orphan" + ); + assert_eq!(orphans[0].line, 5); +} + +#[test] +fn magic_numbers_skipped_for_test_fn_leaves_marker_orphan() { + // A magic number on a *test* function is not a finding (magic-number check + // skips tests), so a `qual:allow(complexity)` marker over it has no target → + // orphan. The `f.is_test || !detect_magic_numbers` short-circuit flipped to + // `&&` would push the magic position and wrongly match the marker. + let fa = make_test_fa_with_complexity( + "src/x.rs", + 6, + ComplexityMetrics { + magic_numbers: vec![MagicNumberOccurrence { + line: 6, + value: "42".into(), + }], + ..Default::default() + }, + ); + assert_eq!( + complexity_orphans_for(fa), + 1, + "magic number on a test fn is no target → marker is orphan" + ); +} + +#[test] +fn error_handling_skipped_for_test_fn_leaves_marker_orphan() { + // A panic in a *test* function is not an error-handling finding, so a + // `qual:allow(complexity)` marker over it has no target → orphan. The + // `!detect_error_handling || f.is_test` short-circuit flipped to `&&` would + // count the panic and wrongly match the marker. + let fa = make_test_fa_with_complexity( + "src/x.rs", + 6, + ComplexityMetrics { + panic_count: 1, + ..Default::default() + }, + ); + assert_eq!( + complexity_orphans_for(fa), + 1, + "panic in a test fn is no error-handling target → marker is orphan" + ); +} diff --git a/src/app/tests/warnings/orphan_support.rs b/src/app/tests/warnings/orphan_support.rs index e051bcb9..563f10b2 100644 --- a/src/app/tests/warnings/orphan_support.rs +++ b/src/app/tests/warnings/orphan_support.rs @@ -231,3 +231,39 @@ pub(crate) fn srp_orphan_count( ) .len() } + +/// Like `make_fa_with_complexity` but flags the function as a test, so the +/// `is_test` short-circuits in `push_magic_numbers` / `exceeds_error_handling` +/// are exercised. +pub(crate) fn make_test_fa_with_complexity( + file: &str, + line: usize, + metrics: crate::adapters::analyzers::iosp::ComplexityMetrics, +) -> FunctionAnalysis { + let mut fa = make_fa_with_complexity(file, line, metrics); + fa.is_test = true; + fa +} + +/// Run the orphan detector for a single `qual:allow(complexity)` marker placed +/// on the same line as `fa`, against an analysis whose only function is `fa`. +pub(crate) fn complexity_orphans_for(fa: FunctionAnalysis) -> usize { + let mut sups = HashMap::new(); + sups.insert( + fa.file.clone(), + vec![crate::findings::Suppression { + line: fa.line, + dimensions: vec![crate::findings::Dimension::Complexity], + reason: None, + }], + ); + let mut analysis = empty_analysis(); + analysis.results = vec![fa]; + crate::app::orphan_suppressions::detect_orphan_suppressions( + &sups, + &std::collections::HashMap::new(), + &analysis, + &Config::default(), + ) + .len() +}