From dce171670f73a0d9b397e4011723c83d0d1bd335 Mon Sep 17 00:00:00 2001
From: Christoffer Lerno <christoffer@aegik.com>
Date: Sat, 4 Feb 2023 15:38:06 +0100
Subject: [PATCH] Use `printn` rather than `println`. Add string methods for
 copying.

---
 README.md                                     |   2 +-
 lib/std/core/runtime.c3                       |   8 +-
 lib/std/core/str.c3                           |   6 +
 lib/std/core/string.c3                        |   6 +-
 lib/std/io/io.c3                              |  57 +-
 lib/std/io/io_file.c3                         |  70 +-
 lib/std/libc/libc.c3                          |   5 +-
 resources/examples/contextfree/boolerr.c3     |   2 +-
 resources/examples/contextfree/multi.c3       |   2 +-
 resources/examples/hello_world_many.c3        |   2 +-
 resources/examples/notworking/madlibs.c3      |   4 +-
 resources/examples/plus_minus.c3              |   2 +-
 resources/rosettacode/antiprime.c3            |   4 +-
 resources/rosettacode/helloworld.c3           |   2 +-
 resources/testfragments/allocators_testing.c3 |   4 +-
 src/build/project_creation.c                  |   2 +-
 src/compiler/llvm_codegen.c                   |  11 -
 src/compiler/llvm_codegen_internal.h          |   3 +-
 src/compiler/llvm_codegen_stmt.c              |  10 +-
 src/compiler/sema_decls.c                     |   7 -
 src/version.h                                 |   2 +-
 test/test_suite/bitstruct/bitstruct_be.c3t    | 296 +++++----
 .../compile_time/ct_builtin_time_date.c3t     | 158 ++++-
 test/test_suite/compile_time/ct_func.c3t      |   4 +-
 test/test_suite/compile_time/ct_memberof.c3t  | 623 +++++++++++-------
 .../compile_time/ct_switch_more_checks.c3     |  18 +-
 .../errors/general_error_regression.c3t       |  81 ++-
 test/test_suite/errors/or_and_rethrow.c3t     | 208 +++++-
 .../expression_block_break.c3                 |   2 +-
 test/test_suite/expressions/call_inline.c3t   |   6 +-
 test/test_suite/from_docs/examples_defer.c3t  | 198 +++++-
 .../from_docs/examples_forswitch.c3t          | 342 +++++++---
 .../initialize/initialize_finalize.c3t        |   2 +-
 .../initializer_lists/subarrays.c3t           | 131 ++--
 .../macro_methods_defined_twice.c3            |   4 +-
 .../methods/enum_distinct_err_methods.c3t     |  10 +-
 test/test_suite/methods/extension_method.c3t  |   2 +-
 .../methods/extension_method_already_exist.c3 |   4 +-
 .../methods/methods_defined_twice.c3          |   4 +-
 39 files changed, 1627 insertions(+), 677 deletions(-)

diff --git a/README.md b/README.md
index 81353717b..46dc10205 100644
--- a/README.md
+++ b/README.md
@@ -228,7 +228,7 @@ import std::io;
 
 fn void main()
 {
-   io::println("Hello, world!");
+   io::printn("Hello, world!");
 }
 ```
 
diff --git a/lib/std/core/runtime.c3 b/lib/std/core/runtime.c3
index af2ec9d04..1215c731f 100644
--- a/lib/std/core/runtime.c3
+++ b/lib/std/core/runtime.c3
@@ -50,7 +50,7 @@ import libc;
 private TestRunner* current_runner;
 fn void test_panic(String message, String file, String function, uint line)
 {
-	io::println("[error]");
+	io::printn("[error]");
 	io::printfn("\n Error: %s", message);
 	io::printfn("  - in %s %s:%s.\n", function, file, line);
 	libc::longjmp(&current_runner.buf, 1);
@@ -64,7 +64,7 @@ fn bool TestRunner.run(TestRunner* runner)
 	builtin::panic = &test_panic;
 	int tests_passed = 0;
 	int tests = runner.test_names.len;
-	io::println("----- TESTS -----");
+	io::printn("----- TESTS -----");
 	foreach(i, String name : runner.test_names)
 	{
 		io::printf("Testing %s ... ", name);
@@ -72,10 +72,10 @@ fn bool TestRunner.run(TestRunner* runner)
 		{
 			if (catch err = runner.test_fns[i]())
 			{
-				io::println("[failed]");
+				io::printn("[failed]");
 				continue;
 			}
-			io::println("[ok]");
+			io::printn("[ok]");
 			tests_passed++;
 		}
 	}
diff --git a/lib/std/core/str.c3 b/lib/std/core/str.c3
index bbc0048d5..7d09211c3 100644
--- a/lib/std/core/str.c3
+++ b/lib/std/core/str.c3
@@ -239,6 +239,11 @@ fn usz! index_of(String s, String needle)
 	return SearchResult.MISSING!;
 }
 
+fn ZString String.zstrcopy(String s, Allocator* allocator = mem::current_allocator()) => copy_zstring(s, allocator) @inline;
+fn ZString String.zstrtcopy(String s) => copy_zstring(s, mem::temp_allocator()) @inline;
+fn String String.copyz(String s, Allocator* allocator = mem::current_allocator()) => copyz(s, allocator) @inline;
+fn String String.tcopyz(String s) => copyz(s, mem::temp_allocator()) @inline;
+
 fn ZString copy_zstring(String s, Allocator* allocator = mem::current_allocator())
 {
     usz len = s.len;
@@ -248,6 +253,7 @@ fn ZString copy_zstring(String s, Allocator* allocator = mem::current_allocator(
     return (ZString)str;
 }
 
+
 fn String copyz(String s, Allocator* allocator = mem::current_allocator())
 {
     usz len = s.len;
diff --git a/lib/std/core/string.c3 b/lib/std/core/string.c3
index 3fcabf515..7ccd96241 100644
--- a/lib/std/core/string.c3
+++ b/lib/std/core/string.c3
@@ -271,12 +271,12 @@ macro void VarString.append(VarString* str, value)
 		$case Char32:
 			str.append_char32(value);
 		$default:
-			$if (@convertible($Type, Char32)):
+			$if (@convertible(value, Char32)):
 				str.append_char32(value);
-			$elif (@convertible($Type, String)):
+			$elif (@convertible(value, String)):
 				str.append_chars(value);
 			$else:
-				$assert("Unsupported type for appending");
+				$assert(false, "Unsupported type for append – use printf instead.");
 			$endif;
 	$endswitch;
 }
diff --git a/lib/std/io/io.c3 b/lib/std/io/io.c3
index 3543d0f23..47978e9e9 100644
--- a/lib/std/io/io.c3
+++ b/lib/std/io/io.c3
@@ -34,37 +34,50 @@ fault IoError
     UNKNOWN_ERROR,
 }
 
-fn int putchar(char c) @inline
+fn void putchar(char c) @inline
 {
-    return libc::putchar(c);
+    libc::putchar(c);
 }
 
-/**
- * @param [&in] message
- * @return `number of bytes printed.`
- */
-fn int print(char* message)
+macro void print(x)
 {
-    char* pointer = message;
-    while (*pointer != '\0')
-    {
-        if (!putchar(*pointer)) return 0;
-        pointer++;
-    }
-    return 1;
+	var $Type = $typeof(x);
+	$switch ($Type):
+	$case String:
+		catch(stdout().print(x));
+	$case ZString:
+		catch(stdout().print(x.as_str()));
+	$case VarString:
+		catch(stdout().print(x.str()));
+	$default:
+		$if (@convertible(x, String)):
+			catch(stdout().print((String)x));
+		$else:
+			catch(stdout().printf("%s", x));
+		$endif;
+	$endswitch;
 }
 
-/**
- * @param [&in] message
- * @return `number of bytes printed.`
- */
-fn int println(char *message = "") @inline
+macro void printn(x = "")
 {
-    return libc::puts(message);
+	var $Type = $typeof(x);
+	$switch ($Type):
+	$case String:
+		catch(stdout().printn(x));
+	$case ZString:
+		catch(stdout().printn(x.as_str()));
+	$case VarString:
+		catch(stdout().printn(x.str()));
+	$default:
+		$if (@convertible(x, String)):
+			catch(stdout().printn((String)x));
+		$else:
+			catch(stdout().printfn("%s", x));
+		$endif;
+	$endswitch;
 }
 
-
-
+macro void println(x = "") => printn(x);
 
 fn File stdout()
 {
diff --git a/lib/std/io/io_file.c3 b/lib/std/io/io_file.c3
index a2141e5fe..1192ed1f2 100644
--- a/lib/std/io/io_file.c3
+++ b/lib/std/io/io_file.c3
@@ -5,18 +5,49 @@ fn void! File.open(File* file, String filename, String mode)
 {
 	@pool()
 	{
-	    char* filename_copy = tmalloc(filename.len + 1);
-        char* mode_copy = tmalloc(mode.len + 1);
-
-	    mem::copy(filename_copy, (char*)(filename), filename.len);
-        mem::copy(mode_copy, (char*)(mode), mode.len);
-        filename_copy[filename.len] = 0;
-        mode_copy[filename.len] = 0;
-        file.file = libc::fopen(filename_copy, mode_copy);
+		file.file = libc::fopen(filename.zstrtcopy(), mode.zstrtcopy());
         if (!file.file) return IoError.FILE_NOT_FOUND!;
 	};
 }
 
+/**
+ * @require file.file != null
+ **/
+fn void! File.reopen(File* file, String filename, String mode)
+{
+	@pool()
+	{
+		file.file = libc::freopen(filename.zstrtcopy(), mode.zstrtcopy(), file.file);
+        if (!file.file) return IoError.FILE_NOT_FOUND!;
+	};
+}
+
+/**
+ * @require file.file != null
+ **/
+fn void! File.chmode(File* file, String filename, String mode)
+{
+	@pool()
+	{
+		file.file = libc::freopen(null, mode.zstrtcopy(), file.file);
+        if (!file.file) return IoError.FILE_NOT_FOUND!;
+	};
+}
+/*
+Implement later
+/**
+ * @require file.file == null
+ **/
+fn void! File.memopen(File* file, char[] data, String mode)
+{
+	@pool()
+	{
+		file.file = libc::memopen(data.ptr, data.len, mode.zstrtcopy(), file.file);
+		// TODO errors
+	};
+}
+*/
+
 /**
  * @require file.file != null
  **/
@@ -102,14 +133,26 @@ fn usz File.write(File* file, void* buffer, usz items, usz element_size = 1)
  * @param [&in] file
  * @require file.file `File must be initialized`
  */
-fn usz! File.println(File* file, String string)
+fn usz! File.printn(File* file, String string)
+{
+	usz len = file.print(string)?;
+	if (!libc::putc('\n', file.file)) return IoError.UNKNOWN_ERROR!;
+    return len + 1;
+}
+
+/**
+ * @param [&in] file
+ * @require file.file `File must be initialized`
+ */
+fn usz! File.print(File* file, String string)
 {
     usz len = string.len;
     if (len != libc::fwrite(string.ptr, 1, len, file.file)) return IoError.UNKNOWN_ERROR!;
-    if (!libc::putc('\n', file.file)) return IoError.UNKNOWN_ERROR!;
-    return len + 1;
+    return len;
 }
 
+fn usz! File.println(File* file, String string) => file.printn(string);
+
 /**
  * @param [&in] file
  * @require file.file `File must be initialized`
@@ -134,10 +177,7 @@ fn VarString File.getline(File* file, Allocator* allocator = mem::current_alloca
  */
 fn String File.tgetline(File* file)
 {
-
-	VarString s = file.getline(mem::temp_allocator());
-	ZString z = s.zstr();
-	return z[:s.len()];
+	return file.getline(mem::temp_allocator()).zstr().as_str();
 }
 
 fn char! File.getc(File* file)
diff --git a/lib/std/libc/libc.c3 b/lib/std/libc/libc.c3
index 69aa23d47..2f1718b88 100644
--- a/lib/std/libc/libc.c3
+++ b/lib/std/libc/libc.c3
@@ -211,9 +211,10 @@ extern fn int feof(CFile stream);
 extern fn int ferror(CFile stream);
 extern fn int fflush(CFile stream);
 extern fn int fgetpos(CFile stream, Fpos* pos);
-extern fn CFile fopen(char* filename, char* mode);
+extern fn CFile fopen(ZString filename, ZString mode);
 extern fn usz fread(void* ptr, usz size, usz nmemb, CFile stream);
-extern fn CFile freopen(char* filename, char* mode, CFile stream);
+extern fn CFile freopen(ZString filename, ZString mode, CFile stream);
+extern fn CFile fmemopen(void* ptr, usz size, ZString mode);
 extern fn int fseek(CFile stream, SeekIndex offset, int whence);
 extern fn int fsetpos(CFile stream, Fpos* pos);
 extern fn SeekIndex ftell(CFile stream);
diff --git a/resources/examples/contextfree/boolerr.c3 b/resources/examples/contextfree/boolerr.c3
index 7a0a35888..244ef82a3 100644
--- a/resources/examples/contextfree/boolerr.c3
+++ b/resources/examples/contextfree/boolerr.c3
@@ -127,7 +127,7 @@ fn void main()
             Summary summary = readAndBuildSummary(url);
             io::printf("  Summary: ");
             summary.print(io::stdout());
-            io::println("");
+            io::printn("");
             String title_sure = summary.title ? summary.title.str() : "";
             io::printf("  Title: %s\n", title_sure);
             bool! has_title = readWhetherTitleNonEmpty(url);
diff --git a/resources/examples/contextfree/multi.c3 b/resources/examples/contextfree/multi.c3
index 6071a1d2b..a1c88eb2c 100644
--- a/resources/examples/contextfree/multi.c3
+++ b/resources/examples/contextfree/multi.c3
@@ -16,7 +16,7 @@ fn void main()
 
  		hello();
  	`;
-	io::println(text);
+	io::printn(text);
 
     // Binary
     const DATA = x"4749463839610100010080"
diff --git a/resources/examples/hello_world_many.c3 b/resources/examples/hello_world_many.c3
index 3ceaadeb2..f793ef5fd 100644
--- a/resources/examples/hello_world_many.c3
+++ b/resources/examples/hello_world_many.c3
@@ -14,6 +14,6 @@ fn void main()
     };
     foreach (greeting : greetings)
     {
-        io::println(greeting);
+        io::printn(greeting);
     }
 }
\ No newline at end of file
diff --git a/resources/examples/notworking/madlibs.c3 b/resources/examples/notworking/madlibs.c3
index 194d02e3c..412e5d212 100644
--- a/resources/examples/notworking/madlibs.c3
+++ b/resources/examples/notworking/madlibs.c3
@@ -3,7 +3,7 @@ import regex, stdio;
 
 fn void main()
 {
-    println("Enter a story template, terminated by an empty line:");
+    printn("Enter a story template, terminated by an empty line:");
     VarString story = "";
     while (1)
     {
@@ -25,5 +25,5 @@ fn void main()
         story = story.replace(s, word);
     }
 
-    println("\nThe story becomes:\n%s\n", story);
+    printn("\nThe story becomes:\n%s\n", story);
 }
\ No newline at end of file
diff --git a/resources/examples/plus_minus.c3 b/resources/examples/plus_minus.c3
index 041c86690..0556cbd0c 100644
--- a/resources/examples/plus_minus.c3
+++ b/resources/examples/plus_minus.c3
@@ -49,7 +49,7 @@ fn void main(String[] args)
 			case "-":
 				add = false;
 			default:
-				io::println("Failed to parse expression.");
+				io::printn("Failed to parse expression.");
 				return;
 		}
 	}
diff --git a/resources/rosettacode/antiprime.c3 b/resources/rosettacode/antiprime.c3
index ceb4850d4..98493070a 100644
--- a/resources/rosettacode/antiprime.c3
+++ b/resources/rosettacode/antiprime.c3
@@ -16,7 +16,7 @@ fn int main()
 {
     int maxDiv;
     int count;
-    io::println("The first 20 anti-primes are:");
+    io::printn("The first 20 anti-primes are:");
     int n = 1;
     while (count < 20)
     {
@@ -29,6 +29,6 @@ fn int main()
         }
         n++;
     }
-    io::println("");
+    io::printn("");
     return 0;
 }
\ No newline at end of file
diff --git a/resources/rosettacode/helloworld.c3 b/resources/rosettacode/helloworld.c3
index c5cf38e46..fbc806ced 100644
--- a/resources/rosettacode/helloworld.c3
+++ b/resources/rosettacode/helloworld.c3
@@ -2,6 +2,6 @@ import std::io;
 
 fn int main()
 {
-    io::println("Hello world");
+    io::printn("Hello world");
     return 0;
 }
\ No newline at end of file
diff --git a/resources/testfragments/allocators_testing.c3 b/resources/testfragments/allocators_testing.c3
index 6ad35ac5e..bbfbc66b1 100644
--- a/resources/testfragments/allocators_testing.c3
+++ b/resources/testfragments/allocators_testing.c3
@@ -23,7 +23,7 @@ fn void setstring(char* dst, String str)
 
 fn void testAllocator(Allocator* a, int val)
 {
-	io::println("Test");
+	io::printn("Test");
 	void* data = a.alloc_aligned(val, 128, 16)!!;
 	io::printf("Aligned with offset %p, align 16: %s offset align 128: %s\n", data, mem::ptr_is_aligned(data, 16), mem::ptr_is_aligned(data + 16, 128));
 	data = a.calloc_aligned(val, 128, 16)!!;
@@ -78,7 +78,7 @@ fn void main()
 	ArenaAllocator aa;
 	aa.init(&&char[1024] {});
 	testAllocator(&aa, 126);
-	io::println("Test dynamic arena");
+	io::printn("Test dynamic arena");
 	DynamicArenaAllocator dynamic_arena;
 	dynamic_arena.init(1024);
     testAllocator(&dynamic_arena, 112);
diff --git a/src/build/project_creation.c b/src/build/project_creation.c
index 781d60de4..8e074a297 100644
--- a/src/build/project_creation.c
+++ b/src/build/project_creation.c
@@ -191,7 +191,7 @@ const char* MAIN_TEMPLATE =
 		"\n"
 		"fn int main(char[][] args)\n"
 		"{\n"
-		"\tio::println(\"Hello, World!\");\n"
+		"\tio::printn(\"Hello, World!\");\n"
 		"\treturn 0;\n"
 		"}\n";
 
diff --git a/src/compiler/llvm_codegen.c b/src/compiler/llvm_codegen.c
index c85c7cdd5..bd10bf97b 100644
--- a/src/compiler/llvm_codegen.c
+++ b/src/compiler/llvm_codegen.c
@@ -1446,14 +1446,3 @@ TypeSize llvm_alloc_size(GenContext *c, LLVMTypeRef type)
 	return (TypeSize)aligned_offset((AlignSize)LLVMStoreSizeOfType(c->target_data, type), llvm_abi_alignment(c, type));
 }
 
