Section 07: FileCheck-Style IR Pattern Matching

Status: In Progress Goal: Expand the existing FileCheck IR assertion framework to 30+ directive-based tests covering RC emission, COW patterns, closure codegen, ABI, and iterator patterns. Tests use // CHECK: directives embedded in .ori source files, compiled through the LLVM pipeline, with the resulting IR matched against directives via literal substring matching. Order-sensitive categories (RC, COW, closure env layout, ABI, iterator cleanup) use .exact mode with CHECK-LABEL function anchoring to enforce ordering. Pure existence/absence checks (e.g., “no RC ops anywhere”, “sret attribute present”) use .matches mode.

Success Criteria:

30+ FileCheck tests in compiler/ori_llvm/tests/codegen/ — satisfies mission criterion: “FileCheck IR assertions” (44 total)
.exact mode with function-scoped IR slicing (via extract_function_ir()) for order-sensitive tests — correctness over convenience
.matches mode reserved for existence/absence-only checks — avoids the multiple-match flaw
No regex syntax ({{.*}}) in CHECK patterns — engine uses literal substring matching only
Every “should optimize” test has a “should NOT optimize” companion — positive+negative pairing
5+ tests per category — satisfies mission criterion: “comprehensive IR coverage” (7 rc + 5 cow + 5 closures + 5 abi + 5 iterator + 3 cross)
aot.rs split below 500-line limit — per impl-hygiene.md file size rule (completed in 07.0)

Context: Behavioral tests (Ori spec tests) verify that programs produce correct output but cannot catch codegen quality regressions. A program that leaks memory due to missing RcDec still produces correct stdout. A COW fast path that silently degrades to always-copy still produces correct output. FileCheck-style tests pin the LLVM IR patterns that indicate correct codegen, catching regressions at the IR level before they manifest as runtime bugs.

Current state: 12 FileCheck tests already exist in compiler/ori_llvm/tests/codegen/ and run via ir_checks.rs (a module inside the aot integration test target). The check.rs matching engine in ori_test_harness is complete with both .matches and .exact modes. This section expands coverage to 30+ tests and fixes known harness limitations.

Matching mode rationale: The .matches mode (order-independent) is convenient but dangerous as default for order-sensitive tests:

RC ordering is load-bearing: ori_rc_inc BEFORE use, ori_rc_dec AFTER last use. .matches mode cannot verify ordering.
COW ordering is load-bearing: is_shared check BEFORE mutation, copy BEFORE write. .matches cannot verify this.
Iterator cleanup placement is load-bearing: ori_iter_drop AFTER loop exit. .matches cannot verify placement.
Multiple-match flaw: In .matches mode, two identical CHECK: ori_rc_inc directives both match the same IR line. A test expecting 2 increments passes with only 1 actual. This is a known limitation of the current engine (see 07.0 task below).
CHECK-NOT global scope: In .matches mode, CHECK-NOT scans the entire module including runtime/stdlib functions. In .exact mode, CHECK-NOT scans from the current position to EOF (not bounded by labels). The robust mitigation is function-scoped IR slicing via extract_function_ir() in the FileCheckStrategy (see 07.0 prerequisite), which feeds only the target function’s IR to the matching engine.

No debug/release revisions for IR-level tests. LLVM IR is identical between debug and release builds — FastISel only affects machine code instruction selection, not the IR. Debug/release revisions only make sense for behavioral/execution tests (in aot/), not IR pattern tests. IR tests compile at default optimization level.

No .ll baseline blessing. FileCheck pins specific patterns, not full IR. Full-IR baseline comparison is Section 12’s role (scripts/ir-baseline.sh). These are complementary: Section 07 pins codegen correctness patterns, Section 12 detects any IR shape drift. Both use ORI_BLESS=1 as the control plane but at different granularities.

Reference implementations:

Rust compiler/tests/codegen/: CHECK directives in Rust source files, compiled with --emit=llvm-ir, matched against LLVM IR.
Zig test/src/LlvmIr.zig (lines 45-73): .matches mode for order-independent matching.
LLVM llvm-project/llvm/utils/FileCheck/: Reference FileCheck with CHECK/CHECK-NOT/CHECK-LABEL/CHECK-NEXT.

Depends on: Section 02 (shared harness provides directive parsing, check engine). Section 02 is complete.

Cross-section notes:

