iter 23.5: prelude free fns + E2E — Eq/Ord milestone close

Five polymorphic prelude free fns (ne/lt/le/gt/ge) plus three E2E
fixtures: positive composition over Int/Bool/Str, user-ADT with
user-written Eq/Ord on IntBox, and Float-NoInstance with a
Float-aware diagnostic addendum cross-referencing DESIGN.md §"Float
semantics".

Two checker-side fixes were needed alongside the prelude additions,
both symmetric to the iter 23.4-prep visibility fix:
- linearity::check_module_with_visible — workspace-aware callee-mode
  resolution so a Borrow-mode user fn forwarding into a prelude poly
  fn (e.g. `at_most x y = not (gt x y)`) doesn't false-fire
  consume-while-borrowed.
- mono::collect_mono_targets — distinguish rigid forall vars from
  unbound metavars; rigid-bearing free-fn targets skip (they get
  re-collected with concrete subst when the enclosing fn itself
  monomorphises). Without this, a polymorphic body calling another
  polymorphic free fn produced a spurious __Unit specialisation
  whose body referenced compare at Unit.

Roadmap split: shipped Eq/Ord half checked, Show + print-rewire half
remains pending behind the heap-Str ABI prerequisite. DESIGN.md
§"Prelude classes" amended.

One pre-existing fixture (test_22b1_missing_method) renamed its
class method ne → tne to avoid collision with the new prelude `ne`.

Bench: check.py + cross_lang.py exit 0; compile_check.py exits 1
with one sub-ms check_ms.local_rec_capture at +26% (tolerance 25%) —
prelude-growth-related noise-band fluctuation, ratifiable per spec
§248-249 and journal Concerns.

crates/ail/tests/eq_float_noinstance.rs

@@ -0,0 +1,45 @@
+//! Pins the Float-aware `NoInstance` diagnostic added in milestone 23.
+//!
+//! Property protected: a polymorphic Eq/Ord helper invoked at Float
+//! fires `no-instance` (since Float has neither Eq nor Ord instance
+//! per DESIGN.md §"Float semantics") AND the diagnostic message
+//! cross-references the canonical Float-semantics section so the
+//! LLM author immediately learns the partial-Float story rather
+//! than seeing a bare "no instance" message.
+
+use ailang_check::check_workspace;
+use ailang_core::workspace::load_workspace;
+use std::path::PathBuf;
+
+fn fixture(name: &str) -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("../../examples")
+        .join(name)
+}
+
+#[test]
+fn eq_at_float_fires_float_aware_noinstance() {
+    let ws = load_workspace(&fixture("eq_float_noinstance.ail.json")).expect("load");
+    let diags = check_workspace(&ws);
+
+    assert!(!diags.is_empty(), "expected NoInstance diagnostic, got none");
+
+    let no_inst = diags
+        .iter()
+        .find(|d| d.code == "no-instance")
+        .unwrap_or_else(|| panic!("expected diagnostic with code 'no-instance', got: {diags:#?}"));
+
+    assert!(
+        no_inst.message.contains("Float"),
+        "expected Float-aware NoInstance diagnostic, got message: {:?}",
+        no_inst.message
+    );
+
+    // Cross-ref to DESIGN.md §Float semantics — the LLM author should be
+    // pointed at the canonical explanation of partial Float orderability.
+    assert!(
+        no_inst.message.contains("Float semantics") || no_inst.message.contains("DESIGN"),
+        "expected NoInstance message to cross-reference DESIGN.md §Float semantics, got: {:?}",
+        no_inst.message
+    );
+}

crates/ail/tests/eq_ord_e2e.rs