-void llvm_set_catch_exit(GenContext *c, LLVMBasicBlockRef block)
-{
-	c->catch_block = block;
-	c->opt_var = NULL;
-}
-
-void llvm_set_catch_exit_and_var(GenContext *c, LLVMBasicBlockRef block, LLVMValueRef catch_var)
-{
-	c->catch_block = block;
-	c->opt_var = catch_var;
-}
diff --git a/src/compiler/llvm_codegen_internal.h b/src/compiler/llvm_codegen_internal.h
index 2c8756e77..46e433b08 100644
--- a/src/compiler/llvm_codegen_internal.h
+++ b/src/compiler/llvm_codegen_internal.h
@@ -459,8 +459,7 @@ void llvm_emit_builtin_call(GenContext *c, BEValue *result_value, Expr *expr);
 // -- Optional --
 LLVMValueRef llvm_emit_is_no_opt(GenContext *c, LLVMValueRef error_value);
 LLVMValueRef llvm_get_opt_ref(GenContext *c, Decl *decl);
-void llvm_set_catch_exit(GenContext *c, LLVMBasicBlockRef block);
-void llvm_set_catch_exit_and_var(GenContext *c, LLVMBasicBlockRef block, LLVMValueRef catch_var);
+
 #define PUSH_OPT() LLVMBasicBlockRef _old_catch = c->catch_block; LLVMValueRef _old_opt_var = c->opt_var
 #define POP_OPT() c->catch_block = _old_catch; c->opt_var = _old_opt_var
 
diff --git a/src/compiler/llvm_codegen_stmt.c b/src/compiler/llvm_codegen_stmt.c
index a949d200d..ef6797b34 100644
--- a/src/compiler/llvm_codegen_stmt.c
+++ b/src/compiler/llvm_codegen_stmt.c
@@ -1222,7 +1222,13 @@ static inline void llvm_emit_asm_block_stmt(GenContext *c, Ast *ast)
 static void llvm_emit_expr_stmt(GenContext *c, Ast *ast)
 {
 	BEValue value;
-	if (IS_OPTIONAL(ast->expr_stmt))
+	Expr *e = ast->expr_stmt;
+	// For a standalone catch, we can ignore storing the value.
+	if (e->expr_kind == EXPR_CATCH)
+	{
+		e = e->inner_expr;
+	}
+	if (IS_OPTIONAL(e))
 	{
 		PUSH_OPT();
 		LLVMBasicBlockRef discard_fail = llvm_basic_block_new(c, "voiderr");
@@ -1236,7 +1242,7 @@ static void llvm_emit_expr_stmt(GenContext *c, Ast *ast)
 		POP_OPT();
 		return;
 	}
-	llvm_emit_expr(c, &value, ast->expr_stmt);
+	llvm_emit_expr(c, &value, e);
 }
 
 LLVMValueRef llvm_emit_string_const(GenContext *c, const char *str, const char *extname)
diff --git a/src/compiler/sema_decls.c b/src/compiler/sema_decls.c
index eb5368e95..e38512407 100644
--- a/src/compiler/sema_decls.c
+++ b/src/compiler/sema_decls.c
@@ -1371,13 +1371,6 @@ static inline bool sema_analyse_method(SemaContext *context, Decl *decl)
 	TypeInfo *parent_type = type_infoptr(decl->func_decl.type_parent);
 	if (!sema_resolve_type_info(context, parent_type)) return false;
 	Type *type = parent_type->type->canonical;
-	if (!type_may_have_sub_elements(type) && !type_underlying_is_numeric(type) && !type_is_arraylike(type))
-	{
-		SEMA_ERROR(decl,
-		           "Methods can not be associated with '%s'",
-		           type_to_error_string(parent_type->type));
-		return false;
-	}
 	Decl **params = decl->func_decl.signature.params;
 	if (!vec_size(params))
 	{
diff --git a/src/version.h b/src/version.h
index 7bdb41d21..69a60ef28 100644
--- a/src/version.h
+++ b/src/version.h
@@ -1 +1 @@
-#define COMPILER_VERSION "0.4.41"
\ No newline at end of file
+#define COMPILER_VERSION "0.4.43"
\ No newline at end of file
diff --git a/test/test_suite/bitstruct/bitstruct_be.c3t b/test/test_suite/bitstruct/bitstruct_be.c3t
index ec6dee02f..a23ff0ca2 100644
--- a/test/test_suite/bitstruct/bitstruct_be.c3t
+++ b/test/test_suite/bitstruct/bitstruct_be.c3t
@@ -25,15 +25,15 @@ fn void main()
 	char[4]* z = (char[4]*)&abc;
 	char[4]* z2 = (char[4]*)&abc2;
 	foreach (d : z2) io::printf(" %x", d);
-	io::println("");
+	io::printn("");
 	foreach (d : z) io::printf(" %x", d);
-	io::println("");
+	io::printn("");
 	io::printfn("abc.a = %x", abc.a);
 	abc.a = 0x1234;
 	abc.b = 0x5678;
 	io::printfn("->abc.a = %x", abc.a);
 	foreach (d : z) io::printf(" %x", d);
-	io::println("");
+	io::printn("");
 
 	IntLE y;
 	y.val = 123;
@@ -103,143 +103,197 @@ voiderr6:                                         ; preds = %after_check5, %loop
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
-  %22 = call i32 @std_io_println(ptr @.str.2) #2
-  %23 = load ptr, ptr %z, align 8
-  store ptr %23, ptr %.anon7, align 8
-  store i64 0, ptr %.anon8, align 8
-  br label %loop.cond9
+  store ptr @.str.2, ptr %x7, align 8
+  store i64 0, ptr %error_var, align 8
+  %22 = call ptr @std_io_stdout()
+  store ptr %22, ptr %result, align 8
+  %23 = call i64 @std_io_File_printn(ptr %retparam8, ptr %result, ptr null, i64 0)
+  %not_err9 = icmp eq i64 %23, 0
+  br i1 %not_err9, label %after_check10, label %assign_optional
 
-loop.cond9:                                       ; preds = %voiderr17, %loop.exit
-  %24 = load i64, ptr %.anon8, align 8
-  %gt10 = icmp ugt i64 4, %24
-  br i1 %gt10, label %loop.body11, label %loop.exit19
+assign_optional:                                  ; preds = %loop.exit
+  store i64 %23, ptr %error_var, align 8
+  br label %noerr_block
 
-loop.body11:                                      ; preds = %loop.cond9
-  %25 = load ptr, ptr %.anon7, align 8
-  %26 = load i64, ptr %.anon8, align 8
-  %27 = getelementptr inbounds [4 x i8], ptr %25, i64 0, i64 %26
-  %28 = load i8, ptr %27, align 1
-  store i8 %28, ptr %d12, align 1
-  %29 = insertvalue %variant undef, ptr %d12, 0
-  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$char" to i64), 1
-  %31 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0
-  store %variant %30, ptr %31, align 16
-  %32 = call i64 @std_io_printf(ptr %retparam13, ptr @.str.3, i64 3, ptr %varargslots14, i64 1)
-  %not_err15 = icmp eq i64 %32, 0
-  br i1 %not_err15, label %after_check16, label %voiderr17
+after_check10:                                    ; preds = %loop.exit
+  br label %noerr_block
 
-after_check16:                                    ; preds = %loop.body11
-  br label %voiderr17
+noerr_block:                                      ; preds = %after_check10, %assign_optional
+  br label %voiderr11
 
-voiderr17:                                        ; preds = %after_check16, %loop.body11
-  %33 = load i64, ptr %.anon8, align 8
-  %add18 = add i64 %33, 1
-  store i64 %add18, ptr %.anon8, align 8
-  br label %loop.cond9
+voiderr11:                                        ; preds = %noerr_block
+  %24 = load ptr, ptr %z, align 8
+  store ptr %24, ptr %.anon12, align 8
+  store i64 0, ptr %.anon13, align 8
+  br label %loop.cond14
 
-loop.exit19:                                      ; preds = %loop.cond9
-  %34 = call i32 @std_io_println(ptr @.str.4) #2
-  %35 = load i32, ptr %abc, align 4
-  %36 = call i32 @llvm.bswap.i32(i32 %35)
-  %37 = and i32 65535, %36
-  %ztrunc = trunc i32 %37 to i16
-  store i16 %ztrunc, ptr %taddr22, align 2
-  %38 = insertvalue %variant undef, ptr %taddr22, 0
-  %39 = insertvalue %variant %38, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
-  %40 = getelementptr inbounds [1 x %variant], ptr %varargslots21, i64 0, i64 0
-  store %variant %39, ptr %40, align 16
-  %41 = call i64 @std_io_printfn(ptr %retparam20, ptr @.str.5, i64 10, ptr %varargslots21, i64 1)
-  %not_err23 = icmp eq i64 %41, 0
-  br i1 %not_err23, label %after_check24, label %voiderr25
+loop.cond14:                                      ; preds = %voiderr22, %voiderr11
+  %25 = load i64, ptr %.anon13, align 8
+  %gt15 = icmp ugt i64 4, %25
+  br i1 %gt15, label %loop.body16, label %loop.exit24
 
-after_check24:                                    ; preds = %loop.exit19
-  br label %voiderr25
+loop.body16:                                      ; preds = %loop.cond14
+  %26 = load ptr, ptr %.anon12, align 8
+  %27 = load i64, ptr %.anon13, align 8
+  %28 = getelementptr inbounds [4 x i8], ptr %26, i64 0, i64 %27
+  %29 = load i8, ptr %28, align 1
+  store i8 %29, ptr %d17, align 1
+  %30 = insertvalue %variant undef, ptr %d17, 0
+  %31 = insertvalue %variant %30, i64 ptrtoint (ptr @"ct$char" to i64), 1
+  %32 = getelementptr inbounds [1 x %variant], ptr %varargslots19, i64 0, i64 0
+  store %variant %31, ptr %32, align 16
+  %33 = call i64 @std_io_printf(ptr %retparam18, ptr @.str.3, i64 3, ptr %varargslots19, i64 1)
+  %not_err20 = icmp eq i64 %33, 0
+  br i1 %not_err20, label %after_check21, label %voiderr22
 
-voiderr25:                                        ; preds = %after_check24, %loop.exit19
-  %42 = load i32, ptr %abc, align 4
-  %43 = call i32 @llvm.bswap.i32(i32 %42)
-  %44 = and i32 %43, -65536
-  %45 = or i32 %44, 4660
-  %46 = call i32 @llvm.bswap.i32(i32 %45)
-  store i32 %46, ptr %abc, align 4
-  %47 = load i32, ptr %abc, align 4
+after_check21:                                    ; preds = %loop.body16
+  br label %voiderr22
+
+voiderr22:                                        ; preds = %after_check21, %loop.body16
+  %34 = load i64, ptr %.anon13, align 8
+  %add23 = add i64 %34, 1
+  store i64 %add23, ptr %.anon13, align 8
+  br label %loop.cond14
+
+loop.exit24:                                      ; preds = %loop.cond14
+  store ptr @.str.4, ptr %x25, align 8
+  store i64 0, ptr %error_var26, align 8
+  %35 = call ptr @std_io_stdout()
+  store ptr %35, ptr %result28, align 8
+  %36 = call i64 @std_io_File_printn(ptr %retparam27, ptr %result28, ptr null, i64 0)
+  %not_err29 = icmp eq i64 %36, 0
+  br i1 %not_err29, label %after_check31, label %assign_optional30
+
+assign_optional30:                                ; preds = %loop.exit24
+  store i64 %36, ptr %error_var26, align 8
+  br label %noerr_block32
+
+after_check31:                                    ; preds = %loop.exit24
+  br label %noerr_block32
+
+noerr_block32:                                    ; preds = %after_check31, %assign_optional30
+  br label %voiderr33
+
+voiderr33:                                        ; preds = %noerr_block32
+  %37 = load i32, ptr %abc, align 4
+  %38 = call i32 @llvm.bswap.i32(i32 %37)
+  %39 = and i32 65535, %38
+  %ztrunc = trunc i32 %39 to i16
+  store i16 %ztrunc, ptr %taddr36, align 2
+  %40 = insertvalue %variant undef, ptr %taddr36, 0
+  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
+  %42 = getelementptr inbounds [1 x %variant], ptr %varargslots35, i64 0, i64 0
+  store %variant %41, ptr %42, align 16
+  %43 = call i64 @std_io_printfn(ptr %retparam34, ptr @.str.5, i64 10, ptr %varargslots35, i64 1)
+  %not_err37 = icmp eq i64 %43, 0
+  br i1 %not_err37, label %after_check38, label %voiderr39
+
+after_check38:                                    ; preds = %voiderr33
+  br label %voiderr39
+
+voiderr39:                                        ; preds = %after_check38, %voiderr33
+  %44 = load i32, ptr %abc, align 4
+  %45 = call i32 @llvm.bswap.i32(i32 %44)
+  %46 = and i32 %45, -65536
+  %47 = or i32 %46, 4660
   %48 = call i32 @llvm.bswap.i32(i32 %47)
-  %49 = and i32 %48, 65535
-  %50 = or i32 %49, 1450704896
-  %51 = call i32 @llvm.bswap.i32(i32 %50)
-  store i32 %51, ptr %abc, align 4
-  %52 = load i32, ptr %abc, align 4
+  store i32 %48, ptr %abc, align 4
+  %49 = load i32, ptr %abc, align 4
+  %50 = call i32 @llvm.bswap.i32(i32 %49)
+  %51 = and i32 %50, 65535
+  %52 = or i32 %51, 1450704896
   %53 = call i32 @llvm.bswap.i32(i32 %52)
-  %54 = and i32 65535, %53
-  %ztrunc28 = trunc i32 %54 to i16
-  store i16 %ztrunc28, ptr %taddr29, align 2
-  %55 = insertvalue %variant undef, ptr %taddr29, 0
-  %56 = insertvalue %variant %55, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
-  %57 = getelementptr inbounds [1 x %variant], ptr %varargslots27, i64 0, i64 0
-  store %variant %56, ptr %57, align 16
-  %58 = call i64 @std_io_printfn(ptr %retparam26, ptr @.str.6, i64 12, ptr %varargslots27, i64 1)
-  %not_err30 = icmp eq i64 %58, 0
-  br i1 %not_err30, label %after_check31, label %voiderr32
+  store i32 %53, ptr %abc, align 4
+  %54 = load i32, ptr %abc, align 4
+  %55 = call i32 @llvm.bswap.i32(i32 %54)
+  %56 = and i32 65535, %55
+  %ztrunc42 = trunc i32 %56 to i16
+  store i16 %ztrunc42, ptr %taddr43, align 2
+  %57 = insertvalue %variant undef, ptr %taddr43, 0
+  %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
+  %59 = getelementptr inbounds [1 x %variant], ptr %varargslots41, i64 0, i64 0
+  store %variant %58, ptr %59, align 16
+  %60 = call i64 @std_io_printfn(ptr %retparam40, ptr @.str.6, i64 12, ptr %varargslots41, i64 1)
+  %not_err44 = icmp eq i64 %60, 0
+  br i1 %not_err44, label %after_check45, label %voiderr46
 
-after_check31:                                    ; preds = %voiderr25
-  br label %voiderr32
+after_check45:                                    ; preds = %voiderr39
+  br label %voiderr46
 
-voiderr32:                                        ; preds = %after_check31, %voiderr25
-  %59 = load ptr, ptr %z, align 8
-  store ptr %59, ptr %.anon33, align 8
-  store i64 0, ptr %.anon34, align 8
-  br label %loop.cond35
+voiderr46:                                        ; preds = %after_check45, %voiderr39
+  %61 = load ptr, ptr %z, align 8
+  store ptr %61, ptr %.anon47, align 8
+  store i64 0, ptr %.anon48, align 8
+  br label %loop.cond49
 
-loop.cond35:                                      ; preds = %voiderr43, %voiderr32
-  %60 = load i64, ptr %.anon34, align 8
-  %gt36 = icmp ugt i64 4, %60
-  br i1 %gt36, label %loop.body37, label %loop.exit45
+loop.cond49:                                      ; preds = %voiderr57, %voiderr46
+  %62 = load i64, ptr %.anon48, align 8
+  %gt50 = icmp ugt i64 4, %62
+  br i1 %gt50, label %loop.body51, label %loop.exit59
 
-loop.body37:                                      ; preds = %loop.cond35
-  %61 = load ptr, ptr %.anon33, align 8
-  %62 = load i64, ptr %.anon34, align 8
-  %63 = getelementptr inbounds [4 x i8], ptr %61, i64 0, i64 %62
-  %64 = load i8, ptr %63, align 1
-  store i8 %64, ptr %d38, align 1
-  %65 = insertvalue %variant undef, ptr %d38, 0
-  %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$char" to i64), 1
-  %67 = getelementptr inbounds [1 x %variant], ptr %varargslots40, i64 0, i64 0
-  store %variant %66, ptr %67, align 16
-  %68 = call i64 @std_io_printf(ptr %retparam39, ptr @.str.7, i64 3, ptr %varargslots40, i64 1)
-  %not_err41 = icmp eq i64 %68, 0
-  br i1 %not_err41, label %after_check42, label %voiderr43
+loop.body51:                                      ; preds = %loop.cond49
+  %63 = load ptr, ptr %.anon47, align 8
+  %64 = load i64, ptr %.anon48, align 8
+  %65 = getelementptr inbounds [4 x i8], ptr %63, i64 0, i64 %64
+  %66 = load i8, ptr %65, align 1
+  store i8 %66, ptr %d52, align 1
+  %67 = insertvalue %variant undef, ptr %d52, 0
+  %68 = insertvalue %variant %67, i64 ptrtoint (ptr @"ct$char" to i64), 1
+  %69 = getelementptr inbounds [1 x %variant], ptr %varargslots54, i64 0, i64 0
+  store %variant %68, ptr %69, align 16
+  %70 = call i64 @std_io_printf(ptr %retparam53, ptr @.str.7, i64 3, ptr %varargslots54, i64 1)
+  %not_err55 = icmp eq i64 %70, 0
+  br i1 %not_err55, label %after_check56, label %voiderr57
 
-after_check42:                                    ; preds = %loop.body37
-  br label %voiderr43
+after_check56:                                    ; preds = %loop.body51
+  br label %voiderr57
 
-voiderr43:                                        ; preds = %after_check42, %loop.body37
-  %69 = load i64, ptr %.anon34, align 8
-  %add44 = add i64 %69, 1
-  store i64 %add44, ptr %.anon34, align 8
-  br label %loop.cond35
+voiderr57:                                        ; preds = %after_check56, %loop.body51
+  %71 = load i64, ptr %.anon48, align 8
+  %add58 = add i64 %71, 1
+  store i64 %add58, ptr %.anon48, align 8
+  br label %loop.cond49
 
-loop.exit45:                                      ; preds = %loop.cond35
-  %70 = call i32 @std_io_println(ptr @.str.8) #2
+loop.exit59:                                      ; preds = %loop.cond49
+  store ptr @.str.8, ptr %x60, align 8
+  store i64 0, ptr %error_var61, align 8
+  %72 = call ptr @std_io_stdout()
+  store ptr %72, ptr %result63, align 8
+  %73 = call i64 @std_io_File_printn(ptr %retparam62, ptr %result63, ptr null, i64 0)
+  %not_err64 = icmp eq i64 %73, 0
+  br i1 %not_err64, label %after_check66, label %assign_optional65
+
+assign_optional65:                                ; preds = %loop.exit59
+  store i64 %73, ptr %error_var61, align 8
+  br label %noerr_block67
+
+after_check66:                                    ; preds = %loop.exit59
+  br label %noerr_block67
+
+noerr_block67:                                    ; preds = %after_check66, %assign_optional65
+  br label %voiderr68
+
+voiderr68:                                        ; preds = %noerr_block67
   store i32 0, ptr %y, align 4
-  %71 = load i32, ptr %y, align 4
+  %74 = load i32, ptr %y, align 4
   store i32 123, ptr %y, align 4
-  %72 = insertvalue %variant undef, ptr %y, 0
-  %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %74 = getelementptr inbounds [2 x %variant], ptr %varargslots47, i64 0, i64 0
-  store %variant %73, ptr %74, align 16
-  %75 = load i32, ptr %y, align 4
-  store i32 %75, ptr %taddr48, align 4
-  %76 = insertvalue %variant undef, ptr %taddr48, 0
-  %77 = insertvalue %variant %76, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %78 = getelementptr inbounds [2 x %variant], ptr %varargslots47, i64 0, i64 1
-  store %variant %77, ptr %78, align 16
-  %79 = call i64 @std_io_printf(ptr %retparam46, ptr @.str.9, i64 18, ptr %varargslots47, i64 2)
-  %not_err49 = icmp eq i64 %79, 0
-  br i1 %not_err49, label %after_check50, label %voiderr51
+  %75 = insertvalue %variant undef, ptr %y, 0
+  %76 = insertvalue %variant %75, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %77 = getelementptr inbounds [2 x %variant], ptr %varargslots70, i64 0, i64 0
+  store %variant %76, ptr %77, align 16
+  %78 = load i32, ptr %y, align 4
+  store i32 %78, ptr %taddr71, align 4
+  %79 = insertvalue %variant undef, ptr %taddr71, 0
+  %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %81 = getelementptr inbounds [2 x %variant], ptr %varargslots70, i64 0, i64 1
+  store %variant %80, ptr %81, align 16
+  %82 = call i64 @std_io_printf(ptr %retparam69, ptr @.str.9, i64 18, ptr %varargslots70, i64 2)
+  %not_err72 = icmp eq i64 %82, 0
+  br i1 %not_err72, label %after_check73, label %voiderr74
 
-after_check50:                                    ; preds = %loop.exit45
-  br label %voiderr51
+after_check73:                                    ; preds = %voiderr68
+  br label %voiderr74
 
-voiderr51:                                        ; preds = %after_check50, %loop.exit45
+voiderr74:                                        ; preds = %after_check73, %voiderr68
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/compile_time/ct_builtin_time_date.c3t b/test/test_suite/compile_time/ct_builtin_time_date.c3t
index 46d37b5aa..3205c634b 100644
--- a/test/test_suite/compile_time/ct_builtin_time_date.c3t
+++ b/test/test_suite/compile_time/ct_builtin_time_date.c3t
@@ -10,11 +10,11 @@ fn void test(int x)
 {
 	io::printfn("%d", x);
 	if (x > 0) $$FUNCTION(x - 1);
-	io::println($$TIME);
-	io::println($$DATE);
+	io::printn($$TIME);
+	io::printn($$DATE);
 	printline();
-	io::println($$FILE);
-	io::println($$MODULE);
+	io::printn($$FILE);
+	io::printn($$MODULE);
 }
 
 bool is_def = $defined($$FUNCTION);
@@ -32,12 +32,28 @@ entry:
   %retparam = alloca i64, align 8
   %varargslots = alloca [1 x %variant], align 16
   %taddr = alloca i32, align 4
+  %x = alloca ptr, align 8
+  %error_var = alloca i64, align 8
   %retparam1 = alloca i64, align 8
-  %varargslots2 = alloca [1 x %variant], align 16
-  %taddr3 = alloca i64, align 8
+  %result = alloca %File, align 8
+  %x5 = alloca ptr, align 8
+  %error_var6 = alloca i64, align 8
   %retparam7 = alloca i64, align 8
-  %varargslots8 = alloca [1 x %variant], align 16
-  %taddr9 = alloca i64, align 8
+  %result8 = alloca %File, align 8
+  %retparam14 = alloca i64, align 8
+  %varargslots15 = alloca [1 x %variant], align 16
+  %taddr16 = alloca i64, align 8
+  %retparam20 = alloca i64, align 8
+  %varargslots21 = alloca [1 x %variant], align 16
+  %taddr22 = alloca i64, align 8
+  %x26 = alloca ptr, align 8
+  %error_var27 = alloca i64, align 8
+  %retparam28 = alloca i64, align 8
+  %result29 = alloca %File, align 8
+  %x35 = alloca ptr, align 8
+  %error_var36 = alloca i64, align 8
+  %retparam37 = alloca i64, align 8
+  %result38 = alloca %File, align 8
   store i32 %0, ptr %taddr, align 4
   %1 = insertvalue %variant undef, ptr %taddr, 0
   %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1
@@ -60,35 +76,111 @@ if.then:                                          ; preds = %voiderr
   br label %if.exit
 
 if.exit:                                          ; preds = %if.then, %voiderr
-  %5 = call i32 @std_io_println(ptr @.str.1) #1
-  %6 = call i32 @std_io_println(ptr @.str.2) #1
-  store i64 14, ptr %taddr3, align 8
-  %7 = insertvalue %variant undef, ptr %taddr3, 0
-  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$long" to i64), 1
-  %9 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0
-  store %variant %8, ptr %9, align 16
-  %10 = call i64 @std_io_printfn(ptr %retparam1, ptr @.str.3, i64 2, ptr %varargslots2, i64 1)
-  %not_err4 = icmp eq i64 %10, 0
-  br i1 %not_err4, label %after_check5, label %voiderr6
+  store ptr @.str.1, ptr %x, align 8
+  store i64 0, ptr %error_var, align 8
+  %5 = call ptr @std_io_stdout()
+  store ptr %5, ptr %result, align 8
+  %6 = load ptr, ptr %x, align 8
+  %7 = call i64 @std_io_File_printn(ptr %retparam1, ptr %result, ptr %6, i64 8)
+  %not_err2 = icmp eq i64 %7, 0
+  br i1 %not_err2, label %after_check3, label %assign_optional
 
-after_check5:                                     ; preds = %if.exit
-  br label %voiderr6
+assign_optional:                                  ; preds = %if.exit
+  store i64 %7, ptr %error_var, align 8
+  br label %noerr_block
 
-voiderr6:                                         ; preds = %after_check5, %if.exit
-  store i64 6, ptr %taddr9, align 8
-  %11 = insertvalue %variant undef, ptr %taddr9, 0
+after_check3:                                     ; preds = %if.exit
+  br label %noerr_block
+
+noerr_block:                                      ; preds = %after_check3, %assign_optional
+  br label %voiderr4
+
+voiderr4:                                         ; preds = %noerr_block
+  store ptr @.str.2, ptr %x5, align 8
+  store i64 0, ptr %error_var6, align 8
+  %8 = call ptr @std_io_stdout()
+  store ptr %8, ptr %result8, align 8
+  %9 = load ptr, ptr %x5, align 8
+  %10 = call i64 @std_io_File_printn(ptr %retparam7, ptr %result8, ptr %9, i64 10)
+  %not_err9 = icmp eq i64 %10, 0
+  br i1 %not_err9, label %after_check11, label %assign_optional10
+
+assign_optional10:                                ; preds = %voiderr4
+  store i64 %10, ptr %error_var6, align 8
+  br label %noerr_block12
+
+after_check11:                                    ; preds = %voiderr4
+  br label %noerr_block12
+
+noerr_block12:                                    ; preds = %after_check11, %assign_optional10
+  br label %voiderr13
+
+voiderr13:                                        ; preds = %noerr_block12
+  store i64 14, ptr %taddr16, align 8
+  %11 = insertvalue %variant undef, ptr %taddr16, 0
   %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$long" to i64), 1
-  %13 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
+  %13 = getelementptr inbounds [1 x %variant], ptr %varargslots15, i64 0, i64 0
   store %variant %12, ptr %13, align 16
-  %14 = call i64 @std_io_printfn(ptr %retparam7, ptr @.str.4, i64 2, ptr %varargslots8, i64 1)
-  %not_err10 = icmp eq i64 %14, 0
-  br i1 %not_err10, label %after_check11, label %voiderr12
+  %14 = call i64 @std_io_printfn(ptr %retparam14, ptr @.str.3, i64 2, ptr %varargslots15, i64 1)
+  %not_err17 = icmp eq i64 %14, 0
+  br i1 %not_err17, label %after_check18, label %voiderr19
 
-after_check11:                                    ; preds = %voiderr6
-  br label %voiderr12
+after_check18:                                    ; preds = %voiderr13
+  br label %voiderr19
 
-voiderr12:                                        ; preds = %after_check11, %voiderr6
-  %15 = call i32 @std_io_println(ptr @.str.5) #1
-  %16 = call i32 @std_io_println(ptr @.str.6) #1
+voiderr19:                                        ; preds = %after_check18, %voiderr13
+  store i64 6, ptr %taddr22, align 8
+  %15 = insertvalue %variant undef, ptr %taddr22, 0
+  %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$long" to i64), 1
+  %17 = getelementptr inbounds [1 x %variant], ptr %varargslots21, i64 0, i64 0
+  store %variant %16, ptr %17, align 16
+  %18 = call i64 @std_io_printfn(ptr %retparam20, ptr @.str.4, i64 2, ptr %varargslots21, i64 1)
+  %not_err23 = icmp eq i64 %18, 0
+  br i1 %not_err23, label %after_check24, label %voiderr25
+
+after_check24:                                    ; preds = %voiderr19
+  br label %voiderr25
+
+voiderr25:                                        ; preds = %after_check24, %voiderr19
+  store ptr @.str.5, ptr %x26, align 8
+  store i64 0, ptr %error_var27, align 8
+  %19 = call ptr @std_io_stdout()
+  store ptr %19, ptr %result29, align 8
+  %20 = load ptr, ptr %x26, align 8
+  %21 = call i64 @std_io_File_printn(ptr %retparam28, ptr %result29, ptr %20, i64 23)
+  %not_err30 = icmp eq i64 %21, 0
+  br i1 %not_err30, label %after_check32, label %assign_optional31
+
+assign_optional31:                                ; preds = %voiderr25
+  store i64 %21, ptr %error_var27, align 8
+  br label %noerr_block33
+
+after_check32:                                    ; preds = %voiderr25
+  br label %noerr_block33
+
+noerr_block33:                                    ; preds = %after_check32, %assign_optional31
+  br label %voiderr34
+
+voiderr34:                                        ; preds = %noerr_block33
+  store ptr @.str.6, ptr %x35, align 8
+  store i64 0, ptr %error_var36, align 8
+  %22 = call ptr @std_io_stdout()
+  store ptr %22, ptr %result38, align 8
+  %23 = load ptr, ptr %x35, align 8
+  %24 = call i64 @std_io_File_printn(ptr %retparam37, ptr %result38, ptr %23, i64 4)
+  %not_err39 = icmp eq i64 %24, 0
+  br i1 %not_err39, label %after_check41, label %assign_optional40
+
+assign_optional40:                                ; preds = %voiderr34
+  store i64 %24, ptr %error_var36, align 8
+  br label %noerr_block42
+
+after_check41:                                    ; preds = %voiderr34
+  br label %noerr_block42
+
+noerr_block42:                                    ; preds = %after_check41, %assign_optional40
+  br label %voiderr43
+
+voiderr43:                                        ; preds = %noerr_block42
   ret void
-}
+}
\ No newline at end of file
diff --git a/test/test_suite/compile_time/ct_func.c3t b/test/test_suite/compile_time/ct_func.c3t
index 85895870b..31c5a82d4 100644
--- a/test/test_suite/compile_time/ct_func.c3t
+++ b/test/test_suite/compile_time/ct_func.c3t
@@ -4,7 +4,7 @@ import std::io;
 
 fn int test()
 {
-	io::println($$FUNC);
+	io::printn($$FUNC);
 	return 1;
 }
 
