ryo-source 0.2.0

//! Comprehensive tests for Pure → syn → source roundtrip conversion.
//!
//! These tests verify that:
//! 1. Source code can be parsed into PureFile
//! 2. PureFile can be converted back to syn types
//! 3. syn types can be formatted back to source code
//! 4. The roundtrip preserves semantic meaning
//! 5. Generated code is valid Rust syntax (parseable by syn)
//! 6. Representative cases compile with rustc (cargo check)

use super::helpers::try_parse_path;
use super::ToSyn;
use crate::pure::ast::PureFile;

// ============================================
// Test Harness
// ============================================

/// Converts source through Pure roundtrip and validates the output is valid Rust.
///
/// This function:
/// 1. Parses source into PureFile
/// 2. Converts back to source via to_source()
/// 3. Validates the output can be parsed by syn (syntax check)
///
/// Returns the generated output for further assertions.
fn assert_valid_rust(source: &str) -> String {
    let pure = PureFile::from_source(source).expect("Input should parse into PureFile");
    let output = pure
        .to_source()
        .expect("to_source should succeed for valid PureFile");

    // P1 validation: Generated code must be valid Rust syntax
    syn::parse_str::<syn::File>(&output).unwrap_or_else(|_| {
        panic!(
            "Generated code must be valid Rust syntax.\nInput:\n{}\nOutput:\n{}",
            source, output
        )
    });

    output
}

/// Validates generated code compiles with rustc via cargo check.
///
/// This is a heavier validation that catches:
/// - Type errors
/// - Name resolution errors
/// - Semantic issues that syn doesn't catch
///
/// Use sparingly on representative cases due to execution time (~1-2s per test).
fn assert_compiles(source: &str) -> String {
    use std::io::Write;
    use std::process::Command;

    let output = assert_valid_rust(source);

    // Create temp directory with Cargo project structure
    let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
    let src_dir = temp_dir.path().join("src");
    std::fs::create_dir_all(&src_dir).expect("Failed to create src dir");

    // Write lib.rs
    let lib_path = src_dir.join("lib.rs");
    let mut file = std::fs::File::create(&lib_path).expect("Failed to create lib.rs");
    // Add common preludes to avoid "not found" errors for std types
    writeln!(file, "#![allow(unused, dead_code)]").unwrap();
    write!(file, "{}", output).expect("Failed to write source");

    // Write Cargo.toml
    let cargo_toml = temp_dir.path().join("Cargo.toml");
    std::fs::write(
        &cargo_toml,
        r#"[package]
name = "roundtrip_test"
version = "0.1.0"
edition = "2021"
"#,
    )
    .expect("Failed to write Cargo.toml");

    // Run cargo check
    let result = Command::new("cargo")
        .args(["check", "--message-format=short"])
        .current_dir(temp_dir.path())
        .output()
        .expect("Failed to run cargo check");

    if !result.status.success() {
        let stderr = String::from_utf8_lossy(&result.stderr);
        panic!(
            "Generated code failed to compile.\n\
             === Input ===\n{}\n\
             === Generated ===\n{}\n\
             === Errors ===\n{}",
            source, output, stderr
        );
    }

    output
}

#[test]
fn test_roundtrip_simple_fn() {
    let source = "fn main() {}";
    let output = assert_valid_rust(source);
    assert!(output.contains("fn main()"));
}

#[test]
fn test_roundtrip_struct() {
    let source = r#"
struct Point {
    x: i32,
    y: i32,
}
"#;
    let output = assert_valid_rust(source);
    assert!(output.contains("struct Point"));
    assert!(output.contains("x: i32"));
    assert!(output.contains("y: i32"));
}

#[test]
fn test_roundtrip_let_else() {
    // `let Some(x) = expr else { return; };` (let-else) must keep its else
    // arm. Losing the `else { ... }` would leave a refutable pattern in a
    // plain `let`, which cargo rejects with E0005 "refutable pattern in
    // local binding". This matches the residual FN class observed by
    // precheck_real_fn_probe after the struct-rest fix landed.
    let source = r#"
fn run(opt: Option<i32>) -> i32 {
    let Some(x) = opt else { return 0; };
    x
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("else"),
        "let-else arm must survive roundtrip.\nOutput:\n{output}"
    );
}

#[test]
fn test_roundtrip_let_mut() {
    // `let mut x = ...;` must keep the `mut` qualifier across roundtrip.
    // Dropping `mut` produces E0596 "cannot borrow as mutable" the next time
    // the executor re-renders an affected file, because subsequent `x.push(..)`
    // / `&mut x` sites lose their backing mutability. This matches the residual
    // FN class hinted at by precheck_real_fn_probe diag
    // "cannot borrow `goal.intents` as mutable".
    let source = r#"
fn run() -> i32 {
    let mut x = 1;
    x += 2;
    x
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("let mut x"),
        "`let mut x` must survive roundtrip.\nOutput:\n{output}"
    );
}

#[test]
fn test_roundtrip_fn_arg_mut() {
    // `fn f(mut goal: Goal)` — function-arg `mut` must survive. Dropping it
    // produces E0596 "cannot borrow `goal.intents` as mutable" at every
    // subsequent mutating use. Direct match for the residual FN diag observed
    // by precheck_real_fn_probe.
    let source = r#"
fn run(mut goal: Vec<i32>) -> Vec<i32> {
    goal.push(1);
    goal
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("mut goal"),
        "fn arg `mut goal` must survive roundtrip.\nOutput:\n{output}"
    );
}

#[test]
fn test_roundtrip_closure_param_mut() {
    // `|mut x| { x.push(..); x }` — closure param `mut` must survive.
    let source = r#"
fn run() -> Vec<i32> {
    let f = |mut x: Vec<i32>| { x.push(1); x };
    f(Vec::new())
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("|mut x"),
        "closure param `|mut x|` must survive roundtrip.\nOutput:\n{output}"
    );
}