Section 11 (CI): The ir_checks module runs as part of cargo test -p ori_llvm --test aot, which test-all.sh already runs. No CI wiring changes needed for existing tests. New tests added to ir_checks.rs are automatically picked up.
Section 12 (Baselines): Section 07 pins patterns via CHECK directives; Section 12 pins full IR shape. No overlap — complementary coverage at different granularities.
aot.rs helpers: The compile_and_capture_ir() function uses the debug binary and ORI_DEBUG_LLVM=1. This is sufficient for IR-level pattern testing since IR is identical between debug/release. If release-specific IR testing is ever needed, compile_to_llvm_ir() (also in aot.rs) provides a separate path.

07.0 Prerequisites: Harness Fixes and aot.rs Split

Goal: Fix known harness bugs that would make tests unreliable, and split the over-limit aot.rs file into proper submodules.

Harness Bug Fixes

Document the multiple-match flaw in check.rs. In .matches mode, two identical CHECK: ori_rc_inc directives both match the same IR line. A test expecting N occurrences of a pattern passes with only 1 actual. Add a //! doc comment in check.rs warning about this. Mitigation: use .exact mode with CHECK-LABEL scoping for any test that cares about occurrence count, or use distinct substring patterns (e.g., include the argument: CHECK: call void @ori_rc_inc(ptr %xs) instead of bare CHECK: ori_rc_inc).
Fix CHECK-NOT scope in exact mode. Currently run_exact_mode in check.rs implements CheckNot by scanning from search_from to EOF. This means CHECK-NOT is unbounded — it picks up symbols from later functions, runtime declarations, and stdlib stubs. Fix: update CheckNot logic to evaluate only the lines between search_from and the next positive Check or CheckLabel match (or EOF if no subsequent matches), aligning with standard LLVM FileCheck semantics where CHECK-NOT checks the region between its preceding and following positive directives.
Add function-scoped IR slicing to the FileCheckStrategy. CHECK-LABEL provides section anchoring within a file, but it does NOT provide true function isolation — CheckNot can still see symbols from later functions. The robust solution: the FileCheckStrategy::execute() method should use extract_function_ir() (from util/ir_capture.rs after the split) to slice the captured module IR to the target function before passing it to run_checks(). Convention: each test file must have a // @function: <name> custom directive specifying the target function. If absent, use _ori_main as default. This ensures CHECK-NOT patterns are truly function-scoped.
Document CHECK-LABEL search behavior. In exact mode, CHECK-LABEL searches from line 0 (resetting search position). Document that LABEL patterns should be specific enough to unambiguously identify the target function (e.g., CHECK-LABEL: define void @_ori_main not just CHECK-LABEL: @main). With function-scoped IR slicing above, CHECK-LABEL is still useful for within-function structure (e.g., anchoring to a specific basic block label) but no longer the primary function isolation mechanism.

aot.rs Split

Split compiler/ori_llvm/tests/aot/util/aot.rs (737 lines) into submodules. The file exceeds the 500-line limit (impl-hygiene.md). Extract to:
- util/compile.rs — compile_and_run(), compile_and_run_capture(), compile_and_run_with_args(), assert_aot_success(), assert_multifile_aot_success(), exit code helpers
- util/ir_capture.rs — compile_and_capture_ir(), extract_function_ir(), compile_to_llvm_ir(), IR inspection helpers
- util/binary.rs — ori_binary(), ir_capture_binary(), stdlib_path(), workspace_root(), path/binary discovery
- util/aot.rs — re-exports from submodules for backward compatibility (thin facade) Each submodule must be under 500 lines. Update util/mod.rs to expose all submodules.
Subsection close-out (07.0) — MANDATORY before starting 07.1:
- All tasks above are [x] and verified
- Update this subsection’s status in section frontmatter to complete
- Run /improve-tooling retrospectively on THIS subsection — Retrospective 07.0: no tooling gaps — test-infrastructure refactoring used cargo test/clippy/test-all.sh, all sufficient
- Repo hygiene check — run diagnostics/repo-hygiene.sh --check and clean any detected temp files. Verified clean 2026-04-13.

07.1 Evolve ir_checks.rs into Harness-Based Runner

File(s): compiler/ori_llvm/tests/aot/ir_checks.rs (existing — evolve)

Current state: ir_checks.rs is a module inside compiler/ori_llvm/tests/aot/main.rs with 12 hand-written test functions, each calling run_filecheck() which compiles a source file from tests/codegen/, parses CHECK directives, and runs check::run_checks() in .matches mode. This works but does not use the shared harness’s run_test_directory() orchestration.

