Brummel
246b5c7455
Ships fn print : forall a. Show a => (a borrow) -> () !IO in the
prelude with explicit-let body \\x -> let s = show x in do
io/print_str s. Three new E2E fixtures + tests verify the full
path:
- show_print_smoke: 4 primitives smoke (print 42 / true / 'hello' /
3.14) — compile, run, expected stdout
- show_user_adt: data IntBox + instance prelude.Show IntBox +
print (MkIntBox 7) — stdout '7'
- show_no_instance: let f : Int -> Int = \\x -> x in do print f —
fires Show-aware NoInstance with DESIGN.md §Prelude(built-in)
classes cross-reference
IR-shape pin in print_mono_body_shape.rs asserts post-mono
print__Int.body is structurally Term::Let → App(show__Int) →
Do(io/print_str). Protects the explicit let-binder for the heap-Str
RC discipline per eob.1 Str carve-out.
Three plan-defects-fixed-inline surfaced during user-ADT E2E,
necessary repairs to make the spec's stated user-ADT trajectory
work end-to-end:
(a) mono.rs (2 sites): MonoTarget::FreeFn::type_args were carrying
bare type-cons references; normalised to canonical
<owner>.<bare> form via workspace_registry.normalize_type_for_lookup
so synthesised cross-module bodies' post-mono walks reach the
registry-keyed instance entries. Symmetric to the existing
class-method-arm normalisation.
(b) codegen/lib.rs (3 sites: resolve_top_level_fn, lower_app
cross-module arm, synth_with_extras Var arm): post-mono
synthesised bodies may carry cross-module references to modules
their source template didn't import (prelude.print__<UserType>
references show_user_adt.show__<UserType> even though prelude
does not import user modules). Fall back to direct
module_user_fns lookup when prefix not in import_map. Both
ends were independently typechecked before mono ran; the
cross-module ref is created by mono not by source.
(c) lib.rs synth FreeFnCall arm: walked Type::Forall.constraints,
substituted rigid vars with fresh metavars, pushed one
ResidualConstraint per declared constraint. Without this,
print f at Int -> Int would silently typecheck and fail with
a confusing 'unknown variable: show' at codegen rather than
fire the right typecheck-time NoInstance diagnostic.
NoInstance Float-aware arm in check/lib.rs:770-779 extended with
a parallel class == 'prelude.Show' branch that cross-references
DESIGN.md §Prelude(built-in) classes verbatim. Negative-fixture
test asserts code 'no-instance' + Show substring + Prelude-(built-in)-
classes substring.
DESIGN.md §Prelude(built-in) classes milestone-24 paragraph flips
fn print from 'ships in 24.3' to 'shipped in iter 24.3' with body
shape + pin file reference. §Float semantics gains a Show-Float
NaN-spelling cross-reference paragraph linking show 1.5 / show nan /
show inf to instance Show Float via float_to_str.
Roadmap P1 'Post-22 Prelude — Show + print rewire' flipped to [x]
with closing summary naming all three shipped iters (24.1 / 24.2 /
24.3). New P2 entry 'Retire io/print_int|bool|float effect-ops +
migrate example corpus to print' inserted at top of P2.
Tests: 556 passed (was 552 + 4 new). bench/cross_lang exit 0;
bench/compile_check + bench/check exit 1 on documented noise-class
metrics per the audit-cma lineage envelope (8th consecutive
audit-grade observation, baseline pristine per conservative-call).
Milestone 24 closes structurally with this iter. Standard audit
pipeline next.
75 lines
3.0 KiB
Rust
75 lines
3.0 KiB
Rust
//! 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.json");
|
|
// 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.json");
|
|
// print (MkIntBox 7) → "7\n" (via user instance prelude.Show
|
|
// IntBox that unwraps via match + int_to_str).
|
|
assert_eq!(stdout, "7", "got: {stdout:?}");
|
|
}
|