Iter 4c: IR-Snapshot-Tests als Codegen-Regressions-Schutz

Vier Snapshots in crates/ail/tests/snapshots/ (sum, max3, hello, list)
sichern den erzeugten LLVM-IR. Test-Helper normalisiert target triple
und trailing whitespace, sonst byte-für-byte-Vergleich. Update via
UPDATE_SNAPSHOTS=1 cargo test ir_snapshot_. Mismatch erzeugt eine
.actual-Datei mit dem aktuellen Output für Diff-Inspektion.

crates/ail/tests/ir_snapshot.rs

@@ -0,0 +1,153 @@
+//! IR-Snapshot-Tests: schützen die Codegen-Pipeline vor unbeabsichtigten
+//! Veränderungen am LLVM-IR. Snapshots in tests/snapshots/. Update mit
+//! UPDATE_SNAPSHOTS=1 cargo test ir_snapshot_.
+
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+fn ail_bin() -> &'static str {
+    env!("CARGO_BIN_EXE_ail")
+}
+
+/// Normalisiert IR-Text für Plattform-Stabilität:
+/// - `target triple = "..."` -> `target triple = "<NORMALIZED>"`
+/// - trailing whitespace pro Zeile entfernen
+/// - LF-Zeilenenden, Datei endet mit genau einem `\n`
+fn normalize(ir: &str) -> String {
+    let mut out = String::with_capacity(ir.len());
+    for line in ir.split('\n') {
+        let line = line.strip_suffix('\r').unwrap_or(line);
+        let trimmed = line.trim_end();
+        if let Some(rest) = trimmed.strip_prefix("target triple = ") {
+            // rest ist `"..."` (mit Anführungszeichen) — komplett normalisieren.
+            let _ = rest;
+            out.push_str("target triple = \"<NORMALIZED>\"");
+        } else {
+            out.push_str(trimmed);
+        }
+        out.push('\n');
+    }
+    // split('\n') erzeugt nach einem trailing `\n` ein leeres letztes Stück,
+    // das oben mit `\n` abgeschlossen wurde. Dadurch enthält `out` typischerweise
+    // genau ein abschließendes `\n`. Doppelte `\n\n` am Ende reduzieren.
+    while out.ends_with("\n\n") {
+        out.pop();
+    }
+    if !out.ends_with('\n') {
+        out.push('\n');
+    }
+    out
+}
+
+fn snapshots_dir() -> PathBuf {
+    let manifest_dir = env!("CARGO_MANIFEST_DIR");
+    Path::new(manifest_dir).join("tests").join("snapshots")
+}
+
+fn examples_dir() -> PathBuf {
+    let manifest_dir = env!("CARGO_MANIFEST_DIR");
+    Path::new(manifest_dir)
+        .parent()
+        .unwrap()
+        .parent()
+        .unwrap()
+        .join("examples")
+}
+
+fn first_diff_line(a: &str, b: &str) -> Option<(usize, String, String)> {
+    let mut la = a.lines();
+    let mut lb = b.lines();
+    let mut idx = 1usize;
+    loop {
+        match (la.next(), lb.next()) {
+            (Some(x), Some(y)) => {
+                if x != y {
+                    return Some((idx, x.to_string(), y.to_string()));
+                }
+            }
+            (Some(x), None) => return Some((idx, x.to_string(), String::from("<EOF>"))),
+            (None, Some(y)) => return Some((idx, String::from("<EOF>"), y.to_string())),
+            (None, None) => return None,
+        }
+        idx += 1;
+    }
+}
+
+fn check_ir_snapshot(example: &str, snapshot_name: &str) {
+    let example_path = examples_dir().join(example);
+    assert!(
+        example_path.exists(),
+        "example missing: {}",
+        example_path.display()
+    );
+
+    let tmpdir = std::env::temp_dir().join(format!(
+        "ailang_ir_snapshot_{}_{}",
+        snapshot_name.replace('.', "_"),
+        std::process::id()
+    ));
+    std::fs::create_dir_all(&tmpdir).unwrap();
+    let out_ll = tmpdir.join(format!("{snapshot_name}.tmp.ll"));
+
+    let status = Command::new(ail_bin())
+        .args(["emit-ir", example_path.to_str().unwrap(), "-o"])
+        .arg(&out_ll)
+        .status()
+        .expect("ail emit-ir failed to run");
+    assert!(status.success(), "ail emit-ir failed for {example}");
+
+    let actual_raw = std::fs::read_to_string(&out_ll).expect("read emitted IR");
+    let actual = normalize(&actual_raw);
+
+    let snapshot_path = snapshots_dir().join(snapshot_name);
+
+    if std::env::var_os("UPDATE_SNAPSHOTS").is_some() {
+        std::fs::create_dir_all(snapshots_dir()).unwrap();
+        std::fs::write(&snapshot_path, &actual).expect("write snapshot");
+        eprintln!("updated snapshot: {}", snapshot_path.display());
+        return;
+    }
+
+    let expected_raw = std::fs::read_to_string(&snapshot_path).unwrap_or_else(|e| {
+        panic!(
+            "missing snapshot {}: {e}\nrun with UPDATE_SNAPSHOTS=1 to create it",
+            snapshot_path.display()
+        )
+    });
+    let expected = normalize(&expected_raw);
+
+    if actual != expected {
+        let actual_path = snapshot_path.with_extension("ll.actual");
+        std::fs::write(&actual_path, &actual).expect("write .actual");
+        let diff_msg = match first_diff_line(&expected, &actual) {
+            Some((line, want, got)) => format!(
+                "first diff at line {line}:\n  expected: {want}\n  actual:   {got}",
+            ),
+            None => "files differ but no line-level diff found (whitespace?)".to_string(),
+        };
+        panic!(
+            "IR snapshot mismatch for {example}\n{diff_msg}\nactual written to: {}\nrun UPDATE_SNAPSHOTS=1 cargo test ir_snapshot_ to refresh.",
+            actual_path.display()
+        );
+    }
+}
+
+#[test]
+fn ir_snapshot_sum() {
+    check_ir_snapshot("sum.ail.json", "sum.ll");
+}
+
+#[test]
+fn ir_snapshot_max3() {
+    check_ir_snapshot("max3.ail.json", "max3.ll");
+}
+
+#[test]
+fn ir_snapshot_hello() {
+    check_ir_snapshot("hello.ail.json", "hello.ll");
+}
+
+#[test]
+fn ir_snapshot_list() {
+    check_ir_snapshot("list.ail.json", "list.ll");
+}