Decision: evolve ir_checks.rs, do NOT create a separate codegen_checks.rs target. Creating a separate integration test binary would:

Duplicate compilation test infrastructure (the aot helpers are already available inside aot/)
Require extracting aot helpers to a shared location just for cross-target imports
Add a second test binary that test-all.sh would need to discover

Instead, evolve ir_checks.rs to use run_test_directory() for automatic test discovery, replacing the existing per-test functions with the discovery runner (see migration task below).

07.2 RC Emission Tests

File(s): compiler/ori_llvm/tests/codegen/rc/ (new subdirectory — test files only; discovered by the harness runner)

Write FileCheck tests that pin RC emission patterns. These tests verify that the AIMS pipeline + LLVM codegen emits the expected RC operations. All RC tests use .exact mode with CHECK-LABEL function anchoring because RC operation ordering is correctness-critical (inc before use, dec after last use).

Important: use actual runtime symbol names. The runtime uses type-specific RC functions, not generic ones. Common patterns in emitted IR:

Lists: ori_buffer_rc_dec, ori_buffer_store_elem_dec, ori_buffer_store_elem_count
Strings: ori_str_rc_inc, ori_str_rc_dec
RC alloc/free: ori_rc_alloc, ori_rc_dec
Verify the actual symbols by running ORI_DEBUG_LLVM=1 cargo run -- build <test.ori> and inspecting the IR before writing CHECK patterns.

Every “should emit RC” test has a companion “should NOT emit RC” test (positive+negative pairing).

compiler/ori_llvm/tests/codegen/rc/shared_value_inc_dec.ori — shared list value produces buffer RC cleanup ops:
```
// CHECK-LABEL: define void @_ori_main
// CHECK: ori_buffer_rc_dec

@main () -> void = {
    let xs = [1, 2, 3];
    let ys = xs;
    print(msg: ys.len().to_str())
}
```
Note: The exact CHECK patterns should be verified against ORI_DEBUG_LLVM=1 output during implementation. The runtime uses type-specific symbols (e.g., ori_buffer_rc_dec for lists, ori_str_rc_inc for strings), not generic ori_rc_inc/ori_rc_dec.

compiler/ori_llvm/tests/codegen/rc/unique_owner_no_rc.ori — unique owner consumed linearly, no RC operations (negative pin):

// CHECK-LABEL: define void @_ori_main
// CHECK-NOT: ori_rc_inc
// CHECK-NOT: ori_str_rc_inc

@main () -> void = {
    let xs = [1, 2, 3];
    print(msg: xs.len().to_str())
}

compiler/ori_llvm/tests/codegen/rc/scalar_no_rc.ori — scalar int/bool have no RC operations (negative pin):

// CHECK-LABEL: define void @_ori_main
// CHECK-NOT: ori_rc_inc
// CHECK-NOT: ori_rc_dec
// CHECK-NOT: ori_buffer_rc

@main () -> void = {
    let x = 42;
    let y = x + 1;
    print(msg: y.to_str())
}

compiler/ori_llvm/tests/codegen/rc/string_copy_inc.ori — string copy produces RC increment:

// CHECK-LABEL: define void @_ori_main
// CHECK: ori_str_rc_inc

@main () -> void = {
    let s = "hello";
    let t = s;
    print(msg: t);
    print(msg: s)
}

compiler/ori_llvm/tests/codegen/rc/loop_rc_balanced.ori — RC in for loop body is balanced:

// CHECK-LABEL: define void @_ori_main

@main () -> void = {
    let xs = ["hello", "world"];
    for x in xs do print(msg: x)
}

compiler/ori_llvm/tests/codegen/rc/nested_struct_sharing.ori — sharing a struct with heap-allocated fields triggers RC:

// CHECK-LABEL: define void @_ori_main

type Wrapper = { inner: [int] }

@main () -> void = {
    let w = Wrapper { inner: [1, 2, 3] };
    let w2 = w;
    print(msg: w2.inner.len().to_str())
}

compiler/ori_llvm/tests/codegen/rc/list_of_strings_elem_dec.ori — list of strings uses element dec for cleanup:

// CHECK-LABEL: define void @_ori_main
// CHECK: ori_buffer_store_elem_dec

@main () -> void = {
    let xs = ["hello", "world"];
    print(msg: xs.len().to_str())
}

