Brummel/AILang
1
0
Fork 0
Code Issues 29 Pull Requests Actions Packages Projects Releases Wiki Activity

iter ext-rename: .ailx → .ail across the live toolchain

Browse Source 
The surface-form file extension changes from .ailx to .ail. AILang's
authoring surface now uses the same .ail stem as its canonical JSON
form (.ail.json), giving the language a single coherent extension
family: .ail is the LLM-authored Form A, .ail.json is the canonical
JSON-AST Form B.

Scope (touched):
- 61 example renames examples/**/*.ailx → .ail (git mv)
- 1 rename experiments/.../rendered/ailx.md → ail.md
- 35 content-edited live-toolchain files (crates/, docs/DESIGN.md,
  docs/roadmap.md, docs/PROSE_ROUNDTRIP.md, skills/, bench/reference/*.c,
  experiment crates under experiments/.../{render,harness,master})
- Experiment-crate cohort rename Cohort::Ailx → Cohort::Ail,
  Form::Ailx → Form::Ail, per_cohort/ailx → per_cohort/ail,
  {form-only: ailx} → {form-only: ail}, ```ailx → ```ail

Out of scope (deliberately untouched, to preserve honest history):
- docs/journal-archive.md (content-frozen per CLAUDE.md)
- docs/journals/, docs/specs/, docs/plans/, bench/orchestrator-stats/
- experiments/.../runs/ (frozen LLM-output artefacts; models actually
  saw .ailx — renaming would falsify the experimental record)

Verification: cargo build/test --workspace green; experiment crate
cargo test green; bench/check.py + compile_check.py + cross_lang.py
all 0-regressed; negative grep for ailx|Ailx|AILX outside the
out-of-scope paths returns zero matches.

Opens immediate follow-up: roadmap.md P2 todo `ail check`/build/run
accept .ail extension — after this rename, .ail is canonical
authoring surface but the CLI still produces a misleading JSON-parse
error on `ail check foo.ail`. That's the next iter.
This commit is contained in:
Brummel
2026-05-12 14:20:27 +02:00
parent 17b370bbb3
commit 72e54f4fd3
97 changed files with 318 additions and 210 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/ail/src/main.rs
+3 -3
View File
@@ -190,7 +190,7 @@ enum Cmd {
#[arg(long)]
json: bool,
},
/// Parses a `.ailx` source file (form (A)) into canonical
/// Parses a `.ail` source file (form (A)) into canonical
/// `.ail.json`. Iter 14c addition; symmetric to `render`.
///
/// The form-(A) projection is one of potentially many producers of
@@ -269,7 +269,7 @@ fn compose_merge_prose_prompt(original_form_a: &str, edited_prose: &str) -> Stri
"You are integrating prose edits back into an AILang module.
ROLE
Your job is to produce an updated AILang module in Form-A (an .ailx
Your job is to produce an updated AILang module in Form-A (an .ail
file) that reflects the human's prose edits while preserving the
load-bearing semantic detail from the original module.
@@ -826,7 +826,7 @@ fn main() -> Result<()> {
}
}
Cmd::Parse { path, output } => {
// Read .ailx, parse via the surface crate, emit canonical
// Read .ail, parse via the surface crate, emit canonical
// JSON. Symmetric to `render` (which goes the other way).
let src = std::fs::read_to_string(&path)
.with_context(|| format!("reading {}", path.display()))?;
crates/ail/tests/e2e.rs
+3 -3
View File
@@ -429,8 +429,8 @@ fn render_parse_round_trip_canonical() {
.expect("run ail render");
assert!(render.status.success(), "ail render failed");
let tmp = std::env::temp_dir().join(format!("ailang_render_e2e_{}.ailx", std::process::id()));
std::fs::write(&tmp, &render.stdout).expect("write rendered ailx");
let tmp = std::env::temp_dir().join(format!("ailang_render_e2e_{}.ail", std::process::id()));
std::fs::write(&tmp, &render.stdout).expect("write rendered ail");
let parsed = Command::new(ail_bin())
.args(["parse", tmp.to_str().unwrap()])
@@ -2153,7 +2153,7 @@ fn build_and_run_with_rc_stats(example: &str) -> (String, u64, u64, i64) {
/// not leak the LCons outer cells.
///
/// Background: 18f.2's tail-latency bench found that
/// `bench_latency_explicit.ailx` peaks at the same RSS as the
/// `bench_latency_explicit.ail` peaks at the same RSS as the
/// implicit-mode variant despite carrying mode annotations
/// throughout the hot path. Diagnosis: in
///
crates/ail/tests/roundtrip_cli.rs
+7 -7
View File
@@ -62,7 +62,7 @@ fn roundtrip_one(fixture: &Path, tmpdir: &Path) -> Result<(), String> {
let bytes_orig = ailang_core::canonical::to_bytes(&original_module);
let h_orig = blake3::hash(&bytes_orig);
// Step B: `ail render <fixture>` → captured stdout = ailx text.
// Step B: `ail render <fixture>` → captured stdout = ail text.
let render_out = Command::new(ail_bin())
.args(["render", fixture.to_str().unwrap()])
.output()
@@ -75,20 +75,20 @@ fn roundtrip_one(fixture: &Path, tmpdir: &Path) -> Result<(), String> {
));
}
// Step C: write the rendered .ailx into the tempdir.
// Step C: write the rendered .ail into the tempdir.
let stem = fixture
.file_name()
.and_then(|n| n.to_str())
.and_then(|n| n.strip_suffix(".ail.json"))
.unwrap_or("fixture");
let tmp_ailx = tmpdir.join(format!("{stem}.round.ailx"));
std::fs::write(&tmp_ailx, &render_out.stdout)
.map_err(|e| format!("write tempfile {}: {e}", tmp_ailx.display()))?;
let tmp_ail = tmpdir.join(format!("{stem}.round.ail"));
std::fs::write(&tmp_ail, &render_out.stdout)
.map_err(|e| format!("write tempfile {}: {e}", tmp_ail.display()))?;
// Step D: `ail parse <tmp_ailx>` → captured stdout = canonical
// Step D: `ail parse <tmp_ail>` → captured stdout = canonical
// bytes + trailing newline.
let parse_out = Command::new(ail_bin())
.args(["parse", tmp_ailx.to_str().unwrap()])
.args(["parse", tmp_ail.to_str().unwrap()])
.output()
.map_err(|e| format!("spawn ail parse: {e}"))?;
if !parse_out.status.success() {
crates/ailang-core/specs/form_a.md
+7 -7
View File
@@ -2,7 +2,7 @@
Form-A is the canonical textual surface of AILang. It is the form that
LLMs generate when asked to produce or edit AILang code, and the form
that `ail parse <file>.ailx` reads. The inverse direction — printing
that `ail parse <file>.ail` reads. The inverse direction — printing
JSON-AST as Form-A — is `ail render <file>.ail.json`. Round-trip
through this pair is the gating contract: `parse(render(m)) == m`
for every well-formed module.
@@ -26,7 +26,7 @@ Lisp-style S-expression dress that:
- omits structural noise (no field tags; positions carry meaning)
- has a real parser with positional error messages
- round-trips through `ail render` ↔ `ail parse` losslessly
- is the form every existing `examples/*.ailx` is written in
- is the form every existing `examples/*.ail` is written in
LLMs generate Form-A; the toolchain converts to JSON.
@@ -48,7 +48,7 @@ LLMs generate Form-A; the toolchain converts to JSON.
DEF*)
```
The module name MUST equal the file stem (`bench_list_sum.ailx` →
The module name MUST equal the file stem (`bench_list_sum.ail` →
`(module bench_list_sum ...)`).
## Imports
@@ -269,11 +269,11 @@ significantly.
## Few-shot corpus
These four modules are real `examples/*.ailx` content. Each one is
These four modules are real `examples/*.ail` content. Each one is
parseable and typechecks clean. Pattern-match against them when
generating new code.
### 1 — `hello.ailx`: minimal IO program
### 1 — `hello.ail`: minimal IO program
```
(module hello
@@ -283,7 +283,7 @@ generating new code.
(body (do io/print_str "Hello, AILang."))))
```
### 2 — `borrow_own_demo.ailx`: mode annotations on a recursive list
### 2 — `borrow_own_demo.ail`: mode annotations on a recursive list
```
(module borrow_own_demo
@@ -333,7 +333,7 @@ generating new code.
(do io/print_int (app sum_list xs)))))))
```
### 3 — `lit_pat.ailx`: literal patterns and nested ctor patterns
### 3 — `lit_pat.ail`: literal patterns and nested ctor patterns
```
(module lit_pat
crates/ailang-surface/tests/round_trip.rs
+33 -33
View File
@@ -10,18 +10,18 @@
//! For every `examples/*.ail.json` fixture, load → `print` →
//! `parse` → canonical bytes; assert byte-equal to original.
//!
//! 2. `every_ailx_fixture_matches_its_json_counterpart`: hand-
//! authored ground-truth check. For every `examples/*.ailx`
//! 2. `every_ail_fixture_matches_its_json_counterpart`: hand-
//! authored ground-truth check. For every `examples/*.ail`
//! fixture, parse → canonical bytes; if a same-stem `.ail.json`
//! counterpart exists, assert canonical-byte equality against
//! it. Pins the `.ailx` corpus against semantic drift between
//! it. Pins the `.ail` corpus against semantic drift between
//! the two forms at the fixture level.
//!
//! 3. `parse_then_print_then_parse_is_idempotent_on_every_ailx_fixture`:
//! 3. `parse_then_print_then_parse_is_idempotent_on_every_ail_fixture`:
//! Direction 2 of the Roundtrip Invariant. For every well-formed
//! `.ailx` text `t`, asserts `canonical_bytes(parse(t))` equals
//! `.ail` text `t`, asserts `canonical_bytes(parse(t))` equals
//! `canonical_bytes(parse(print(parse(t))))`. Robust against
//! future `.ailx` fixtures without a JSON counterpart.
//! future `.ail` fixtures without a JSON counterpart.
use std::path::{Path, PathBuf};
@@ -100,7 +100,7 @@ fn round_trip_one(path: &Path) -> Result<(), String> {
Ok(())
}
fn list_ailx_fixtures() -> Vec<PathBuf> {
fn list_ail_fixtures() -> Vec<PathBuf> {
let dir = examples_dir();
let mut paths: Vec<PathBuf> = std::fs::read_dir(&dir)
.unwrap_or_else(|e| panic!("read_dir({}): {e}", dir.display()))
@@ -109,7 +109,7 @@ fn list_ailx_fixtures() -> Vec<PathBuf> {
.filter(|p| {
p.file_name()
.and_then(|n| n.to_str())
.map(|n| n.ends_with(".ailx"))
.map(|n| n.ends_with(".ail"))
.unwrap_or(false)
})
.collect();
@@ -118,11 +118,11 @@ fn list_ailx_fixtures() -> Vec<PathBuf> {
}
#[test]
fn every_ailx_fixture_matches_its_json_counterpart() {
let fixtures = list_ailx_fixtures();
fn every_ail_fixture_matches_its_json_counterpart() {
let fixtures = list_ail_fixtures();
assert!(
!fixtures.is_empty(),
"no .ailx fixtures found under {}",
"no .ail fixtures found under {}",
examples_dir().display()
);
@@ -130,32 +130,32 @@ fn every_ailx_fixture_matches_its_json_counterpart() {
let mut paired = 0usize;
let mut parse_only = 0usize;
for ailx_path in &fixtures {
let text = match std::fs::read_to_string(ailx_path) {
for ail_path in &fixtures {
let text = match std::fs::read_to_string(ail_path) {
Ok(t) => t,
Err(e) => {
failures.push(format!("{}: read failed: {e}", ailx_path.display()));
failures.push(format!("{}: read failed: {e}", ail_path.display()));
continue;
}
};
let parsed = match ailang_surface::parse(&text) {
Ok(m) => m,
Err(e) => {
failures.push(format!("{}: parse failed: {e}", ailx_path.display()));
failures.push(format!("{}: parse failed: {e}", ail_path.display()));
continue;
}
};
// Same-stem counterpart lookup. `<stem>.ailx` → `<stem>.ail.json`.
let stem = ailx_path
// Same-stem counterpart lookup. `<stem>.ail` → `<stem>.ail.json`.
let stem = ail_path
.file_name()
.and_then(|n| n.to_str())
.and_then(|n| n.strip_suffix(".ailx"))
.and_then(|n| n.strip_suffix(".ail"))
.unwrap_or("");
let json_path = ailx_path.with_file_name(format!("{stem}.ail.json"));
let json_path = ail_path.with_file_name(format!("{stem}.ail.json"));
if !json_path.exists() {
// Spec: parse success alone is sufficient for `.ailx` files
// Spec: parse success alone is sufficient for `.ail` files
// without a JSON counterpart. (Today: none expected.)
parse_only += 1;
continue;
@@ -166,7 +166,7 @@ fn every_ailx_fixture_matches_its_json_counterpart() {
Err(e) => {
failures.push(format!(
"{}: load_module({}) failed: {e}",
ailx_path.display(),
ail_path.display(),
json_path.display()
));
continue;
@@ -179,7 +179,7 @@ fn every_ailx_fixture_matches_its_json_counterpart() {
let s_round = String::from_utf8_lossy(&bytes_parsed).into_owned();
failures.push(format!(
"{} vs {}: canonical bytes differ.\noriginal: {s_orig}\nparsed: {s_round}",
ailx_path.display(),
ail_path.display(),
json_path.display()
));
continue;
@@ -189,7 +189,7 @@ fn every_ailx_fixture_matches_its_json_counterpart() {
if !failures.is_empty() {
panic!(
"{} of {} .ailx fixture(s) failed cross-check (paired ok: {}, parse-only: {}):\n{}",
"{} of {} .ail fixture(s) failed cross-check (paired ok: {}, parse-only: {}):\n{}",
failures.len(),
fixtures.len(),
paired,
@@ -198,27 +198,27 @@ fn every_ailx_fixture_matches_its_json_counterpart() {
);
}
eprintln!(
".ailx cross-check ok ({} paired, {} parse-only)",
".ail cross-check ok ({} paired, {} parse-only)",
paired, parse_only
);
}
/// Direction 2 of the Roundtrip Invariant (DESIGN.md §"Roundtrip
/// Invariant"): for every well-formed `.ailx` text `t`, the
/// Invariant"): for every well-formed `.ail` text `t`, the
/// composition `parse → print → parse` is idempotent on the AST.
///
/// For the 57 `.ailx` fixtures that have a JSON counterpart this
/// For the 57 `.ail` fixtures that have a JSON counterpart this
/// follows logically from `print_then_parse_round_trips_every_fixture`
/// + `every_ailx_fixture_matches_its_json_counterpart`. This test
/// + `every_ail_fixture_matches_its_json_counterpart`. This test
/// asserts the property directly so it stays robust for future
/// `.ailx` fixtures without a JSON counterpart, and so the spec's
/// `.ail` fixtures without a JSON counterpart, and so the spec's
/// Direction-2 claim has a dedicated enforcement point.
#[test]
fn parse_then_print_then_parse_is_idempotent_on_every_ailx_fixture() {
let fixtures = list_ailx_fixtures();
fn parse_then_print_then_parse_is_idempotent_on_every_ail_fixture() {
let fixtures = list_ail_fixtures();
assert!(
!fixtures.is_empty(),
"no .ailx fixtures found under {}",
"no .ail fixtures found under {}",
examples_dir().display()
);
@@ -266,12 +266,12 @@ fn parse_then_print_then_parse_is_idempotent_on_every_ailx_fixture() {
if !failures.is_empty() {
panic!(
"{} of {} .ailx fixture(s) failed idempotency check (passed: {}):\n{}",
"{} of {} .ail fixture(s) failed idempotency check (passed: {}):\n{}",
failures.len(),
fixtures.len(),
passed,
failures.join("\n\n")
);
}
eprintln!("parse→print→parse idempotency ok for {passed} .ailx fixtures");
eprintln!("parse→print→parse idempotency ok for {passed} .ail fixtures");
}