@@ -13,7 +13,7 @@ struct Foo
 
 fn void Foo.tester(Foo* f)
 {
-	io::println($$FUNC);
+	io::printn($$FUNC);
 }
 
 fn void main()
diff --git a/test/test_suite/compile_time/ct_memberof.c3t b/test/test_suite/compile_time/ct_memberof.c3t
index 546e7351a..4309c1843 100644
--- a/test/test_suite/compile_time/ct_memberof.c3t
+++ b/test/test_suite/compile_time/ct_memberof.c3t
@@ -8,7 +8,7 @@ macro print_args($Type)
 {
 	var $params = $Type.params;
 	$foreach ($param : $params):
-		io::println($param.nameof);
+		io::printn($param.nameof);
 	$endforeach;
 }
 
@@ -46,8 +46,8 @@ fn void test(int x)
 	print_args($typeof(&test));
 	print_args($typeof(&hell));
 	print_args($typeof(&hello));
-	io::println($typeof(&test).returns.nameof);
-	io::println($typeof(&hell).returns.nameof);
+	io::printn($typeof(&test).returns.nameof);
+	io::printn($typeof(&hell).returns.nameof);
 	print_fields(Foo);
 	print_fields(Bar);
 	print_fields(Bark);
@@ -117,281 +117,442 @@ entry:
 ; Function Attrs: nounwind
 define void @test_test(i32 %0) #0 {
 entry:
+  %x = alloca ptr, align 8
+  %error_var = alloca i64, align 8
   %retparam = alloca i64, align 8
+  %result = alloca %File, align 8
+  %x1 = alloca ptr, align 8
+  %error_var2 = alloca i64, align 8
+  %retparam3 = alloca i64, align 8
+  %result4 = alloca %File, align 8
+  %x10 = alloca ptr, align 8
+  %error_var11 = alloca i64, align 8
+  %retparam12 = alloca i64, align 8
+  %result13 = alloca %File, align 8
+  %x19 = alloca ptr, align 8
+  %error_var20 = alloca i64, align 8
+  %retparam21 = alloca i64, align 8
+  %result22 = alloca %File, align 8
+  %x28 = alloca ptr, align 8
+  %error_var29 = alloca i64, align 8
+  %retparam30 = alloca i64, align 8
+  %result31 = alloca %File, align 8
+  %x37 = alloca ptr, align 8
+  %error_var38 = alloca i64, align 8
+  %retparam39 = alloca i64, align 8
+  %result40 = alloca %File, align 8
+  %x46 = alloca ptr, align 8
+  %error_var47 = alloca i64, align 8
+  %retparam48 = alloca i64, align 8
+  %result49 = alloca %File, align 8
+  %retparam55 = alloca i64, align 8
   %varargslots = alloca [1 x %variant], align 16
   %taddr = alloca ptr, align 8