Verify new test files are discovered by the harness runner — no manual entry points needed after 07.1 migration. Confirmed: WalkDir-based discovery finds all 7 files in rc/ subdirectory; run_all_codegen_filecheck passes with 19 total tests.
TPR checkpoint — /tpr-review covering 07.0–07.2 implementation work (superseded by final full-section TPR, iteration 6 clean)
Subsection close-out (07.2) — MANDATORY before starting 07.3:
- All tasks above are [x] and the subsection’s behavior is verified
- Update this subsection’s status in section frontmatter to complete
- Run /improve-tooling retrospectively on THIS subsection — Retrospective 07.2: no tooling gaps. ORI_DEBUG_LLVM=1 dump + grep was sufficient for symbol verification. FileCheck runner error messages clear and diagnostic.
- Repo hygiene check — run diagnostics/repo-hygiene.sh --check and clean any detected temp files. Verified clean 2026-04-13.

07.3 COW and Closure Tests

File(s): compiler/ori_llvm/tests/codegen/cow/ (new), compiler/ori_llvm/tests/codegen/closures/ (new)

COW Pattern Tests

COW is one of the highest-risk codegen areas — a silent degradation from fast-path to always-copy is invisible to behavioral tests. COW tests use .exact mode with CHECK-LABEL because is_shared check ordering relative to mutation is correctness-critical.

compiler/ori_llvm/tests/codegen/cow/mutation_triggers_store_ops.ori — list mutation via index assignment emits store operations:
```
// CHECK-LABEL: define void @_ori_main
// CHECK: ori_buffer_store_elem_dec
// CHECK: ori_buffer_store_elem_count

@main () -> void = {
    let xs = [1, 2, 3];
    xs[0] = 42;
    print(msg: xs[0].to_str())
}
```
Note: Index assignment (xs[0] = 42) is supported and already tested in compiler/ori_llvm/tests/codegen/cow_is_shared_check.ori. The spec test at tests/spec/expressions/index_access.ori:359 is skipped for a different aspect of index assignment.

compiler/ori_llvm/tests/codegen/cow/shared_mutation_triggers_copy.ori — shared value mutation triggers copy:

// CHECK-LABEL: define void @_ori_main

@main () -> void = {
    let xs = [1, 2, 3];
    let ys = xs;
    ys[0] = 42;
    print(msg: ys[0].to_str());
    print(msg: xs[0].to_str())
}

compiler/ori_llvm/tests/codegen/cow/unique_mutation_no_copy.ori — unique owner mutation skips copy (negative pin):

// CHECK-LABEL: define void @_ori_main
// CHECK-NOT: memcpy

@main () -> void = {
    let xs = [1, 2, 3];
    xs[0] = 42;
    print(msg: xs[0].to_str())
}

compiler/ori_llvm/tests/codegen/cow/map_insert.ori — map mutation via .insert():

// CHECK-LABEL: define void @_ori_main

@main () -> void = {
    let m = {"a": 1, "b": 2};
    let m2 = m;
    m2.insert(key: "a", value: 42);
    print(msg: m2["a"].to_str())
}

Note: Map bracket mutation (m["a"] = 42) may not be supported — verify during implementation. .insert() is the safe alternative.

compiler/ori_llvm/tests/codegen/cow/drop_at_scope_end.ori — drop hint emitted for COW values at scope end:

// CHECK-LABEL: define void @_ori_main

@main () -> void = {
    let xs = [1, 2, 3];
    let ys = xs;
    print(msg: ys.len().to_str())
}

Closure Codegen Tests

Closure tests pin capture patterns, environment layout, and RC for captured values. Closure env layout tests use .exact mode with CHECK-LABEL because the environment allocation must happen before closure invocation.

compiler/ori_llvm/tests/codegen/closures/capture_allocates_env.ori — closure with captures creates env allocation:

// CHECK-LABEL: define void @_ori_main
// CHECK: ori_rc_alloc

@main () -> void = {
    let x = "hello";
    let f = () -> str = x;
    print(msg: f())
}

compiler/ori_llvm/tests/codegen/closures/no_capture_no_env.ori — closure without captures has no env allocation (negative pin):

// CHECK-LABEL: define void @_ori_main
// CHECK-NOT: ori_rc_alloc

@main () -> void = {
    let f = (x: int) -> int = x + 1;
    print(msg: f(x: 5).to_str())
}

