Expected output of ./repro.sh

 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

# Expected output of ./repro.sh

Recorded against upstream `main` as of 2026-09-18, Go 1.27.1, linux/amd64.

```
=== CLI: rust -> nim (exit code, then stderr tail) ===
00-comment-fails.rs      exit=0  <no error>       emitted:  
00-comment.rs            exit=0  <no error>       emitted:  
01-trivial.rs            exit=0  <no error>       emitted:  
02-if-block.rs           exit=0  <no error>       emitted:  
03-macro.rs              exit=0  <no error>       emitted:  
04-lifetime.rs           exit=1  r2many: unmatched delimiter ")" at 47

=== Frontend prober: UAST node kinds actually produced ===
00-comment-fails.rs      err: expected expression near "/"
00-comment.rs            node kinds: map[CALL:1 CONTROL:1 DISPATCH:1 EFFECT:3 MEMORY:1 SYMBOL:2 block:4 call:2 expression:4 identifier:4 lvalue:1 program:1 temporary:1 unknown:9]
01-trivial.rs            node kinds: map[CALL:1 CONTROL:2 DISPATCH:2 EFFECT:4 MEMORY:1 SYMBOL:7 assign:4 binary:2 block:4 builtin:1 call:2 expression:8 identifier:16 lvalue:1 program:1 temporary:1 unknown:20]
02-if-block.rs           err: expected "" near "s"
03-macro.rs              err: expected "" near ","
04-lifetime.rs           err: expected expression near ")"
05-equivalent.R          node kinds: map[CLOSURE:1 EFFECT:3 FUNCTION:1 MEMORY:1 OWNERSHIP:1 STORAGE:1 SYMBOL:2 assign:4 block:4 expression:2 function:5 identifier:4 lvalue:1 parameter:2 program:1 unknown:11]
```

## Reading this

- `emitted:` blank means the Nim file is **one byte: a newline**. A complete,
  empty program, written on exit 0.
- `00-comment.rs` vs `00-comment-fails.rs` differ only by one `//` line.
- `01-trivial.rs` reports **no error** and produces `call:2 CALL:1` with no
  function node: `fn f(...)` was read as a call to `f`.
- The last two lines are the same program in Rust and in R. Only R yields
  `FUNCTION:1 CLOSURE:1 function:5 parameter:2`.