-  %retparam1 = alloca i64, align 8
-  %varargslots2 = alloca [2 x %variant], align 16
-  %taddr3 = alloca ptr, align 8
-  %taddr4 = alloca ptr, align 8
-  %retparam8 = alloca i64, align 8
-  %varargslots9 = alloca [2 x %variant], align 16
-  %taddr10 = alloca ptr, align 8
-  %taddr11 = alloca ptr, align 8
-  %retparam15 = alloca i64, align 8
-  %varargslots16 = alloca [2 x %variant], align 16
-  %taddr17 = alloca ptr, align 8
-  %taddr18 = alloca ptr, align 8
-  %retparam22 = alloca i64, align 8
-  %varargslots23 = alloca [2 x %variant], align 16
-  %taddr24 = alloca ptr, align 8
-  %taddr25 = alloca ptr, align 8
-  %retparam29 = alloca i64, align 8
-  %varargslots30 = alloca [1 x %variant], align 16
-  %taddr31 = alloca ptr, align 8
-  %retparam35 = alloca i64, align 8
-  %varargslots36 = alloca [2 x %variant], align 16
-  %taddr37 = alloca ptr, align 8
-  %taddr38 = alloca ptr, align 8
-  %retparam42 = alloca i64, align 8
-  %varargslots43 = alloca [2 x %variant], align 16
-  %taddr44 = alloca ptr, align 8
-  %taddr45 = alloca ptr, align 8
-  %retparam49 = alloca i64, align 8
-  %varargslots50 = alloca [2 x %variant], align 16
-  %taddr51 = alloca ptr, align 8
-  %taddr52 = alloca ptr, align 8
-  %retparam56 = alloca i64, align 8
-  %varargslots57 = alloca [2 x %variant], align 16
-  %taddr58 = alloca ptr, align 8
-  %taddr59 = alloca ptr, align 8
-  %retparam63 = alloca i64, align 8
-  %varargslots64 = alloca [1 x %variant], align 16
-  %taddr65 = alloca ptr, align 8
-  %retparam69 = alloca i64, align 8
-  %varargslots70 = alloca [2 x %variant], align 16
-  %taddr71 = alloca ptr, align 8
-  %taddr72 = alloca ptr, align 8
-  %retparam76 = alloca i64, align 8
-  %varargslots77 = alloca [2 x %variant], align 16
-  %taddr78 = alloca ptr, align 8
-  %taddr79 = alloca ptr, align 8
-  %1 = call i32 @std_io_println(ptr @.str) #1
-  %2 = call i32 @std_io_println(ptr @.str.10) #1
-  %3 = call i32 @std_io_println(ptr @.str.11) #1
-  %4 = call i32 @std_io_println(ptr @.str.12) #1
-  %5 = call i32 @std_io_println(ptr @.str.13) #1
-  %6 = call i32 @std_io_println(ptr @.str.14) #1
-  %7 = call i32 @std_io_println(ptr @.str.15) #1
-  store ptr @.str.17, ptr %taddr, align 8
-  %8 = insertvalue %variant undef, ptr %taddr, 0
-  %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
-  %10 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
-  store %variant %9, ptr %10, align 16
-  %11 = call i64 @std_io_printfn(ptr %retparam, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
-  %not_err = icmp eq i64 %11, 0
-  br i1 %not_err, label %after_check, label %voiderr
+  %retparam59 = alloca i64, align 8
+  %varargslots60 = alloca [2 x %variant], align 16
+  %taddr61 = alloca ptr, align 8
+  %taddr62 = alloca ptr, align 8
+  %retparam66 = alloca i64, align 8
+  %varargslots67 = alloca [2 x %variant], align 16
+  %taddr68 = alloca ptr, align 8
+  %taddr69 = alloca ptr, align 8
+  %retparam73 = alloca i64, align 8
+  %varargslots74 = alloca [2 x %variant], align 16
+  %taddr75 = alloca ptr, align 8
+  %taddr76 = alloca ptr, align 8
+  %retparam80 = alloca i64, align 8
+  %varargslots81 = alloca [2 x %variant], align 16
+  %taddr82 = alloca ptr, align 8
+  %taddr83 = alloca ptr, align 8
+  %retparam87 = alloca i64, align 8
+  %varargslots88 = alloca [1 x %variant], align 16
+  %taddr89 = alloca ptr, align 8
+  %retparam93 = alloca i64, align 8
+  %varargslots94 = alloca [2 x %variant], align 16
+  %taddr95 = alloca ptr, align 8
+  %taddr96 = alloca ptr, align 8
+  %retparam100 = alloca i64, align 8
+  %varargslots101 = alloca [2 x %variant], align 16
+  %taddr102 = alloca ptr, align 8
+  %taddr103 = alloca ptr, align 8
+  %retparam107 = alloca i64, align 8
+  %varargslots108 = alloca [2 x %variant], align 16
+  %taddr109 = alloca ptr, align 8
+  %taddr110 = alloca ptr, align 8
+  %retparam114 = alloca i64, align 8
+  %varargslots115 = alloca [2 x %variant], align 16
+  %taddr116 = alloca ptr, align 8
+  %taddr117 = alloca ptr, align 8
+  %retparam121 = alloca i64, align 8
+  %varargslots122 = alloca [1 x %variant], align 16
+  %taddr123 = alloca ptr, align 8
+  %retparam127 = alloca i64, align 8
+  %varargslots128 = alloca [2 x %variant], align 16
+  %taddr129 = alloca ptr, align 8
+  %taddr130 = alloca ptr, align 8
+  %retparam134 = alloca i64, align 8
+  %varargslots135 = alloca [2 x %variant], align 16
+  %taddr136 = alloca ptr, align 8
+  %taddr137 = alloca ptr, align 8
+  store ptr @.str, ptr %x, align 8
+  store i64 0, ptr %error_var, align 8
+  %1 = call ptr @std_io_stdout()
+  store ptr %1, ptr %result, align 8
+  %2 = load ptr, ptr %x, align 8
+  %3 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %2, i64 3)
+  %not_err = icmp eq i64 %3, 0
+  br i1 %not_err, label %after_check, label %assign_optional
+
+assign_optional:                                  ; preds = %entry
+  store i64 %3, ptr %error_var, align 8
+  br label %noerr_block
 
 after_check:                                      ; preds = %entry
+  br label %noerr_block
+
+noerr_block:                                      ; preds = %after_check, %assign_optional
   br label %voiderr
 
-voiderr:                                          ; preds = %after_check, %entry
-  store ptr @.str.19, ptr %taddr3, align 8
-  %12 = insertvalue %variant undef, ptr %taddr3, 0
-  %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
-  %14 = getelementptr inbounds [2 x %variant], ptr %varargslots2, i64 0, i64 0
-  store %variant %13, ptr %14, align 16
-  store ptr @.str.20, ptr %taddr4, align 8
-  %15 = insertvalue %variant undef, ptr %taddr4, 0
-  %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
-  %17 = getelementptr inbounds [2 x %variant], ptr %varargslots2, i64 0, i64 1
-  store %variant %16, ptr %17, align 16
-  %18 = call i64 @std_io_printfn(ptr %retparam1, ptr @.str.18, i64 6, ptr %varargslots2, i64 2)
-  %not_err5 = icmp eq i64 %18, 0
-  br i1 %not_err5, label %after_check6, label %voiderr7
+voiderr:                                          ; preds = %noerr_block
+  store ptr @.str.10, ptr %x1, align 8
+  store i64 0, ptr %error_var2, align 8
+  %4 = call ptr @std_io_stdout()
+  store ptr %4, ptr %result4, align 8
+  %5 = load ptr, ptr %x1, align 8
+  %6 = call i64 @std_io_File_printn(ptr %retparam3, ptr %result4, ptr %5, i64 3)
+  %not_err5 = icmp eq i64 %6, 0
+  br i1 %not_err5, label %after_check7, label %assign_optional6
 
-after_check6:                                     ; preds = %voiderr
-  br label %voiderr7
+assign_optional6:                                 ; preds = %voiderr
+  store i64 %6, ptr %error_var2, align 8
+  br label %noerr_block8
 