compiler/ori_llvm/tests/codegen/closures/nested_closure_rc_chain.ori — multiple closures sharing a captured list create RC chain (adapted from plan: closure-returning-closure not supported by call syntax, so two closures sharing xs exercises the same RC chain pattern):

// CHECK-LABEL: define void @_ori_main
// CHECK: ori_rc_alloc
// CHECK: ori_rc_alloc

@main () -> void = {
    let xs = [1, 2, 3];
    let f = () -> int = xs.len();
    let g = () -> int = xs.len();
    print(msg: f().to_str());
    print(msg: g().to_str())
}

compiler/ori_llvm/tests/codegen/closures/closure_in_loop.ori — closure created inside loop:

// CHECK-LABEL: define void @_ori_main

@main () -> void = {
    let xs = [1, 2, 3];
    for x in xs do {
        let f = () -> str = x.to_str();
        print(msg: f())
    }
}

compiler/ori_llvm/tests/codegen/closures/closure_as_argument.ori — closure passed as function argument:

// CHECK-LABEL: define void @_ori_main

@apply (f: () -> int) -> int = f();

@main () -> void = {
    let x = 10;
    let result = apply(f: () -> int = x * 2);
    print(msg: result.to_str())
}

Verify new test files are discovered by the harness runner — no manual entry points needed after 07.1 migration. Confirmed: WalkDir discovery finds all 10 files in cow/ and closures/ subdirectories; run_all_codegen_filecheck passes with 29 total tests.
Subsection close-out (07.3) — MANDATORY before starting 07.4:
- All tasks above are [x] and the subsection’s behavior is verified
- Update this subsection’s status in section frontmatter to complete
- Run /improve-tooling retrospectively on THIS subsection — Retrospective 07.3: no tooling gaps. Adapted nested closure test (compiler limitation discovered — closure-returning-closure call syntax unsupported; filed as context, not a blocker for IR testing).
- Repo hygiene check — run diagnostics/repo-hygiene.sh --check and clean any detected temp files. Verified clean 2026-04-13.

07.4 ABI, Iterator, and Cross-Feature Interaction Tests

File(s): compiler/ori_llvm/tests/codegen/abi/ (new), compiler/ori_llvm/tests/codegen/iterator/ (new), compiler/ori_llvm/tests/codegen/cross/ (new)

ABI Tests

Verify parameter passing modes and return conventions. ABI prologue/epilogue tests use .exact mode with CHECK-LABEL to verify function signature structure.

compiler/ori_llvm/tests/codegen/abi/scalar_direct_pass.ori — scalar params passed directly (not via pointer):

// @function: _ori_add
// CHECK-LABEL: define i64 @_ori_add
// CHECK-NOT: sret

@add (a: int, b: int) -> int = a + b;

@main () -> void = print(msg: add(a: 1, b: 2).to_str())

compiler/ori_llvm/tests/codegen/abi/struct_sret_return.ori — large struct returned via sret pointer (adapted: uses 3-field Triple not 2-field Point, since 2-field structs fit in 2 registers and don’t use sret; uses .matches mode since sret appears on the define line):

// @function: _ori_make_point
// CHECK-LABEL: define void @_ori_make_point
// CHECK: sret

type Point = { x: int, y: int }

@make_point (x: int, y: int) -> Point = Point { x, y };

@main () -> void = {
    let p = make_point(x: 1, y: 2);
    print(msg: p.x.to_str())
}

compiler/ori_llvm/tests/codegen/abi/void_return.ori — void return convention:

// CHECK-LABEL: define void @_ori_main

@main () -> void = print(msg: "hello")

compiler/ori_llvm/tests/codegen/abi/borrowed_param_no_rc.ori — borrowed param passed without RC operations:

// @function: _ori_helper
// CHECK-LABEL: define i64 @_ori_helper
// CHECK-NOT: ori_rc_inc
// CHECK-NOT: ori_rc_dec

@helper (xs: [int]) -> int = xs.len();

@main () -> void = {
    let xs = [1, 2, 3];
    print(msg: helper(xs:).to_str())
}

compiler/ori_llvm/tests/codegen/abi/multi_param_mixed.ori — multiple params with mixed types:

// @function: _ori_mixed
// CHECK-LABEL: define void @_ori_mixed

@mixed (n: int, s: str, b: bool) -> void = {
    if b then print(msg: s) else print(msg: n.to_str())
};