#[test]
fn test_roundtrip_for_binding_mut() {
    // `for mut x in iter { x.push(..); }` — for-loop binding `mut` must survive.
    let source = r#"
fn run(items: Vec<Vec<i32>>) {
    for mut x in items {
        x.push(1);
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("for mut x"),
        "for-loop binding `mut` must survive roundtrip.\nOutput:\n{output}"
    );
}

#[test]
fn test_roundtrip_struct_destructure_mut() {
    // `let Foo { mut field, .. } = x;` — struct-destructure field `mut` must
    // survive. Loss would silently demote a mutating field binding into a
    // read-only one, producing E0596 on subsequent `field.push(..)`.
    let source = r#"
struct Foo { field: Vec<i32> }
fn run(foo: Foo) -> Vec<i32> {
    let Foo { mut field } = foo;
    field.push(1);
    field
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("mut field"),
        "struct destructure `mut field` must survive roundtrip.\nOutput:\n{output}"
    );
}

#[test]
fn test_roundtrip_cfg_test_mod_preserves_attribute() {
    // `#[cfg(test)] mod tests { use tempfile::TempDir; ... }` — an inline
    // test module gated by `#[cfg(test)]` whose body imports a dev-only
    // crate (`tempfile`). Losing the `#[cfg(test)]` attribute on round-trip
    // would leak the `use tempfile::TempDir` into the production scope, and
    // cargo check rejects it with `unresolved import tempfile` because
    // `tempfile` is a dev-dependency only.
    //
    // Direct match for the residual Lint FN RL061 axis 2 captured by
    // `rl061_tempfile_fn_observe`: ExtractTrait against
    // `<impl AllowStore>` / `<impl AcChanges>` syncs 23 files in
    // ryo-suggest, and the diagnostics surface as
    // `unresolved import tempfile` originating from the inline test
    // module of `generator/store.rs` / `pattern/rule_store.rs`.
    let source = r#"
pub struct Service;

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::TempDir;

    fn helper() -> TempDir { TempDir::new().unwrap() }
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("#[cfg(test)]"),
        "`#[cfg(test)]` on an inline test module must survive roundtrip.\nOutput:\n{output}"
    );
    assert!(
        output.contains("use tempfile"),
        "test-module body must survive roundtrip with its dev-only imports intact.\nOutput:\n{output}"
    );
}

#[test]
fn test_roundtrip_fn_arg_struct_pattern() {
    // `fn execute_group(SpecGroup { x, .. }: SpecGroup)` — the source
    // uses a struct destructure pattern as the parameter binding. The
    // previous `pat_to_name` collapse turned this into
    // `PureParam::Typed { name: "SpecGroup", .. }`, and re-emission
    // synthesised `SpecGroup: SpecGroup`. Rust's grammar parses the
    // uppercase-leading identifier as a `Pat::Path` and cargo rejects
    // it with "patterns aren't allowed in functions without bodies"
    // whenever the function happens to be inside a trait body-less
    // signature (the residual RL061 axis-1 captured by
    // `rl061_tempfile_fn_observe` against `<impl ExecutionOrchestrator>`).
    //
    // PureParam::Typed now carries an `Option<PurePattern>` that
    // preserves the original pattern, and `to_syn` re-emits it
    // verbatim. Round-trip must keep `SpecGroup { x, .. }` intact.
    let source = r#"
struct SpecGroup { x: u32 }
fn execute_group(SpecGroup { x, .. }: SpecGroup) -> u32 { x }
"#;
    let output = assert_valid_rust(source);
    // prettyplease expands the shorthand `{ x }` to `{ x: x }`, which is
    // semantically identical; check for the struct-destructure shape
    // (`SpecGroup { ... }`) rather than the exact original spelling.
    assert!(
        output.contains("SpecGroup {") && output.contains(".. }: SpecGroup"),
        "fn-arg struct-destructure pattern must survive roundtrip.\nOutput:\n{output}"
    );
    // Crucially: the lossy `SpecGroup: SpecGroup` collapse must NOT appear.
    assert!(
        !output.contains("(SpecGroup: SpecGroup)"),
        "fn-arg must not collapse to the lossy `Name: Type` form that cargo \
         rejects with `patterns aren't allowed`.\nOutput:\n{output}"
    );
}

#[test]
fn test_roundtrip_tuple_variant_from_attribute() {
    // `enum E { Foo(#[from] Inner) }` — thiserror's `#[from]` on a tuple
    // variant's inner field is the trigger for auto-deriving
    // `impl From<Inner> for E`. Dropping the attribute on round-trip removes
    // the From impl and downstream `?` operator usages stop compiling with
    // "couldn't convert the error". This is the residual Pattern FN observed
    // by `dsl-macro-verbatim` × `Api::suggest_scan_with_precheck_limit`
    // (10 × "`?` couldn't convert the error to `ApiError`") — the root cause
    // is the `PureFields::Tuple` carrier dropping per-field attrs, fixed by
    // promoting the carrier to `Vec<PureTupleField>`.
    let source = r#"
#[derive(Debug, thiserror::Error)]
pub enum ApiError {
    #[error("Storage error: {0}")]
    Storage(#[from] StorageError),
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("#[from]"),
        "Tuple-variant `#[from]` attribute must survive roundtrip.\nOutput:\n{output}"
    );
}

#[test]
fn test_roundtrip_tuple_struct_field_attribute() {
    // Same shape on a tuple struct (rather than an enum variant). Confirms
    // the fix covers tuple-struct fields as well — relevant for any derive
    // macro that inspects positional field attrs (`#[serde(skip)]`,
    // `#[validate(...)]`, etc.).
    let source = r#"
#[derive(Debug)]
pub struct Wrapper(#[from] Inner);
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("#[from]"),
        "Tuple-struct field `#[from]` attribute must survive roundtrip.\nOutput:\n{output}"
    );
}

#[test]
fn test_roundtrip_external_mod_decl_preserves_private_vis() {
    // `mod types;` (private external module declaration) must survive
    // roundtrip with its visibility intact. Dropping the privacy promotes
    // the declaration to `pub mod types;`, which is a real-world cargo
    // hazard: at scale (`dsl_macro_verbatim_diff_observe` on
    // `crates/ryo-app/src/api/mod.rs`) the AST round-trip surfaces
    // `pub mod types;` appended to file tail while the original
    // `mod types;` is also dropped from its declared position. The
    // promoted re-emission then collides with re-export rules
    // (`pub use types::*;` flagged as `pub use of private item`)
    // and downstream visibility lints fire on the entire `types::`
    // surface.
    let source = r#"
mod types;
pub mod public_types;

pub use types::*;
"#;
    let output = assert_valid_rust(source);

    // `mod types;` (no `pub`) must remain `mod types;` post-roundtrip.
    // Both `mod types;` and `pub mod types;` would satisfy a naive
    // contains check on the bare identifier, so assert the explicit
    // private form survives.
    assert!(
        output.contains("mod types;"),
        "External `mod types;` declaration must survive roundtrip.\nOutput:\n{output}"
    );
    assert!(
        !output
            .replace("pub mod public_types;", "")
            .contains("pub mod types"),
        "Private `mod types;` must NOT be promoted to `pub mod types;`.\nOutput:\n{output}"
    );
    // Sanity: the actually-public declaration is still public.
    assert!(
        output.contains("pub mod public_types;"),
        "`pub mod public_types;` must remain public.\nOutput:\n{output}"
    );
}

#[test]
fn test_roundtrip_external_mod_decl_preserves_compound_cfg_attribute() {
    // `#[cfg(any(test, feature = "test-utils"))] mod test_harness;` must
    // preserve its compound cfg attribute across roundtrip. The simple
    // `#[cfg(test)] mod foo;` form has its own `extract_cfg_test_scope`
    // path that lifts the attribute into `ModScope::Test`, but compound
    // cfg meta lists (`any(...)` / `all(...)` / `not(...)`) do not match
    // the exact-`cfg(test)` predicate and therefore must remain in
    // `PureMod.attrs` untouched. Real-world hazard surfaced by
    // `r9_symbol_path_resolver_diff_observe` on
    // `crates/ryo-symbol/src/lib.rs`:
    //
    //     -#[cfg(any(test, feature = "test-utils"))]
    //      mod test_harness;
    //
    // After the cfg attribute is silently dropped the module body is
    // visible in every cargo build configuration, but the original
    // `#[cfg(any(test, feature = "test-utils"))] use crate::test_harness::...;`
    // call sites elsewhere in the workspace fail with `unresolved
    // import test_harness` because their cfg conjunction no longer
    // matches the (now unconditional) `mod test_harness` decl.
    let source = r#"
#[cfg(any(test, feature = "test-utils"))]
mod test_harness;
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("#[cfg(any(test, feature = \"test-utils\"))]"),
        "Compound `#[cfg(any(test, feature = \"test-utils\"))]` attribute must survive roundtrip on `mod test_harness;`.\nOutput:\n{output}"
    );
    assert!(
        output.contains("mod test_harness;"),
        "External `mod test_harness;` declaration must survive roundtrip.\nOutput:\n{output}"
    );
}

