Make full integration harness warning-clean under -Werror and enforce it in Linux CI.

Cod-e-Codes · Cod-e-Codes · commit bd7bf5171a20 · 2026-06-25T19:10:12.000-04:00
Track binding reads in cgen to silence unused locals, fix string literal .data casts, regenerate example C snapshots, and replace the 13-test warning smoke with the full test_runner.sh harness.
diff --git a/.cursor/skills/ion-integration-tests/SKILL.md b/.cursor/skills/ion-integration-tests/SKILL.md
@@ -57,7 +57,7 @@ RUNTIME_OBJ=/tmp/ion_runtime.o ./test_runner.sh
 CFLAGS="-Wall -Wextra -Werror" RUNTIME_OBJ=.ion_test_runtime_werror.o ./test_runner.sh
 ```
 
-Local `-Werror` over the full harness is not yet supported; CI runs `-Werror` on a curated smoke subset in `.github/workflows/ci.yml`.
+Local full-harness `-Werror` matches the Linux CI warning-clean job.
 
 ```bash
 CFLAGS="-fsanitize=address,undefined -fno-omit-frame-pointer" LDFLAGS="-fsanitize=address,undefined" ./test_runner.sh
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -67,42 +67,15 @@ jobs:
           test_array_to_slice_coercion 10
           EOF
 
-      - name: Generated C warning-clean smoke (Linux)
+      - name: Generated C warning-clean (Linux)
         shell: bash
         env:
           COMPILER: ${{ github.workspace }}/target/release/ion-compiler
+          ION_BUILD: ${{ github.workspace }}/target/release/ion-build
           CC: gcc
           CFLAGS: -Wall -Wextra -Werror
-        run: |
-          cd tests
-          "$CC" $CFLAGS -c ../runtime/ion_runtime.c -I. -I.. -I../runtime -o .ion_test_runtime_werror.o
-          while IFS=' ' read -r test expected; do
-            "$COMPILER" "$test.ion" >/dev/null
-            "$CC" $CFLAGS "$test.c" .ion_test_runtime_werror.o -I. -I.. -I../runtime -lpthread -o "$test"
-            set +e
-            "./$test" >/dev/null
-            status=$?
-            set -e
-            if [ "$status" -ne "$expected" ]; then
-              echo "$test: expected exit $expected, got $status"
-              exit 1
-            fi
-            rm -f "$test.c" "$test"
-          done <<'EOF'
-          test_basic 42
-          test_move_basic 10
-          test_arithmetic 30
-          test_struct_basic 7
-          test_box_basic 0
-          test_break_continue 27
-          test_defer_block 1
-          test_ref_valid 0
-          test_defer_basic 7
-          test_for_string 0
-          test_spawn_channel 0
-          test_array_to_slice_coercion 10
-          test_string_push_byte 79
-          EOF
+          RUNTIME_OBJ: .ion_test_runtime_werror.o
+        run: cd tests && bash test_runner.sh
 
   integration:
     permissions:
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -2,7 +2,7 @@
 
 ## 2026-06
 