@main () -> void = mixed(n: 42, s: "hello", b: true)

Iterator Tests

Verify iterator codegen patterns. Iterator cleanup tests use .exact mode because ori_iter_drop placement relative to loop exit is correctness-critical.

compiler/ori_llvm/tests/codegen/iterator/for_loop_normal_drop.ori — normal for loop exit triggers iter_drop:

// CHECK-LABEL: define void @_ori_main
// CHECK: ori_iter_drop

@main () -> void = {
    let xs = [1, 2, 3];
    for x in xs do print(msg: x.to_str())
}

compiler/ori_llvm/tests/codegen/iterator/break_triggers_drop.ori — early break still triggers iter_drop:

// CHECK-LABEL: define void @_ori_main
// CHECK: ori_iter_drop

@main () -> void = {
    let xs = [1, 2, 3, 4, 5];
    for x in xs do {
        if x == 3 then break;
        print(msg: x.to_str())
    }
}

compiler/ori_llvm/tests/codegen/iterator/map_filter_chain.ori — chained iterator methods produce composed iteration:

// CHECK-LABEL: define void @_ori_main

@main () -> void = {
    let xs = [1, 2, 3, 4, 5];
    let ys = xs.iter().filter(predicate: x -> x > 2).collect();
    print(msg: ys.len().to_str())
}

compiler/ori_llvm/tests/codegen/iterator/enumerate_produces_tuple.ori — enumerate produces (int, T) tuples:

// CHECK-LABEL: define void @_ori_main

@main () -> void = {
    let xs = ["a", "b", "c"];
    for (i, x) in xs.iter().enumerate() do {
        print(msg: `{i}: {x}`)
    }
}

compiler/ori_llvm/tests/codegen/iterator/collect_materializes.ori — collect materializes iterator into list:

// CHECK-LABEL: define void @_ori_main

@main () -> void = {
    let xs = [1, 2, 3];
    let doubled = xs.iter().map(transform: x -> x * 2).collect();
    print(msg: doubled.len().to_str())
}

Cross-Feature Interaction Tests

Tests that verify codegen correctness at feature boundaries — where compilers most commonly break.

compiler/ori_llvm/tests/codegen/cross/cow_inside_closure.ori — COW push inside a closure capturing a list:

// CHECK-LABEL: define void @_ori_main

@main () -> void = {
    let xs = [1, 2, 3];
    let mutator = () -> void = {
        xs.push(value: 4);
        print(msg: xs.len().to_str())
    };
    mutator()
}

compiler/ori_llvm/tests/codegen/cross/rc_iterator_break.ori — RC-tracked value inside for loop with early break:

// CHECK-LABEL: define void @_ori_main
// CHECK: ori_iter_drop

@main () -> void = {
    let xs = ["hello", "world", "!"];
    for x in xs do {
        if x == "!" then break;
        let copy = x;
        print(msg: copy)
    }
}

compiler/ori_llvm/tests/codegen/cross/closure_loop_drop.ori — closure capturing a value, created inside a loop, properly drops env:

// CHECK-LABEL: define void @_ori_main

@main () -> void = {
    let names = ["alice", "bob"];
    for name in names do {
        let greet = () -> str = `hello {name}`;
        print(msg: greet())
    }
}

Verify test count: 42 tests total (12 flat + 7 rc + 5 cow + 5 closures + 5 abi + 5 iterator + 3 cross), exceeds the 30+ requirement.
TPR checkpoint — /tpr-review covering 07.3–07.4 implementation work (superseded by final full-section TPR, iteration 6 clean)
Subsection close-out (07.4) — MANDATORY before starting 07.N:
- All tasks above are [x] and the subsection’s behavior is verified
- Update this subsection’s status in section frontmatter to complete
- Run /improve-tooling retrospectively on THIS subsection — Retrospective 07.4: no tooling gaps. Learned CHECK-LABEL exact-mode semantics (search starts AFTER label line); FileCheck error messages correctly diagnosed the mismatch.
- Repo hygiene check — run diagnostics/repo-hygiene.sh --check and clean any detected temp files. Verified clean 2026-04-13.

07.R Third Party Review Findings