#[test]
fn test_roundtrip_external_mod_decl() {
    // `mod foo;` (external file module — body-less, semi-terminated) must
    // survive roundtrip. Dropping it leaves `pub use foo::*;` and any other
    // path referring to the submodule unresolved, which cargo eventually
    // reports as a cascade of name-resolution errors. In real workloads the
    // surfaced symptom is "`?` couldn't convert the error to `ApiError`"
    // (S182g0 dsl-macro-verbatim Pattern FN, ryo-app::api::Api::suggest_scan_with_precheck_limit
    // — every method that returns `ApiResult<T>` loses its outer error type
    // once `mod types;` falls off the top of `api/mod.rs` and the rest of
    // the file's type lookups fail).
    let source = r#"
mod types;
pub use types::*;
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("mod types"),
        "External `mod types;` declaration must survive roundtrip.\nOutput:\n{output}"
    );
}

#[test]
fn test_roundtrip_struct_functional_update() {
    // PureExpr::Struct must preserve `..rest` (functional update syntax).
    // Regression: struct literals with `..Default::default()` dropped the rest
    // field on roundtrip, producing spurious "missing fields" cargo errors when
    // a mutation re-rendered an affected file.
    let source = r#"
fn make() -> Foo {
    Foo { a: 1, ..Default::default() }
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains(".."),
        "Functional update `..Default::default()` must survive roundtrip.\nOutput:\n{output}"
    );
}

