AILang/crates/ail/tests/show_print_e2e.rs

//! End-to-end tests for the `print` polymorphic helper shipped in
//! milestone 24.3.
//!
//! Each test compiles a `.ail.json` workspace via the `ail build`
//! subcommand, runs the resulting native binary, and asserts on stdout.
//!
//! Properties protected:
//! - `print_primitives_smoke_runs_end_to_end`: `print` at four primitive
//!   types (Int / Bool / Str / Float) emits the expected textual
//!   representation of each value via the prelude Show instances +
//!   `io/print_str`. The four `print__T` mono symbols synthesise from
//!   the prelude `instance prelude.Show T` bodies and route through the
//!   corresponding `<T>_to_str` runtime primitive.
//! - `print_user_adt_runs_end_to_end`: `print` composes with a
//!   user-declared `instance prelude.Show IntBox` to emit a user-ADT's
//!   structural representation. Confirms that the post-mono synthesised
//!   `print__<UserType>` body's nested `show x` call rewrites to the
//!   user instance's `show__<UserType>` mono symbol and that the
//!   cross-module reference from `prelude.print__<UserType>` to
//!   `<user_module>.show__<UserType>` lowers cleanly through codegen.

use std::path::PathBuf;
use std::process::Command;

fn fixture_path(name: &str) -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("../../examples")
        .join(name)
}

fn build_and_run(fixture: &str) -> String {
    let src = fixture_path(fixture);
    let out = std::env::temp_dir().join(format!("ail_{}.bin", fixture.replace('.', "_")));

    let build = Command::new(env!("CARGO_BIN_EXE_ail"))
        .args(["build", src.to_str().unwrap(), "-o", out.to_str().unwrap()])
        .output()
        .expect("ail build");
    assert!(
        build.status.success(),
        "ail build failed for {fixture}:\nstdout: {}\nstderr: {}",
        String::from_utf8_lossy(&build.stdout),
        String::from_utf8_lossy(&build.stderr),
    );

    let run = Command::new(&out).output().expect("run binary");
    assert!(
        run.status.success(),
        "binary exited non-zero:\nstdout: {}\nstderr: {}",
        String::from_utf8_lossy(&run.stdout),
        String::from_utf8_lossy(&run.stderr),
    );
    String::from_utf8_lossy(&run.stdout).trim().to_string()
}

#[test]
fn print_primitives_smoke_runs_end_to_end() {
    let stdout = build_and_run("show_print_smoke.ail");
    // print 42        → "42\n"   (int_to_str + puts)
    // print true      → "true\n" (bool_to_str + puts)
    // print "hello"   → "hello\n" (str_clone + puts)
    // print 3.14      → "3.14\n" (float_to_str / libc %g + puts)
    // puts emits each Str + a trailing newline; trimmed output is
    // "42\ntrue\nhello\n3.14".
    assert_eq!(stdout, "42\ntrue\nhello\n3.14", "got: {stdout:?}");
}

#[test]
fn print_user_adt_runs_end_to_end() {
    let stdout = build_and_run("show_user_adt.ail");
    // print (MkIntBox 7) → "7\n" (via user instance prelude.Show
    // IntBox that unwraps via match + int_to_str).
    assert_eq!(stdout, "7", "got: {stdout:?}");
}

/// RED pin (rpe-bug-1, 2026-05-14): `(app print <arg>)` where `<arg>`
/// contains a class-method call (here `eq 1 2 : Bool`) must lower
/// cleanly. The iter 24.3 rewire taught `synth` to push a `Show T`
/// residual for `print`'s declared constraint at the same `Var` site
/// where the poly-free-fn observation is pushed (see
/// `crates/ailang-check/src/lib.rs` lines 2908-2960). But the
/// mono-rewrite walker in `crates/ailang-check/src/mono.rs`
/// (`interleave_slots` and `rewrite_mono_calls`) treats every
/// poly-free-fn `Var` as consuming exactly one free-fn slot — it does
/// not advance the class-residual cursor for the constraint that was
/// pushed at the same site. The consequence is a one-position
/// misalignment: the *next* class-method call in the body consumes
/// the `Show T` slot, rewriting `eq` → `show__Bool`. Codegen then
/// reports `call prelude.show__Bool arg type mismatch: expected i1,
/// got i64`.
///
/// Property protected: a `print` call whose argument contains a
/// class-method invocation lowers to a valid IR call sequence — the
/// `eq` (or other class-method) call is rewritten to its correct
/// mono symbol, not to a stale `Show T` residual symbol.
///
/// Fixture `examples/print_eq_arg_repro.ail` exercises the shape
/// `(app print (app eq 1 2))`. Expected stdout: `"false"` (Show Bool
/// of `eq 1 2` → false). This test is GREEN once the cursor
/// alignment in `interleave_slots` / `rewrite_mono_calls` is fixed
/// to advance the class cursor for constraints carried by a
/// poly-free-fn Var.
#[test]
fn print_with_class_method_arg_does_not_misalign_mono_cursor() {
    let stdout = build_and_run("print_eq_arg_repro.ail");
    assert_eq!(stdout, "false", "got: {stdout:?}");
}