[TPR-07-001-codex][high] section-07-filecheck.md:72 — Replace claimed CHECK-LABEL function scoping with real function slicing. Resolved: Fixed on 2026-04-12. Added extract_function_ir() slicing to FileCheckStrategy in 07.0+07.1, fixed CHECK-NOT scope in check.rs as prerequisite.
[TPR-07-002-codex][high] section-07-filecheck.md:268 — Rewrite COW mutation examples to supported set/insert forms. Resolved: Fixed on 2026-04-12. Replaced xs[0] = 42 with .updated() and .push(), m["a"] = 42 with .insert(). Added notes about unsupported syntax.
[TPR-07-003-codex][medium] section-07-filecheck.md:164 — Retarget RC checks to actual runtime symbols. Resolved: Fixed on 2026-04-12. Added type-specific symbol guidance, updated examples to use ori_buffer_rc_dec/ori_str_rc_inc, added verification instructions.
[TPR-07-001-gemini][high] section-07-filecheck.md:65 — Fix CHECK-NOT unbounded scope in exact mode. Resolved: Fixed on 2026-04-12. Added check.rs fix as prerequisite in 07.0 (bound CHECK-NOT to region between positive directives). Same root cause as TPR-07-001-codex.
[TPR-07-002-gemini][high] section-07-filecheck.md:121 — Remove duplicate per-file manual tests. Resolved: Fixed on 2026-04-12. Updated 07.1 to delete per-file manual test functions after migration to discovery runner.
[TPR-07-003-gemini][medium] section-07-filecheck.md:79 — Update aot.rs split target list to actual functions. Resolved: Fixed on 2026-04-12. Replaced compile_and_check_output()/compile_expect_error() with actual functions: compile_and_run_capture(), assert_aot_success(), etc.

Round 2 findings (iteration 2):

[TPR-07-001-codex][high] section-07-filecheck.md:6 — Replace remaining CHECK-LABEL function-scoping contract with real function slicing in frontmatter. Resolved: Fixed on 2026-04-12. Updated goal, success criteria, and exit criteria to reference function-scoped IR slicing.
[TPR-07-002-codex][high] section-07-filecheck.md:258 — Delete per-file ir_checks entry-point tasks in 07.2/07.3. Resolved: Fixed on 2026-04-12. Replaced with “verify discovery runner picks up new files” tasks.
[TPR-07-003-codex][medium] section-07-filecheck.md:140 — Select exact mode for CHECK-NEXT files too. Resolved: Fixed on 2026-04-12. Updated mode selection to trigger on CHECK-LABEL OR CHECK-NEXT.
[TPR-07-004-codex][medium] section-07-filecheck.md:289 — Restore list index assignment — it IS supported. Resolved: Fixed on 2026-04-12. Restored xs[0] = 42 in COW examples, updated notes.
[TPR-07-005-codex][medium] 00-overview.md:29 — Reconcile overview mission criterion with no-revision decision. Resolved: Fixed on 2026-04-12. Updated overview to reference .exact + function slicing instead of debug/release revisions.
[TPR-07-001-gemini][high] section-07-filecheck.md:277 — Replace .updated() with .set() — .updated() doesn’t exist. Resolved: Fixed on 2026-04-12. Restored index assignment syntax instead (verified to work via existing cow_is_shared_check.ori).
[TPR-07-002-gemini][high] section-07-filecheck.md:435 — Add @function: directives to ABI tests targeting non-main functions. Resolved: Fixed on 2026-04-12. Added // @function: _ori_add, _ori_make_point, _ori_helper, _ori_mixed to respective test examples.

Round 3 findings (§07.2–07.4 implementation TPR):