-voiderr7:                                         ; preds = %after_check6, %voiderr
-  store ptr @.str.22, ptr %taddr10, align 8
-  %19 = insertvalue %variant undef, ptr %taddr10, 0
-  %20 = insertvalue %variant %19, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
-  %21 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 0
-  store %variant %20, ptr %21, align 16
-  store ptr @.str.23, ptr %taddr11, align 8
-  %22 = insertvalue %variant undef, ptr %taddr11, 0
-  %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
-  %24 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 1
+after_check7:                                     ; preds = %voiderr
+  br label %noerr_block8
+
+noerr_block8:                                     ; preds = %after_check7, %assign_optional6
+  br label %voiderr9
+
+voiderr9:                                         ; preds = %noerr_block8
+  store ptr @.str.11, ptr %x10, align 8
+  store i64 0, ptr %error_var11, align 8
+  %7 = call ptr @std_io_stdout()
+  store ptr %7, ptr %result13, align 8
+  %8 = load ptr, ptr %x10, align 8
+  %9 = call i64 @std_io_File_printn(ptr %retparam12, ptr %result13, ptr %8, i64 6)
+  %not_err14 = icmp eq i64 %9, 0
+  br i1 %not_err14, label %after_check16, label %assign_optional15
+
+assign_optional15:                                ; preds = %voiderr9
+  store i64 %9, ptr %error_var11, align 8
+  br label %noerr_block17
+
+after_check16:                                    ; preds = %voiderr9
+  br label %noerr_block17
+
+noerr_block17:                                    ; preds = %after_check16, %assign_optional15
+  br label %voiderr18
+
+voiderr18:                                        ; preds = %noerr_block17
+  store ptr @.str.12, ptr %x19, align 8
+  store i64 0, ptr %error_var20, align 8
+  %10 = call ptr @std_io_stdout()
+  store ptr %10, ptr %result22, align 8
+  %11 = load ptr, ptr %x19, align 8
+  %12 = call i64 @std_io_File_printn(ptr %retparam21, ptr %result22, ptr %11, i64 6)
+  %not_err23 = icmp eq i64 %12, 0
+  br i1 %not_err23, label %after_check25, label %assign_optional24
+
+assign_optional24:                                ; preds = %voiderr18
+  store i64 %12, ptr %error_var20, align 8
+  br label %noerr_block26
+
+after_check25:                                    ; preds = %voiderr18
+  br label %noerr_block26
+
+noerr_block26:                                    ; preds = %after_check25, %assign_optional24
+  br label %voiderr27
+
+voiderr27:                                        ; preds = %noerr_block26
+  store ptr @.str.13, ptr %x28, align 8
+  store i64 0, ptr %error_var29, align 8
+  %13 = call ptr @std_io_stdout()
+  store ptr %13, ptr %result31, align 8
+  %14 = load ptr, ptr %x28, align 8
+  %15 = call i64 @std_io_File_printn(ptr %retparam30, ptr %result31, ptr %14, i64 9)
+  %not_err32 = icmp eq i64 %15, 0
+  br i1 %not_err32, label %after_check34, label %assign_optional33
+
+assign_optional33:                                ; preds = %voiderr27
+  store i64 %15, ptr %error_var29, align 8
+  br label %noerr_block35
+
+after_check34:                                    ; preds = %voiderr27
+  br label %noerr_block35
+
+noerr_block35:                                    ; preds = %after_check34, %assign_optional33
+  br label %voiderr36
+
+voiderr36:                                        ; preds = %noerr_block35
+  store ptr @.str.14, ptr %x37, align 8
+  store i64 0, ptr %error_var38, align 8
+  %16 = call ptr @std_io_stdout()
+  store ptr %16, ptr %result40, align 8
+  %17 = load ptr, ptr %x37, align 8
+  %18 = call i64 @std_io_File_printn(ptr %retparam39, ptr %result40, ptr %17, i64 4)
+  %not_err41 = icmp eq i64 %18, 0
+  br i1 %not_err41, label %after_check43, label %assign_optional42
+
+assign_optional42:                                ; preds = %voiderr36
+  store i64 %18, ptr %error_var38, align 8
+  br label %noerr_block44
+
+after_check43:                                    ; preds = %voiderr36
+  br label %noerr_block44
+
+noerr_block44:                                    ; preds = %after_check43, %assign_optional42
+  br label %voiderr45
+
+voiderr45:                                        ; preds = %noerr_block44
+  store ptr @.str.15, ptr %x46, align 8
+  store i64 0, ptr %error_var47, align 8
+  %19 = call ptr @std_io_stdout()
+  store ptr %19, ptr %result49, align 8
+  %20 = load ptr, ptr %x46, align 8
+  %21 = call i64 @std_io_File_printn(ptr %retparam48, ptr %result49, ptr %20, i64 3)
+  %not_err50 = icmp eq i64 %21, 0
+  br i1 %not_err50, label %after_check52, label %assign_optional51
+
+assign_optional51:                                ; preds = %voiderr45
+  store i64 %21, ptr %error_var47, align 8
+  br label %noerr_block53
+
+after_check52:                                    ; preds = %voiderr45
+  br label %noerr_block53
+
+noerr_block53:                                    ; preds = %after_check52, %assign_optional51
+  br label %voiderr54
+
+voiderr54:                                        ; preds = %noerr_block53
+  store ptr @.str.17, ptr %taddr, align 8
+  %22 = insertvalue %variant undef, ptr %taddr, 0
+  %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
+  %24 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %23, ptr %24, align 16
-  %25 = call i64 @std_io_printfn(ptr %retparam8, ptr @.str.21, i64 6, ptr %varargslots9, i64 2)
-  %not_err12 = icmp eq i64 %25, 0
-  br i1 %not_err12, label %after_check13, label %voiderr14
+  %25 = call i64 @std_io_printfn(ptr %retparam55, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
+  %not_err56 = icmp eq i64 %25, 0
+  br i1 %not_err56, label %after_check57, label %voiderr58
 
-after_check13:                                    ; preds = %voiderr7
-  br label %voiderr14
+after_check57:                                    ; preds = %voiderr54
+  br label %voiderr58
 
-voiderr14:                                        ; preds = %after_check13, %voiderr7
-  store ptr @.str.25, ptr %taddr17, align 8
-  %26 = insertvalue %variant undef, ptr %taddr17, 0
-  %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1
-  %28 = getelementptr inbounds [2 x %variant], ptr %varargslots16, i64 0, i64 0
+voiderr58:                                        ; preds = %after_check57, %voiderr54
+  store ptr @.str.19, ptr %taddr61, align 8
+  %26 = insertvalue %variant undef, ptr %taddr61, 0
+  %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
+  %28 = getelementptr inbounds [2 x %variant], ptr %varargslots60, i64 0, i64 0
   store %variant %27, ptr %28, align 16
-  store ptr @.str.26, ptr %taddr18, align 8
-  %29 = insertvalue %variant undef, ptr %taddr18, 0
-  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
-  %31 = getelementptr inbounds [2 x %variant], ptr %varargslots16, i64 0, i64 1
+  store ptr @.str.20, ptr %taddr62, align 8
+  %29 = insertvalue %variant undef, ptr %taddr62, 0
+  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
+  %31 = getelementptr inbounds [2 x %variant], ptr %varargslots60, i64 0, i64 1
   store %variant %30, ptr %31, align 16
-  %32 = call i64 @std_io_printfn(ptr %retparam15, ptr @.str.24, i64 6, ptr %varargslots16, i64 2)
-  %not_err19 = icmp eq i64 %32, 0
-  br i1 %not_err19, label %after_check20, label %voiderr21
+  %32 = call i64 @std_io_printfn(ptr %retparam59, ptr @.str.18, i64 6, ptr %varargslots60, i64 2)
+  %not_err63 = icmp eq i64 %32, 0
+  br i1 %not_err63, label %after_check64, label %voiderr65
 
-after_check20:                                    ; preds = %voiderr14
-  br label %voiderr21
+after_check64:                                    ; preds = %voiderr58
+  br label %voiderr65
 
-voiderr21:                                        ; preds = %after_check20, %voiderr14
-  store ptr @.str.28, ptr %taddr24, align 8
-  %33 = insertvalue %variant undef, ptr %taddr24, 0
-  %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
-  %35 = getelementptr inbounds [2 x %variant], ptr %varargslots23, i64 0, i64 0
+voiderr65:                                        ; preds = %after_check64, %voiderr58
+  store ptr @.str.22, ptr %taddr68, align 8
+  %33 = insertvalue %variant undef, ptr %taddr68, 0
+  %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
+  %35 = getelementptr inbounds [2 x %variant], ptr %varargslots67, i64 0, i64 0
   store %variant %34, ptr %35, align 16
-  store ptr @.str.29, ptr %taddr25, align 8
-  %36 = insertvalue %variant undef, ptr %taddr25, 0
-  %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1
-  %38 = getelementptr inbounds [2 x %variant], ptr %varargslots23, i64 0, i64 1
+  store ptr @.str.23, ptr %taddr69, align 8
+  %36 = insertvalue %variant undef, ptr %taddr69, 0
+  %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
+  %38 = getelementptr inbounds [2 x %variant], ptr %varargslots67, i64 0, i64 1
   store %variant %37, ptr %38, align 16
-  %39 = call i64 @std_io_printfn(ptr %retparam22, ptr @.str.27, i64 6, ptr %varargslots23, i64 2)
-  %not_err26 = icmp eq i64 %39, 0
-  br i1 %not_err26, label %after_check27, label %voiderr28
+  %39 = call i64 @std_io_printfn(ptr %retparam66, ptr @.str.21, i64 6, ptr %varargslots67, i64 2)
+  %not_err70 = icmp eq i64 %39, 0
+  br i1 %not_err70, label %after_check71, label %voiderr72
 
-after_check27:                                    ; preds = %voiderr21
-  br label %voiderr28
+after_check71:                                    ; preds = %voiderr65
+  br label %voiderr72
 
-voiderr28:                                        ; preds = %after_check27, %voiderr21
-  store ptr @.str.31, ptr %taddr31, align 8
-  %40 = insertvalue %variant undef, ptr %taddr31, 0
-  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
-  %42 = getelementptr inbounds [1 x %variant], ptr %varargslots30, i64 0, i64 0
+voiderr72:                                        ; preds = %after_check71, %voiderr65
+  store ptr @.str.25, ptr %taddr75, align 8
+  %40 = insertvalue %variant undef, ptr %taddr75, 0
+  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1
+  %42 = getelementptr inbounds [2 x %variant], ptr %varargslots74, i64 0, i64 0
   store %variant %41, ptr %42, align 16
-  %43 = call i64 @std_io_printfn(ptr %retparam29, ptr @.str.30, i64 8, ptr %varargslots30, i64 1)
-  %not_err32 = icmp eq i64 %43, 0
-  br i1 %not_err32, label %after_check33, label %voiderr34
+  store ptr @.str.26, ptr %taddr76, align 8
+  %43 = insertvalue %variant undef, ptr %taddr76, 0
+  %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
+  %45 = getelementptr inbounds [2 x %variant], ptr %varargslots74, i64 0, i64 1
+  store %variant %44, ptr %45, align 16
+  %46 = call i64 @std_io_printfn(ptr %retparam73, ptr @.str.24, i64 6, ptr %varargslots74, i64 2)
+  %not_err77 = icmp eq i64 %46, 0
+  br i1 %not_err77, label %after_check78, label %voiderr79
 
-after_check33:                                    ; preds = %voiderr28
-  br label %voiderr34
+after_check78:                                    ; preds = %voiderr72
+  br label %voiderr79
 
-voiderr34:                                        ; preds = %after_check33, %voiderr28
-  store ptr @.str.33, ptr %taddr37, align 8
-  %44 = insertvalue %variant undef, ptr %taddr37, 0
-  %45 = insertvalue %variant %44, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
-  %46 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 0
-  store %variant %45, ptr %46, align 16
-  store ptr @.str.34, ptr %taddr38, align 8
-  %47 = insertvalue %variant undef, ptr %taddr38, 0
-  %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
-  %49 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 1
+voiderr79:                                        ; preds = %after_check78, %voiderr72
+  store ptr @.str.28, ptr %taddr82, align 8
+  %47 = insertvalue %variant undef, ptr %taddr82, 0
+  %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
+  %49 = getelementptr inbounds [2 x %variant], ptr %varargslots81, i64 0, i64 0
   store %variant %48, ptr %49, align 16
-  %50 = call i64 @std_io_printfn(ptr %retparam35, ptr @.str.32, i64 6, ptr %varargslots36, i64 2)
-  %not_err39 = icmp eq i64 %50, 0
-  br i1 %not_err39, label %after_check40, label %voiderr41
+  store ptr @.str.29, ptr %taddr83, align 8
+  %50 = insertvalue %variant undef, ptr %taddr83, 0
+  %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1
+  %52 = getelementptr inbounds [2 x %variant], ptr %varargslots81, i64 0, i64 1
+  store %variant %51, ptr %52, align 16
+  %53 = call i64 @std_io_printfn(ptr %retparam80, ptr @.str.27, i64 6, ptr %varargslots81, i64 2)
+  %not_err84 = icmp eq i64 %53, 0
+  br i1 %not_err84, label %after_check85, label %voiderr86
 
-after_check40:                                    ; preds = %voiderr34
-  br label %voiderr41
+after_check85:                                    ; preds = %voiderr79
+  br label %voiderr86
 
-voiderr41:                                        ; preds = %after_check40, %voiderr34
-  store ptr @.str.36, ptr %taddr44, align 8
-  %51 = insertvalue %variant undef, ptr %taddr44, 0
-  %52 = insertvalue %variant %51, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
-  %53 = getelementptr inbounds [2 x %variant], ptr %varargslots43, i64 0, i64 0
-  store %variant %52, ptr %53, align 16
-  store ptr @.str.37, ptr %taddr45, align 8
-  %54 = insertvalue %variant undef, ptr %taddr45, 0
-  %55 = insertvalue %variant %54, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
-  %56 = getelementptr inbounds [2 x %variant], ptr %varargslots43, i64 0, i64 1
+voiderr86:                                        ; preds = %after_check85, %voiderr79
+  store ptr @.str.31, ptr %taddr89, align 8
+  %54 = insertvalue %variant undef, ptr %taddr89, 0
+  %55 = insertvalue %variant %54, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
+  %56 = getelementptr inbounds [1 x %variant], ptr %varargslots88, i64 0, i64 0
   store %variant %55, ptr %56, align 16
-  %57 = call i64 @std_io_printfn(ptr %retparam42, ptr @.str.35, i64 6, ptr %varargslots43, i64 2)
-  %not_err46 = icmp eq i64 %57, 0
-  br i1 %not_err46, label %after_check47, label %voiderr48
+  %57 = call i64 @std_io_printfn(ptr %retparam87, ptr @.str.30, i64 8, ptr %varargslots88, i64 1)
+  %not_err90 = icmp eq i64 %57, 0
+  br i1 %not_err90, label %after_check91, label %voiderr92
 
-after_check47:                                    ; preds = %voiderr41
-  br label %voiderr48
+after_check91:                                    ; preds = %voiderr86
+  br label %voiderr92
 
-voiderr48:                                        ; preds = %after_check47, %voiderr41
-  store ptr @.str.39, ptr %taddr51, align 8
-  %58 = insertvalue %variant undef, ptr %taddr51, 0
-  %59 = insertvalue %variant %58, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1
-  %60 = getelementptr inbounds [2 x %variant], ptr %varargslots50, i64 0, i64 0
+voiderr92:                                        ; preds = %after_check91, %voiderr86
+  store ptr @.str.33, ptr %taddr95, align 8
+  %58 = insertvalue %variant undef, ptr %taddr95, 0
+  %59 = insertvalue %variant %58, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
+  %60 = getelementptr inbounds [2 x %variant], ptr %varargslots94, i64 0, i64 0
   store %variant %59, ptr %60, align 16
-  store ptr @.str.40, ptr %taddr52, align 8
-  %61 = insertvalue %variant undef, ptr %taddr52, 0
-  %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
-  %63 = getelementptr inbounds [2 x %variant], ptr %varargslots50, i64 0, i64 1
+  store ptr @.str.34, ptr %taddr96, align 8
+  %61 = insertvalue %variant undef, ptr %taddr96, 0
+  %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
+  %63 = getelementptr inbounds [2 x %variant], ptr %varargslots94, i64 0, i64 1
   store %variant %62, ptr %63, align 16
-  %64 = call i64 @std_io_printfn(ptr %retparam49, ptr @.str.38, i64 6, ptr %varargslots50, i64 2)
-  %not_err53 = icmp eq i64 %64, 0
-  br i1 %not_err53, label %after_check54, label %voiderr55
+  %64 = call i64 @std_io_printfn(ptr %retparam93, ptr @.str.32, i64 6, ptr %varargslots94, i64 2)
+  %not_err97 = icmp eq i64 %64, 0
+  br i1 %not_err97, label %after_check98, label %voiderr99
 
-after_check54:                                    ; preds = %voiderr48
-  br label %voiderr55
+after_check98:                                    ; preds = %voiderr92
+  br label %voiderr99
 
-voiderr55:                                        ; preds = %after_check54, %voiderr48
-  store ptr @.str.42, ptr %taddr58, align 8
-  %65 = insertvalue %variant undef, ptr %taddr58, 0
-  %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
-  %67 = getelementptr inbounds [2 x %variant], ptr %varargslots57, i64 0, i64 0
+voiderr99:                                        ; preds = %after_check98, %voiderr92
+  store ptr @.str.36, ptr %taddr102, align 8
+  %65 = insertvalue %variant undef, ptr %taddr102, 0
+  %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
+  %67 = getelementptr inbounds [2 x %variant], ptr %varargslots101, i64 0, i64 0
   store %variant %66, ptr %67, align 16
-  store ptr @.str.43, ptr %taddr59, align 8
-  %68 = insertvalue %variant undef, ptr %taddr59, 0
-  %69 = insertvalue %variant %68, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
-  %70 = getelementptr inbounds [2 x %variant], ptr %varargslots57, i64 0, i64 1
+  store ptr @.str.37, ptr %taddr103, align 8
+  %68 = insertvalue %variant undef, ptr %taddr103, 0
+  %69 = insertvalue %variant %68, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
+  %70 = getelementptr inbounds [2 x %variant], ptr %varargslots101, i64 0, i64 1
   store %variant %69, ptr %70, align 16
-  %71 = call i64 @std_io_printfn(ptr %retparam56, ptr @.str.41, i64 6, ptr %varargslots57, i64 2)
-  %not_err60 = icmp eq i64 %71, 0
-  br i1 %not_err60, label %after_check61, label %voiderr62
+  %71 = call i64 @std_io_printfn(ptr %retparam100, ptr @.str.35, i64 6, ptr %varargslots101, i64 2)
+  %not_err104 = icmp eq i64 %71, 0
+  br i1 %not_err104, label %after_check105, label %voiderr106
 
-after_check61:                                    ; preds = %voiderr55
-  br label %voiderr62
+after_check105:                                   ; preds = %voiderr99
+  br label %voiderr106
 
-voiderr62:                                        ; preds = %after_check61, %voiderr55
-  store ptr @.str.45, ptr %taddr65, align 8
-  %72 = insertvalue %variant undef, ptr %taddr65, 0
-  %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
-  %74 = getelementptr inbounds [1 x %variant], ptr %varargslots64, i64 0, i64 0
+voiderr106:                                       ; preds = %after_check105, %voiderr99
+  store ptr @.str.39, ptr %taddr109, align 8
+  %72 = insertvalue %variant undef, ptr %taddr109, 0
+  %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1
+  %74 = getelementptr inbounds [2 x %variant], ptr %varargslots108, i64 0, i64 0
   store %variant %73, ptr %74, align 16
-  %75 = call i64 @std_io_printfn(ptr %retparam63, ptr @.str.44, i64 8, ptr %varargslots64, i64 1)
-  %not_err66 = icmp eq i64 %75, 0
-  br i1 %not_err66, label %after_check67, label %voiderr68
+  store ptr @.str.40, ptr %taddr110, align 8
+  %75 = insertvalue %variant undef, ptr %taddr110, 0
+  %76 = insertvalue %variant %75, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
+  %77 = getelementptr inbounds [2 x %variant], ptr %varargslots108, i64 0, i64 1
+  store %variant %76, ptr %77, align 16
+  %78 = call i64 @std_io_printfn(ptr %retparam107, ptr @.str.38, i64 6, ptr %varargslots108, i64 2)
+  %not_err111 = icmp eq i64 %78, 0
+  br i1 %not_err111, label %after_check112, label %voiderr113
 
-after_check67:                                    ; preds = %voiderr62
-  br label %voiderr68
+after_check112:                                   ; preds = %voiderr106
+  br label %voiderr113
 
-voiderr68:                                        ; preds = %after_check67, %voiderr62
-  store ptr @.str.47, ptr %taddr71, align 8
-  %76 = insertvalue %variant undef, ptr %taddr71, 0
-  %77 = insertvalue %variant %76, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
-  %78 = getelementptr inbounds [2 x %variant], ptr %varargslots70, i64 0, i64 0
-  store %variant %77, ptr %78, align 16
-  store ptr @.str.48, ptr %taddr72, align 8
-  %79 = insertvalue %variant undef, ptr %taddr72, 0
+voiderr113:                                       ; preds = %after_check112, %voiderr106
+  store ptr @.str.42, ptr %taddr116, align 8
+  %79 = insertvalue %variant undef, ptr %taddr116, 0
   %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
-  %81 = getelementptr inbounds [2 x %variant], ptr %varargslots70, i64 0, i64 1
+  %81 = getelementptr inbounds [2 x %variant], ptr %varargslots115, i64 0, i64 0
   store %variant %80, ptr %81, align 16
-  %82 = call i64 @std_io_printfn(ptr %retparam69, ptr @.str.46, i64 6, ptr %varargslots70, i64 2)
-  %not_err73 = icmp eq i64 %82, 0
-  br i1 %not_err73, label %after_check74, label %voiderr75
+  store ptr @.str.43, ptr %taddr117, align 8
+  %82 = insertvalue %variant undef, ptr %taddr117, 0
+  %83 = insertvalue %variant %82, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
+  %84 = getelementptr inbounds [2 x %variant], ptr %varargslots115, i64 0, i64 1
+  store %variant %83, ptr %84, align 16
+  %85 = call i64 @std_io_printfn(ptr %retparam114, ptr @.str.41, i64 6, ptr %varargslots115, i64 2)
+  %not_err118 = icmp eq i64 %85, 0
+  br i1 %not_err118, label %after_check119, label %voiderr120
 
-after_check74:                                    ; preds = %voiderr68
-  br label %voiderr75
+after_check119:                                   ; preds = %voiderr113
+  br label %voiderr120
 
-voiderr75:                                        ; preds = %after_check74, %voiderr68
-  store ptr @.str.50, ptr %taddr78, align 8
-  %83 = insertvalue %variant undef, ptr %taddr78, 0
-  %84 = insertvalue %variant %83, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
-  %85 = getelementptr inbounds [2 x %variant], ptr %varargslots77, i64 0, i64 0
-  store %variant %84, ptr %85, align 16
-  store ptr @.str.51, ptr %taddr79, align 8
-  %86 = insertvalue %variant undef, ptr %taddr79, 0
-  %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
-  %88 = getelementptr inbounds [2 x %variant], ptr %varargslots77, i64 0, i64 1
+voiderr120:                                       ; preds = %after_check119, %voiderr113
+  store ptr @.str.45, ptr %taddr123, align 8
+  %86 = insertvalue %variant undef, ptr %taddr123, 0
+  %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
+  %88 = getelementptr inbounds [1 x %variant], ptr %varargslots122, i64 0, i64 0
   store %variant %87, ptr %88, align 16
-  %89 = call i64 @std_io_printfn(ptr %retparam76, ptr @.str.49, i64 6, ptr %varargslots77, i64 2)
-  %not_err80 = icmp eq i64 %89, 0
-  br i1 %not_err80, label %after_check81, label %voiderr82
+  %89 = call i64 @std_io_printfn(ptr %retparam121, ptr @.str.44, i64 8, ptr %varargslots122, i64 1)
+  %not_err124 = icmp eq i64 %89, 0
+  br i1 %not_err124, label %after_check125, label %voiderr126
 
-after_check81:                                    ; preds = %voiderr75
-  br label %voiderr82
+after_check125:                                   ; preds = %voiderr120
+  br label %voiderr126
 
-voiderr82:                                        ; preds = %after_check81, %voiderr75
+voiderr126:                                       ; preds = %after_check125, %voiderr120
+  store ptr @.str.47, ptr %taddr129, align 8
+  %90 = insertvalue %variant undef, ptr %taddr129, 0
+  %91 = insertvalue %variant %90, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
+  %92 = getelementptr inbounds [2 x %variant], ptr %varargslots128, i64 0, i64 0
+  store %variant %91, ptr %92, align 16
+  store ptr @.str.48, ptr %taddr130, align 8
+  %93 = insertvalue %variant undef, ptr %taddr130, 0
+  %94 = insertvalue %variant %93, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
+  %95 = getelementptr inbounds [2 x %variant], ptr %varargslots128, i64 0, i64 1
+  store %variant %94, ptr %95, align 16
+  %96 = call i64 @std_io_printfn(ptr %retparam127, ptr @.str.46, i64 6, ptr %varargslots128, i64 2)
+  %not_err131 = icmp eq i64 %96, 0
+  br i1 %not_err131, label %after_check132, label %voiderr133
+
+after_check132:                                   ; preds = %voiderr126
+  br label %voiderr133
+
+voiderr133:                                       ; preds = %after_check132, %voiderr126
+  store ptr @.str.50, ptr %taddr136, align 8
+  %97 = insertvalue %variant undef, ptr %taddr136, 0
+  %98 = insertvalue %variant %97, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
+  %99 = getelementptr inbounds [2 x %variant], ptr %varargslots135, i64 0, i64 0
+  store %variant %98, ptr %99, align 16
+  store ptr @.str.51, ptr %taddr137, align 8
+  %100 = insertvalue %variant undef, ptr %taddr137, 0
+  %101 = insertvalue %variant %100, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
+  %102 = getelementptr inbounds [2 x %variant], ptr %varargslots135, i64 0, i64 1
+  store %variant %101, ptr %102, align 16
+  %103 = call i64 @std_io_printfn(ptr %retparam134, ptr @.str.49, i64 6, ptr %varargslots135, i64 2)
+  %not_err138 = icmp eq i64 %103, 0
+  br i1 %not_err138, label %after_check139, label %voiderr140
+
+after_check139:                                   ; preds = %voiderr133
+  br label %voiderr140
+
+voiderr140:                                       ; preds = %after_check139, %voiderr133
   ret void
 }
 
diff --git a/test/test_suite/compile_time/ct_switch_more_checks.c3 b/test/test_suite/compile_time/ct_switch_more_checks.c3
index 4f4abb444..45f5b9791 100644
--- a/test/test_suite/compile_time/ct_switch_more_checks.c3
+++ b/test/test_suite/compile_time/ct_switch_more_checks.c3
@@ -6,9 +6,9 @@ fn void foo()
 	int a;
 	$switch ($typeof(a)):
 		$case int..float: // #error: $case ranges are only allowed for floats
-			io::println("Hello");
+			io::printn("Hello");
 		$default:
-			io::println("World");
+			io::printn("World");
 	$endswitch;
 }
 
@@ -17,9 +17,9 @@ fn void foo2()
 	int a;
 	$switch ($typeof(a)):
 		$case true..false: // #error: $case ranges are only allowed
-			io::println("Hello");
+			io::printn("Hello");
 		$default:
-			io::println("World");
+			io::printn("World");
 	$endswitch;
 }
 
@@ -28,9 +28,9 @@ fn void foo3()
 	int a;
 	$switch ({ 1, 3 }): // #error: Only types, strings, integers, floats and booleans
 		$case 1:
-			io::println("Hello");
+			io::printn("Hello");
 		$default:
-			io::println("World");
+			io::printn("World");
 	$endswitch;
 }
 
@@ -39,10 +39,10 @@ fn void main()
 	int a;
 	$switch ("abc"):
 		$case "cde":
-			io::println("!!!");
+			io::printn("!!!");
 		$case "abc":
-			io::println("Hello");
+			io::printn("Hello");
 		$default:
-			io::println("World");
+			io::printn("World");
 	$endswitch;
 }
diff --git a/test/test_suite/errors/general_error_regression.c3t b/test/test_suite/errors/general_error_regression.c3t
index cd268875a..92fc03a23 100644
--- a/test/test_suite/errors/general_error_regression.c3t
+++ b/test/test_suite/errors/general_error_regression.c3t
@@ -29,17 +29,17 @@ enum MyEnum
 
 fn void Foo.hello(Foo *f)
 {
-    io::println("Hello from Foo");
+    io::printn("Hello from Foo");
 }
 
 fn void Bar.hello(Bar *b)
 {
-    io::println("Hello from Bar");
+    io::printn("Hello from Bar");
 }
 
 fn void MyEnum.hello(MyEnum *myenum)
 {
-    io::println("Hello from MyEnum");
+    io::printn("Hello from MyEnum");
 }
 fn void main()
 {
@@ -74,19 +74,88 @@ fn void main()
 
 define void @foo_Foo_hello(ptr %0) #0 {
 entry:
-  %1 = call i32 @std_io_println(ptr @.str.12) #1
+  %x = alloca ptr, align 8
+  %error_var = alloca i64, align 8
+  %retparam = alloca i64, align 8
+  %result = alloca %File, align 8
+  store ptr @.str.12, ptr %x, align 8
+  store i64 0, ptr %error_var, align 8
+  %1 = call ptr @std_io_stdout()
+  store ptr %1, ptr %result, align 8
+  %2 = load ptr, ptr %x, align 8
+  %3 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %2, i64 14)
+  %not_err = icmp eq i64 %3, 0
+  br i1 %not_err, label %after_check, label %assign_optional
+
+assign_optional:                                  ; preds = %entry
+  store i64 %3, ptr %error_var, align 8
+  br label %noerr_block
+
+after_check:                                      ; preds = %entry
+  br label %noerr_block
+
+noerr_block:                                      ; preds = %after_check, %assign_optional
+  br label %voiderr
+
+voiderr:                                          ; preds = %noerr_block
   ret void
 }
 
 define void @foo_Bar_hello(ptr %0) #0 {
 entry:
