From ac696b22b3f03ae9670a9d1d154ce7ff848b5e55 Mon Sep 17 00:00:00 2001 From: Mel Date: Wed, 6 May 2026 18:48:56 +0200 Subject: Tests for new IR transpiler Signed-off-by: Mel --- boot/tests/transpile/basic.cskt | 16 +++++++--- boot/tests/transpile/compound_assigns.cskt | 27 ++++++++++++++++ boot/tests/transpile/conditionals.cskt | 37 ++++++++++++++++++++++ boot/tests/transpile/expressions.cskt | 27 ++++++++++++++++ boot/tests/transpile/functions.cskt | 49 +++++++++++++++++++++++++++++ boot/tests/transpile/loops.cskt | 43 +++++++++++++++++++++++++ boot/tests/transpile/types_and_aliases.cskt | 32 +++++++++++++++++++ 7 files changed, 227 insertions(+), 4 deletions(-) create mode 100644 boot/tests/transpile/compound_assigns.cskt create mode 100644 boot/tests/transpile/conditionals.cskt create mode 100644 boot/tests/transpile/expressions.cskt create mode 100644 boot/tests/transpile/functions.cskt create mode 100644 boot/tests/transpile/loops.cskt create mode 100644 boot/tests/transpile/types_and_aliases.cskt (limited to 'boot') diff --git a/boot/tests/transpile/basic.cskt b/boot/tests/transpile/basic.cskt index eb22b84..5844f94 100644 --- a/boot/tests/transpile/basic.cskt +++ b/boot/tests/transpile/basic.cskt @@ -1,7 +1,9 @@ -the transpiler has to follow a simple pattern of -the files it creates to make viable c source. -here we check that the simplest possible file has -all of the expected parts needed. +smoke test for the ir-driven transpiler: every translation +unit starts with the core preamble, optionally declares types +(forward + full def in topological order), then forward-decls +all functions, then bodies, then the runtime trailer when a +`main` is present. `main` is renamed to `catskill_main` so the +runtime can wrap it. <<< @@ -9,3 +11,9 @@ main = fun () { } >>> + +#include "core.c" +void catskill_main(void); +void catskill_main(void) { +} +#include "runtime.c" diff --git a/boot/tests/transpile/compound_assigns.cskt b/boot/tests/transpile/compound_assigns.cskt new file mode 100644 index 0000000..e480f31 --- /dev/null +++ b/boot/tests/transpile/compound_assigns.cskt @@ -0,0 +1,27 @@ +compound assigns are desugared during lowering so the c output +only ever has plain assignments. + +<<< + +main = fun () { + var x int = 0 + x += 1 + x *= 2 + x++ + x -= 3 + x-- +} + +>>> + +#include "core.c" +void catskill_main(void); +void catskill_main(void) { + integer x = 0; + x = x + 1; + x = x * 2; + x = x + 1; + x = x - 3; + x = x - 1; +} +#include "runtime.c" diff --git a/boot/tests/transpile/conditionals.cskt b/boot/tests/transpile/conditionals.cskt new file mode 100644 index 0000000..96c3877 --- /dev/null +++ b/boot/tests/transpile/conditionals.cskt @@ -0,0 +1,37 @@ +if/else-if/else chains and nested conditionals emit as a single +chained `if () { } else if () { } else { }` c block. + +<<< + +classify = fun (n int) int { + if n < 0 { + return -1 + } else if n == 0 { + return 0 + } else { + return 1 + } +} + +main = fun () { + classify(5) +} + +>>> + +#include "core.c" +integer classify(integer n); +void catskill_main(void); +integer classify(integer n) { + if (n < 0) { + return -1; + } else if (n == 0) { + return 0; + } else { + return 1; + } +} +void catskill_main(void) { + classify(5); +} +#include "runtime.c" diff --git a/boot/tests/transpile/expressions.cskt b/boot/tests/transpile/expressions.cskt new file mode 100644 index 0000000..c127b9a --- /dev/null +++ b/boot/tests/transpile/expressions.cskt @@ -0,0 +1,27 @@ +precedence-aware expression emission only inserts parentheses when the +child binds more loosely than the parent expects. + +<<< + +main = fun () { + var a int = 1 + 2 * 3 + var b int = (1 + 2) * 3 + var c int = 10 - 4 - 1 + var d int = 10 - (4 - 1) + var e int = -1 + 2 + var f bool = a == b && c != 0 || d > 0 +} + +>>> + +#include "core.c" +void catskill_main(void); +void catskill_main(void) { + integer a = 1 + 2 * 3; + integer b = (1 + 2) * 3; + integer c = 10 - 4 - 1; + integer d = 10 - (4 - 1); + integer e = -1 + 2; + bool f = a == b && c != 0 || d > 0; +} +#include "runtime.c" diff --git a/boot/tests/transpile/functions.cskt b/boot/tests/transpile/functions.cskt new file mode 100644 index 0000000..889ffb3 --- /dev/null +++ b/boot/tests/transpile/functions.cskt @@ -0,0 +1,49 @@ +all function forwards land before any function body, so +mutual recursion compiles without ordering games. +`main` is renamed to `catskill_main` and wrapped by the +runtime trailer to allow catskill programs to receive +arguments using preferred types instead of the classic +`argc` and `argv`. + +<<< + +is_even = fun (n int) bool { + if n == 0 { + return true + } + return is_odd(n - 1) +} + +is_odd = fun (n int) bool { + if n == 0 { + return false + } + return is_even(n - 1) +} + +main = fun () { + is_even(10) +} + +>>> + +#include "core.c" +bool is_even(integer n); +bool is_odd(integer n); +void catskill_main(void); +bool is_even(integer n) { + if (n == 0) { + return true; + } + return is_odd(n - 1); +} +bool is_odd(integer n) { + if (n == 0) { + return false; + } + return is_even(n - 1); +} +void catskill_main(void) { + is_even(10); +} +#include "runtime.c" diff --git a/boot/tests/transpile/loops.cskt b/boot/tests/transpile/loops.cskt new file mode 100644 index 0000000..d6493d9 --- /dev/null +++ b/boot/tests/transpile/loops.cskt @@ -0,0 +1,43 @@ +while loops are 1:1; c-style and range for-each both desugar to +a `{ var; while { body; iter; } }` block. + +<<< + +main = fun () { + var i int = 0 + while i < 10 { + i++ + } + for j int = 0, j < 5, j++ { + var k int = j + } + for r int = 0..3 { + var s int = r + } +} + +>>> + +#include "core.c" +void catskill_main(void); +void catskill_main(void) { + integer i = 0; + while (i < 10) { + i = i + 1; + } + { + integer j = 0; + while (j < 5) { + integer k = j; + j = j + 1; + } + } + { + integer r = 0; + while (r < 3) { + integer s = r; + r = r + 1; + } + } +} +#include "runtime.c" diff --git a/boot/tests/transpile/types_and_aliases.cskt b/boot/tests/transpile/types_and_aliases.cskt new file mode 100644 index 0000000..cccc4e6 --- /dev/null +++ b/boot/tests/transpile/types_and_aliases.cskt @@ -0,0 +1,32 @@ +structures forward-declare then emit their full definition +in topological dependency order. +an alias to a struct emits as a c typedef. +primitives are resolved to c directly on use. + +<<< + +Point = type { x int, y int } +Node = type { value int, next &Node } +Coord = type Point + +main = fun () { +} + +>>> + +#include "core.c" +struct Point; +struct Node; +struct Point { + integer x; + integer y; +}; +struct Node { + integer value; + struct Node* next; +}; +typedef struct Point Coord; +void catskill_main(void); +void catskill_main(void) { +} +#include "runtime.c" -- cgit 1.4.1