[TPR-07-001-codex][high] compiler/ori_llvm/tests/aot/ir_checks.rs:68 — COW index assignment tests pass despite E4003 ARC internal error. Resolved: Fixed on 2026-04-12. Rewrote 3 COW tests to use .push() instead of xs[0] = 42 (which hits E4003 before desugaring). Now CHECK patterns match actual COW ops (ori_list_push_cow), not incidental list creation ops.
[TPR-07-002-codex][medium] compiler/ori_llvm/tests/codegen/cross/cow_inside_closure.ori:7 — Tests check incidental setup helpers instead of feature-specific ops. Resolved: Fixed on 2026-04-12. Tightened CHECK patterns: cow_inside_closure checks ori_list_push_cow, enumerate checks ori_iter_enumerate, map_filter_chain checks ori_iter_filter + ori_iter_collect, closure_loop_drop checks ori_rc_dec.
[TPR-07-003-codex][medium] compiler/ori_llvm/tests/codegen/abi/multi_param_mixed.ori:5 — ABI assertions too weak. Resolved: Fixed on 2026-04-12. multi_param_mixed now checks i64, ptr, i1 types. borrowed_param_no_rc adds readonly check and type-specific ori_buffer_rc_inc negative pin.
[TPR-07-001-gemini][high] compiler/ori_llvm/tests/codegen/cow/shared_mutation_triggers_copy.ori:1 — COW tests masked by E4003 error recovery. Resolved: Fixed on 2026-04-12. Same root cause and fix as TPR-07-001-codex (agreement in substance though not by merge-findings criteria).
[TPR-07-002-gemini][high] compiler/ori_llvm/tests/codegen/abi/multi_param_mixed.ori:5 — Missing parameter assertions. Resolved: Fixed on 2026-04-12. Same fix as TPR-07-003-codex.
[TPR-07-003-gemini][high] compiler/ori_llvm/tests/codegen/cross/closure_loop_drop.ori:6 — Missing ori_rc_dec for env drop. Resolved: Fixed on 2026-04-12. Added CHECK: ori_rc_dec with correct ordering (alloc → iter_drop → rc_dec).
[TPR-07-004-gemini][medium] compiler/ori_llvm/tests/codegen/cross/cow_inside_closure.ori:7 — Missing actual COW verification. Resolved: Fixed on 2026-04-12. Restructured test so COW push happens in _ori_main (not lambda), added CHECK: ori_list_push_cow.
[TPR-07-005-gemini][medium] compiler/ori_llvm/tests/codegen/iterator/for_loop_normal_drop.ori:1 — Missing try operator drop test. Resolved: Fixed on 2026-04-12. Added try_operator_triggers_drop.ori targeting _ori_process with CHECK: ori_iter_drop.
[TPR-07-006-gemini][medium] compiler/ori_llvm/tests/codegen/abi/struct_sret_return.ori:1 — Missing small struct direct return test. Resolved: Fixed on 2026-04-12. Added small_struct_direct_return.ori with CHECK: %ori.Point and CHECK-NOT: sret.

Round 5 findings (confirmation re-review with strengthened gemini):

[TPR-07-001-codex][medium] compiler/ori_llvm/tests/codegen/abi/multi_param_mixed.ori:7 — CHECK: i1 matches branch instruction, not parameter. Resolved: Fixed on 2026-04-12. Put the full define fastcc void @_ori_mixed(i64 noundef %0, ptr ... %1, i1 noundef %2) on one CHECK line.
[TPR-07-001-gemini][high] compiler/ori_llvm/tests/codegen/abi/multi_param_mixed.ori:8 — Same issue as TPR-07-001-codex (agreement in substance). Resolved: Same fix as TPR-07-001-codex.
[TPR-07-002-gemini][high] compiler/ori_llvm/tests/codegen/cow_is_shared_check.ori:9 — Unique owner doesn’t exercise shared COW path. Resolved: Fixed on 2026-04-12. Added let ys = xs; to force RC > 1 before .push().
[TPR-07-003-gemini][high] compiler/ori_llvm/tests/codegen/iterator/map_filter_chain.ori:7 — SSA variable capture not supported by engine. Resolved: Acknowledged as tool limitation on 2026-04-12. Our FileCheck engine uses literal substring matching — no regex variable captures. The .exact mode ordering (CHECK-LABEL + sequential CHECKs) is the strongest guarantee available. Added note in plan.
[TPR-07-004-gemini][critical] compiler/ori_llvm/tests/codegen/iterator/map_filter_chain.ori:12 — Element size mismatch with repr-opt narrowed list. Resolved: Filed as BUG-04-071 (critical) on 2026-04-12. Test fixed to use values > 2^31 to avoid repr-opt narrowing — sidesteps the bug in the test while the fix is tracked separately.

07.N Completion Checklist

Exit Criteria: compiler/ori_llvm/tests/codegen/ contains 30+ FileCheck-style tests covering RC emission, COW patterns, closure codegen, ABI, iterator patterns, and cross-feature interactions. All tests pass via timeout 150 cargo test -p ori_llvm --test aot -- ir_checks. Order-sensitive tests use .exact mode with CHECK-LABEL function scoping. Pure existence/absence tests use .matches mode. No regex patterns. Every positive pin has a negative companion. A deliberately introduced codegen regression (e.g., removing an RC dec) causes the corresponding FileCheck test to fail.