ilo 26.5.0

ilo - the token-minimal programming language AI agents write
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

// Regression: `fld` used as a binding name must surface the friendly
// ILO-P011 reserved-word error, not a misleading ILO-T006 arity mismatch
// from the fold builtin. Mirrors the `cnt`/`brk` handling from commit
// 8928635. Personas reach for `fld` as a natural variable name (field /
// fold / folder) and previously paid the retry tax on a cryptic error.
//
// The fix lives in the parser, so all engines surface the same error.
// Tests confirm each engine's CLI path emits ILO-P011 with the right
// wording.

use std::process::Command;

fn ilo() -> Command {
    Command::new(env!("CARGO_BIN_EXE_ilo"))
}

fn run(engine: &str, src: &str, entry: &str) -> (bool, String) {
    let out = ilo()
        .args([src, engine, entry])
        .output()
        .expect("failed to run ilo");
    (
        out.status.success(),
        String::from_utf8_lossy(&out.stderr).into_owned(),
    )
}

// `fld=5` at top level inside a function body.
const FLD_BINDING_IN_BODY: &str = "f>n;fld=5;fld";

fn check_fld_binding(engine: &str) {
    let (ok, stderr) = run(engine, FLD_BINDING_IN_BODY, "f");
    assert!(!ok, "engine={engine}: expected parse failure");
    assert!(
        stderr.contains("ILO-P011"),
        "engine={engine}: missing ILO-P011, stderr={stderr}"
    );
    assert!(
        stderr.contains("`fld` is reserved for the fold builtin"),
        "engine={engine}: missing friendly message, stderr={stderr}"
    );
    assert!(
        stderr.contains("field") || stderr.contains("folder"),
        "engine={engine}: hint should suggest field/folder, stderr={stderr}"
    );
    // Should not cascade into the verifier's misleading arity error.
    assert!(
        !stderr.contains("ILO-T006"),
        "engine={engine}: arity cascade leaked, stderr={stderr}"
    );
    assert!(
        !stderr.contains("arity mismatch"),
        "engine={engine}: arity cascade leaked, stderr={stderr}"
    );
}

#[test]
fn fld_binding_in_body_tree() {
    check_fld_binding("--vm");
}

#[test]
fn fld_binding_in_body_vm() {
    check_fld_binding("--vm");
}

#[test]
#[cfg(feature = "cranelift")]
fn fld_binding_in_body_cranelift() {
    check_fld_binding("--jit");
}

// `fld=5` inside a loop body, the natural shape a persona writes when
// accumulating a fold-style value across iterations.
const FLD_BINDING_IN_LOOP: &str = "f a:n>n;@i 0..a{fld=i};1";

fn check_fld_binding_loop(engine: &str) {
    let (ok, stderr) = run(engine, FLD_BINDING_IN_LOOP, "f");
    assert!(!ok, "engine={engine}: expected parse failure");
    assert!(
        stderr.contains("ILO-P011"),
        "engine={engine}: missing ILO-P011, stderr={stderr}"
    );
    assert!(
        stderr.contains("`fld` is reserved for the fold builtin"),
        "engine={engine}: missing friendly message, stderr={stderr}"
    );
    assert!(
        !stderr.contains("ILO-T006"),
        "engine={engine}: arity cascade leaked, stderr={stderr}"
    );
}

#[test]
fn fld_binding_in_loop_tree() {
    check_fld_binding_loop("--vm");
}

#[test]
fn fld_binding_in_loop_vm() {
    check_fld_binding_loop("--vm");
}

#[test]
#[cfg(feature = "cranelift")]
fn fld_binding_in_loop_cranelift() {
    check_fld_binding_loop("--jit");
}

// Sanity: `fld` as the fold builtin still works after the fix.
#[test]
fn fld_as_builtin_still_works() {
    let out = ilo()
        .args(["add x:n y:n>n;+x y;f>n;fld add [1 2 3 4] 0", "--vm", "f"])
        .output()
        .expect("failed to run ilo");
    assert!(
        out.status.success(),
        "fld builtin broken: stderr={}",
        String::from_utf8_lossy(&out.stderr)
    );
    let stdout = String::from_utf8_lossy(&out.stdout);
    assert!(stdout.contains("10"), "expected 10, got: {stdout}");
}