-- **Readiness hardening**: beta compatibility and runtime ABI documents, a lightweight security policy, CLI/`ion-build` multi-error type diagnostics, sanitizer CI smoke (6 tests), and generated-C `-Werror` CI smoke on a curated subset of 13 integration tests (not the full harness; most generated C is not yet warning-clean under `-Wall -Wextra -Werror`). Cgen warning-hygiene improvements (`ION_MAYBE_UNUSED`, borrow/defer silences, string `for...in` length casts), `String` runtime data as `uint8_t*`, and `CFLAGS`/`LDFLAGS` support in the integration harness.
+- **Readiness hardening**: beta compatibility and runtime ABI documents, a lightweight security policy, CLI/`ion-build` multi-error type diagnostics, sanitizer CI smoke (6 tests), and full integration harness `-Wall -Wextra -Werror` on Linux CI. Cgen warning-hygiene improvements (`ION_MAYBE_UNUSED`, binding usage tracking, borrow/defer silences, string literal `.data`/`uint8_t*` casts, string `for...in` length casts), `String` runtime data as `uint8_t*`, and `CFLAGS`/`LDFLAGS` support in the integration harness.
 - **Language**: `for` iteration, `match` guards, `else if`, `break`/`continue`, `loop {}`, `+=`, hex/bin literals, function types `fn(T) -> R`, tuple literals and destructuring. Capture-free fn literals (`fn(T) -> R` lowered to static C function pointers; `ClosureCapture` for outer bindings).
 - **Stdlib & runtime**: `fmt.ion`, `Result<T, E>`, `fs.read_to_string`, `String::push_byte`.
 - **Compiler**: scope-drop codegen, `pthread` spawn, slice bounds checks, array-to-slice coercion, struct/enum field drops, `String` equality, module function name mangling, lasting-borrow rules (ION_SPEC 5.3), field-path borrow exclusivity, move/copy tracking fixes, generic monomorphization, generated C file banner (repo-relative source labels via `portable_source_label`, GNU C note, merged stdlib note, multi-file provenance, comment-safe path escaping).
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
@@ -20,7 +20,7 @@ cargo install --path . --bin ion-compiler --bin ion-build
 
 `ion-lsp` is built with the release command above; point the editor extension at `target/release/ion-lsp` (see README IDE Support).
 
-CI (`.github/workflows/ci.yml`) builds all three binaries on Linux, runs integration tests, ASan/UBSan smoke on generated C, and a `-Wall -Wextra -Werror` smoke subset on Linux (full-suite warning-clean builds are not yet enforced). The Windows job builds `ion-compiler` and `ion-build` only. Build `ion-lsp` locally for IDE work.
+CI (`.github/workflows/ci.yml`) builds all three binaries on Linux, runs integration tests, ASan/UBSan smoke on generated C, and the full integration harness under `-Wall -Wextra -Werror` on Linux. The Windows job builds `ion-compiler` and `ion-build` only. Build `ion-lsp` locally for IDE work.
 
 ## Test
 
diff --git a/examples/access_log.c b/examples/access_log.c
@@ -186,6 +186,7 @@ int scan_logs(ion_sender_t ION_MAYBE_UNUSED code_tx, int ION_MAYBE_UNUSED expect
         __for_i_1660 = (__for_i_1660 + 1);
     }
     ret_val = auth_failures;
+    if (code_tx.channel) { ion_channel_handle_drop(code_tx.channel); }
     goto epilogue;
 epilogue:
         return ret_val;