-  %1 = call i32 @std_io_println(ptr @.str.13) #1
+  %x = alloca ptr, align 8
+  %error_var = alloca i64, align 8
+  %retparam = alloca i64, align 8
+  %result = alloca %File, align 8
+  store ptr @.str.13, ptr %x, align 8
+  store i64 0, ptr %error_var, align 8
+  %1 = call ptr @std_io_stdout()
+  store ptr %1, ptr %result, align 8
+  %2 = load ptr, ptr %x, align 8
+  %3 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %2, i64 14)
+  %not_err = icmp eq i64 %3, 0
+  br i1 %not_err, label %after_check, label %assign_optional
+
+assign_optional:                                  ; preds = %entry
+  store i64 %3, ptr %error_var, align 8
+  br label %noerr_block
+
+after_check:                                      ; preds = %entry
+  br label %noerr_block
+
+noerr_block:                                      ; preds = %after_check, %assign_optional
+  br label %voiderr
+
+voiderr:                                          ; preds = %noerr_block
   ret void
 }
 
 define void @foo_MyEnum_hello(ptr %0) #0 {
 entry:
-  %1 = call i32 @std_io_println(ptr @.str.14) #1
+  %x = alloca ptr, align 8
+  %error_var = alloca i64, align 8
+  %retparam = alloca i64, align 8
+  %result = alloca %File, align 8
+  store ptr @.str.14, ptr %x, align 8
+  store i64 0, ptr %error_var, align 8
+  %1 = call ptr @std_io_stdout()
+  store ptr %1, ptr %result, align 8
+  %2 = load ptr, ptr %x, align 8
+  %3 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %2, i64 17)
+  %not_err = icmp eq i64 %3, 0
+  br i1 %not_err, label %after_check, label %assign_optional
+
+assign_optional:                                  ; preds = %entry
+  store i64 %3, ptr %error_var, align 8
+  br label %noerr_block
+
+after_check:                                      ; preds = %entry
+  br label %noerr_block
+
+noerr_block:                                      ; preds = %after_check, %assign_optional
+  br label %voiderr
+
+voiderr:                                          ; preds = %noerr_block
   ret void
 }
 
diff --git a/test/test_suite/errors/or_and_rethrow.c3t b/test/test_suite/errors/or_and_rethrow.c3t
index 7e792208d..645c3607e 100644
--- a/test/test_suite/errors/or_and_rethrow.c3t
+++ b/test/test_suite/errors/or_and_rethrow.c3t
@@ -4,7 +4,7 @@ import std::io;
 
 fault Foo { ABC }
 
-fn void blurb() { io::println("Blurb");}
+fn void blurb() { io::printn("Blurb");}
 
 macro int! tester()
 {
@@ -14,19 +14,19 @@ macro int! tester()
 fn void! test(int x)
 {
 	io::printfn("test(%d)", x);
-	if (x || (tester()?)) io::println("Ok1");
-	io::println("Test next");
-	if (tester()? || x) io::println("Ok?");
-	io::println("Test ok");
+	if (x || (tester()?)) io::printn("Ok1");
+	io::printn("Test next");
+	if (tester()? || x) io::printn("Ok?");
+	io::printn("Test ok");
 }
 
 fn void! test2(int x)
 {
 	io::printfn("test2(%d)", x);
-	if (x && (tester()?)) io::println("Ok1");
-	io::println("Test next");
-	if ((tester()?) && x) io::println("Ok?");
-	io::println("Test ok");
+	if (x && (tester()?)) io::printn("Ok1");
+	io::printn("Test next");
+	if ((tester()?) && x) io::printn("Ok?");
+	io::printn("Test ok");
 }
 
 fn void main()
@@ -46,8 +46,24 @@ entry:
   %taddr = alloca i32, align 4
   %error_var = alloca i64, align 8
   %blockret = alloca i32, align 4
+  %x = alloca ptr, align 8
   %error_var1 = alloca i64, align 8
-  %blockret2 = alloca i32, align 4
+  %retparam2 = alloca i64, align 8
+  %result = alloca %File, align 8
+  %x6 = alloca ptr, align 8
+  %error_var7 = alloca i64, align 8
+  %retparam8 = alloca i64, align 8
+  %result9 = alloca %File, align 8
+  %error_var15 = alloca i64, align 8
+  %blockret16 = alloca i32, align 4
+  %x21 = alloca ptr, align 8
+  %error_var22 = alloca i64, align 8
+  %retparam23 = alloca i64, align 8
+  %result24 = alloca %File, align 8
+  %x31 = alloca ptr, align 8
+  %error_var32 = alloca i64, align 8
+  %retparam33 = alloca i64, align 8
+  %result34 = alloca %File, align 8
   %reterr = alloca i64, align 8
   store i32 %0, ptr %taddr, align 4
   %1 = insertvalue %variant undef, ptr %taddr, 0
@@ -81,24 +97,104 @@ or.phi:                                           ; preds = %voiderr
   br label %if.then
 
 if.then:                                          ; preds = %or.phi
-  %6 = call i32 @std_io_println(ptr @.str.2) #1
+  store ptr @.str.2, ptr %x, align 8
+  store i64 0, ptr %error_var1, align 8
+  %6 = call ptr @std_io_stdout()
+  store ptr %6, ptr %result, align 8
+  %7 = load ptr, ptr %x, align 8
+  %8 = call i64 @std_io_File_printn(ptr %retparam2, ptr %result, ptr %7, i64 3)
+  %not_err3 = icmp eq i64 %8, 0
+  br i1 %not_err3, label %after_check4, label %assign_optional
+
+assign_optional:                                  ; preds = %if.then
+  store i64 %8, ptr %error_var1, align 8
+  br label %noerr_block
+
+after_check4:                                     ; preds = %if.then
+  br label %noerr_block
+
+noerr_block:                                      ; preds = %after_check4, %assign_optional
+  br label %voiderr5
+
+voiderr5:                                         ; preds = %noerr_block
   br label %if.exit
 
-if.exit:                                          ; preds = %if.then
-  %7 = call i32 @std_io_println(ptr @.str.3) #1
-  store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var1, align 8
-  br label %opt_block_cleanup3
+if.exit:                                          ; preds = %voiderr5
+  store ptr @.str.3, ptr %x6, align 8
+  store i64 0, ptr %error_var7, align 8
+  %9 = call ptr @std_io_stdout()
+  store ptr %9, ptr %result9, align 8
+  %10 = load ptr, ptr %x6, align 8
+  %11 = call i64 @std_io_File_printn(ptr %retparam8, ptr %result9, ptr %10, i64 9)
+  %not_err10 = icmp eq i64 %11, 0
+  br i1 %not_err10, label %after_check12, label %assign_optional11
 
-opt_block_cleanup3:                               ; preds = %if.exit
+assign_optional11:                                ; preds = %if.exit
+  store i64 %11, ptr %error_var7, align 8
+  br label %noerr_block13
+
+after_check12:                                    ; preds = %if.exit
+  br label %noerr_block13
+
+noerr_block13:                                    ; preds = %after_check12, %assign_optional11
+  br label %voiderr14
+
+voiderr14:                                        ; preds = %noerr_block13
+  store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var15, align 8
+  br label %opt_block_cleanup17
+
+opt_block_cleanup17:                              ; preds = %voiderr14
   call void @foo_blurb()
-  br label %guard_block4
+  br label %guard_block18
 
-guard_block4:                                     ; preds = %opt_block_cleanup3
-  %8 = load i64, ptr %error_var1, align 8
-  ret i64 %8
+guard_block18:                                    ; preds = %opt_block_cleanup17
+  %12 = load i64, ptr %error_var15, align 8
+  ret i64 %12
 
-if.exit6:                                         ; No predecessors!
-  %9 = call i32 @std_io_println(ptr @.str.5) #1
+if.then20:                                        ; No predecessors!
+  store ptr @.str.4, ptr %x21, align 8
+  store i64 0, ptr %error_var22, align 8
+  %13 = call ptr @std_io_stdout()
+  store ptr %13, ptr %result24, align 8
+  %14 = load ptr, ptr %x21, align 8
+  %15 = call i64 @std_io_File_printn(ptr %retparam23, ptr %result24, ptr %14, i64 3)
+  %not_err25 = icmp eq i64 %15, 0
+  br i1 %not_err25, label %after_check27, label %assign_optional26
+
+assign_optional26:                                ; preds = %if.then20
+  store i64 %15, ptr %error_var22, align 8
+  br label %noerr_block28
+
+after_check27:                                    ; preds = %if.then20
+  br label %noerr_block28
+
+noerr_block28:                                    ; preds = %after_check27, %assign_optional26
+  br label %voiderr29
+
+voiderr29:                                        ; preds = %noerr_block28
+  br label %if.exit30
+
+if.exit30:                                        ; preds = %voiderr29
+  store ptr @.str.5, ptr %x31, align 8
+  store i64 0, ptr %error_var32, align 8
+  %16 = call ptr @std_io_stdout()
+  store ptr %16, ptr %result34, align 8
+  %17 = load ptr, ptr %x31, align 8
+  %18 = call i64 @std_io_File_printn(ptr %retparam33, ptr %result34, ptr %17, i64 7)
+  %not_err35 = icmp eq i64 %18, 0
+  br i1 %not_err35, label %after_check37, label %assign_optional36
+
+assign_optional36:                                ; preds = %if.exit30
+  store i64 %18, ptr %error_var32, align 8
+  br label %noerr_block38
+
+after_check37:                                    ; preds = %if.exit30
+  br label %noerr_block38
+
+noerr_block38:                                    ; preds = %after_check37, %assign_optional36
+  br label %voiderr39
+
+voiderr39:                                        ; preds = %noerr_block38
   ret i64 0
 }
 
@@ -110,8 +206,16 @@ entry:
   %taddr = alloca i32, align 4
   %error_var = alloca i64, align 8
   %blockret = alloca i32, align 4
+  %x = alloca ptr, align 8
   %error_var1 = alloca i64, align 8
-  %blockret2 = alloca i32, align 4
+  %retparam2 = alloca i64, align 8
+  %result = alloca %File, align 8
+  %error_var6 = alloca i64, align 8
+  %blockret7 = alloca i32, align 4
+  %x12 = alloca ptr, align 8
+  %error_var13 = alloca i64, align 8
+  %retparam14 = alloca i64, align 8
+  %result15 = alloca %File, align 8
   %reterr = alloca i64, align 8
   store i32 %0, ptr %taddr, align 4
   %1 = insertvalue %variant undef, ptr %taddr, 0
@@ -145,19 +249,57 @@ and.phi:                                          ; preds = %voiderr
   br label %if.exit
 
 if.exit:                                          ; preds = %and.phi
-  %6 = call i32 @std_io_println(ptr @.str.7) #1
-  store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var1, align 8
-  br label %opt_block_cleanup3
+  store ptr @.str.7, ptr %x, align 8
+  store i64 0, ptr %error_var1, align 8
+  %6 = call ptr @std_io_stdout()
+  store ptr %6, ptr %result, align 8
+  %7 = load ptr, ptr %x, align 8
+  %8 = call i64 @std_io_File_printn(ptr %retparam2, ptr %result, ptr %7, i64 9)
+  %not_err3 = icmp eq i64 %8, 0
+  br i1 %not_err3, label %after_check4, label %assign_optional
 
-opt_block_cleanup3:                               ; preds = %if.exit
+assign_optional:                                  ; preds = %if.exit
+  store i64 %8, ptr %error_var1, align 8
+  br label %noerr_block
+
+after_check4:                                     ; preds = %if.exit
+  br label %noerr_block
+
+noerr_block:                                      ; preds = %after_check4, %assign_optional
+  br label %voiderr5
+
+voiderr5:                                         ; preds = %noerr_block
+  store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var6, align 8
+  br label %opt_block_cleanup8
+
+opt_block_cleanup8:                               ; preds = %voiderr5
   call void @foo_blurb()
-  br label %guard_block4
+  br label %guard_block9
 
-guard_block4:                                     ; preds = %opt_block_cleanup3
-  %7 = load i64, ptr %error_var1, align 8
-  ret i64 %7
+guard_block9:                                     ; preds = %opt_block_cleanup8
+  %9 = load i64, ptr %error_var6, align 8
+  ret i64 %9
 
-if.exit5:                                         ; No predecessors!
-  %8 = call i32 @std_io_println(ptr @.str.8) #1
+if.exit11:                                        ; No predecessors!
+  store ptr @.str.8, ptr %x12, align 8
+  store i64 0, ptr %error_var13, align 8
+  %10 = call ptr @std_io_stdout()
+  store ptr %10, ptr %result15, align 8
+  %11 = load ptr, ptr %x12, align 8
+  %12 = call i64 @std_io_File_printn(ptr %retparam14, ptr %result15, ptr %11, i64 7)
+  %not_err16 = icmp eq i64 %12, 0
+  br i1 %not_err16, label %after_check18, label %assign_optional17
+
+assign_optional17:                                ; preds = %if.exit11
+  store i64 %12, ptr %error_var13, align 8
+  br label %noerr_block19
+
+after_check18:                                    ; preds = %if.exit11
+  br label %noerr_block19
+
+noerr_block19:                                    ; preds = %after_check18, %assign_optional17
+  br label %voiderr20
+
+voiderr20:                                        ; preds = %noerr_block19
   ret i64 0
 }
diff --git a/test/test_suite/expression_block/expression_block_break.c3 b/test/test_suite/expression_block/expression_block_break.c3
index 6c558005d..6202496a0 100644
--- a/test/test_suite/expression_block/expression_block_break.c3
+++ b/test/test_suite/expression_block/expression_block_break.c3
@@ -8,6 +8,6 @@ fn int main()
     {
         return {| break; return 0; |}; // #error: There is no valid target for 'break', did you make a mistake
     }
-    io::println("I didn't return.");
+    io::printn("I didn't return.");
     return 0;
 }
\ No newline at end of file
diff --git a/test/test_suite/expressions/call_inline.c3t b/test/test_suite/expressions/call_inline.c3t
index 65e8183b0..47ff6e7e3 100644
--- a/test/test_suite/expressions/call_inline.c3t
+++ b/test/test_suite/expressions/call_inline.c3t
@@ -4,17 +4,17 @@ import std::io;
 
 fn void test1() @inline
 {
-    io::println("Inline!");
+    io::printn("Inline!");
 }
 
 fn void test2() @noinline
 {
-    io::println("No inline!");
+    io::printn("No inline!");
 }
 
 fn void test3()
 {
-    io::println("Plain");
+    io::printn("Plain");
 }
 
 fn void main()
