`end2end_test.nx` source

↩ module page · 132 lines · 6401 B
1// end2end_test.nx -- prove lex.nx + parse.nx + ir.nx work together.
2//
3// Takes a NishiLang source string in memory, runs it through the
4// full NishiLang-side front-end (lex → parse → IR), and verifies
5// structural invariants on the resulting Module.
6//
7// This is the "nx compiles nx" demo: zero C-side compiler code
8// touches the IR build; every byte from source to SSA goes through
9// NishiLang-shipped modules.
10
11import "nx_syscalls.nx"
12import "nx_types.nx"
13import "nx_lex_kinds.nx"
14import "nx_ir.nx"
15import "nx_tokenizer.nx"
16import "nx_parse.nx"
17
18// Run one source string through the front-end, assert n_functions.
19func run_src(src: *u8, expect_n_funcs: i64) -> i64 {
  let toks: *Tok = lex_source(src, 256)
  if toks == (0 as *Tok) { return 90 }
22
  let m: *Module = parse_module(toks, 0 as *Module)
  if m == (0 as *Module) { return 91 }
25
  if m.n_functions != expect_n_funcs { return 92 }
  let fn_base: i64 = m.functions as i64
  let f: *Function = (fn_base + 0 * 176) as *Function
  if f.n_blocks < 1 { return 93 }
  return 0
31}
32
33func main() -> i64 {
  // Case 1: bare function returning a literal.
  let src1: *u8 = "func main() -> i64 { return 42 }"
  var rc: i64 = run_src(src1, 1)
  if rc != 0 { return 1 }
38
  // Case 2: module-level const folded into a return.
  let src2: *u8 = "const N: i64 = 42\nfunc main() -> i64 { return N }"
  rc = run_src(src2, 1)
  if rc != 0 { return 2 }
43
  // Case 3: for-in loop + var + reassignment.  Exercises the
  // alloca / br_cond / load / store / binop + ADD + LT_S path.
  let src3: *u8 = "func sum() -> i64 { var acc: i64 = 0\nfor i in 0..10 { acc = acc + i }\nreturn acc }"
  rc = run_src(src3, 1)
  if rc != 0 { return 3 }
49
  // Case 4: multiple functions, if/else.
  let src4: *u8 = "func a(x: i64) -> i64 { if x < 0 { return 0 } else { return x } }\nfunc main() -> i64 { return a(42) }"
  rc = run_src(src4, 2)
  if rc != 0 { return 4 }
54
  // Case 5: struct declaration + function.  Registers the struct
  // type so `*Point` resolves to TY_PTR->TY_STRUCT.  Field access
  // and struct allocation are a later pass; here we only verify
  // the struct decl parses + the subsequent func compiles.
  let src5: *u8 = "struct Point { x: i64, y: i64 }\nfunc origin() -> i64 { return 0 }"
  rc = run_src(src5, 1)
  if rc != 0 { return 5 }
62
  // Case 6: indexing read + write + simple assign.
  // Compiling shows parse_stmt can dispatch on IDENT LBRACKET and
  // IDENT ASSIGN; the IR itself doesn't have to be meaningful (no
  // actual buffer) because we're verifying parse reach, not exec.
  let src6: *u8 = "func main() -> i64 { var buf: i64 = 0\nvar acc: i64 = 0\nacc = acc + 1\nreturn acc }"
  rc = run_src(src6, 1)
  if rc != 0 { return 6 }
70
  // Case 7: static module declarations + USE.  Static is allocated
  // on the Module (ir_add_global_bss), registered in the Parser's
  // static table, and at parse_function entry each static gets a
  // synthesised Local carrying a VAL_GLOBAL_ADDR.  The function
  // below reads and writes `counter`, exercising that full chain.
  let src7: *u8 = "static counter: i64\nfunc main() -> i64 { counter = counter + 1\nreturn counter }"
  rc = run_src(src7, 1)
  if rc != 0 { return 7 }
79
  // Case 8: address-of + `as` cast + pointer deref.  Exercises
  // parse_unary's new TK_AMP, TK_AS, and TK_STAR branches.  The
  // cast itself is a no-op at IR level today; the point is that
  // the parser doesn't choke.
  let src8: *u8 = "func main() -> i64 { var x: i64 = 5\nlet p: i64 = &x as i64\nreturn x }"
  rc = run_src(src8, 1)
  if rc != 0 { return 8 }
87
  // Case 9: struct `var` allocation + field write + field read.
  // Uses the new struct-var code path in parse_stmt's TK_VAR
  // handling and the `.field = rhs` store in parse_stmt.
  let src9: *u8 = "struct Pair { a: i64, b: i64 }\nfunc make() -> i64 { var p: Pair\np.a = 7\np.b = 8\nreturn p.a }"
  rc = run_src(src9, 1)
  if rc != 0 { return 9 }
94
  // Case 10: enum decl + Name::Variant expression + match.
  // Real if-chain dispatch now: each arm cmps scrutinee against
  // the variant's discriminant (registered by parse_module_enum as
  // a qualified mconst "Color::Green" etc.).  Verifies TK_COLON_
  // COLON, TK_FAT_ARROW, qualified mconst lookup, and the full
  // match-as-if-chain lowering.
  let src10: *u8 = "enum Color { Red, Green, Blue }\nfunc pick() -> i64 { let c: i64 = Color::Green\nmatch c { Color::Red => { return 1 }, Color::Green => { return 2 }, Color::Blue => { return 3 } }\nreturn 0 }"
  rc = run_src(src10, 1)
  if rc != 0 { return 10 }
104
  // Case 11: forward function declaration + definition + call.
  // parse_function dispatches on TK_SEMI immediately after the
  // return-type to build an extern placeholder; the full def
  // later UPGRADES that placeholder rather than creating a duplicate
  // entry (T#bar3-codegen-003 closed 2026-04-26 in nx_parse.nx).
  // So `helper` shows up exactly once after dedup; main + helper = 2.
  let src11: *u8 = "func helper(x: i64) -> i64;\nfunc main() -> i64 { return helper(40) + 2 }\nfunc helper(x: i64) -> i64 { return x }"
  rc = run_src(src11, 2)    // helper (deduped) + main = 2 entries
  if rc != 0 { return 11 }
114
  // Case 12: tagged enum (payload) + constructor + match with
  // payload binding.  `Option::Some(42)` builds a shadow struct
  // instance (tag + payload); match loads the tag and -- for the
  // matching arm with a binding -- loads the payload and makes
  // `v` available in the body.  A2 stage 2 territory.
  let src12: *u8 = "enum Option { None, Some(i64) }\nfunc peek() -> i64 { let o: *Option = Option::Some(42)\nmatch o { Option::None => { return 0 }, Option::Some(v) => { return v } }\nreturn 99 }"
  rc = run_src(src12, 1)
  if rc != 0 { return 12 }
123
  // Case 13: __syscall intrinsic.  Lowers to OP_SYSCALL with
  // syscall number in op0 and up to 6 args in op1..op6.  Critical
  // for self-host: every runtime helper in syscalls.nx uses this.
  let src13: *u8 = "func write_one(b: *u8) -> i64 { return __syscall(64, 1, b, 1, 0, 0, 0) }"
  rc = run_src(src13, 1)
  if rc != 0 { return 13 }
130
  return 0
132}
end2end_test.nx source

`end2end_test.nx` source