#[test]
fn test_roundtrip_impl() {
    let source = r#"
impl Point {
    fn new(x: i32, y: i32) -> Self {
        Self { x, y }
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(output.contains("impl Point"));
    assert!(output.contains("fn new"));
}

#[test]
fn test_roundtrip_use() {
    let source = "use std::io;";
    let output = assert_valid_rust(source);
    assert!(output.contains("use std::io"));
}

#[test]
fn test_roundtrip_complex() {
    let source = r#"
use std::collections::HashMap;

struct Config {
    name: String,
    value: i32,
}

impl Config {
    fn new(name: &str, value: i32) -> Self {
        Self {
            name: name.to_string(),
            value,
        }
    }

    fn get_value(&self) -> i32 {
        self.value
    }
}

fn main() {
    let config = Config::new("test", 42);
    let result = config.get_value();
    println!("{}", result);
}
"#;
    let output = assert_valid_rust(source);
    assert!(output.contains("use std::collections::HashMap"));
    assert!(output.contains("struct Config"));
    assert!(output.contains("impl Config"));
    assert!(output.contains("fn main()"));
}

// ============================================
// Regression tests for DOGFOODING_BUGS.md
// ============================================

/// Bug 1: Pat::Verbatim panic (qualified path pattern)
/// prettyplease panicked on `Pat::Verbatim` for path patterns like `Some`, `None`, `Enum::Variant`
#[test]
fn test_roundtrip_path_pattern_option() {
    let source = r#"
fn handle_option(x: Option<i32>) {
    match x {
        Some(v) => println!("{}", v),
        None => println!("none"),
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(output.contains("Some"));
    assert!(output.contains("None"));
}

/// Bug 1: Qualified path with enum variant (e.g., `Enum::Variant`)
#[test]
fn test_roundtrip_qualified_path_pattern() {
    let source = r#"
enum Status {
    Ok,
    Err,
}

fn check(s: Status) {
    match s {
        Status::Ok => println!("ok"),
        Status::Err => println!("err"),
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(output.contains("Status::Ok"));
    assert!(output.contains("Status::Err"));
}

/// Bug 2: Tuple struct pattern with numbered fields (e.g., `Some(x)`, `Ok(v)`)
/// `to_syn.rs` panicked with "Ident cannot be a number" for tuple struct patterns
#[test]
fn test_roundtrip_tuple_struct_pattern() {
    let source = r#"
fn extract(opt: Option<i32>) {
    if let Some(v) = opt {
        println!("{}", v);
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(output.contains("Some"));
}

/// Bug 2: Multiple fields in tuple struct pattern
#[test]
fn test_roundtrip_tuple_struct_multi_field() {
    let source = r#"
struct Point(i32, i32);

fn extract(p: Point) {
    let Point(x, y) = p;
    println!("{} {}", x, y);
}
"#;
    let output = assert_valid_rust(source);
    assert!(output.contains("Point"));
}

/// Bug 3: Raw identifier (e.g., `r#async`, `r#type`)
/// `ident()` function panicked with "r#async is not a valid Ident"
#[test]
fn test_roundtrip_raw_identifier_fn() {
    let source = r#"
fn r#async() -> i32 {
    42
}
"#;
    let output = assert_valid_rust(source);
    // The output should contain the raw identifier
    assert!(output.contains("r#async") || output.contains("async"));
}

/// Bug 3: Raw identifier in variable binding
#[test]
fn test_roundtrip_raw_identifier_variable() {
    let source = r#"
fn use_raw() {
    let r#type = 1;
    let r#match = 2;
    println!("{} {}", r#type, r#match);
}
"#;
    let output = assert_valid_rust(source);
    // Should compile without panic
    assert!(output.contains("fn use_raw"));
}

/// Additional pattern: Range pattern
#[test]
fn test_roundtrip_range_pattern() {
    let source = r#"
fn check_range(n: i32) {
    match n {
        0..=10 => println!("small"),
        _ => println!("large"),
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(output.contains("0"));
    assert!(output.contains("10"));
}

/// Additional pattern: Slice pattern
#[test]
fn test_roundtrip_slice_pattern() {
    let source = r#"
fn check_slice(arr: &[i32]) {
    match arr {
        [] => println!("empty"),
        [first] => println!("{}", first),
        [first, rest @ ..] => println!("{} and more", first),
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(output.contains("first"));
}

// ============================================
// Fix tests for generics and assignment
// ============================================

/// Test try_parse_path with generic type parameters
#[test]
fn test_parse_path_with_generics() {
    // Simple generic
    let path = try_parse_path("Vec<i32>").unwrap();
    assert_eq!(path.segments.len(), 1);
    assert_eq!(path.segments[0].ident.to_string(), "Vec");

    // Nested generic
    let path = try_parse_path("Vec<Option<String>>").unwrap();
    assert_eq!(path.segments.len(), 1);

    // Module path with generic
    let path = try_parse_path("std::vec::Vec<i32>").unwrap();
    assert_eq!(path.segments.len(), 3);
}

/// Test roundtrip for assignment expression
#[test]
fn test_roundtrip_assignment_expression() {
    let source = r#"
fn assign_test() {
    let mut x = 0;
    x = 42;
}
"#;
    let output = assert_valid_rust(source);
    assert!(output.contains("x = 42"));
}

/// Test roundtrip for derive attribute
#[test]
fn test_roundtrip_derive_attribute() {
    let source = r#"
#[derive(Debug, Clone)]
struct Foo {
    x: i32,
}
"#;
    let output = assert_valid_rust(source);
    assert!(output.contains("#[derive(Debug, Clone)]"));
}

/// Test roundtrip for type with generic parameters
#[test]
fn test_roundtrip_generic_type() {
    let source = r#"
fn generic_fn() -> Vec<String> {
    Vec::new()
}
"#;
    let output = assert_valid_rust(source);
    assert!(output.contains("Vec<String>") || output.contains("Vec< String >"));
}

/// Test roundtrip for field type with generic
#[test]
fn test_roundtrip_struct_with_generic_field() {
    let source = r#"
struct Container {
    items: Vec<LintCategory>,
}
"#;
    let output = assert_valid_rust(source);
    assert!(output.contains("Vec"));
    assert!(output.contains("LintCategory"));
}

/// Test roundtrip for struct pattern with rest (..)
#[test]
fn test_roundtrip_struct_pattern_with_rest() {
    let source = r#"
struct Point { x: i32, y: i32, z: i32 }

fn use_pattern(p: Point) {
    let Point { x, .. } = p;
    println!("{}", x);
}
"#;
    let output = assert_valid_rust(source);
    // Should contain rest pattern
    assert!(
        output.contains(".."),
        "Output should contain '..': {}",
        output
    );
}

/// Test roundtrip for rest-only struct pattern (no fields, just `{ .. }`)
#[test]
fn test_roundtrip_rest_only_struct_pattern() {
    let source = r#"
enum Foo {
    Bar { x: i32, y: i32 },
    Baz,
}

fn match_foo(f: Foo) {
    match f {
        Foo::Bar { .. } => println!("bar"),
        Foo::Baz => println!("baz"),
    }
}
"#;
    let output = assert_valid_rust(source);
    // Should preserve `{ .. }` not convert to `()`
    assert!(
        output.contains("Bar { .. }") || output.contains("Bar {..}"),
        "Output should contain 'Bar {{ .. }}', got: {}",
        output
    );
    // Should NOT contain `Bar()`
    assert!(
        !output.contains("Bar()"),
        "Output should NOT contain 'Bar()', got: {}",
        output
    );
}

/// Test roundtrip for turbofish in method call (e.g., `.collect::<Vec<_>>()`)
#[test]
fn test_roundtrip_turbofish_method_call() {
    let source = r#"
fn turbofish_test() {
    let v = [1, 2, 3].iter().collect::<Vec<_>>();
    let s = "hello".parse::<i32>();
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("collect::<") || output.contains("collect ::< "),
        "Output should contain turbofish 'collect::<': {}",
        output
    );
    assert!(
        output.contains("parse::<") || output.contains("parse ::< "),
        "Output should contain turbofish 'parse::<': {}",
        output
    );
}

/// Test roundtrip for range expressions
#[test]
fn test_roundtrip_range_expression() {
    let source = r#"
fn range_test() {
    let a = 0..10;
    let b = 0..=10;
    let c = ..10;
    let d = 0..;
    for i in 0..5 {
        println!("{}", i);
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("0..10") || output.contains("0 .. 10"),
        "Output should contain '0..10': {}",
        output
    );
    assert!(
        output.contains("0..=10") || output.contains("0 ..= 10"),
        "Output should contain '0..=10': {}",
        output
    );
}

/// Test roundtrip for cast expressions
#[test]
fn test_roundtrip_cast_expression() {
    let source = r#"
fn cast_test() {
    let x = 42u8 as i32;
    let y = 3.14f64 as i64;
    let ptr = &x as *const i32;
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("as i32"),
        "Output should contain 'as i32': {}",
        output
    );
    assert!(
        output.contains("as i64"),
        "Output should contain 'as i64': {}",
        output
    );
}

/// Test roundtrip for if let expression
#[test]
fn test_roundtrip_if_let_expression() {
    let source = r#"
fn if_let_test(opt: Option<i32>) {
    if let Some(x) = opt {
        println!("{}", x);
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("if let Some"),
        "Output should contain 'if let Some': {}",
        output
    );
}

/// Test roundtrip for while let expression
#[test]
fn test_roundtrip_while_let_expression() {
    let source = r#"
fn while_let_test(mut iter: std::vec::IntoIter<i32>) {
    while let Some(x) = iter.next() {
        println!("{}", x);
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("while let Some"),
        "Output should contain 'while let Some': {}",
        output
    );
}

/// Test roundtrip for move closure
#[test]
fn test_roundtrip_move_closure() {
    let source = r#"
fn move_closure_test() {
    let x = 42;
    let f = move || x + 1;
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("move"),
        "Output should contain 'move': {}",
        output
    );
}

/// Test roundtrip for async closure (unstable, but should parse)
#[test]
fn test_roundtrip_async_closure() {
    let source = r#"
fn async_closure_test() {
    let f = async || 42;
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("async"),
        "Output should contain 'async': {}",
        output
    );
}

/// Test roundtrip for typed closure params and return type
#[test]
fn test_roundtrip_typed_closure() {
    let source = r#"
fn typed_closure_test() {
    let f = |x: i32, y: String| -> bool { x > 0 };
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("i32"),
        "Output should contain param type 'i32': {}",
        output
    );
    assert!(
        output.contains("String"),
        "Output should contain param type 'String': {}",
        output
    );
    assert!(
        output.contains("bool"),
        "Output should contain return type 'bool': {}",
        output
    );
}

/// Test roundtrip for async block
#[test]
fn test_roundtrip_async_block() {
    let source = r#"
fn async_block_test() {
    let fut = async {
        42
    };
    let fut_move = async move {
        42
    };
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("async"),
        "Output should contain 'async': {}",
        output
    );
}

/// Test roundtrip for unsafe block
#[test]
fn test_roundtrip_unsafe_block() {
    let source = r#"
fn unsafe_block_test() {
    let x = unsafe {
        std::mem::zeroed::<i32>()
    };
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("unsafe"),
        "Output should contain 'unsafe': {}",
        output
    );
}

/// Test roundtrip for array repeat
#[test]
fn test_roundtrip_array_repeat() {
    let source = r#"
fn array_repeat_test() {
    let zeros = [0; 10];
    let ones = [1u8; 256];
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("[0; 10]") || output.contains("[0 ; 10]"),
        "Output should contain '[0; 10]': {}",
        output
    );
}

/// Test adding derive via PureAttribute (simulates AddDeriveMutation)
#[test]
fn test_add_derive_via_pure_attribute() {
    use crate::pure::ast::{
        PureAttrMeta, PureAttribute, PureField, PureFields, PureGenerics, PureStruct, PureType,
        PureVis,
    };

    // Create a struct without derives
    let mut s = PureStruct {
        name: "Foo".to_string(),
        vis: PureVis::Public,
        generics: PureGenerics::default(),
        attrs: vec![],
        fields: PureFields::Named(vec![PureField {
            name: "x".to_string(),
            vis: PureVis::Private,
            ty: PureType::Path("i32".to_string()),
            attrs: vec![],
        }]),
    };

    // Add derive attribute (as AddDeriveMutation does)
    s.attrs.push(PureAttribute {
        path: "derive".to_string(),
        meta: PureAttrMeta::List("Debug, Clone".to_string()),
        is_inner: false,
    });

    // Convert to syn and back to string
    let syn_struct = s.to_syn().unwrap();
    let output = prettyplease::unparse(&syn::File {
        shebang: None,
        attrs: vec![],
        items: vec![syn::Item::Struct(syn_struct)],
    });

    assert!(
        output.contains("#[derive(Debug, Clone)]") || output.contains("#[derive(Debug , Clone)]"),
        "Output should contain '#[derive(Debug, Clone)]': {}",
        output
    );
}

// ============================================
// Compile Verification Tests (P1 - cargo check)
// ============================================
//
// These tests verify that generated code actually compiles with rustc.
// They are slower (~1-2s each) but catch type errors and semantic issues.
// Run with: cargo test compile_check -- --ignored

/// Struct with impl block - representative of typical mutation output
#[test]
#[ignore = "slow: requires cargo check"]
fn compile_check_struct_with_impl() {
    let source = r#"
#[derive(Debug, Clone)]
pub struct Point {
    pub x: i32,
    pub y: i32,
}

impl Point {
    pub fn new(x: i32, y: i32) -> Self {
        Self { x, y }
    }

    pub fn distance(&self, other: &Point) -> f64 {
        let dx = (self.x - other.x) as f64;
        let dy = (self.y - other.y) as f64;
        (dx * dx + dy * dy).sqrt()
    }
}
"#;
    assert_compiles(source);
}

/// Enum with match - tests pattern generation
#[test]
#[ignore = "slow: requires cargo check"]
fn compile_check_enum_with_match() {
    let source = r#"
#[derive(Debug, Clone, PartialEq)]
pub enum Status {
    Pending,
    InProgress { progress: u8 },
    Done,
}

impl Status {
    pub fn is_complete(&self) -> bool {
        matches!(self, Status::Done)
    }

    pub fn description(&self) -> &'static str {
        match self {
            Status::Pending => "Not started",
            Status::InProgress { progress } if *progress > 50 => "More than half done",
            Status::InProgress { .. } => "In progress",
            Status::Done => "Complete",
        }
    }
}
"#;
    assert_compiles(source);
}

/// Generics and traits - complex type system usage
#[test]
#[ignore = "slow: requires cargo check"]
fn compile_check_generics_and_traits() {
    let source = r#"
use std::fmt::Display;

pub trait Printable {
    fn print(&self);
}

pub struct Container<T> {
    value: T,
}

impl<T: Display> Container<T> {
    pub fn new(value: T) -> Self {
        Self { value }
    }
}

impl<T: Display> Printable for Container<T> {
    fn print(&self) {
        println!("{}", self.value);
    }
}
"#;
    assert_compiles(source);
}

/// Complex expressions - closures, iterators, method chains
#[test]
#[ignore = "slow: requires cargo check"]
fn compile_check_complex_expressions() {
    let source = r#"
pub fn process_data(data: Vec<i32>) -> Vec<i32> {
    data.iter()
        .filter(|&x| *x > 0)
        .map(|x| x * 2)
        .collect::<Vec<_>>()
}

pub fn with_closure() -> impl Fn(i32) -> i32 {
    let multiplier = 3;
    move |x| x * multiplier
}
"#;
    assert_compiles(source);
}

/// Full module structure - simulates real-world file
#[test]
#[ignore = "slow: requires cargo check"]
fn compile_check_full_module() {
    let source = r#"
//! A simple todo list module.

use std::collections::HashMap;

/// A single todo item.
#[derive(Debug, Clone)]
pub struct TodoItem {
    pub id: u32,
    pub title: String,
    pub completed: bool,
}

impl TodoItem {
    pub fn new(id: u32, title: impl Into<String>) -> Self {
        Self {
            id,
            title: title.into(),
            completed: false,
        }
    }

    pub fn complete(&mut self) {
        self.completed = true;
    }
}

/// A collection of todo items.
#[derive(Debug, Default)]
pub struct TodoList {
    items: HashMap<u32, TodoItem>,
    next_id: u32,
}

impl TodoList {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn add(&mut self, title: impl Into<String>) -> u32 {
        let id = self.next_id;
        self.next_id += 1;
        self.items.insert(id, TodoItem::new(id, title));
        id
    }

    pub fn get(&self, id: u32) -> Option<&TodoItem> {
        self.items.get(&id)
    }

    pub fn complete(&mut self, id: u32) -> bool {
        if let Some(item) = self.items.get_mut(&id) {
            item.complete();
            true
        } else {
            false
        }
    }

    pub fn pending(&self) -> impl Iterator<Item = &TodoItem> {
        self.items.values().filter(|item| !item.completed)
    }
}
"#;
    assert_compiles(source);
}

/// Test that type annotations on let bindings are preserved during roundtrip
#[test]
fn test_roundtrip_let_type_annotation() {
    let source = r#"
fn test_type_annotations() {
    let x: i32 = 42;
    let args: Vec<String> = vec![];
    let map: std::collections::HashMap<String, i32> = Default::default();
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains(": i32"),
        "Output should preserve ': i32' type annotation: {}",
        output
    );
    assert!(
        output.contains(": Vec<String>"),
        "Output should preserve ': Vec<String>' type annotation: {}",
        output
    );
    assert!(
        output.contains("HashMap<String, i32>"),
        "Output should preserve 'HashMap<String, i32>' type annotation: {}",
        output
    );
}

/// Test type annotations with mut bindings
#[test]
fn test_roundtrip_let_mut_type_annotation() {
    let source = r#"
fn test_mut_type_annotations() {
    let mut count: usize = 0;
    let mut buffer: Vec<u8> = Vec::new();
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("mut count: usize"),
        "Output should preserve 'mut count: usize': {}",
        output
    );
    assert!(
        output.contains("mut buffer: Vec<u8>"),
        "Output should preserve 'mut buffer: Vec<u8>': {}",
        output
    );
}

// ============================================
// Label and ABI Roundtrip Tests
// ============================================

/// Test roundtrip for labeled loop
#[test]
fn test_roundtrip_labeled_loop() {
    let source = r#"
fn labeled_loop_test() {
    'outer: loop {
        'inner: loop {
            break 'outer;
        }
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("'outer") || output.contains("' outer"),
        "Output should contain 'outer label: {}",
        output
    );
    assert!(
        output.contains("'inner") || output.contains("' inner"),
        "Output should contain 'inner label: {}",
        output
    );
    assert!(
        output.contains("break 'outer") || output.contains("break ' outer"),
        "Output should contain 'break 'outer': {}",
        output
    );
}

/// Test roundtrip for labeled while loop
#[test]
fn test_roundtrip_labeled_while() {
    let source = r#"
fn labeled_while_test() {
    let mut i = 0;
    'outer: while i < 10 {
        i += 1;
        if i == 5 {
            continue 'outer;
        }
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("'outer") || output.contains("' outer"),
        "Output should contain 'outer label: {}",
        output
    );
    assert!(
        output.contains("continue 'outer") || output.contains("continue ' outer"),
        "Output should contain 'continue 'outer': {}",
        output
    );
}

/// Test roundtrip for labeled for loop
#[test]
fn test_roundtrip_labeled_for() {
    let source = r#"
fn labeled_for_test() {
    'outer: for i in 0..10 {
        for j in 0..10 {
            if i + j > 15 {
                break 'outer;
            }
        }
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("'outer") || output.contains("' outer"),
        "Output should contain 'outer label: {}",
        output
    );
}

/// Test roundtrip for labeled block
#[test]
fn test_roundtrip_labeled_block() {
    let source = r#"
fn labeled_block_test() -> i32 {
    let result = 'block: {
        if true {
            break 'block 42;
        }
        0
    };
    result
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("'block") || output.contains("' block"),
        "Output should contain 'block label: {}",
        output
    );
    assert!(
        output.contains("break 'block 42") || output.contains("break ' block 42"),
        "Output should contain 'break 'block 42': {}",
        output
    );
}

/// Test roundtrip for break with value (no label)
#[test]
fn test_roundtrip_break_with_value() {
    let source = r#"
fn break_with_value_test() -> i32 {
    loop {
        break 42;
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("break 42"),
        "Output should contain 'break 42': {}",
        output
    );
}

/// Test roundtrip for break with label and value
#[test]
fn test_roundtrip_break_label_and_value() {
    let source = r#"
fn break_label_value_test() -> i32 {
    'outer: loop {
        loop {
            break 'outer 100;
        }
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("break 'outer 100") || output.contains("break ' outer 100"),
        "Output should contain 'break 'outer 100': {}",
        output
    );
}

/// Test roundtrip for continue with label
#[test]
fn test_roundtrip_continue_with_label() {
    let source = r#"
fn continue_label_test() {
    'outer: for i in 0..5 {
        for j in 0..5 {
            if j == 2 {
                continue 'outer;
            }
        }
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("continue 'outer") || output.contains("continue ' outer"),
        "Output should contain 'continue 'outer': {}",
        output
    );
}

/// Test roundtrip for extern "C" function
#[test]
fn test_roundtrip_extern_c_fn() {
    let source = r#"
extern "C" fn c_function(x: i32) -> i32 {
    x + 1
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains(r#"extern "C""#),
        r#"Output should contain 'extern "C"': {}"#,
        output
    );
}

/// Test roundtrip for extern "system" function
#[test]
fn test_roundtrip_extern_system_fn() {
    let source = r#"
extern "system" fn system_function() {}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains(r#"extern "system""#),
        r#"Output should contain 'extern "system"': {}"#,
        output
    );
}

/// Test roundtrip for extern block with multiple functions
#[test]
fn test_roundtrip_extern_block() {
    let source = r#"
extern "C" {
    fn strlen(s: *const u8) -> usize;
    fn memcpy(dest: *mut u8, src: *const u8, n: usize) -> *mut u8;
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains(r#"extern "C""#),
        r#"Output should contain 'extern "C"': {}"#,
        output
    );
    assert!(
        output.contains("strlen"),
        "Output should contain 'strlen': {}",
        output
    );
    assert!(
        output.contains("memcpy"),
        "Output should contain 'memcpy': {}",
        output
    );
}

/// Test roundtrip for nested labeled loops
#[test]
fn test_roundtrip_nested_labeled_loops() {
    let source = r#"
fn nested_labels() {
    'a: loop {
        'b: loop {
            'c: loop {
                break 'a;
            }
            continue 'b;
        }
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("'a") || output.contains("' a"),
        "Output should contain label 'a: {}",
        output
    );
    assert!(
        output.contains("'b") || output.contains("' b"),
        "Output should contain label 'b: {}",
        output
    );
    assert!(
        output.contains("'c") || output.contains("' c"),
        "Output should contain label 'c: {}",
        output
    );
    assert!(
        output.contains("break 'a") || output.contains("break ' a"),
        "Output should contain 'break 'a': {}",
        output
    );
    assert!(
        output.contains("continue 'b") || output.contains("continue ' b"),
        "Output should contain 'continue 'b': {}",
        output
    );
}

/// Compile verification test for labeled loops
#[test]
#[ignore = "slow: requires cargo check"]
fn compile_check_labeled_loops() {
    let source = r#"
pub fn search_matrix(matrix: Vec<Vec<i32>>, target: i32) -> Option<(usize, usize)> {
    'row: for (i, row) in matrix.iter().enumerate() {
        for (j, &val) in row.iter().enumerate() {
            if val == target {
                return Some((i, j));
            }
            if val > target {
                continue 'row;
            }
        }
    }
    None
}

pub fn find_first_match(data: &[&[i32]], predicate: impl Fn(i32) -> bool) -> Option<i32> {
    'outer: for slice in data {
        for &item in *slice {
            if predicate(item) {
                break 'outer Some(item);
            }
        }
    }
    None
}
"#;
    assert_compiles(source);
}

/// Compile verification test for extern functions
#[test]
#[ignore = "slow: requires cargo check"]
fn compile_check_extern_functions() {
    let source = r#"
extern "C" fn add_c(a: i32, b: i32) -> i32 {
    a + b
}

extern "C" fn noop() {}

pub fn use_extern() -> i32 {
    add_c(1, 2)
}
"#;
    assert_compiles(source);
}

// ============================================
// Inline Module Tests
// ============================================

/// Test inline module with use statements
#[test]
fn test_roundtrip_inline_mod_with_uses() {
    let source = r#"
mod utils {
    use std::collections::HashMap;
    use std::io::Write;

    pub fn helper() {}
}
"#;
    let output = assert_valid_rust(source);
    assert!(output.contains("mod utils"), "Output: {}", output);
    assert!(
        output.contains("use std::collections::HashMap"),
        "Output: {}",
        output
    );
    assert!(output.contains("use std::io::Write"), "Output: {}", output);
    assert!(output.contains("pub fn helper"), "Output: {}", output);
}

/// Test inline module with multiple items and uses
#[test]
fn test_roundtrip_inline_mod_complex() {
    let source = r#"
pub mod models {
    use serde::{Deserialize, Serialize};

    pub struct User {
        pub name: String,
        pub age: u32,
    }

    pub fn create_user(name: String, age: u32) -> User {
        User { name, age }
    }
}
"#;
    let output = assert_valid_rust(source);
    assert!(output.contains("pub mod models"), "Output: {}", output);
    assert!(output.contains("use serde"), "Output: {}", output);
    assert!(output.contains("struct User"), "Output: {}", output);
}

/// Test file module declaration (mod foo;)
#[test]
fn test_roundtrip_file_mod_declaration() {
    let source = r#"
mod utils;
pub mod config;
"#;
    let output = assert_valid_rust(source);
    assert!(
        output.contains("mod utils ;") || output.contains("mod utils;"),
        "Output: {}",
        output
    );
    assert!(
        output.contains("pub mod config ;") || output.contains("pub mod config;"),
        "Output: {}",
        output
    );
}

/// Test nested inline modules
#[test]
fn test_roundtrip_nested_inline_mods() {
    let source = r#"
mod outer {
    use std::io;

    mod inner {
        use std::fmt;

        pub fn format_it() {}
    }

    pub fn outer_fn() {}
}
"#;
    let output = assert_valid_rust(source);
    assert!(output.contains("mod outer"), "Output: {}", output);
    assert!(output.contains("mod inner"), "Output: {}", output);
    assert!(output.contains("use std::io"), "Output: {}", output);
    assert!(output.contains("use std::fmt"), "Output: {}", output);
}

/// Test inline module preserves use statement ordering
#[test]
fn test_roundtrip_mod_use_ordering() {
    let source = r#"
mod ordered {
    use a::A;
    use b::B;
    use c::C;

    struct Item;
}
"#;
    let output = assert_valid_rust(source);
    // Uses should appear before struct
    let use_pos = output.find("use a::A").expect("use a::A not found");
    let struct_pos = output.find("struct Item").expect("struct Item not found");
    assert!(
        use_pos < struct_pos,
        "Use statements should come before items. Output: {}",
        output
    );
}

// ============================================
// ToSyn Result Tests
// ============================================

/// Test that to_source() returns Ok for valid input
#[test]
fn test_to_source_result_success() {
    let source = r#"
fn hello() -> String {
    "world".to_string()
}
"#;
    let pure = PureFile::from_source(source).expect("Should parse");
    let result = pure.to_source();
    assert!(
        result.is_ok(),
        "to_source should succeed: {:?}",
        result.err()
    );

    let output = result.unwrap();
    assert!(output.contains("fn hello"));
    assert!(output.contains("world"));
}

/// Test that to_syn() returns Ok for valid input
#[test]
fn test_to_syn_result_success() {
    let source = r#"
struct Point { x: i32, y: i32 }
"#;
    let pure = PureFile::from_source(source).expect("Should parse");
    let result = pure.to_syn();
    assert!(result.is_ok(), "to_syn should succeed: {:?}", result.err());

    let file = result.unwrap();
    assert_eq!(file.items.len(), 1);
}

// =====================================================================
// B-3: PureExpr::Verbatim end-to-end
// =====================================================================

/// Build a tiny PureFile with a single fn whose body returns an
/// expression-level Verbatim, and assert the raw bytes survive
/// `to_source` 1:1 (the stub identifier is replaced by the raw text).
#[test]
fn test_pureexpr_verbatim_splices_raw_bytes_in_fn_body() {
    use crate::pure::ast::{
        PureBlock, PureExpr, PureFn, PureGenerics, PureItem, PureStmt, PureVis,
    };

    let raw = "html ! { < div > { value } < / div > }";
    let body = PureBlock {
        stmts: vec![PureStmt::Expr(PureExpr::Verbatim(raw.to_string()))],
    };
    let f = PureFn {
        attrs: vec![],
        vis: PureVis::Private,
        is_async: false,
        is_async_inferred: false,
        is_const: false,
        is_unsafe: false,
        abi: None,
        name: "dsl_body".to_string(),
        generics: PureGenerics::default(),
        params: vec![],
        ret: None,
        body,
    };
    let file = PureFile {
        attrs: vec![],
        items: vec![PureItem::Fn(f)],
    };

    let out = file.to_source().expect("to_source");

    // Raw payload survived 1:1.
    assert!(
        out.contains(raw),
        "raw expr-verbatim payload should survive 1:1, got:\n{}",
        out
    );
    // Stub identifier must NOT leak into the output (splice succeeded).
    assert!(
        !out.contains("__ryo_verbatim_expr_"),
        "stub identifier should be spliced away, got:\n{}",
        out
    );
}

/// Multiple PureExpr::Verbatim instances should each get a fresh
/// per-call index and splice independently — no collisions.
#[test]
fn test_pureexpr_verbatim_multiple_get_independent_indices() {
    use crate::pure::ast::{
        PureBlock, PureExpr, PureFn, PureGenerics, PureItem, PureStmt, PureVis,
    };

    let raw_a = "html ! { < a > }";
    let raw_b = "html ! { < b > }";
    let mk_fn = |name: &str, raw: &str| PureFn {
        attrs: vec![],
        vis: PureVis::Private,
        is_async: false,
        is_async_inferred: false,
        is_const: false,
        is_unsafe: false,
        abi: None,
        name: name.to_string(),
        generics: PureGenerics::default(),
        params: vec![],
        ret: None,
        body: PureBlock {
            stmts: vec![PureStmt::Expr(PureExpr::Verbatim(raw.to_string()))],
        },
    };
    let file = PureFile {
        attrs: vec![],
        items: vec![
            PureItem::Fn(mk_fn("a", raw_a)),
            PureItem::Fn(mk_fn("b", raw_b)),
        ],
    };

    let out = file.to_source().expect("to_source");

    assert!(
        out.contains(raw_a),
        "raw_a should be present, got:\n{}",
        out
    );
    assert!(
        out.contains(raw_b),
        "raw_b should be present, got:\n{}",
        out
    );
    assert!(
        !out.contains("__ryo_verbatim_expr_"),
        "no stub identifier should leak, got:\n{}",
        out
    );
}

// =====================================================================
// B-3-cont: PureStmt::Verbatim end-to-end
// =====================================================================

/// Verify that a stmt-level Verbatim survives `to_source` 1:1 and the
/// stub identifier does not leak.
#[test]
fn test_purestmt_verbatim_splices_raw_line_in_fn_body() {
    use crate::pure::ast::{PureBlock, PureFn, PureGenerics, PureItem, PureStmt, PureVis};

    // Raw stmt with deliberate spacing the user wants to keep verbatim.
    let raw = "let __x  =  \"keep   me\".to_string();";
    let body = PureBlock {
        stmts: vec![PureStmt::Verbatim(raw.to_string())],
    };
    let f = PureFn {
        attrs: vec![],
        vis: PureVis::Private,
        is_async: false,
        is_async_inferred: false,
        is_const: false,
        is_unsafe: false,
        abi: None,
        name: "stmt_carrier".to_string(),
        generics: PureGenerics::default(),
        params: vec![],
        ret: None,
        body,
    };
    let file = PureFile {
        attrs: vec![],
        items: vec![PureItem::Fn(f)],
    };

    let out = file.to_source().expect("to_source");

    assert!(
        out.contains(raw),
        "raw stmt-verbatim payload should survive 1:1, got:\n{}",
        out
    );
    assert!(
        !out.contains("__ryo_verbatim_stmt_"),
        "stmt stub identifier should be spliced away, got:\n{}",
        out
    );
}

/// PureStmt::Verbatim and PureExpr::Verbatim use **independent
/// registries / index counters** — verify that mixing both in the
/// same file does not collide their splices.
#[test]
fn test_purestmt_and_pureexpr_verbatim_coexist_without_collision() {
    use crate::pure::ast::{
        PureBlock, PureExpr, PureFn, PureGenerics, PureItem, PureStmt, PureVis,
    };

    let stmt_raw = "tracing :: info ! ( \"hi\" );";
    let expr_raw = "html ! { < div > }";
    let body = PureBlock {
        stmts: vec![
            PureStmt::Verbatim(stmt_raw.to_string()),
            PureStmt::Expr(PureExpr::Verbatim(expr_raw.to_string())),
        ],
    };
    let f = PureFn {
        attrs: vec![],
        vis: PureVis::Private,
        is_async: false,
        is_async_inferred: false,
        is_const: false,
        is_unsafe: false,
        abi: None,
        name: "mix".to_string(),
        generics: PureGenerics::default(),
        params: vec![],
        ret: None,
        body,
    };
    let file = PureFile {
        attrs: vec![],
        items: vec![PureItem::Fn(f)],
    };

    let out = file.to_source().expect("to_source");

    assert!(
        out.contains(stmt_raw),
        "stmt raw must survive, got:\n{}",
        out
    );
    assert!(
        out.contains(expr_raw),
        "expr raw must survive, got:\n{}",
        out
    );
    assert!(
        !out.contains("__ryo_verbatim_stmt_"),
        "no stmt stub should leak, got:\n{}",
        out
    );
    assert!(
        !out.contains("__ryo_verbatim_expr_"),
        "no expr stub should leak, got:\n{}",
        out
    );
}

/// Successive calls must reset both registries — same contract as the
/// expr-level reset test, extended to cover stmt.
#[test]
fn test_purestmt_verbatim_registry_resets_between_calls() {
    use crate::pure::ast::{PureBlock, PureFn, PureGenerics, PureItem, PureStmt, PureVis};

    let raw = "let n = 1 + 2 ;";
    let mk = || PureFile {
        attrs: vec![],
        items: vec![PureItem::Fn(PureFn {
            attrs: vec![],
            vis: PureVis::Private,
            is_async: false,
            is_async_inferred: false,
            is_const: false,
            is_unsafe: false,
            abi: None,
            name: "f".to_string(),
            generics: PureGenerics::default(),
            params: vec![],
            ret: None,
            body: PureBlock {
                stmts: vec![PureStmt::Verbatim(raw.to_string())],
            },
        })],
    };
    let first = mk().to_source().expect("first");
    let second = mk().to_source().expect("second");
    assert_eq!(
        first, second,
        "successive to_source calls must be byte-identical"
    );
    assert!(first.contains(raw) && second.contains(raw));
    assert!(!first.contains("__ryo_verbatim_stmt_"));
}

/// A second call to to_source after a successful first call must
/// reset the registry — otherwise indices would accumulate and the
/// stub identifier search would miss.
#[test]
fn test_pureexpr_verbatim_registry_resets_between_calls() {
    use crate::pure::ast::{
        PureBlock, PureExpr, PureFn, PureGenerics, PureItem, PureStmt, PureVis,
    };

    let raw = "tracing :: info ! ( \"x\" )";
    let mk = || PureFile {
        attrs: vec![],
        items: vec![PureItem::Fn(PureFn {
            attrs: vec![],
            vis: PureVis::Private,
            is_async: false,
            is_async_inferred: false,
            is_const: false,
            is_unsafe: false,
            abi: None,
            name: "f".to_string(),
            generics: PureGenerics::default(),
            params: vec![],
            ret: None,
            body: PureBlock {
                stmts: vec![PureStmt::Expr(PureExpr::Verbatim(raw.to_string()))],
            },
        })],
    };
    let first = mk().to_source().expect("first call");
    let second = mk().to_source().expect("second call");
    assert!(first.contains(raw) && second.contains(raw));
    assert!(!first.contains("__ryo_verbatim_expr_"));
    assert!(!second.contains("__ryo_verbatim_expr_"));
    // The two outputs should be byte-identical: a leaky registry
    // would cause the second run to use idx=1 instead of idx=0,
    // shifting the stub identifier (which would never be found,
    // and a stub would leak — already covered above) or simply
    // producing a different formatted form.
    assert_eq!(
        first, second,
        "successive to_source calls should produce identical output"
    );
}