diff --git a/test/test_suite/from_docs/examples_defer.c3t b/test/test_suite/from_docs/examples_defer.c3t
index 4bc7ddd58..bd35d768b 100644
--- a/test/test_suite/from_docs/examples_defer.c3t
+++ b/test/test_suite/from_docs/examples_defer.c3t
@@ -4,7 +4,7 @@ import std::io;
 
 fn void test(int x)
 {
-    defer io::println();
+    defer io::printn();
     defer io::print("A");
     if (x == 1) return;
     {
@@ -29,29 +29,197 @@ entry:
   br i1 %eq, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %entry
-  %1 = call i32 @std_io_print(ptr @.str)
-  %2 = call i32 @std_io_println(ptr @.str.1) #1
+  store ptr @.str, ptr %x, align 8
+  store i64 0, ptr %error_var, align 8
+  %1 = call ptr @std_io_stdout()
+  store ptr %1, ptr %result, align 8
+  %2 = load ptr, ptr %x, align 8
+  %3 = call i64 @std_io_File_print(ptr %retparam, ptr %result, ptr %2, i64 1)
+  %not_err = icmp eq i64 %3, 0
+  br i1 %not_err, label %after_check, label %assign_optional
+
+assign_optional:                                  ; preds = %if.then
+  store i64 %3, ptr %error_var, align 8
+  br label %noerr_block
+
+after_check:                                      ; preds = %if.then
+  br label %noerr_block
+
+noerr_block:                                      ; preds = %after_check, %assign_optional
+  br label %voiderr
+
+voiderr:                                          ; preds = %noerr_block
+  store ptr @.str.1, ptr %x1, align 8
+  store i64 0, ptr %error_var2, align 8
+  %4 = call ptr @std_io_stdout()
+  store ptr %4, ptr %result4, align 8
+  %5 = call i64 @std_io_File_printn(ptr %retparam3, ptr %result4, ptr null, i64 0)
+  %not_err5 = icmp eq i64 %5, 0
+  br i1 %not_err5, label %after_check7, label %assign_optional6
+
+assign_optional6:                                 ; preds = %voiderr
+  store i64 %5, ptr %error_var2, align 8
+  br label %noerr_block8
+
+after_check7:                                     ; preds = %voiderr
+  br label %noerr_block8
+
+noerr_block8:                                     ; preds = %after_check7, %assign_optional6
+  br label %voiderr9
+
+voiderr9:                                         ; preds = %noerr_block8
   ret void
 
 if.exit:                                          ; preds = %entry
-  %eq1 = icmp eq i32 %0, 0
-  br i1 %eq1, label %if.then2, label %if.exit3
+  %eq10 = icmp eq i32 %0, 0
+  br i1 %eq10, label %if.then11, label %if.exit39
 
-if.then2:                                         ; preds = %if.exit
-  %3 = call i32 @std_io_print(ptr @.str.2)
-  %4 = call i32 @std_io_print(ptr @.str.3)
-  %5 = call i32 @std_io_println(ptr @.str.4) #1
+if.then11:                                        ; preds = %if.exit
+  store ptr @.str.2, ptr %x12, align 8
+  store i64 0, ptr %error_var13, align 8
+  %6 = call ptr @std_io_stdout()
+  store ptr %6, ptr %result15, align 8
+  %7 = load ptr, ptr %x12, align 8
+  %8 = call i64 @std_io_File_print(ptr %retparam14, ptr %result15, ptr %7, i64 1)
+  %not_err16 = icmp eq i64 %8, 0
+  br i1 %not_err16, label %after_check18, label %assign_optional17
+
+assign_optional17:                                ; preds = %if.then11
+  store i64 %8, ptr %error_var13, align 8
+  br label %noerr_block19
+
+after_check18:                                    ; preds = %if.then11
+  br label %noerr_block19
+
+noerr_block19:                                    ; preds = %after_check18, %assign_optional17
+  br label %voiderr20
+
+voiderr20:                                        ; preds = %noerr_block19
+  store ptr @.str.3, ptr %x21, align 8
+  store i64 0, ptr %error_var22, align 8
+  %9 = call ptr @std_io_stdout()
+  store ptr %9, ptr %result24, align 8
+  %10 = load ptr, ptr %x21, align 8
+  %11 = call i64 @std_io_File_print(ptr %retparam23, ptr %result24, ptr %10, i64 1)
+  %not_err25 = icmp eq i64 %11, 0
+  br i1 %not_err25, label %after_check27, label %assign_optional26
+
+assign_optional26:                                ; preds = %voiderr20
+  store i64 %11, ptr %error_var22, align 8
+  br label %noerr_block28
+
+after_check27:                                    ; preds = %voiderr20
+  br label %noerr_block28
+
+noerr_block28:                                    ; preds = %after_check27, %assign_optional26
+  br label %voiderr29
+
+voiderr29:                                        ; preds = %noerr_block28
+  store ptr @.str.4, ptr %x30, align 8
+  store i64 0, ptr %error_var31, align 8
+  %12 = call ptr @std_io_stdout()
+  store ptr %12, ptr %result33, align 8
+  %13 = call i64 @std_io_File_printn(ptr %retparam32, ptr %result33, ptr null, i64 0)
+  %not_err34 = icmp eq i64 %13, 0
+  br i1 %not_err34, label %after_check36, label %assign_optional35
+
+assign_optional35:                                ; preds = %voiderr29
+  store i64 %13, ptr %error_var31, align 8
+  br label %noerr_block37
+
+after_check36:                                    ; preds = %voiderr29
+  br label %noerr_block37
+
+noerr_block37:                                    ; preds = %after_check36, %assign_optional35
+  br label %voiderr38
+
+voiderr38:                                        ; preds = %noerr_block37
   ret void
 
-if.exit3:                                         ; preds = %if.exit
-  %6 = call i32 @std_io_print(ptr @.str.5)
-  %7 = call i32 @std_io_print(ptr @.str.6)
-  %8 = call i32 @std_io_print(ptr @.str.7)
-  %9 = call i32 @std_io_println(ptr @.str.8) #1
+if.exit39:                                        ; preds = %if.exit
+  store ptr @.str.5, ptr %x40, align 8
+  store i64 0, ptr %error_var41, align 8
+  %14 = call ptr @std_io_stdout()
+  store ptr %14, ptr %result43, align 8
+  %15 = load ptr, ptr %x40, align 8
+  %16 = call i64 @std_io_File_print(ptr %retparam42, ptr %result43, ptr %15, i64 1)
+  %not_err44 = icmp eq i64 %16, 0
+  br i1 %not_err44, label %after_check46, label %assign_optional45
+
+assign_optional45:                                ; preds = %if.exit39
+  store i64 %16, ptr %error_var41, align 8
+  br label %noerr_block47
+
+after_check46:                                    ; preds = %if.exit39
+  br label %noerr_block47
+
+noerr_block47:                                    ; preds = %after_check46, %assign_optional45
+  br label %voiderr48
+
+voiderr48:                                        ; preds = %noerr_block47
+  store ptr @.str.6, ptr %x49, align 8
+  store i64 0, ptr %error_var50, align 8
+  %17 = call ptr @std_io_stdout()
+  store ptr %17, ptr %result52, align 8
+  %18 = load ptr, ptr %x49, align 8
+  %19 = call i64 @std_io_File_print(ptr %retparam51, ptr %result52, ptr %18, i64 1)
+  %not_err53 = icmp eq i64 %19, 0
+  br i1 %not_err53, label %after_check55, label %assign_optional54
+
+assign_optional54:                                ; preds = %voiderr48
+  store i64 %19, ptr %error_var50, align 8
+  br label %noerr_block56
+
+after_check55:                                    ; preds = %voiderr48
+  br label %noerr_block56
+
+noerr_block56:                                    ; preds = %after_check55, %assign_optional54
+  br label %voiderr57
+
+voiderr57:                                        ; preds = %noerr_block56
+  store ptr @.str.7, ptr %x58, align 8
+  store i64 0, ptr %error_var59, align 8
+  %20 = call ptr @std_io_stdout()
+  store ptr %20, ptr %result61, align 8
+  %21 = load ptr, ptr %x58, align 8
+  %22 = call i64 @std_io_File_print(ptr %retparam60, ptr %result61, ptr %21, i64 1)
+  %not_err62 = icmp eq i64 %22, 0
+  br i1 %not_err62, label %after_check64, label %assign_optional63
+
+assign_optional63:                                ; preds = %voiderr57
+  store i64 %22, ptr %error_var59, align 8
+  br label %noerr_block65
+
+after_check64:                                    ; preds = %voiderr57
+  br label %noerr_block65
+
+noerr_block65:                                    ; preds = %after_check64, %assign_optional63
+  br label %voiderr66
+
+voiderr66:                                        ; preds = %noerr_block65
+  store ptr @.str.8, ptr %x67, align 8
+  store i64 0, ptr %error_var68, align 8
+  %23 = call ptr @std_io_stdout()
+  store ptr %23, ptr %result70, align 8
+  %24 = call i64 @std_io_File_printn(ptr %retparam69, ptr %result70, ptr null, i64 0)
+  %not_err71 = icmp eq i64 %24, 0
+  br i1 %not_err71, label %after_check73, label %assign_optional72
+
+assign_optional72:                                ; preds = %voiderr66
+  store i64 %24, ptr %error_var68, align 8
+  br label %noerr_block74
+
+after_check73:                                    ; preds = %voiderr66
+  br label %noerr_block74
+
+noerr_block74:                                    ; preds = %after_check73, %assign_optional72
+  br label %voiderr75
+
+voiderr75:                                        ; preds = %noerr_block74
   ret void
 }
 
-; Function Attrs: nounwind
+
 define void @defer1_main() #0 {
 entry:
   call void @defer1_test(i32 1)
diff --git a/test/test_suite/from_docs/examples_forswitch.c3t b/test/test_suite/from_docs/examples_forswitch.c3t
index 437e4c4a5..7afaa5bd5 100644
--- a/test/test_suite/from_docs/examples_forswitch.c3t
+++ b/test/test_suite/from_docs/examples_forswitch.c3t
@@ -31,10 +31,10 @@ fn void demo_enum(Height h)
     {
         case LOW:
         case MEDIUM:
-            io::println("Not high");
+            io::printn("Not high");
             // Implicit break.
         case HIGH:
-            io::println("High");
+            io::printn("High");
     }
 
     // This also works
@@ -42,10 +42,10 @@ fn void demo_enum(Height h)
     {
         case LOW:
         case MEDIUM:
-            io::println("Not high");
+            io::printn("Not high");
             // Implicit break.
         case Height.HIGH:
-            io::println("High");
+            io::printn("High");
     }
 
     // Completely empty cases are not allowed.
@@ -54,7 +54,7 @@ fn void demo_enum(Height h)
         case LOW:
             break; // Explicit break required, since switches can't be empty.
         case MEDIUM:
-            io::println("Medium");
+            io::printn("Medium");
         case HIGH:
             break;
     }