@@ -0,0 +1,126 @@
+//! End-to-end tests for the Eq/Ord prelude shipped in milestone 23.
+//!
+//! These tests compile a `.ail.json` workspace via the `ail build`
+//! subcommand, run the resulting native binary, and assert on stdout.
+//! Together they protect:
+//!
+//! 1. Polymorphic-helper composition over the prelude free fns at
+//!    three primitive types (`eq_ord_polymorphic_runs_end_to_end`).
+//!    Property: a user-defined `forall a. Ord a => …` helper that
+//!    calls `gt`/`not` is monomorphised correctly at Int / Bool / Str.
+//! 2. User-ADT integration with the unified mono pass
+//!    (`eq_ord_user_adt_runs_end_to_end`). Property: `instance Eq T`
+//!    + `instance Ord T` for a user-defined `T` produces working
+//!    mono symbols when invoked through the prelude.
+//! 3. Mono-symbol body-hash stability for `eq__IntBox`
+//!    (`eq_ord_user_adt_eq_intbox_hash_stable`). Property: the user
+//!    instance body that the unified pass emits for IntBox is
+//!    bit-stable across refactors; drift here means either a
+//!    legitimate emission change (re-record) or a regression
+//!    (investigate). Mirrors `crates/ail/tests/mono_hash_stability.rs`.
+
+use ailang_check::{check_workspace, monomorphise_workspace};
+use ailang_core::ast::Def;
+use ailang_core::hash::def_hash;
+use ailang_core::workspace::load_workspace;
+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:\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 eq_ord_polymorphic_runs_end_to_end() {
+    let stdout = build_and_run("eq_ord_polymorphic.ail.json");
+    // Helper `at_most(3, 5)` at Int = true → 1
+    // `at_most(true, false)` at Bool = false → 0
+    // `at_most("abc", "abd")` at Str = true → 1
+    // `io/print_int` emits one int per line, so stdout is "1\n0\n1"
+    // after `.trim()` strips the trailing newline.
+    assert_eq!(stdout, "1\n0\n1", "expected 1\\n0\\n1, got {stdout:?}");
+}
+
+#[test]
+fn eq_ord_user_adt_runs_end_to_end() {
+    let stdout = build_and_run("eq_ord_user_adt.ail.json");
+    // eq(MkIntBox 3, MkIntBox 3) = true → 1
+    // eq(MkIntBox 3, MkIntBox 5) = false → 0
+    // `io/print_int` emits one int per line; trimmed stdout is "1\n0".
+    assert_eq!(stdout, "1\n0", "expected 1\\n0, got {stdout:?}");
+}
+
+#[test]
+fn eq_ord_user_adt_eq_intbox_hash_stable() {
+    let ws = load_workspace(&fixture_path("eq_ord_user_adt.ail.json")).expect("load");
+    let diags = check_workspace(&ws);
+    assert!(diags.is_empty(), "typecheck failed: {diags:#?}");
+    let mono = monomorphise_workspace(&ws).expect("mono");
+
+    // The mono symbol for `eq` at a user-defined ADT uses the
+    // `<method>__<8-hex-prefix>` mangling per DESIGN.md
+    // §"Mangling scheme" (primitives use the bare type name; compound
+    // / user-defined types use the 8-hex BLAKE3 prefix of the
+    // canonical type bytes). We look up the single `eq__` symbol
+    // synthesised at `IntBox` — there is only one user instance,
+    // so the find-by-prefix is unambiguous in this fixture.
+    let eq_intbox = mono
+        .modules
+        .values()
+        .flat_map(|m| m.defs.iter())
+        .find_map(|d| match d {
+            Def::Fn(f) if f.name.starts_with("eq__") && f.name != "eq__Int"
+                && f.name != "eq__Bool" && f.name != "eq__Str" =>
+            {
+                Some(f)
+            }
+            _ => None,
+        })
+        .expect("eq__<IntBox-hash> not synthesised");
+
+    // The 8-hex-prefix in the mono-symbol name is the BLAKE3 prefix
+    // of the canonical IntBox type bytes (DESIGN.md §"Mangling
+    // scheme"). Drift here means either the canonical-form encoding
+    // changed or the type's canonical bytes changed — both warrant
+    // investigation before re-pinning.
+    assert_eq!(
+        eq_intbox.name, "eq__cde77856",
+        "eq__IntBox mono-symbol name drifted — type-mangling regression?"
+    );
+
+    // The body hash pins the unified mono pass's IntBox eq emission.
+    // Drift means either a legitimate refactor (re-record) or a
+    // regression in user-instance body propagation (investigate).
+    let h = def_hash(&Def::Fn(eq_intbox.clone()));
+    assert_eq!(
+        h, "9daaffa7528d2a1c",
+        "eq__IntBox body hash drifted — see mono_hash_stability.rs for the resolution pattern"
+    );
+}