@@ -221,20 +222,19 @@ int main(void) {
     int server_errors = ({ int tmp; ion_channel_recv(&done_rx_mut, &tmp); tmp; });
     if (server_errors != 1) {
         ret_val = 1;
+        (void)auth_failures;
         if (done_rx_mut.channel) { ion_channel_handle_drop(done_rx_mut.channel); }
         goto epilogue;
     }
     if (auth_failures != 1) {
         ret_val = 2;
-        if (done_rx_mut.channel) { ion_channel_handle_drop(done_rx_mut.channel); }
         goto epilogue;
     }
     ion_string_t* server_line = fmt_int_to_string(server_errors);
     io_println(server_line);
     ion_string_t* auth_line = fmt_int_to_string(auth_failures);
     io_println(auth_line);
     ret_val = 0;
-    if (done_rx_mut.channel) { ion_channel_handle_drop(done_rx_mut.channel); }
     goto epilogue;
 epilogue:
         return ret_val;
@@ -244,9 +244,11 @@ void io_print(ion_string_t* ION_MAYBE_UNUSED s) {
     {
         int _result = write(1, s->data, (int)s->len);
         (void)_result;
+        (void)_result;
     }
     goto epilogue;
 epilogue:
+        if (s) { ion_string_free(s); }
         return;
 }
 
@@ -256,19 +258,24 @@ void io_println(ion_string_t* ION_MAYBE_UNUSED s) {
         (void)_result;
         int _newline = write(1, (uint8_t*)"\n", 1);
         (void)_newline;
+        (void)_newline;
+        (void)_result;
     }
     goto epilogue;
 epilogue:
+        if (s) { ion_string_free(s); }
         return;
 }
 
 void io_print_str(uint8_t* ION_MAYBE_UNUSED s, int ION_MAYBE_UNUSED len) {
     if (len < 0) {
-                goto epilogue;
+                (void)s;
+        goto epilogue;
     }
     {
         int _result = write(1, s, len);
         (void)_result;
+        (void)_result;
     }
     goto epilogue;
 epilogue:
@@ -284,15 +291,20 @@ void io_print_int(int ION_MAYBE_UNUSED n) {
         {
             int _result = write(1, (uint8_t*)"0", 1);
             (void)_result;
+            (void)_result;
         }
-                goto epilogue;
+                (void)negative;
+        (void)len;
+        (void)buf;
+        goto epilogue;
     }
     if (value < 0) {
         negative = 1;
         if (value == (-2147483648)) {
             {
                 int _result = write(1, (uint8_t*)"-2147483648", 11);
                 (void)_result;
+                (void)_result;
             }
                         goto epilogue;
         }
@@ -315,11 +327,13 @@ void io_print_int(int ION_MAYBE_UNUSED n) {
         {
             int _minus = write(1, (uint8_t*)"-", 1);
             (void)_minus;
+            (void)_minus;
         }
     }
     {
         int _result = write(1, &buf[0], len);
         (void)_result;
+        (void)_result;
     }
     goto epilogue;
 epilogue:
@@ -338,6 +352,7 @@ void fmt_println_int(int ION_MAYBE_UNUSED n) {
     {
         int _newline = write(1, (uint8_t*)"\n", 1);
         (void)_newline;
+        (void)_newline;
     }
     goto epilogue;
 epilogue:
@@ -353,14 +368,17 @@ ion_string_t* fmt_int_to_string(int ION_MAYBE_UNUSED n) {
     ion_string_t* result = ion_string_new();
     if (value == 0) {
         ret_val = ion_string_from_literal("0", 1);
+        (void)result;
+        (void)negative;
+        (void)len;
+        (void)buf;
         if (result) { ion_string_free(result); }
         goto epilogue;
     }
     if (value < 0) {
         negative = 1;
         if (value == (-2147483648)) {
             ret_val = ion_string_from_literal("-2147483648", 11);
-            if (result) { ion_string_free(result); }
             goto epilogue;
         }
         value = (0 - value);
diff --git a/examples/channel_worker.c b/examples/channel_worker.c
@@ -65,8 +65,6 @@ int main(void) {
         goto epilogue;
     }
     ret_val = 0;
-    if (done_rx_mut.channel) { ion_channel_handle_drop(done_rx_mut.channel); }
-    if (job_tx.channel) { ion_channel_handle_drop(job_tx.channel); }
     goto epilogue;
 epilogue:
         return ret_val;
diff --git a/examples/hello_world.c b/examples/hello_world.c
@@ -21,6 +21,7 @@ int main(void) {
     {
         int _result = write(1, (uint8_t*)"Hello, World!\n", 14);
         (void)_result;
+        (void)_result;
     }
     ret_val = 0;
     goto epilogue;
diff --git a/examples/hello_world_safe.c b/examples/hello_world_safe.c
@@ -33,9 +33,11 @@ void io_print(ion_string_t* ION_MAYBE_UNUSED s) {
     {
         int _result = write(1, s->data, (int)s->len);
         (void)_result;
+        (void)_result;
     }
     goto epilogue;
 epilogue:
+        if (s) { ion_string_free(s); }
         return;
 }
 
@@ -45,19 +47,24 @@ void io_println(ion_string_t* ION_MAYBE_UNUSED s) {
         (void)_result;
         int _newline = write(1, (uint8_t*)"\n", 1);
         (void)_newline;
+        (void)_newline;
+        (void)_result;
     }
     goto epilogue;
 epilogue:
+        if (s) { ion_string_free(s); }
         return;
 }
 
 void io_print_str(uint8_t* ION_MAYBE_UNUSED s, int ION_MAYBE_UNUSED len) {
     if (len < 0) {
-                goto epilogue;
+                (void)s;
+        goto epilogue;
     }
     {
         int _result = write(1, s, len);
         (void)_result;
+        (void)_result;
     }
     goto epilogue;
 epilogue:
@@ -73,15 +80,20 @@ void io_print_int(int ION_MAYBE_UNUSED n) {
         {
             int _result = write(1, (uint8_t*)"0", 1);
             (void)_result;
+            (void)_result;
         }
-                goto epilogue;
+                (void)negative;
+        (void)len;
+        (void)buf;
+        goto epilogue;
     }
     if (value < 0) {
         negative = 1;
         if (value == (-2147483648)) {
             {
                 int _result = write(1, (uint8_t*)"-2147483648", 11);
                 (void)_result;
+                (void)_result;
             }
                         goto epilogue;
         }
@@ -104,11 +116,13 @@ void io_print_int(int ION_MAYBE_UNUSED n) {
         {
             int _minus = write(1, (uint8_t*)"-", 1);
             (void)_minus;
+            (void)_minus;
         }
     }
     {
         int _result = write(1, &buf[0], len);
         (void)_result;
+        (void)_result;
     }
     goto epilogue;
 epilogue:
diff --git a/examples/http_server.c b/examples/http_server.c
@@ -73,6 +73,12 @@ int handle_client(int ION_MAYBE_UNUSED client_fd) {
         int _sent6 = send_sys(client_fd, (uint8_t*)"<html><head><title>Ion HTTP Server</title></head><body><h1>Hello from Ion!</h1><p>This is a simple HTTP server written in Ion.</p></body></html>", 89, 0);
         (void)_sent6;
         close(client_fd);
+        (void)_sent6;
+        (void)_sent5;
+        (void)_sent4;
+        (void)_sent3;
+        (void)_sent2;
+        (void)_sent1;
     }
     ret_val = 0;
     goto epilogue;
@@ -142,6 +148,7 @@ static void* ion_spawn_entry_0(void* arg) {
     free(ctx);
     int _result = handle_client(client_fd);
     (void)_result;
+    (void)_result;
     goto spawn_0_epilogue;
 spawn_0_epilogue:
     return NULL;
diff --git a/examples/showcase.c b/examples/showcase.c
@@ -27,16 +27,16 @@ typedef struct Vec_int {
     size_t elem_size;
 } Vec_int;
 
-typedef struct tuple_ion_sender_t_ion_receiver_t {
-    ion_sender_t f0;
-    ion_receiver_t f1;
-} tuple_ion_sender_t_ion_receiver_t;
-
 typedef struct tuple_int_int {
     int f0;
     int f1;
 } tuple_int_int;
 
+typedef struct tuple_ion_sender_t_ion_receiver_t {
+    ion_sender_t f0;
+    ion_receiver_t f1;
+} tuple_ion_sender_t_ion_receiver_t;
+
 typedef struct Point {
     int x;
     int y;
@@ -249,7 +249,6 @@ int for_loop_example(void) {
         goto epilogue;
     }
     ret_val = 0;
-    if (__for_container_2197) { ion_vec_free((ion_vec_t*)(__for_container_2197)); }
     goto epilogue;
 epilogue:
         return ret_val;
@@ -383,7 +382,9 @@ int pattern_matching_example(void) {
         }
         case 1: { // Err
             int _c = match_val_5.data.variant_1.code;
+            (void)_c;
             ret_val = 6;
+            (void)_c;
             goto epilogue;
             break;
         }
@@ -403,6 +404,8 @@ int reference_example(void) {
         (void)_ref_y;
         int* _ref_x = &x;
         (void)_ref_x;
+        (void)_ref_x;
+        (void)_ref_y;
     }
     Vec_int* values = ((Vec_int*)(ion_vec_new(sizeof(int))));
     ion_vec_push((ion_vec_t*)(values), &((int){x}), sizeof(int));
@@ -502,8 +505,6 @@ int spawn_channel_example(void) {
         goto epilogue;
     }
     ret_val = 0;
-    if (rx_back_mut.channel) { ion_channel_handle_drop(rx_back_mut.channel); }
-    if (tx.channel) { ion_channel_handle_drop(tx.channel); }
     goto epilogue;
 epilogue:
         return ret_val;
@@ -514,6 +515,7 @@ int fn_literal_example(void) {
     int (*twice)(int) = ion_fn_lit_0;
     if (twice(21) != 42) {
         ret_val = 1;
+        (void)twice;
         goto epilogue;
     }
     ret_val = 0;
diff --git a/examples/spawn_channel.c b/examples/spawn_channel.c
@@ -52,8 +52,6 @@ int main(void) {
         goto epilogue;
     }
     ret_val = 1;
-    if (rx_back_mut.channel) { ion_channel_handle_drop(rx_back_mut.channel); }
-    if (tx.channel) { ion_channel_handle_drop(tx.channel); }
     goto epilogue;
 epilogue:
         return ret_val;
diff --git a/examples/text_summary/text_summary.c b/examples/text_summary/text_summary.c
diff --git a/src/cgen/mod.rs b/src/cgen/mod.rs
diff --git a/tests/README.md b/tests/README.md

Original file line number	Diff line number	Diff line change
`@@ -186,6 +186,7 @@ int scan_logs(ion_sender_t ION_MAYBE_UNUSED code_tx, int ION_MAYBE_UNUSED expect`
`186`	`186`	`__for_i_1660 = (__for_i_1660 + 1);`
`187`	`187`	`}`
`188`	`188`	`ret_val = auth_failures;`
	`189`	`+ if (code_tx.channel) { ion_channel_handle_drop(code_tx.channel); }`
`189`	`190`	`goto epilogue;`
`190`	`191`	`epilogue:`
`191`	`192`	`return ret_val;`
`@@ -221,20 +222,19 @@ int main(void) {`
`221`	`222`	`int server_errors = ({ int tmp; ion_channel_recv(&done_rx_mut, &tmp); tmp; });`
`222`	`223`	`if (server_errors != 1) {`
`223`	`224`	`ret_val = 1;`
	`225`	`+ (void)auth_failures;`
`224`	`226`	`if (done_rx_mut.channel) { ion_channel_handle_drop(done_rx_mut.channel); }`
`225`	`227`	`goto epilogue;`
`226`	`228`	`}`
`227`	`229`	`if (auth_failures != 1) {`
`228`	`230`	`ret_val = 2;`
`229`		`- if (done_rx_mut.channel) { ion_channel_handle_drop(done_rx_mut.channel); }`
`230`	`231`	`goto epilogue;`
`231`	`232`	`}`
`232`	`233`	`ion_string_t* server_line = fmt_int_to_string(server_errors);`
`233`	`234`	`io_println(server_line);`
`234`	`235`	`ion_string_t* auth_line = fmt_int_to_string(auth_failures);`
`235`	`236`	`io_println(auth_line);`
`236`	`237`	`ret_val = 0;`
`237`		`- if (done_rx_mut.channel) { ion_channel_handle_drop(done_rx_mut.channel); }`
`238`	`238`	`goto epilogue;`
`239`	`239`	`epilogue:`
`240`	`240`	`return ret_val;`
`@@ -244,9 +244,11 @@ void io_print(ion_string_t* ION_MAYBE_UNUSED s) {`
`244`	`244`	`{`
`245`	`245`	`int _result = write(1, s->data, (int)s->len);`
`246`	`246`	`(void)_result;`
	`247`	`+ (void)_result;`
`247`	`248`	`}`
`248`	`249`	`goto epilogue;`
`249`	`250`	`epilogue:`
	`251`	`+ if (s) { ion_string_free(s); }`
`250`	`252`	`return;`
`251`	`253`	`}`
`252`	`254`
`@@ -256,19 +258,24 @@ void io_println(ion_string_t* ION_MAYBE_UNUSED s) {`
`256`	`258`	`(void)_result;`
`257`	`259`	`int _newline = write(1, (uint8_t*)"\n", 1);`
`258`	`260`	`(void)_newline;`
	`261`	`+ (void)_newline;`
	`262`	`+ (void)_result;`
`259`	`263`	`}`
`260`	`264`	`goto epilogue;`
`261`	`265`	`epilogue:`
	`266`	`+ if (s) { ion_string_free(s); }`
`262`	`267`	`return;`
`263`	`268`	`}`
`264`	`269`
`265`	`270`	`void io_print_str(uint8_t* ION_MAYBE_UNUSED s, int ION_MAYBE_UNUSED len) {`
`266`	`271`	`if (len < 0) {`
`267`		`- goto epilogue;`
	`272`	`+ (void)s;`
	`273`	`+ goto epilogue;`
`268`	`274`	`}`
`269`	`275`	`{`
`270`	`276`	`int _result = write(1, s, len);`
`271`	`277`	`(void)_result;`
	`278`	`+ (void)_result;`
`272`	`279`	`}`
`273`	`280`	`goto epilogue;`
`274`	`281`	`epilogue:`
`@@ -284,15 +291,20 @@ void io_print_int(int ION_MAYBE_UNUSED n) {`
`284`	`291`	`{`
`285`	`292`	`int _result = write(1, (uint8_t*)"0", 1);`
`286`	`293`	`(void)_result;`
	`294`	`+ (void)_result;`
`287`	`295`	`}`
`288`		`- goto epilogue;`
	`296`	`+ (void)negative;`
	`297`	`+ (void)len;`
	`298`	`+ (void)buf;`
	`299`	`+ goto epilogue;`
`289`	`300`	`}`
`290`	`301`	`if (value < 0) {`
`291`	`302`	`negative = 1;`
`292`	`303`	`if (value == (-2147483648)) {`
`293`	`304`	`{`
`294`	`305`	`int _result = write(1, (uint8_t*)"-2147483648", 11);`
`295`	`306`	`(void)_result;`
	`307`	`+ (void)_result;`
`296`	`308`	`}`
`297`	`309`	`goto epilogue;`
`298`	`310`	`}`
`@@ -315,11 +327,13 @@ void io_print_int(int ION_MAYBE_UNUSED n) {`
`315`	`327`	`{`
`316`	`328`	`int _minus = write(1, (uint8_t*)"-", 1);`
`317`	`329`	`(void)_minus;`
	`330`	`+ (void)_minus;`
`318`	`331`	`}`
`319`	`332`	`}`
`320`	`333`	`{`
`321`	`334`	`int _result = write(1, &buf[0], len);`
`322`	`335`	`(void)_result;`
	`336`	`+ (void)_result;`
`323`	`337`	`}`
`324`	`338`	`goto epilogue;`
`325`	`339`	`epilogue:`
`@@ -338,6 +352,7 @@ void fmt_println_int(int ION_MAYBE_UNUSED n) {`
`338`	`352`	`{`
`339`	`353`	`int _newline = write(1, (uint8_t*)"\n", 1);`
`340`	`354`	`(void)_newline;`
	`355`	`+ (void)_newline;`
`341`	`356`	`}`
`342`	`357`	`goto epilogue;`
`343`	`358`	`epilogue:`
`@@ -353,14 +368,17 @@ ion_string_t* fmt_int_to_string(int ION_MAYBE_UNUSED n) {`
`353`	`368`	`ion_string_t* result = ion_string_new();`
`354`	`369`	`if (value == 0) {`
`355`	`370`	`ret_val = ion_string_from_literal("0", 1);`
	`371`	`+ (void)result;`
	`372`	`+ (void)negative;`
	`373`	`+ (void)len;`
	`374`	`+ (void)buf;`
`356`	`375`	`if (result) { ion_string_free(result); }`
`357`	`376`	`goto epilogue;`
`358`	`377`	`}`
`359`	`378`	`if (value < 0) {`
`360`	`379`	`negative = 1;`
`361`	`380`	`if (value == (-2147483648)) {`
`362`	`381`	`ret_val = ion_string_from_literal("-2147483648", 11);`
`363`		`- if (result) { ion_string_free(result); }`
`364`	`382`	`goto epilogue;`
`365`	`383`	`}`
`366`	`384`	`value = (0 - value);`
Original file line number	Diff line number	Diff line change
`@@ -65,8 +65,6 @@ int main(void) {`
`65`	`65`	`goto epilogue;`
`66`	`66`	`}`
`67`	`67`	`ret_val = 0;`
`68`		`- if (done_rx_mut.channel) { ion_channel_handle_drop(done_rx_mut.channel); }`
`69`		`- if (job_tx.channel) { ion_channel_handle_drop(job_tx.channel); }`
`70`	`68`	`goto epilogue;`
`71`	`69`	`epilogue:`
`72`	`70`	`return ret_val;`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@ int main(void) {`
`21`	`21`	`{`
`22`	`22`	`int _result = write(1, (uint8_t*)"Hello, World!\n", 14);`
`23`	`23`	`(void)_result;`
	`24`	`+ (void)_result;`
`24`	`25`	`}`
`25`	`26`	`ret_val = 0;`
`26`	`27`	`goto epilogue;`
Original file line number	Diff line number	Diff line change
`@@ -33,9 +33,11 @@ void io_print(ion_string_t* ION_MAYBE_UNUSED s) {`
`33`	`33`	`{`
`34`	`34`	`int _result = write(1, s->data, (int)s->len);`
`35`	`35`	`(void)_result;`
	`36`	`+ (void)_result;`
`36`	`37`	`}`
`37`	`38`	`goto epilogue;`
`38`	`39`	`epilogue:`
	`40`	`+ if (s) { ion_string_free(s); }`
`39`	`41`	`return;`
`40`	`42`	`}`
`41`	`43`
`@@ -45,19 +47,24 @@ void io_println(ion_string_t* ION_MAYBE_UNUSED s) {`
`45`	`47`	`(void)_result;`
`46`	`48`	`int _newline = write(1, (uint8_t*)"\n", 1);`
`47`	`49`	`(void)_newline;`
	`50`	`+ (void)_newline;`
	`51`	`+ (void)_result;`
`48`	`52`	`}`
`49`	`53`	`goto epilogue;`
`50`	`54`	`epilogue:`
	`55`	`+ if (s) { ion_string_free(s); }`
`51`	`56`	`return;`
`52`	`57`	`}`
`53`	`58`
`54`	`59`	`void io_print_str(uint8_t* ION_MAYBE_UNUSED s, int ION_MAYBE_UNUSED len) {`
`55`	`60`	`if (len < 0) {`
`56`		`- goto epilogue;`
	`61`	`+ (void)s;`
	`62`	`+ goto epilogue;`
`57`	`63`	`}`
`58`	`64`	`{`
`59`	`65`	`int _result = write(1, s, len);`
`60`	`66`	`(void)_result;`
	`67`	`+ (void)_result;`
`61`	`68`	`}`
`62`	`69`	`goto epilogue;`
`63`	`70`	`epilogue:`
`@@ -73,15 +80,20 @@ void io_print_int(int ION_MAYBE_UNUSED n) {`
`73`	`80`	`{`
`74`	`81`	`int _result = write(1, (uint8_t*)"0", 1);`
`75`	`82`	`(void)_result;`
	`83`	`+ (void)_result;`
`76`	`84`	`}`
`77`		`- goto epilogue;`
	`85`	`+ (void)negative;`
	`86`	`+ (void)len;`
	`87`	`+ (void)buf;`
	`88`	`+ goto epilogue;`
`78`	`89`	`}`
`79`	`90`	`if (value < 0) {`
`80`	`91`	`negative = 1;`
`81`	`92`	`if (value == (-2147483648)) {`
`82`	`93`	`{`
`83`	`94`	`int _result = write(1, (uint8_t*)"-2147483648", 11);`
`84`	`95`	`(void)_result;`
	`96`	`+ (void)_result;`
`85`	`97`	`}`
`86`	`98`	`goto epilogue;`
`87`	`99`	`}`
`@@ -104,11 +116,13 @@ void io_print_int(int ION_MAYBE_UNUSED n) {`
`104`	`116`	`{`
`105`	`117`	`int _minus = write(1, (uint8_t*)"-", 1);`
`106`	`118`	`(void)_minus;`
	`119`	`+ (void)_minus;`
`107`	`120`	`}`
`108`	`121`	`}`
`109`	`122`	`{`
`110`	`123`	`int _result = write(1, &buf[0], len);`
`111`	`124`	`(void)_result;`
	`125`	`+ (void)_result;`
`112`	`126`	`}`
`113`	`127`	`goto epilogue;`
`114`	`128`	`epilogue:`