@@ -76,15 +76,15 @@ fn void demo_enum(Height h)
     {
         case LOW:
             int a = 1;
-            io::println("A");
+            io::printn("A");
             nextcase;
         case MEDIUM:
             int a = 2;
-            io::println("B");
+            io::printn("B");
             nextcase;
         case HIGH:
             // a is not defined here
-            io::println("C");
+            io::printn("C");
     }
 }
 /* #expect: examples.ll
@@ -121,12 +121,44 @@ unreachable_block:                                ; No predecessors!
 define void @examples_demo_enum(i32 %0) #0 {
 entry:
   %switch = alloca i32, align 4
-  %switch2 = alloca i32, align 4
-  %switch7 = alloca i32, align 4
-  %switch13 = alloca i32, align 4
-  %switch17 = alloca i32, align 4
+  %x = alloca ptr, align 8
+  %error_var = alloca i64, align 8
+  %retparam = alloca i64, align 8
+  %result = alloca %File, align 8
+  %x2 = alloca ptr, align 8
+  %error_var3 = alloca i64, align 8
+  %retparam4 = alloca i64, align 8
+  %result5 = alloca %File, align 8
+  %switch11 = alloca i32, align 4
+  %x14 = alloca ptr, align 8
+  %error_var15 = alloca i64, align 8
+  %retparam16 = alloca i64, align 8
+  %result17 = alloca %File, align 8
+  %x24 = alloca ptr, align 8
+  %error_var25 = alloca i64, align 8
+  %retparam26 = alloca i64, align 8
+  %result27 = alloca %File, align 8
+  %switch34 = alloca i32, align 4
+  %x38 = alloca ptr, align 8
+  %error_var39 = alloca i64, align 8
+  %retparam40 = alloca i64, align 8
+  %result41 = alloca %File, align 8
+  %switch49 = alloca i32, align 4
+  %switch53 = alloca i32, align 4
   %a = alloca i32, align 4
-  %a21 = alloca i32, align 4
+  %x56 = alloca ptr, align 8
+  %error_var57 = alloca i64, align 8
+  %retparam58 = alloca i64, align 8
+  %result59 = alloca %File, align 8
+  %a66 = alloca i32, align 4
+  %x67 = alloca ptr, align 8
+  %error_var68 = alloca i64, align 8
+  %retparam69 = alloca i64, align 8
+  %result70 = alloca %File, align 8
+  %x77 = alloca ptr, align 8
+  %error_var78 = alloca i64, align 8
+  %retparam79 = alloca i64, align 8
+  %result80 = alloca %File, align 8
   store i32 %0, ptr %switch, align 4
   br label %switch.entry
 
@@ -139,99 +171,251 @@ switch.entry:                                     ; preds = %entry
   ]
 
 switch.case:                                      ; preds = %switch.entry, %switch.entry
-  %2 = call i32 @std_io_println(ptr @.str.1) #1
+  store ptr @.str.1, ptr %x, align 8
+  store i64 0, ptr %error_var, align 8
+  %2 = call ptr @std_io_stdout()
+  store ptr %2, ptr %result, align 8
+  %3 = load ptr, ptr %x, align 8
+  %4 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %3, i64 8)
+  %not_err = icmp eq i64 %4, 0
+  br i1 %not_err, label %after_check, label %assign_optional
+
+assign_optional:                                  ; preds = %switch.case
+  store i64 %4, ptr %error_var, align 8
+  br label %noerr_block
+
+after_check:                                      ; preds = %switch.case
+  br label %noerr_block
+
+noerr_block:                                      ; preds = %after_check, %assign_optional
+  br label %voiderr
+
+voiderr:                                          ; preds = %noerr_block
   br label %switch.exit
 
 switch.case1:                                     ; preds = %switch.entry
-  %3 = call i32 @std_io_println(ptr @.str.2) #1
+  store ptr @.str.2, ptr %x2, align 8
+  store i64 0, ptr %error_var3, align 8
+  %5 = call ptr @std_io_stdout()
+  store ptr %5, ptr %result5, align 8
+  %6 = load ptr, ptr %x2, align 8
+  %7 = call i64 @std_io_File_printn(ptr %retparam4, ptr %result5, ptr %6, i64 4)
+  %not_err6 = icmp eq i64 %7, 0
+  br i1 %not_err6, label %after_check8, label %assign_optional7
+
+assign_optional7:                                 ; preds = %switch.case1
+  store i64 %7, ptr %error_var3, align 8
+  br label %noerr_block9
+
+after_check8:                                     ; preds = %switch.case1
+  br label %noerr_block9
+
+noerr_block9:                                     ; preds = %after_check8, %assign_optional7
+  br label %voiderr10
+
+voiderr10:                                        ; preds = %noerr_block9
   br label %switch.exit
 
-switch.exit:                                      ; preds = %switch.case1, %switch.case, %switch.entry
-  store i32 %0, ptr %switch2, align 4
-  br label %switch.entry3
+switch.exit:                                      ; preds = %voiderr10, %voiderr, %switch.entry
+  store i32 %0, ptr %switch11, align 4
+  br label %switch.entry12
 
-switch.entry3:                                    ; preds = %switch.exit
-  %4 = load i32, ptr %switch2, align 4
-  switch i32 %4, label %switch.exit6 [
-    i32 0, label %switch.case4
-    i32 1, label %switch.case4
-    i32 2, label %switch.case5
+switch.entry12:                                   ; preds = %switch.exit
+  %8 = load i32, ptr %switch11, align 4
+  switch i32 %8, label %switch.exit33 [
+    i32 0, label %switch.case13
+    i32 1, label %switch.case13
+    i32 2, label %switch.case23
   ]
 
-switch.case4:                                     ; preds = %switch.entry3, %switch.entry3
-  %5 = call i32 @std_io_println(ptr @.str.3) #1
-  br label %switch.exit6
+switch.case13:                                    ; preds = %switch.entry12, %switch.entry12
+  store ptr @.str.3, ptr %x14, align 8
+  store i64 0, ptr %error_var15, align 8
+  %9 = call ptr @std_io_stdout()
+  store ptr %9, ptr %result17, align 8
+  %10 = load ptr, ptr %x14, align 8
+  %11 = call i64 @std_io_File_printn(ptr %retparam16, ptr %result17, ptr %10, i64 8)
+  %not_err18 = icmp eq i64 %11, 0
+  br i1 %not_err18, label %after_check20, label %assign_optional19
 
-switch.case5:                                     ; preds = %switch.entry3
-  %6 = call i32 @std_io_println(ptr @.str.4) #1
-  br label %switch.exit6
+assign_optional19:                                ; preds = %switch.case13
+  store i64 %11, ptr %error_var15, align 8
+  br label %noerr_block21
 
-switch.exit6:                                     ; preds = %switch.case5, %switch.case4, %switch.entry3
-  store i32 %0, ptr %switch7, align 4
-  br label %switch.entry8
+after_check20:                                    ; preds = %switch.case13
+  br label %noerr_block21
 
-switch.entry8:                                    ; preds = %switch.exit6
-  %7 = load i32, ptr %switch7, align 4
-  switch i32 %7, label %switch.exit12 [
-    i32 0, label %switch.case9
-    i32 1, label %switch.case10
-    i32 2, label %switch.case11
+noerr_block21:                                    ; preds = %after_check20, %assign_optional19
+  br label %voiderr22
+
+voiderr22:                                        ; preds = %noerr_block21
+  br label %switch.exit33
+
+switch.case23:                                    ; preds = %switch.entry12
+  store ptr @.str.4, ptr %x24, align 8
+  store i64 0, ptr %error_var25, align 8
+  %12 = call ptr @std_io_stdout()
+  store ptr %12, ptr %result27, align 8
+  %13 = load ptr, ptr %x24, align 8
+  %14 = call i64 @std_io_File_printn(ptr %retparam26, ptr %result27, ptr %13, i64 4)
+  %not_err28 = icmp eq i64 %14, 0
+  br i1 %not_err28, label %after_check30, label %assign_optional29
+
+assign_optional29:                                ; preds = %switch.case23
+  store i64 %14, ptr %error_var25, align 8
+  br label %noerr_block31
+
+after_check30:                                    ; preds = %switch.case23
+  br label %noerr_block31
+
+noerr_block31:                                    ; preds = %after_check30, %assign_optional29
+  br label %voiderr32
+
+voiderr32:                                        ; preds = %noerr_block31
+  br label %switch.exit33
+
+switch.exit33:                                    ; preds = %voiderr32, %voiderr22, %switch.entry12
+  store i32 %0, ptr %switch34, align 4
+  br label %switch.entry35
+
+switch.entry35:                                   ; preds = %switch.exit33
+  %15 = load i32, ptr %switch34, align 4
+  switch i32 %15, label %switch.exit48 [
+    i32 0, label %switch.case36
+    i32 1, label %switch.case37
+    i32 2, label %switch.case47
   ]
 
-switch.case9:                                     ; preds = %switch.entry8
-  br label %switch.exit12
+switch.case36:                                    ; preds = %switch.entry35
+  br label %switch.exit48
 
-switch.case10:                                    ; preds = %switch.entry8
-  %8 = call i32 @std_io_println(ptr @.str.5) #1
-  br label %switch.exit12
+switch.case37:                                    ; preds = %switch.entry35
+  store ptr @.str.5, ptr %x38, align 8
+  store i64 0, ptr %error_var39, align 8
+  %16 = call ptr @std_io_stdout()
+  store ptr %16, ptr %result41, align 8
+  %17 = load ptr, ptr %x38, align 8
+  %18 = call i64 @std_io_File_printn(ptr %retparam40, ptr %result41, ptr %17, i64 6)
+  %not_err42 = icmp eq i64 %18, 0
+  br i1 %not_err42, label %after_check44, label %assign_optional43
 
-switch.case11:                                    ; preds = %switch.entry8
-  br label %switch.exit12
+assign_optional43:                                ; preds = %switch.case37
+  store i64 %18, ptr %error_var39, align 8
+  br label %noerr_block45
 
-switch.exit12:                                    ; preds = %switch.case11, %switch.case10, %switch.case9, %switch.entry8
-  store i32 %0, ptr %switch13, align 4
-  br label %switch.entry14
+after_check44:                                    ; preds = %switch.case37
+  br label %noerr_block45
 
-switch.entry14:                                   ; preds = %switch.exit12
-  %9 = load i32, ptr %switch13, align 4
-  switch i32 %9, label %switch.default [
-    i32 0, label %switch.case15
-    i32 1, label %switch.case15
-    i32 2, label %switch.case15
+noerr_block45:                                    ; preds = %after_check44, %assign_optional43
+  br label %voiderr46
+
+voiderr46:                                        ; preds = %noerr_block45
+  br label %switch.exit48
+
+switch.case47:                                    ; preds = %switch.entry35
+  br label %switch.exit48
+
+switch.exit48:                                    ; preds = %switch.case47, %voiderr46, %switch.case36, %switch.entry35
+  store i32 %0, ptr %switch49, align 4
+  br label %switch.entry50
+
+switch.entry50:                                   ; preds = %switch.exit48
+  %19 = load i32, ptr %switch49, align 4
+  switch i32 %19, label %switch.default [
+    i32 0, label %switch.case51
+    i32 1, label %switch.case51
+    i32 2, label %switch.case51
   ]
 
-switch.case15:                                    ; preds = %switch.entry14, %switch.entry14, %switch.entry14
-  br label %switch.exit16
+switch.case51:                                    ; preds = %switch.entry50, %switch.entry50, %switch.entry50
+  br label %switch.exit52
 
-switch.default:                                   ; preds = %switch.entry14
-  br label %switch.exit16
+switch.default:                                   ; preds = %switch.entry50
+  br label %switch.exit52
 
-switch.exit16:                                    ; preds = %switch.default, %switch.case15
-  store i32 %0, ptr %switch17, align 4
-  br label %switch.entry18
+switch.exit52:                                    ; preds = %switch.default, %switch.case51
+  store i32 %0, ptr %switch53, align 4
+  br label %switch.entry54
 
-switch.entry18:                                   ; preds = %switch.exit16
-  %10 = load i32, ptr %switch17, align 4
-  switch i32 %10, label %switch.exit23 [
-    i32 0, label %switch.case19
-    i32 1, label %switch.case20
-    i32 2, label %switch.case22
+switch.entry54:                                   ; preds = %switch.exit52
+  %20 = load i32, ptr %switch53, align 4
+  switch i32 %20, label %switch.exit86 [
+    i32 0, label %switch.case55
+    i32 1, label %switch.case65
+    i32 2, label %switch.case76
   ]
 
-switch.case19:                                    ; preds = %switch.entry18
+switch.case55:                                    ; preds = %switch.entry54
   store i32 1, ptr %a, align 4
-  %11 = call i32 @std_io_println(ptr @.str.6) #1
-  br label %switch.case20
+  store ptr @.str.6, ptr %x56, align 8
+  store i64 0, ptr %error_var57, align 8
+  %21 = call ptr @std_io_stdout()
+  store ptr %21, ptr %result59, align 8
+  %22 = load ptr, ptr %x56, align 8
+  %23 = call i64 @std_io_File_printn(ptr %retparam58, ptr %result59, ptr %22, i64 1)
+  %not_err60 = icmp eq i64 %23, 0
+  br i1 %not_err60, label %after_check62, label %assign_optional61
 
-switch.case20:                                    ; preds = %switch.entry18, %switch.case19
-  store i32 2, ptr %a21, align 4
-  %12 = call i32 @std_io_println(ptr @.str.7) #1
-  br label %switch.case22
+assign_optional61:                                ; preds = %switch.case55
+  store i64 %23, ptr %error_var57, align 8
+  br label %noerr_block63
 
-switch.case22:                                    ; preds = %switch.entry18, %switch.case20
-  %13 = call i32 @std_io_println(ptr @.str.8) #1
-  br label %switch.exit23
+after_check62:                                    ; preds = %switch.case55
+  br label %noerr_block63
 
-switch.exit23:                                    ; preds = %switch.case22, %switch.entry18
+noerr_block63:                                    ; preds = %after_check62, %assign_optional61
+  br label %voiderr64
+
+voiderr64:                                        ; preds = %noerr_block63
+  br label %switch.case65
+
+switch.case65:                                    ; preds = %switch.entry54, %voiderr64
+  store i32 2, ptr %a66, align 4
+  store ptr @.str.7, ptr %x67, align 8
+  store i64 0, ptr %error_var68, align 8
+  %24 = call ptr @std_io_stdout()
+  store ptr %24, ptr %result70, align 8
+  %25 = load ptr, ptr %x67, align 8
+  %26 = call i64 @std_io_File_printn(ptr %retparam69, ptr %result70, ptr %25, i64 1)
+  %not_err71 = icmp eq i64 %26, 0
+  br i1 %not_err71, label %after_check73, label %assign_optional72
+
+assign_optional72:                                ; preds = %switch.case65
+  store i64 %26, ptr %error_var68, align 8
+  br label %noerr_block74
+
+after_check73:                                    ; preds = %switch.case65
+  br label %noerr_block74
+
+noerr_block74:                                    ; preds = %after_check73, %assign_optional72
+  br label %voiderr75
+
+voiderr75:                                        ; preds = %noerr_block74
+  br label %switch.case76
+
+switch.case76:                                    ; preds = %switch.entry54, %voiderr75
+  store ptr @.str.8, ptr %x77, align 8
+  store i64 0, ptr %error_var78, align 8
+  %27 = call ptr @std_io_stdout()
+  store ptr %27, ptr %result80, align 8
+  %28 = load ptr, ptr %x77, align 8
+  %29 = call i64 @std_io_File_printn(ptr %retparam79, ptr %result80, ptr %28, i64 1)
+  %not_err81 = icmp eq i64 %29, 0
+  br i1 %not_err81, label %after_check83, label %assign_optional82
+
+assign_optional82:                                ; preds = %switch.case76
+  store i64 %29, ptr %error_var78, align 8
+  br label %noerr_block84
+
+after_check83:                                    ; preds = %switch.case76
+  br label %noerr_block84
+
+noerr_block84:                                    ; preds = %after_check83, %assign_optional82
+  br label %voiderr85
+
+voiderr85:                                        ; preds = %noerr_block84
+  br label %switch.exit86
+
+switch.exit86:                                    ; preds = %voiderr85, %switch.entry54
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/initialize/initialize_finalize.c3t b/test/test_suite/initialize/initialize_finalize.c3t
index a3df1e4e2..d50ae84cc 100644
--- a/test/test_suite/initialize/initialize_finalize.c3t
+++ b/test/test_suite/initialize/initialize_finalize.c3t
@@ -4,7 +4,7 @@ import std::io;
 
 fn void main()
 {
-	io::println("Hello, world!");
+	io::printn("Hello, world!");
 }
 extern fn void puts(char*);
 
diff --git a/test/test_suite/initializer_lists/subarrays.c3t b/test/test_suite/initializer_lists/subarrays.c3t
index e850895e1..fc0d9a3d4 100644
--- a/test/test_suite/initializer_lists/subarrays.c3t
+++ b/test/test_suite/initializer_lists/subarrays.c3t
@@ -25,7 +25,7 @@ fn int main()
     libc::printf("%d\n", arrbar[1].x);
     int[] x = { 1, 2, 3 };
     int* y = &&(int[3]{ 123, 234, 567 });
-    io::println("Start:");
+    io::printn("Start:");
     libc::printf("X len: %d mid element %d\n", (int)(x.len), x[1]);
     libc::printf("Y mid element %d\n", y[1]);
     libc::printf("Fofeo second element %d\n", fofeo[1]);
@@ -34,7 +34,7 @@ fn int main()
 
     //var $foo = { 1, 2, 3 };
     bool xy = ! int[] { 1, 2, 3 };
-    if (!xy) io::println("Ok");
+    if (!xy) io::printn("Ok");
     Bar b = {};
     Baz z = {};
     int[] sub = {};
@@ -49,7 +49,6 @@ fn int main()
 %"Bar[]" = type { ptr, i64 }
 %"int[]" = type { ptr, i64 }
 %Baz = type { double }
-
 @"ct$subarrays_Baz" = linkonce constant %.introspect { i8 11, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
 @"ct$subarrays_Bar" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
 @.taddr = private global [2 x %Bar] [%Bar { i32 3, i32 4 }, %Bar { i32 8, i32 9 }], align 8
@@ -73,10 +72,18 @@ entry:
   %literal = alloca [3 x i32], align 4
   %y = alloca ptr, align 8
   %literal2 = alloca [3 x i32], align 4
+  %x3 = alloca ptr, align 8
+  %error_var = alloca i64, align 8
+  %retparam = alloca i64, align 8
+  %result = alloca %File, align 8
   %ffe = alloca %Baz, align 8
   %azz = alloca [1 x i32], align 4
   %xy = alloca i8, align 1
-  %literal6 = alloca [3 x i32], align 4
+  %literal7 = alloca [3 x i32], align 4
+  %x9 = alloca ptr, align 8
+  %error_var10 = alloca i64, align 8
+  %retparam11 = alloca i64, align 8
+  %result12 = alloca %File, align 8
   %b = alloca %Bar, align 4
   %z = alloca %Baz, align 8
   %sub = alloca %"int[]", align 8
@@ -106,52 +113,80 @@ entry:
   %12 = getelementptr inbounds [3 x i32], ptr %literal2, i64 0, i64 2
   store i32 567, ptr %12, align 4
   store ptr %literal2, ptr %y, align 8
-  %13 = call i32 @std_io_println(ptr @.str.5) #3
-  %14 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1
-  %15 = load i64, ptr %14, align 8
-  %uisitrunc = trunc i64 %15 to i32
-  %16 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0
-  %17 = load ptr, ptr %16, align 8
-  %ptroffset3 = getelementptr inbounds i32, ptr %17, i64 1
-  %18 = load i32, ptr %ptroffset3, align 4
-  %19 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %uisitrunc, i32 %18)
-  %20 = load ptr, ptr %y, align 8
-  %ptroffset4 = getelementptr inbounds i32, ptr %20, i64 1
-  %21 = load i32, ptr %ptroffset4, align 4
-  %22 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %21)
-  %23 = load ptr, ptr @subarrays_fofeo, align 8
-  %ptroffset5 = getelementptr inbounds i32, ptr %23, i64 1
-  %24 = load i32, ptr %ptroffset5, align 4
-  %25 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %24)
+  store ptr @.str.5, ptr %x3, align 8
+  store i64 0, ptr %error_var, align 8
+  %13 = call ptr @std_io_stdout()
+  store ptr %13, ptr %result, align 8
+  %14 = load ptr, ptr %x3, align 8
+  %15 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %14, i64 6)
+  %not_err = icmp eq i64 %15, 0
+  br i1 %not_err, label %after_check, label %assign_optional
+assign_optional:                                  ; preds = %entry
+  store i64 %15, ptr %error_var, align 8
+  br label %noerr_block
+after_check:                                      ; preds = %entry
+  br label %noerr_block
+noerr_block:                                      ; preds = %after_check, %assign_optional
+  br label %voiderr
+voiderr:                                          ; preds = %noerr_block
+  %16 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1
+  %17 = load i64, ptr %16, align 8
+  %uisitrunc = trunc i64 %17 to i32
+  %18 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0
+  %19 = load ptr, ptr %18, align 8
+  %ptroffset4 = getelementptr inbounds i32, ptr %19, i64 1
+  %20 = load i32, ptr %ptroffset4, align 4
+  %21 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %uisitrunc, i32 %20)
+  %22 = load ptr, ptr %y, align 8
+  %ptroffset5 = getelementptr inbounds i32, ptr %22, i64 1
+  %23 = load i32, ptr %ptroffset5, align 4
+  %24 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %23)
+  %25 = load ptr, ptr @subarrays_fofeo, align 8
+  %ptroffset6 = getelementptr inbounds i32, ptr %25, i64 1
+  %26 = load i32, ptr %ptroffset6, align 4
+  %27 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %26)
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %ffe, ptr align 8 @.__const, i32 8, i1 false)
-  %26 = getelementptr inbounds [1 x i32], ptr %azz, i64 0, i64 0
-  store i32 0, ptr %26, align 4
-  %27 = getelementptr inbounds [3 x i32], ptr %literal6, i64 0, i64 0
-  store i32 1, ptr %27, align 4
-  %28 = getelementptr inbounds [3 x i32], ptr %literal6, i64 0, i64 1
-  store i32 2, ptr %28, align 4
-  %29 = getelementptr inbounds [3 x i32], ptr %literal6, i64 0, i64 2
-  store i32 3, ptr %29, align 4
-  %30 = insertvalue %"int[]" undef, ptr %literal6, 0
-  %31 = insertvalue %"int[]" %30, i64 3, 1
-  %32 = extractvalue %"int[]" %31, 1
-  %not = icmp eq i64 %32, 0
-  %33 = zext i1 %not to i8
-  store i8 %33, ptr %xy, align 1
-  %34 = load i8, ptr %xy, align 1
-  %35 = trunc i8 %34 to i1
-  %not7 = xor i1 %35, true
-  br i1 %not7, label %if.then, label %if.exit
-
-if.then:                                          ; preds = %entry
-  %36 = call i32 @std_io_println(ptr @.str.9) #3
+  %28 = getelementptr inbounds [1 x i32], ptr %azz, i64 0, i64 0
+  store i32 0, ptr %28, align 4
+  %29 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 0
+  store i32 1, ptr %29, align 4
+  %30 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 1
+  store i32 2, ptr %30, align 4
+  %31 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 2
+  store i32 3, ptr %31, align 4
+  %32 = insertvalue %"int[]" undef, ptr %literal7, 0
+  %33 = insertvalue %"int[]" %32, i64 3, 1
+  %34 = extractvalue %"int[]" %33, 1
+  %not = icmp eq i64 %34, 0
+  %35 = zext i1 %not to i8
+  store i8 %35, ptr %xy, align 1
+  %36 = load i8, ptr %xy, align 1
+  %37 = trunc i8 %36 to i1
+  %not8 = xor i1 %37, true
+  br i1 %not8, label %if.then, label %if.exit
+if.then:                                          ; preds = %voiderr
+  store ptr @.str.9, ptr %x9, align 8
+  store i64 0, ptr %error_var10, align 8
+  %38 = call ptr @std_io_stdout()
+  store ptr %38, ptr %result12, align 8
+  %39 = load ptr, ptr %x9, align 8
+  %40 = call i64 @std_io_File_printn(ptr %retparam11, ptr %result12, ptr %39, i64 2)
+  %not_err13 = icmp eq i64 %40, 0
+  br i1 %not_err13, label %after_check15, label %assign_optional14
+assign_optional14:                                ; preds = %if.then
+  store i64 %40, ptr %error_var10, align 8
+  br label %noerr_block16
+after_check15:                                    ; preds = %if.then
+  br label %noerr_block16
+noerr_block16:                                    ; preds = %after_check15, %assign_optional14
+  br label %voiderr17
+voiderr17:                                        ; preds = %noerr_block16
   br label %if.exit
-
-if.exit:                                          ; preds = %if.then, %entry
-  %37 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 0
-  store i32 0, ptr %37, align 4
-  %38 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1
-  store i32 0, ptr %38, align 4
+if.exit:                                          ; preds = %voiderr17, %voiderr
+  %41 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 0
+  store i32 0, ptr %41, align 4
+  %42 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1
+  store i32 0, ptr %42, align 4
   call void @llvm.memset.p0.i64(ptr align 8 %z, i8 0, i64 8, i1 false)
   store %"int[]" zeroinitializer, ptr %sub, align 8
   store %"Bar[]" zeroinitializer, ptr %foo, align 8
diff --git a/test/test_suite/macro_methods/macro_methods_defined_twice.c3 b/test/test_suite/macro_methods/macro_methods_defined_twice.c3
index ebfd29857..e98a0a558 100644
--- a/test/test_suite/macro_methods/macro_methods_defined_twice.c3
+++ b/test/test_suite/macro_methods/macro_methods_defined_twice.c3
@@ -11,14 +11,14 @@ import std::io;
 
 macro void foo::Bar.@test(Bar &bar)
 {
-    io::println("Inside of baz::Bar.test");
+    io::printn("Inside of baz::Bar.test");
 }
 
 module bad;
 import foo;
 macro void Bar.@test(Bar &bar) // #error: This macro method is already defined for 'Bar'.
 {
-    io::println("Inside of baz::Bar.test");
+    io::printn("Inside of baz::Bar.test");
 }
 
 module abc;
diff --git a/test/test_suite/methods/enum_distinct_err_methods.c3t b/test/test_suite/methods/enum_distinct_err_methods.c3t
index dd1127d7d..93e24cafd 100644
--- a/test/test_suite/methods/enum_distinct_err_methods.c3t
+++ b/test/test_suite/methods/enum_distinct_err_methods.c3t
@@ -45,20 +45,18 @@ fn int main()
 
 define void @foo_Foo_hello(ptr %0) #0 {
 entry:
-  %1 = call i32 @std_io_println(ptr @.str) #1
+  store ptr @.str, ptr %x, align 8
   ret void
 }
 
 define void @foo_Bar_hello(ptr %0) #0 {
 entry:
-  %1 = call i32 @std_io_println(ptr @.str.1) #1
-  ret void
+  store ptr @.str.1, ptr %x, align 8
 }
 
 define void @foo_MyEnum_hello(ptr %0) #0 {
 entry:
-  %1 = call i32 @std_io_println(ptr @.str.2) #1
-  ret void
+  store ptr @.str.2, ptr %x, align 8
 }
 
 define i32 @main() #0 {
@@ -73,4 +71,4 @@ entry:
   call void @foo_Bar_hello(ptr %b)
   call void @foo_MyEnum_hello(ptr %a)
   ret i32 0
-}
+}
\ No newline at end of file
diff --git a/test/test_suite/methods/extension_method.c3t b/test/test_suite/methods/extension_method.c3t
index 4e795cbc1..3f215c1fe 100644
--- a/test/test_suite/methods/extension_method.c3t
+++ b/test/test_suite/methods/extension_method.c3t
@@ -11,7 +11,7 @@ import std::io;
 
 fn void foo::Bar.test(Bar *bar)
 {
-    io::println("Inside of baz::Bar.test");
+    io::printn("Inside of baz::Bar.test");
 }
 
 module abc;
diff --git a/test/test_suite/methods/extension_method_already_exist.c3 b/test/test_suite/methods/extension_method_already_exist.c3
index beccdbca1..8bd16a1ef 100644
--- a/test/test_suite/methods/extension_method_already_exist.c3
+++ b/test/test_suite/methods/extension_method_already_exist.c3
@@ -2,7 +2,7 @@ module foo;
 
 fn void Bar.test(Bar *bar)
 {
-    io::println("Inside of baz::Bar.test");
+    io::printn("Inside of baz::Bar.test");
 }
 
 struct Bar
@@ -16,7 +16,7 @@ import std::io;
 
 fn void foo::Bar.test(Bar *bar) // #error: This method is already defined for 'Bar'
 {
-    io::println("Inside of baz::Bar.test");
+    io::printn("Inside of baz::Bar.test");
 }
 
 module abc;
diff --git a/test/test_suite/methods/methods_defined_twice.c3 b/test/test_suite/methods/methods_defined_twice.c3
index b03f6580c..5c60adf53 100644
--- a/test/test_suite/methods/methods_defined_twice.c3
+++ b/test/test_suite/methods/methods_defined_twice.c3
@@ -11,12 +11,12 @@ import std::io;
 
 fn void foo::Bar.test(Bar *bar)
 {
-    io::println("Inside of baz::Bar.test");
+    io::printn("Inside of baz::Bar.test");
 }
 
 fn void Bar.test(Bar *bar) // #error: This method is already defined for
 {
-    io::println("Inside of baz::Bar.test");
+    io::printn("Inside of baz::Bar.test");
 }
 
 module abc;