crates/ail/tests/prelude_free_fns.rs

@@ -0,0 +1,82 @@
+//! Workspace-level tests for the polymorphic prelude free fns
+//! `ne` / `lt` / `le` / `gt` / `ge` shipped in milestone 23.
+//!
+//! Property protected: each free fn is monomorphised on demand at the
+//! call site's concrete type, producing a mono symbol named
+//! `<fn>__<TypeName>`. If the unified mono pass (iter 23.4) stops
+//! emitting the free-fn mono arm, or the prelude entry for the fn
+//! gets renamed / dropped, these tests fail.
+//!
+//! See `crates/ail/tests/mono_unification.rs` (iter 23.4) for the
+//! end-to-end runtime correctness checks; this file checks only that
+//! the mono symbols are produced.
+
+use ailang_check::{check_workspace, monomorphise_workspace};
+use ailang_core::workspace::load_workspace;
+use std::path::PathBuf;
+
+fn fixture(name: &str) -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("../../examples")
+        .join(name)
+}
+
+fn mono_symbol_names(workspace_name: &str) -> Vec<String> {
+    let ws = load_workspace(&fixture(workspace_name)).expect("load");
+    let diags = check_workspace(&ws);
+    assert!(diags.is_empty(), "typecheck failed: {:#?}", diags);
+    let mono = monomorphise_workspace(&ws).expect("mono");
+    mono.modules
+        .values()
+        .flat_map(|m| m.defs.iter())
+        .filter_map(|d| match d {
+            ailang_core::ast::Def::Fn(f) => Some(f.name.clone()),
+            _ => None,
+        })
+        .collect()
+}
+
+#[test]
+fn ne_at_int_produces_mono_symbol() {
+    let names = mono_symbol_names("ne_at_int_smoke.ail.json");
+    assert!(
+        names.iter().any(|n| n == "ne__Int"),
+        "expected ne__Int in workspace, found: {names:#?}"
+    );
+}
+
+#[test]
+fn lt_at_int_produces_mono_symbol() {
+    let names = mono_symbol_names("lt_at_int_smoke.ail.json");
+    assert!(
+        names.iter().any(|n| n == "lt__Int"),
+        "expected lt__Int in workspace, found: {names:#?}"
+    );
+}
+
+#[test]
+fn le_at_str_produces_mono_symbol() {
+    let names = mono_symbol_names("le_at_str_smoke.ail.json");
+    assert!(
+        names.iter().any(|n| n == "le__Str"),
+        "expected le__Str in workspace, found: {names:#?}"
+    );
+}
+
+#[test]
+fn gt_at_bool_produces_mono_symbol() {
+    let names = mono_symbol_names("gt_at_bool_smoke.ail.json");
+    assert!(
+        names.iter().any(|n| n == "gt__Bool"),
+        "expected gt__Bool in workspace, found: {names:#?}"
+    );
+}
+
+#[test]
+fn ge_at_int_produces_mono_symbol() {
+    let names = mono_symbol_names("ge_at_int_smoke.ail.json");
+    assert!(
+        names.iter().any(|n| n == "ge__Int"),
+        "expected ge__Int in workspace, found: {names:#?}"
+    );
+}