test(codegen): RED-pin #53 — monomorphic (new T args) over a user ADT must build

A monomorphic `(new Counter 42)` over a user-defined ADT that declares a
`new` fn passes `ail check` but crashes `ail build --alloc=rc` with
`unknown variable: Counter.new`. Distinct root from #51 (the polymorphic
type-arg drop, fixed by ee4107c) — the #51 fix deliberately left the
monomorphic app-lowering path unchanged.

Root (data-flow traced): the `Term::New` desugar
(crates/ailang-core/src/desugar.rs ~1091) lowers the no-type-arg
monomorphic `(new Counter 42)` to `Term::App { callee:
Var("Counter.new") }`. The checker's TypeDef-first ladder resolves that
dotted callee, so `ail check` is clean; codegen's call-lowering
(`lower_app` / `is_static_callee` in crates/ailang-codegen/src/lib.rs)
does not recognise the dotted `Counter.new` user-ADT constructor callee,
so the `Term::Var` arm falls through to `CodegenError::UnknownVar`
(lib.rs:1712). The documented `lower_app`↔`is_static_callee` lockstep
pair — a check↔codegen disagreement on whether `Counter.new` resolves.
The user `new` fn body IS codegen'd; only the dotted call-site is
unrecognised.

The RED test is minimal and autonomous: a single inline module (user
ADT + `new` fn + a `main` calling `(new Counter 42)`), minimised from
the 3-module 35-symbol kem_2_counter_new.ail reproducer — the
match/print scaffolding is dropped because the crash is at the
call-site lowering, independent of how the result is consumed. Asserts
check passes, build succeeds, the binary runs and prints `ok`. RED at
HEAD (fails at build with the exact symptom). GREEN side resolves the
dotted T.new user-ADT callee at codegen, symmetric to the checker.

refs #53

crates/ail/tests/user_adt_new_mono_pin.rs

@@ -0,0 +1,116 @@
+//! E2E regression pin for #53 — a monomorphic `(new T args)` over a
+//! user-defined ADT that declares a `new` fn must build, not just check.
+//!
+//! Property protected: for a single-module program with `(data Counter
+//! (ctor MkCounter (con Int)))`, a `(fn new …)` constructing it, and a
+//! `main` that calls `(new Counter 42)`, the whole pipeline
+//! (`ail check` AND `ail build --alloc=rc`) succeeds and the binary
+//! runs. The monomorphic `(new T …)` form carries no `NewArg::Type`, so
+//! the `Term::New` desugar lowers it to `(app T.new <values…>)` — a
+//! type-scoped `Var` callee `Counter.new` (desugar.rs:1091-1097). The
+//! checker's TypeDef-first ladder resolves that callee, so `ail check`
+//! is clean; codegen's call-lowering does not, so the call falls through
+//! to the indirect path and aborts with `unknown variable: `Counter.new``
+//! (CodegenError::UnknownVar, ailang-codegen/src/lib.rs:1712). The check
+//! pass and the codegen pass disagree on whether `Counter.new` resolves
+//! — a check↔codegen mismatch on the monomorphic dotted constructor
+//! callee.
+//!
+//! This is distinct-root from #51: #51 was the polymorphic
+//! `(new T <elem> …)` leg (a dropped `NewArg::Type`); the #51 fix left
+//! the monomorphic app-lowering path deliberately unchanged. This pin
+//! covers the monomorphic-over-user-ADT path.
+//!
+//! The fixture is inline and autonomous (single module, no imports, no
+//! shared file, no kernel-tier RawBuf), minimised from the 3-module
+//! 35-symbol `kem_2_counter_new.ail` reproducer: the match/print
+//! scaffolding is dropped because the crash is at the `(new Counter 42)`
+//! call-site lowering, independent of how the result is consumed.
+
+use std::path::Path;
+use std::process::Command;
+
+fn ail_bin() -> &'static str {
+    env!("CARGO_BIN_EXE_ail")
+}
+
+fn write_tmp(src: &str) -> std::path::PathBuf {
+    let dir = std::env::temp_dir().join(format!(
+        "user_adt_new_mono_{}",
+        std::process::id()
+    ));
+    std::fs::create_dir_all(&dir).unwrap();
+    let p = dir.join("user_adt_new_mono.ail");
+    std::fs::write(&p, src).unwrap();
+    p
+}
+
+/// The minimal autonomous trigger: a user ADT + a `new` fn + a `main`
+/// that calls `(new Counter 42)` and binds the result.
+const PROG: &str = r#"(module user_adt_new_mono
+
+  (data Counter
+    (ctor MkCounter (con Int)))
+
+  (fn new
+    (doc "Build a Counter initialised to the given value.")
+    (type (fn-type (params (con Int)) (ret (con Counter))))
+    (params n)
+    (body (term-ctor Counter MkCounter n)))
+
+  (fn main
+    (type (fn-type (params) (ret (con Unit)) (effects IO)))
+    (params)
+    (body
+      (let c (new Counter 42)
+        (do io/print_str "ok\n")))))
+"#;
+
+#[test]
+fn mono_new_over_user_adt_builds_and_runs() {
+    let src = write_tmp(PROG);
+
+    // `ail check` is clean today — the TypeDef-first ladder resolves
+    // `Counter.new`. This half already passes; it documents that the
+    // bug is NOT a check-layer rejection.
+    let check = Command::new(ail_bin())
+        .args(["check", src.to_str().unwrap()])
+        .output()
+        .expect("ail check failed to run");
+    assert!(
+        check.status.success(),
+        "ail check must accept `(new Counter 42)` over a user ADT; got:\n{}",
+        String::from_utf8_lossy(&check.stderr)
+    );
+
+    // The failing half (#53): `ail build --alloc=rc` aborts with
+    // `unknown variable: `Counter.new``. Once fixed, the build must
+    // succeed and the binary must run cleanly.
+    let out = std::env::temp_dir().join(format!("user_adt_new_mono_bin_{}", std::process::id()));
+    let build = Command::new(ail_bin())
+        .args(["build", src.to_str().unwrap(), "--alloc=rc", "-o"])
+        .arg(&out)
+        .output()
+        .expect("ail build failed to run");
+    assert!(
+        build.status.success(),
+        "ail build --alloc=rc must compile a monomorphic `(new Counter 42)` over a \
+         user ADT, but it failed (regression #53 — check↔codegen mismatch on the \
+         `Counter.new` dotted constructor callee):\n{}",
+        String::from_utf8_lossy(&build.stderr)
+    );
+
+    assert!(Path::new(&out).exists(), "build reported success but produced no binary");
+
+    let run = Command::new(&out).output().expect("execute compiled binary");
+    assert!(
+        run.status.success(),
+        "the compiled binary must run cleanly; stderr:\n{}",
+        String::from_utf8_lossy(&run.stderr)
+    );
+    assert_eq!(
+        String::from_utf8_lossy(&run.stdout),
+        "ok\n",
+        "the program prints `ok` after constructing the Counter"
+    );
+}