Updated native variants of file handling. Fixed $if folding chain.

2026-02-27 12:01:16 +00:00 · 2023-02-23 17:35:34 +01:00
parent f86aa136cb
commit 2a6339a25e
17 changed files with 653 additions and 445 deletions
--- a/lib/std/core/env.c3
+++ b/lib/std/core/env.c3
@@ -128,6 +128,11 @@ const bool BENCHMARKING = $$BENCHMARKING;
 const bool TESTING = $$TESTING;
 const MemoryEnvironment MEMORY_ENV = (MemoryEnvironment)$$MEMORY_ENVIRONMENT;

+macro bool os_is_win32()
+{
+	return OS_TYPE == OsType.WIN32;
+}
+
 macro bool os_is_posix()
 {
 	$switch (OS_TYPE):
@@ -205,3 +210,4 @@ $if (COMPILER_LIBC_AVAILABLE && OS_TYPE != OsType.WIN32):
 	};
 $endif;
 }
+
--- a/lib/std/io/dir.c3
+++ b/lib/std/io/dir.c3
@@ -3,8 +3,7 @@ import std::io::os;
 // In progress.
 typedef Path = distinct String;

-const PREFERRED_SEPARATOR = USE_WIN32_FILESYSTEM ? '\\' : '/';
-const USE_WIN32_FILESYSTEM @private = env::OS_TYPE != OsType.WIN32;
+const PREFERRED_SEPARATOR = env::os_is_win32() ? '\\' : '/';

 fault PathResult
 {
@@ -23,7 +22,7 @@ fn String! tgetcwd()

 macro bool is_separator(char c)
 {
-	$if (USE_WIN32_FILESYSTEM):
+	$if (env::os_is_win32()):
 		return c == '/' || c == '\\';
 	$else:
 		return c == '/';
@@ -49,7 +48,7 @@ const bool[256] RESERVED_PATH_CHAR_WIN32 = {

 macro bool is_reserved_path_char(char c)
 {
-$if (USE_WIN32_FILESYSTEM):
+$if (env::os_is_win32()):
 	return RESERVED_PATH_CHAR_WIN32[c];
 $else:
 	return RESERVED_PATH_CHAR_POSIX[c];
@@ -60,7 +59,7 @@ fn usz! root_name_len(String path) @private
 {
 	usz len = path.len;
 	if (!len) return 0;
-	$if (USE_WIN32_FILESYSTEM):
+	$if (env::os_is_win32()):
 		switch (path[0])
 		{
 			case '\\':
@@ -157,7 +156,7 @@ fn Path Path.root_directory(Path path)
 	String path_str = (String)path;
 	usz len = path_str.len;
 	if (!len) return (Path)"";
-	$if (USE_WIN32_FILESYSTEM):
+	$if (env::os_is_win32()):
 		usz root_len = root_name_len(path_str)!!;
 		if (root_len == len || !is_separator(path_str[root_len])) return (Path)"";
 		return (Path)path_str[root_len..root_len];
--- a/lib/std/io/io.c3
+++ b/lib/std/io/io.c3
@@ -21,16 +21,23 @@ fault IoError
    FILE_NOT_FOUND,
    FILE_NOT_VALID,
    INVALID_POSITION,
-    FILE_OVERFLOW,
+    OVERFLOW,
    FILE_IS_PIPE,
    FILE_EOF,
    INCOMPLETE_WRITE,
-    FILE_NOT_DIR,
    NO_PERMISSION,
+    OUT_OF_DISK,
    INVALID_PUSHBACK,
    EOF,
+    TOO_MANY_DESCRIPTORS,
+    FILE_IS_DIR,
+    READ_ONLY,
+    FILE_NOT_DIR,
+    SYMLINK_FAILED,
+    ALREADY_EXISTS,
    NOT_SEEKABLE,
    NAME_TOO_LONG,
+    WOULD_BLOCK,
    INTERRUPTED,
    GENERAL_ERROR,
    UNKNOWN_ERROR,
--- a/lib/std/io/io_file.c3
+++ b/lib/std/io/io_file.c3
@@ -2,23 +2,11 @@ module std::io;
 import libc;


-$if (env::OS_TYPE == OsType.WIN32):
-extern fn void* _wfopen(Char16*, Char16*) @local;
-$endif;
+

 fn void! File.open(File* file, String filename, String mode)
 {
-	@pool()
-	{
-$if (env::OS_TYPE == OsType.WIN32):
-		file.file = (CFile)_wfopen(
-			str::utf8to16(filename, mem::temp_allocator())!!,
-			str::utf8to16(mode, mem::temp_allocator())!!);
-$else:
-		file.file = libc::fopen(filename.zstrtcopy(), mode.zstrtcopy());
-$endif;
-        if (!file.file) return IoError.FILE_NOT_FOUND!;
-	};
+	file.file = os::native_fopen(filename, mode)?;
 }

 /**
@@ -26,24 +14,19 @@ $endif;
 **/
 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!;
-	};
+	file.file = os::native_freopen(file.file, filename, mode)?;
 }

 /**
 * @require file.file != null
 **/
-fn void! File.chmode(File* file, String filename, String mode)
+fn usz! File.seek(File file, isz offset, Seek seek_mode = Seek.SET)
 {
-	@pool()
-	{
-		file.file = libc::freopen(null, mode.zstrtcopy(), file.file);
-        if (!file.file) return IoError.FILE_NOT_FOUND!;
-	};
+	os::native_fseek(file.file, offset, seek_mode)?;
+	return os::native_ftell(file.file);
 }
+
+
 /*
 Implement later
 /**
@@ -59,25 +42,6 @@ fn void! File.memopen(File* file, char[] data, String mode)
 }
 */

-/**
- * @require file.file != null
- **/
-fn usz! File.seek(File *file, isz offset, Seek seekMode = Seek.SET)
-{
-    if (libc::fseek(file.file, (SeekIndex)(offset), (int)(seekMode)))
-    {
-        switch (libc::errno())
-        {
-            case errno::EBADF: return IoError.NOT_SEEKABLE!;
-            case errno::EINVAL: return IoError.INVALID_POSITION!;
-            case errno::EOVERFLOW: return IoError.FILE_OVERFLOW!;
-            case errno::ESPIPE: return IoError.FILE_IS_PIPE!;
-            default: return IoError.UNKNOWN_ERROR!;
-        }
-    }
-    if (seekMode == Seek.SET) return offset;
-    return libc::ftell(file.file);
-}

 /**
 * @require file && file.file != null
@@ -124,9 +88,9 @@ fn bool File.eof(File* file) @inline
 /**
 * @param [in] buffer
 */
-fn usz File.read(File* file, char[] buffer)
+fn usz! File.read(File* file, char[] buffer)
 {
-    return libc::fread(buffer.ptr, 1, buffer.len, file.file);
+	return os::native_fread(file.file, buffer);
 }

 /**
@@ -134,16 +98,16 @@ fn usz File.read(File* file, char[] buffer)
 * @param [&out] buffer
 * @require file.file `File must be initialized`
 */
-fn usz File.write(File* file, char[] buffer)
+fn usz! File.write(File file, char[] buffer)
 {
-    return libc::fwrite(buffer.ptr, 1, buffer.len, file.file);
+	return os::native_fwrite(file.file, buffer);
 }

 /**
 * @param [&in] file
 * @require file.file `File must be initialized`
 */
-fn usz! File.printn(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!;
@@ -154,14 +118,14 @@ fn usz! File.printn(File* file, String string)
 * @param [&in] file
 * @require file.file `File must be initialized`
 */
-fn usz! File.print(File* file, String string)
+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 (len != file.write((char[])string)?) return IoError.UNKNOWN_ERROR!;
    return len;
 }

-fn usz! File.println(File* file, String string) => file.printn(string);
+fn usz! File.println(File file, String string) => file.printn(string);

 /**
 * @param [&in] file
--- a/lib/std/io/os/file.c3
+++ b/lib/std/io/os/file.c3
@@ -0,0 +1,188 @@
+module std::io::os;
+import libc;
+
+define FopenFn = fn CFile!(String, String);
+define FreopenFn = fn CFile!(CFile, String, String);
+define FcloseFn = fn void!(CFile);
+define FseekFn = fn void!(CFile, isz, Seek);
+define FtellFn = fn usz!(CFile);
+define FwriteFn = fn usz!(CFile, char[] buffer);
+define FreadFn = fn usz!(CFile, char[] buffer);
+
+$if (!$defined(native_fopen_fn)):
+FopenFn native_fopen_fn @weak;
+$endif;
+$if (!$defined(native_fclose_fn)):
+FcloseFn native_fclose_fn @weak;
+$endif;
+$if (!$defined(native_freopen_fn)):
+FreopenFn native_freopen_fn @weak;
+$endif;
+$if (!$defined(native_fseek_fn)):
+FseekFn native_fseek_fn @weak;
+$endif;
+$if (!$defined(native_ftell_fn)):
+FtellFn native_ftell_fn @weak;
+$endif;
+$if (!$defined(native_fwrite_fn)):
+FwriteFn native_fwrite_fn @weak;
+$endif;
+$if (!$defined(native_fread_fn)):
+FreadFn native_fread_fn @weak;
+$endif;
+
+
+/**
+ * @require mode.len > 0
+ * @require filename.len > 0
+ **/
+fn CFile! native_fopen(String filename, String mode) @inline
+{
+$if (!env::COMPILER_LIBC_AVAILABLE):
+		if (native_fopen_fn) return native_fopen_fn(filename, mode);
+		unreachable("Tried to call fopen without support.");
+$else:
+	@pool()
+	{
+	$if (env::os_is_win32()):
+		CFile file = (CFile)_wfopen(
+			str::utf8to16(filename, mem::temp_allocator())!!,
+			str::utf8to16(mode, mem::temp_allocator())!!);
+	$else:
+		CFile file = libc::fopen(filename.zstrtcopy(), mode.zstrtcopy());
+	$endif;
+		return file ?: file_open_errno()!;
+	};
+$endif;
+}
+
+/**
+ * @require mode.len > 0
+ * @require filename.len > 0
+ **/
+fn CFile! native_freopen(CFile file, String filename, String mode) @inline
+{
+$if (!env::COMPILER_LIBC_AVAILABLE):
+		if (native_freopen_fn) return native_freopen_fn(file, filename, mode);
+		unreachable("Tried to call freopen without support.");
+$else:
+	@pool()
+	{
+	$if (env::os_is_win32()):
+		file = (CFile)_wfreopen(
+			str::utf8to16(filename, mem::temp_allocator())!!,
+			str::utf8to16(mode, mem::temp_allocator())!!,
+			file);
+	$else:
+		file = libc::freopen(filename.zstrtcopy(), mode.zstrtcopy(), file);
+	$endif;
+		return file ?: file_open_errno()!;
+	};
+$endif;
+}
+
+fn void! native_fseek(CFile file, isz offset, Seek seek_mode) @inline
+{
+$if (!env::COMPILER_LIBC_AVAILABLE):
+	if (native_fseek_fn) return native_fseek_fn(file, offset, seek_mode);
+	unreachable("Tried to call fseek without support.");
+$else:
+	$if (env::os_is_win32()):
+		bool success = _fseeki64(file, (long)offset, (int)seek_mode) == 0;
+	$else:
+		bool success = libc::fseek(file, (SeekIndex)offset, (CInt)seek_mode) == 0;
+	$endif;
+		if (!success) return file_seek_errno()!;
+$endif;
+}
+
+fn usz! native_ftell(CFile file) @inline
+{
+$if (!env::COMPILER_LIBC_AVAILABLE):
+	if (native_ftell_fn) return native_ftell_fn(file);
+	unreachable("Tried to call ftell without support.");
+$else:
+	$if (env::os_is_win32()):
+		long index = _ftelli64(file);
+		return index >= 0 ? index : file_seek_errno()!;
+	$else:
+		SeekIndex index = libc::ftell(file);
+		return index >= 0 ? index : file_seek_errno()!;
+	$endif;
+$endif;
+}
+
+fn usz! native_fwrite(CFile file, char[] buffer) @inline
+{
+$if (!env::COMPILER_LIBC_AVAILABLE):
+	if (native_fwrite_fn) return native_fwrite_fn(file, buffer);
+	unreachable("Tried to call fwrite without support.");
+$else:
+    return libc::fwrite(buffer.ptr, 1, buffer.len, file);
+$endif;
+}
+
+fn usz! native_fread(CFile file, char[] buffer) @inline
+{
+$if (!env::COMPILER_LIBC_AVAILABLE):
+	if (native_fread_fn) return native_fread_fn(file, buffer);
+	unreachable("Tried to call fread without support.");
+$else:
+    return libc::fread(buffer.ptr, 1, buffer.len, file);
+$endif;
+}
+
+macro anyerr file_open_errno() @local
+{
+	switch (libc::errno())
+	{
+	    case errno::EACCES: return IoError.NO_PERMISSION;
+	    case errno::EDQUOT: return IoError.OUT_OF_DISK;
+	    case errno::EBADF: return IoError.FILE_NOT_VALID;
+	    case errno::EEXIST: return IoError.ALREADY_EXISTS;
+	    case errno::EINTR: return IoError.INTERRUPTED;
+	    case errno::EFAULT: return IoError.GENERAL_ERROR;
+	    case errno::EISDIR: return IoError.FILE_IS_DIR;
+	    case errno::ELOOP: return IoError.SYMLINK_FAILED;
+	    case errno::EMFILE: return IoError.TOO_MANY_DESCRIPTORS;
+	    case errno::ENAMETOOLONG: return IoError.NAME_TOO_LONG;
+	    case errno::ENFILE: return IoError.OUT_OF_DISK;
+	    case errno::ENOTDIR: return IoError.FILE_NOT_DIR;
+		case errno::ENOENT: return IoError.FILE_NOT_FOUND;
+	    case errno::ENOSPC: return IoError.OUT_OF_DISK;
+		case errno::ENXIO: return IoError.FILE_NOT_FOUND;
+		case errno::EOVERFLOW: return IoError.OVERFLOW;
+		case errno::EROFS: return IoError.READ_ONLY;
+		case errno::EOPNOTSUPP: return IoError.UNSUPPORTED_OPERATION;
+	    case errno::EIO: return IoError.INCOMPLETE_WRITE;
+	    case errno::EWOULDBLOCK: return IoError.WOULD_BLOCK;
+	    default: return IoError.UNKNOWN_ERROR;
+	}
+}
+
+macro anyerr file_seek_errno() @local
+{
+	switch (libc::errno())
+	{
+		case errno::ESPIPE: return IoError.FILE_IS_PIPE;
+		case errno::EPIPE: return IoError.FILE_IS_PIPE;
+		case errno::EOVERFLOW: return IoError.OVERFLOW;
+	    case errno::ENXIO: return IoError.FILE_NOT_FOUND;
+	    case errno::ENOSPC: return IoError.OUT_OF_DISK;
+        case errno::EIO: return IoError.INCOMPLETE_WRITE;
+		case errno::EINVAL: return IoError.INVALID_POSITION;
+	    case errno::EINTR: return IoError.INTERRUPTED;
+	    case errno::EFBIG: return IoError.OUT_OF_DISK;
+	    case errno::EBADF: return IoError.FILE_NOT_VALID;
+	    case errno::EAGAIN: return IoError.WOULD_BLOCK;
+	    default: return IoError.UNKNOWN_ERROR;
+	}
+}
+
+// Win functions
+$if (env::os_is_win32()):
+extern fn void* _wfopen(Char16*, Char16*) @local;
+extern fn void* _wfreopen(Char16*, Char16*, CFile) @local;
+extern fn int _fseeki64(CFile, long, int) @local;
+extern fn long _ftelli64(CFile) @local;
+$endif;
--- a/lib/std/libc/libc.c3
+++ b/lib/std/libc/libc.c3
@@ -425,6 +425,7 @@ const Errno ECONNRESET = 54;    // Connection reset by peer Macos
 const Errno ENETDOWN = 50;      // Network is down MacOS
 const Errno ENETUNREACH = 51;   // Network is unreachable MacOS
 const Errno ENETRESET = 52;     // Network dropped connection because of reset MacOS
+const Errno EOPNOTSUPP = 45;    // Operation not supported on transport endpoint

 $elif (env::OS_TYPE == OsType.WIN32):
 const Errno EDEADLK = 36;       // Resource deadlock would occur Win32
@@ -435,6 +436,7 @@ const Errno ENETDOWN = 116;     // Network is down
 const Errno ECONNRESET = 108;   // Connection reset by peer
 const Errno ENETUNREACH = 118;  // Network is unreachable
 const Errno ENETRESET = 117;    // Network dropped connection because of reset
+const Errno EOPNOTSUPP = 130;   // Operation not supported on transport endpoint

 $else:
 const Errno EDEADLK = 35;       // Resource deadlock would occur Linux (others?)
@@ -445,10 +447,12 @@ const Errno ENETDOWN = 100;     // Network is down
 const Errno ECONNRESET = 104;   // Connection reset by peer
 const Errno ENETUNREACH = 101;  // Network is unreachable
 const Errno ENETRESET = 102;    // Network dropped connection because of reset
+const Errno EOPNOTSUPP = 95;    // Operation not supported on transport endpoint

 $endif;


+
 /*
 const Errno ENOLCK = 37;  /* No record locks available */
 const Errno ENOSYS = 38;  /* Function not implemented */
@@ -506,7 +510,6 @@ const Errno EPROTOTYPE = 91;  /* Protocol wrong type for socket */
 const Errno ENOPROTOOPT = 92;  /* Protocol not available */
 const Errno EPROTONOSUPPORT = 93;  /* Protocol not supported */
 const Errno ESOCKTNOSUPPORT = 94;  /* Socket type not supported */
-const Errno EOPNOTSUPP = 95;  /* Operation not supported on transport endpoint */
 const Errno EPFNOSUPPORT = 96;  /* Protocol family not supported */
 const Errno EAFNOSUPPORT = 97;  /* Address family not supported by protocol */
 const Errno EADDRINUSE = 98;  /* Address already in use */
--- a/src/compiler/sema_expr.c
+++ b/src/compiler/sema_expr.c
@@ -1715,7 +1715,6 @@ bool sema_expr_analyse_macro_call(SemaContext *context, Expr *call_expr, Expr *s
 			}
 		}
 		param->var.init_expr = args[i];
-		VarDeclKind kind = param->var.kind;
 	}

 	Decl **body_params = call_expr->call_expr.body_arguments;
--- a/src/compiler/sema_stmts.c
+++ b/src/compiler/sema_stmts.c
@@ -1881,27 +1881,27 @@ static bool sema_analyse_nextcase_stmt(SemaContext *context, Ast *statement)

 static inline bool sema_analyse_then_overwrite(SemaContext *context, Ast *statement, AstId replacement)
 {
-	statement->ast_kind = AST_NOP_STMT;
 	if (!replacement)
 	{
+		statement->ast_kind = AST_NOP_STMT;
 		return true;
 	}
-	AstId current = replacement;
 	Ast *last;
+	AstId next = statement->next;
+	*statement = *astptr(replacement);
+	AstId current = astid(statement);
 	while (1)
 	{
 		Ast *curr_ast = astptr(current);
 		if (!sema_analyse_statement(context, curr_ast)) return false;
-		current = curr_ast->next;
-		if (!current)
+		if (!curr_ast->next)
 		{
 			last = curr_ast;
 			break;
 		}
+		current = curr_ast->next;
 	}
-	// NOP and insert after.
-	last->next = statement->next;
-	statement->next = replacement;
+	last->next = next;
 	return true;
 }

--- a/src/version.h
+++ b/src/version.h
@@ -1 +1 @@
-#define COMPILER_VERSION "0.4.81"
+#define COMPILER_VERSION "0.4.82"
--- a/test/test_suite/bitstruct/bitstruct_be.c3t
+++ b/test/test_suite/bitstruct/bitstruct_be.c3t
@@ -92,114 +92,117 @@ loop.exit:                                        ; preds = %loop.cond
  store ptr @.str.2, ptr %x4, align 8
  %22 = call ptr @std.io.stdout()
  store ptr %22, ptr %result, align 8
-  %23 = call i64 @std.io.File.printn(ptr %retparam5, ptr %result, ptr null, i64 0)
-  %24 = load ptr, ptr %z, align 8
-  store ptr %24, ptr %.anon6, align 8
+  %23 = load ptr, ptr %result, align 8
+  %24 = call i64 @std.io.File.printn(ptr %retparam5, ptr %23, ptr null, i64 0)
+  %25 = load ptr, ptr %z, align 8
+  store ptr %25, ptr %.anon6, align 8
  store i64 0, ptr %.anon7, align 8
  br label %loop.cond8

 loop.cond8:                                       ; preds = %loop.body10, %loop.exit
-  %25 = load i64, ptr %.anon7, align 8
-  %gt9 = icmp ugt i64 4, %25
+  %26 = load i64, ptr %.anon7, align 8
+  %gt9 = icmp ugt i64 4, %26
  br i1 %gt9, label %loop.body10, label %loop.exit15

 loop.body10:                                      ; preds = %loop.cond8
-  %26 = load ptr, ptr %.anon6, align 8
-  %27 = load i64, ptr %.anon7, 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 %d11, align 1
-  %30 = insertvalue %variant undef, ptr %d11, 0
-  %31 = insertvalue %variant %30, i64 ptrtoint (ptr @"$ct.char" to i64), 1
-  %32 = getelementptr inbounds [1 x %variant], ptr %varargslots13, i64 0, i64 0
-  store %variant %31, ptr %32, align 16
-  %33 = call i64 @std.io.printf(ptr %retparam12, ptr @.str.3, i64 3, ptr %varargslots13, i64 1)
-  %34 = load i64, ptr %.anon7, align 8
-  %add14 = add i64 %34, 1
+  %27 = load ptr, ptr %.anon6, align 8
+  %28 = load i64, ptr %.anon7, align 8
+  %29 = getelementptr inbounds [4 x i8], ptr %27, i64 0, i64 %28
+  %30 = load i8, ptr %29, align 1
+  store i8 %30, ptr %d11, align 1
+  %31 = insertvalue %variant undef, ptr %d11, 0
+  %32 = insertvalue %variant %31, i64 ptrtoint (ptr @"$ct.char" to i64), 1
+  %33 = getelementptr inbounds [1 x %variant], ptr %varargslots13, i64 0, i64 0
+  store %variant %32, ptr %33, align 16
+  %34 = call i64 @std.io.printf(ptr %retparam12, ptr @.str.3, i64 3, ptr %varargslots13, i64 1)
+  %35 = load i64, ptr %.anon7, align 8
+  %add14 = add i64 %35, 1
  store i64 %add14, ptr %.anon7, align 8
  br label %loop.cond8

 loop.exit15:                                      ; preds = %loop.cond8
  store ptr @.str.4, ptr %x16, align 8
-  %35 = call ptr @std.io.stdout()
-  store ptr %35, ptr %result18, align 8
-  %36 = call i64 @std.io.File.printn(ptr %retparam17, ptr %result18, ptr null, i64 0)
-  %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
+  %36 = call ptr @std.io.stdout()
+  store ptr %36, ptr %result18, align 8
+  %37 = load ptr, ptr %result18, align 8
+  %38 = call i64 @std.io.File.printn(ptr %retparam17, ptr %37, ptr null, i64 0)
+  %39 = load i32, ptr %abc, align 4
+  %40 = call i32 @llvm.bswap.i32(i32 %39)
+  %41 = and i32 65535, %40
+  %ztrunc = trunc i32 %41 to i16
  store i16 %ztrunc, ptr %taddr21, align 2
-  %40 = insertvalue %variant undef, ptr %taddr21, 0
-  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
-  %42 = getelementptr inbounds [1 x %variant], ptr %varargslots20, i64 0, i64 0
-  store %variant %41, ptr %42, align 16
-  %43 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.5, i64 10, ptr %varargslots20, i64 1)
-  %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)
-  store i32 %48, ptr %abc, align 4
-  %49 = load i32, ptr %abc, align 4
+  %42 = insertvalue %variant undef, ptr %taddr21, 0
+  %43 = insertvalue %variant %42, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
+  %44 = getelementptr inbounds [1 x %variant], ptr %varargslots20, i64 0, i64 0
+  store %variant %43, ptr %44, align 16
+  %45 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.5, i64 10, ptr %varargslots20, i64 1)
+  %46 = load i32, ptr %abc, align 4
+  %47 = call i32 @llvm.bswap.i32(i32 %46)
+  %48 = and i32 %47, -65536
+  %49 = or i32 %48, 4660
  %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)
-  store i32 %53, ptr %abc, align 4
-  %54 = load i32, ptr %abc, align 4
+  store i32 %50, ptr %abc, align 4
+  %51 = load i32, ptr %abc, align 4
+  %52 = call i32 @llvm.bswap.i32(i32 %51)
+  %53 = and i32 %52, 65535
+  %54 = or i32 %53, 1450704896
  %55 = call i32 @llvm.bswap.i32(i32 %54)
-  %56 = and i32 65535, %55
-  %ztrunc24 = trunc i32 %56 to i16
+  store i32 %55, ptr %abc, align 4
+  %56 = load i32, ptr %abc, align 4
+  %57 = call i32 @llvm.bswap.i32(i32 %56)
+  %58 = and i32 65535, %57
+  %ztrunc24 = trunc i32 %58 to i16
  store i16 %ztrunc24, ptr %taddr25, align 2
-  %57 = insertvalue %variant undef, ptr %taddr25, 0
-  %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
-  %59 = getelementptr inbounds [1 x %variant], ptr %varargslots23, i64 0, i64 0
-  store %variant %58, ptr %59, align 16
-  %60 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.6, i64 12, ptr %varargslots23, i64 1)
-  %61 = load ptr, ptr %z, align 8
-  store ptr %61, ptr %.anon26, align 8
+  %59 = insertvalue %variant undef, ptr %taddr25, 0
+  %60 = insertvalue %variant %59, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
+  %61 = getelementptr inbounds [1 x %variant], ptr %varargslots23, i64 0, i64 0
+  store %variant %60, ptr %61, align 16
+  %62 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.6, i64 12, ptr %varargslots23, i64 1)
+  %63 = load ptr, ptr %z, align 8
+  store ptr %63, ptr %.anon26, align 8
  store i64 0, ptr %.anon27, align 8
  br label %loop.cond28

 loop.cond28:                                      ; preds = %loop.body30, %loop.exit15
-  %62 = load i64, ptr %.anon27, align 8
-  %gt29 = icmp ugt i64 4, %62
+  %64 = load i64, ptr %.anon27, align 8
+  %gt29 = icmp ugt i64 4, %64
  br i1 %gt29, label %loop.body30, label %loop.exit35

 loop.body30:                                      ; preds = %loop.cond28
-  %63 = load ptr, ptr %.anon26, align 8
-  %64 = load i64, ptr %.anon27, 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 %d31, align 1
-  %67 = insertvalue %variant undef, ptr %d31, 0
-  %68 = insertvalue %variant %67, i64 ptrtoint (ptr @"$ct.char" to i64), 1
-  %69 = getelementptr inbounds [1 x %variant], ptr %varargslots33, i64 0, i64 0
-  store %variant %68, ptr %69, align 16
-  %70 = call i64 @std.io.printf(ptr %retparam32, ptr @.str.7, i64 3, ptr %varargslots33, i64 1)
-  %71 = load i64, ptr %.anon27, align 8
-  %add34 = add i64 %71, 1
+  %65 = load ptr, ptr %.anon26, align 8
+  %66 = load i64, ptr %.anon27, align 8
+  %67 = getelementptr inbounds [4 x i8], ptr %65, i64 0, i64 %66
+  %68 = load i8, ptr %67, align 1
+  store i8 %68, ptr %d31, align 1
+  %69 = insertvalue %variant undef, ptr %d31, 0
+  %70 = insertvalue %variant %69, i64 ptrtoint (ptr @"$ct.char" to i64), 1
+  %71 = getelementptr inbounds [1 x %variant], ptr %varargslots33, i64 0, i64 0
+  store %variant %70, ptr %71, align 16
+  %72 = call i64 @std.io.printf(ptr %retparam32, ptr @.str.7, i64 3, ptr %varargslots33, i64 1)
+  %73 = load i64, ptr %.anon27, align 8
+  %add34 = add i64 %73, 1
  store i64 %add34, ptr %.anon27, align 8
  br label %loop.cond28

 loop.exit35:                                      ; preds = %loop.cond28
  store ptr @.str.8, ptr %x36, align 8
-  %72 = call ptr @std.io.stdout()
-  store ptr %72, ptr %result38, align 8
-  %73 = call i64 @std.io.File.printn(ptr %retparam37, ptr %result38, ptr null, i64 0)
+  %74 = call ptr @std.io.stdout()
+  store ptr %74, ptr %result38, align 8
+  %75 = load ptr, ptr %result38, align 8
+  %76 = call i64 @std.io.File.printn(ptr %retparam37, ptr %75, ptr null, i64 0)
  store i32 0, ptr %y, align 4
-  %74 = load i32, ptr %y, align 4
+  %77 = load i32, ptr %y, align 4
  store i32 123, ptr %y, align 4
-  %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 %varargslots40, i64 0, i64 0
-  store %variant %76, ptr %77, align 16
-  %78 = load i32, ptr %y, align 4
-  store i32 %78, ptr %taddr41, align 4
-  %79 = insertvalue %variant undef, ptr %taddr41, 0
-  %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"$ct.int" to i64), 1
-  %81 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1
-  store %variant %80, ptr %81, align 16
-  %82 = call i64 @std.io.printf(ptr %retparam39, ptr @.str.9, i64 18, ptr %varargslots40, i64 2)
+  %78 = insertvalue %variant undef, ptr %y, 0
+  %79 = insertvalue %variant %78, i64 ptrtoint (ptr @"$ct.int" to i64), 1
+  %80 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 0
+  store %variant %79, ptr %80, align 16
+  %81 = load i32, ptr %y, align 4
+  store i32 %81, ptr %taddr41, align 4
+  %82 = insertvalue %variant undef, ptr %taddr41, 0
+  %83 = insertvalue %variant %82, i64 ptrtoint (ptr @"$ct.int" to i64), 1
+  %84 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1
+  store %variant %83, ptr %84, align 16
+  %85 = call i64 @std.io.printf(ptr %retparam39, ptr @.str.9, i64 18, ptr %varargslots40, i64 2)
  ret void
 }
--- a/test/test_suite/compile_time/ct_builtin_time_date.c3t
+++ b/test/test_suite/compile_time/ct_builtin_time_date.c3t
@@ -58,44 +58,46 @@ entry:
  %4 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
  %gt = icmp sgt i32 %0, 0
  br i1 %gt, label %if.then, label %if.exit
-
 if.then:                                          ; preds = %entry
  %sub = sub i32 %0, 1
  call void @test.test(i32 %sub)
  br label %if.exit
-
 if.exit:                                          ; preds = %if.then, %entry
  store ptr @.str.1, ptr %x, 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)
+  %6 = load ptr, ptr %result, align 8
+  %7 = load ptr, ptr %x, align 8
+  %8 = call i64 @std.io.File.printn(ptr %retparam1, ptr %6, ptr %7, i64 8)
  store ptr @.str.2, ptr %x2, align 8
-  %8 = call ptr @std.io.stdout()
-  store ptr %8, ptr %result4, align 8
-  %9 = load ptr, ptr %x2, align 8
-  %10 = call i64 @std.io.File.printn(ptr %retparam3, ptr %result4, ptr %9, i64 10)
+  %9 = call ptr @std.io.stdout()
+  store ptr %9, ptr %result4, align 8
+  %10 = load ptr, ptr %result4, align 8
+  %11 = load ptr, ptr %x2, align 8
+  %12 = call i64 @std.io.File.printn(ptr %retparam3, ptr %10, ptr %11, i64 10)
  store i64 14, ptr %taddr7, align 8
-  %11 = insertvalue %variant undef, ptr %taddr7, 0
-  %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"$ct.long" to i64), 1
-  %13 = getelementptr inbounds [1 x %variant], ptr %varargslots6, i64 0, i64 0
-  store %variant %12, ptr %13, align 16
-  %14 = call i64 @std.io.printfn(ptr %retparam5, ptr @.str.3, i64 2, ptr %varargslots6, i64 1)
+  %13 = insertvalue %variant undef, ptr %taddr7, 0
+  %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"$ct.long" to i64), 1
+  %15 = getelementptr inbounds [1 x %variant], ptr %varargslots6, i64 0, i64 0
+  store %variant %14, ptr %15, align 16
+  %16 = call i64 @std.io.printfn(ptr %retparam5, ptr @.str.3, i64 2, ptr %varargslots6, i64 1)
  store i64 6, ptr %taddr10, align 8
-  %15 = insertvalue %variant undef, ptr %taddr10, 0
-  %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"$ct.long" to i64), 1
-  %17 = getelementptr inbounds [1 x %variant], ptr %varargslots9, i64 0, i64 0
-  store %variant %16, ptr %17, align 16
-  %18 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.4, i64 2, ptr %varargslots9, i64 1)
+  %17 = insertvalue %variant undef, ptr %taddr10, 0
+  %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"$ct.long" to i64), 1
+  %19 = getelementptr inbounds [1 x %variant], ptr %varargslots9, i64 0, i64 0
+  store %variant %18, ptr %19, align 16
+  %20 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.4, i64 2, ptr %varargslots9, i64 1)
  store ptr @.str.5, ptr %x11, align 8
-  %19 = call ptr @std.io.stdout()
-  store ptr %19, ptr %result13, align 8
-  %20 = load ptr, ptr %x11, align 8
-  %21 = call i64 @std.io.File.printn(ptr %retparam12, ptr %result13, ptr %20, i64 23)
+  %21 = call ptr @std.io.stdout()
+  store ptr %21, ptr %result13, align 8
+  %22 = load ptr, ptr %result13, align 8
+  %23 = load ptr, ptr %x11, align 8
+  %24 = call i64 @std.io.File.printn(ptr %retparam12, ptr %22, ptr %23, i64 23)
  store ptr @.str.6, ptr %x14, align 8
-  %22 = call ptr @std.io.stdout()
-  store ptr %22, ptr %result16, align 8
-  %23 = load ptr, ptr %x14, align 8
-  %24 = call i64 @std.io.File.printn(ptr %retparam15, ptr %result16, ptr %23, i64 4)
+  %25 = call ptr @std.io.stdout()
+  store ptr %25, ptr %result16, align 8
+  %26 = load ptr, ptr %result16, align 8
+  %27 = load ptr, ptr %x14, align 8
+  %28 = call i64 @std.io.File.printn(ptr %retparam15, ptr %26, ptr %27, i64 4)
  ret void
 }
--- a/test/test_suite/compile_time/ct_memberof.c3t
+++ b/test/test_suite/compile_time/ct_memberof.c3t
@@ -190,166 +190,173 @@ entry:
  store ptr @.str, ptr %x, 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)
+  %2 = load ptr, ptr %result, align 8
+  %3 = load ptr, ptr %x, align 8
+  %4 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %3, i64 3)
  store ptr @.str.10, ptr %x1, align 8
-  %4 = call ptr @std.io.stdout()
-  store ptr %4, ptr %result3, align 8
-  %5 = load ptr, ptr %x1, align 8
-  %6 = call i64 @std.io.File.printn(ptr %retparam2, ptr %result3, ptr %5, i64 3)
+  %5 = call ptr @std.io.stdout()
+  store ptr %5, ptr %result3, align 8
+  %6 = load ptr, ptr %result3, align 8
+  %7 = load ptr, ptr %x1, align 8
+  %8 = call i64 @std.io.File.printn(ptr %retparam2, ptr %6, ptr %7, i64 3)
  store ptr @.str.11, ptr %x4, align 8
-  %7 = call ptr @std.io.stdout()
-  store ptr %7, ptr %result6, align 8
-  %8 = load ptr, ptr %x4, align 8
-  %9 = call i64 @std.io.File.printn(ptr %retparam5, ptr %result6, ptr %8, i64 6)
+  %9 = call ptr @std.io.stdout()
+  store ptr %9, ptr %result6, align 8
+  %10 = load ptr, ptr %result6, align 8
+  %11 = load ptr, ptr %x4, align 8
+  %12 = call i64 @std.io.File.printn(ptr %retparam5, ptr %10, ptr %11, i64 6)
  store ptr @.str.12, ptr %x7, align 8
-  %10 = call ptr @std.io.stdout()
-  store ptr %10, ptr %result9, align 8
-  %11 = load ptr, ptr %x7, align 8
-  %12 = call i64 @std.io.File.printn(ptr %retparam8, ptr %result9, ptr %11, i64 6)
-  store ptr @.str.13, ptr %x10, align 8
  %13 = call ptr @std.io.stdout()
-  store ptr %13, ptr %result12, align 8
-  %14 = load ptr, ptr %x10, align 8
-  %15 = call i64 @std.io.File.printn(ptr %retparam11, ptr %result12, ptr %14, i64 9)
+  store ptr %13, ptr %result9, align 8
+  %14 = load ptr, ptr %result9, align 8
+  %15 = load ptr, ptr %x7, align 8
+  %16 = call i64 @std.io.File.printn(ptr %retparam8, ptr %14, ptr %15, i64 6)
+  store ptr @.str.13, ptr %x10, align 8
+  %17 = call ptr @std.io.stdout()
+  store ptr %17, ptr %result12, align 8
+  %18 = load ptr, ptr %result12, align 8
+  %19 = load ptr, ptr %x10, align 8
+  %20 = call i64 @std.io.File.printn(ptr %retparam11, ptr %18, ptr %19, i64 9)
  store ptr @.str.14, ptr %x13, align 8
-  %16 = call ptr @std.io.stdout()
-  store ptr %16, ptr %result15, align 8
-  %17 = load ptr, ptr %x13, align 8
-  %18 = call i64 @std.io.File.printn(ptr %retparam14, ptr %result15, ptr %17, i64 4)
+  %21 = call ptr @std.io.stdout()
+  store ptr %21, ptr %result15, align 8
+  %22 = load ptr, ptr %result15, align 8
+  %23 = load ptr, ptr %x13, align 8
+  %24 = call i64 @std.io.File.printn(ptr %retparam14, ptr %22, ptr %23, i64 4)
  store ptr @.str.15, ptr %x16, align 8
-  %19 = call ptr @std.io.stdout()
-  store ptr %19, ptr %result18, align 8
-  %20 = load ptr, ptr %x16, align 8
-  %21 = call i64 @std.io.File.printn(ptr %retparam17, ptr %result18, ptr %20, i64 3)
+  %25 = call ptr @std.io.stdout()
+  store ptr %25, ptr %result18, align 8
+  %26 = load ptr, ptr %result18, align 8
+  %27 = load ptr, ptr %x16, align 8
+  %28 = call i64 @std.io.File.printn(ptr %retparam17, ptr %26, ptr %27, i64 3)
  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 %retparam19, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
-  store ptr @.str.19, ptr %taddr22, align 8
-  %26 = insertvalue %variant undef, ptr %taddr22, 0
-  %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
-  %28 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 0
-  store %variant %27, ptr %28, align 16
-  store ptr @.str.20, ptr %taddr23, align 8
-  %29 = insertvalue %variant undef, ptr %taddr23, 0
+  %29 = insertvalue %variant undef, ptr %taddr, 0
  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
-  %31 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 1
+  %31 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
  store %variant %30, ptr %31, align 16
-  %32 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.18, i64 6, ptr %varargslots21, i64 2)
-  store ptr @.str.22, ptr %taddr26, align 8
-  %33 = insertvalue %variant undef, ptr %taddr26, 0
-  %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
-  %35 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 0
+  %32 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
+  store ptr @.str.19, ptr %taddr22, align 8
+  %33 = insertvalue %variant undef, ptr %taddr22, 0
+  %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
+  %35 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 0
  store %variant %34, ptr %35, align 16
-  store ptr @.str.23, ptr %taddr27, align 8
-  %36 = insertvalue %variant undef, ptr %taddr27, 0
-  %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
-  %38 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 1
+  store ptr @.str.20, ptr %taddr23, align 8
+  %36 = insertvalue %variant undef, ptr %taddr23, 0
+  %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
+  %38 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 1
  store %variant %37, ptr %38, align 16
-  %39 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.21, i64 6, ptr %varargslots25, i64 2)
-  store ptr @.str.25, ptr %taddr30, align 8
-  %40 = insertvalue %variant undef, ptr %taddr30, 0
-  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"$ct.p$a0$char" to i64), 1
-  %42 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 0
+  %39 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.18, i64 6, ptr %varargslots21, i64 2)
+  store ptr @.str.22, ptr %taddr26, align 8
+  %40 = insertvalue %variant undef, ptr %taddr26, 0
+  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
+  %42 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 0
  store %variant %41, ptr %42, align 16
-  store ptr @.str.26, ptr %taddr31, align 8
-  %43 = insertvalue %variant undef, ptr %taddr31, 0
-  %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
-  %45 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 1
+  store ptr @.str.23, ptr %taddr27, align 8
+  %43 = insertvalue %variant undef, ptr %taddr27, 0
+  %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
+  %45 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 1
  store %variant %44, ptr %45, align 16
-  %46 = call i64 @std.io.printfn(ptr %retparam28, ptr @.str.24, i64 6, ptr %varargslots29, i64 2)
-  store ptr @.str.28, ptr %taddr34, align 8
-  %47 = insertvalue %variant undef, ptr %taddr34, 0
-  %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
-  %49 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 0
+  %46 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.21, i64 6, ptr %varargslots25, i64 2)
+  store ptr @.str.25, ptr %taddr30, align 8
+  %47 = insertvalue %variant undef, ptr %taddr30, 0
+  %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"$ct.p$a0$char" to i64), 1
+  %49 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 0
  store %variant %48, ptr %49, align 16
-  store ptr @.str.29, ptr %taddr35, align 8
-  %50 = insertvalue %variant undef, ptr %taddr35, 0
-  %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.p$a6$char" to i64), 1
-  %52 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 1
+  store ptr @.str.26, ptr %taddr31, align 8
+  %50 = insertvalue %variant undef, ptr %taddr31, 0
+  %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
+  %52 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 1
  store %variant %51, ptr %52, align 16
-  %53 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.27, i64 6, ptr %varargslots33, i64 2)
-  store ptr @.str.31, ptr %taddr38, align 8
-  %54 = insertvalue %variant undef, ptr %taddr38, 0
-  %55 = insertvalue %variant %54, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
-  %56 = getelementptr inbounds [1 x %variant], ptr %varargslots37, i64 0, i64 0
+  %53 = call i64 @std.io.printfn(ptr %retparam28, ptr @.str.24, i64 6, ptr %varargslots29, i64 2)
+  store ptr @.str.28, ptr %taddr34, align 8
+  %54 = insertvalue %variant undef, ptr %taddr34, 0
+  %55 = insertvalue %variant %54, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
+  %56 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 0
  store %variant %55, ptr %56, align 16
-  %57 = call i64 @std.io.printfn(ptr %retparam36, ptr @.str.30, i64 8, ptr %varargslots37, i64 1)
-  store ptr @.str.33, ptr %taddr41, align 8
-  %58 = insertvalue %variant undef, ptr %taddr41, 0
-  %59 = insertvalue %variant %58, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
-  %60 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 0
-  store %variant %59, ptr %60, align 16
-  store ptr @.str.34, ptr %taddr42, align 8
-  %61 = insertvalue %variant undef, ptr %taddr42, 0
-  %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
-  %63 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1
+  store ptr @.str.29, ptr %taddr35, align 8
+  %57 = insertvalue %variant undef, ptr %taddr35, 0
+  %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"$ct.p$a6$char" to i64), 1
+  %59 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 1
+  store %variant %58, ptr %59, align 16
+  %60 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.27, i64 6, ptr %varargslots33, i64 2)
+  store ptr @.str.31, ptr %taddr38, align 8
+  %61 = insertvalue %variant undef, ptr %taddr38, 0
+  %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
+  %63 = getelementptr inbounds [1 x %variant], ptr %varargslots37, i64 0, i64 0
  store %variant %62, ptr %63, align 16
-  %64 = call i64 @std.io.printfn(ptr %retparam39, ptr @.str.32, i64 6, ptr %varargslots40, i64 2)
-  store ptr @.str.36, ptr %taddr45, align 8
-  %65 = insertvalue %variant undef, ptr %taddr45, 0
+  %64 = call i64 @std.io.printfn(ptr %retparam36, ptr @.str.30, i64 8, ptr %varargslots37, i64 1)
+  store ptr @.str.33, ptr %taddr41, align 8
+  %65 = insertvalue %variant undef, ptr %taddr41, 0
  %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
-  %67 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 0
+  %67 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 0
  store %variant %66, ptr %67, align 16
-  store ptr @.str.37, ptr %taddr46, align 8
-  %68 = insertvalue %variant undef, ptr %taddr46, 0
-  %69 = insertvalue %variant %68, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
-  %70 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 1
+  store ptr @.str.34, ptr %taddr42, align 8
+  %68 = insertvalue %variant undef, ptr %taddr42, 0
+  %69 = insertvalue %variant %68, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
+  %70 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1
  store %variant %69, ptr %70, align 16
-  %71 = call i64 @std.io.printfn(ptr %retparam43, ptr @.str.35, i64 6, ptr %varargslots44, i64 2)
-  store ptr @.str.39, ptr %taddr49, align 8
-  %72 = insertvalue %variant undef, ptr %taddr49, 0
-  %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"$ct.p$a0$char" to i64), 1
-  %74 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 0
+  %71 = call i64 @std.io.printfn(ptr %retparam39, ptr @.str.32, i64 6, ptr %varargslots40, i64 2)
+  store ptr @.str.36, ptr %taddr45, align 8
+  %72 = insertvalue %variant undef, ptr %taddr45, 0
+  %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
+  %74 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 0
  store %variant %73, ptr %74, align 16
-  store ptr @.str.40, ptr %taddr50, align 8
-  %75 = insertvalue %variant undef, ptr %taddr50, 0
+  store ptr @.str.37, ptr %taddr46, align 8
+  %75 = insertvalue %variant undef, ptr %taddr46, 0
  %76 = insertvalue %variant %75, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
-  %77 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 1
+  %77 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 1
  store %variant %76, ptr %77, align 16
-  %78 = call i64 @std.io.printfn(ptr %retparam47, ptr @.str.38, i64 6, ptr %varargslots48, i64 2)
-  store ptr @.str.42, ptr %taddr53, align 8
-  %79 = insertvalue %variant undef, ptr %taddr53, 0
-  %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
-  %81 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 0
+  %78 = call i64 @std.io.printfn(ptr %retparam43, ptr @.str.35, i64 6, ptr %varargslots44, i64 2)
+  store ptr @.str.39, ptr %taddr49, align 8
+  %79 = insertvalue %variant undef, ptr %taddr49, 0
+  %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"$ct.p$a0$char" to i64), 1
+  %81 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 0
  store %variant %80, ptr %81, align 16
-  store ptr @.str.43, ptr %taddr54, align 8
-  %82 = insertvalue %variant undef, ptr %taddr54, 0
-  %83 = insertvalue %variant %82, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
-  %84 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 1
+  store ptr @.str.40, ptr %taddr50, align 8
+  %82 = insertvalue %variant undef, ptr %taddr50, 0
+  %83 = insertvalue %variant %82, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
+  %84 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 1
  store %variant %83, ptr %84, align 16
-  %85 = call i64 @std.io.printfn(ptr %retparam51, ptr @.str.41, i64 6, ptr %varargslots52, i64 2)
-  store ptr @.str.45, ptr %taddr57, align 8
-  %86 = insertvalue %variant undef, ptr %taddr57, 0
-  %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
-  %88 = getelementptr inbounds [1 x %variant], ptr %varargslots56, i64 0, i64 0
+  %85 = call i64 @std.io.printfn(ptr %retparam47, ptr @.str.38, i64 6, ptr %varargslots48, i64 2)
+  store ptr @.str.42, ptr %taddr53, align 8
+  %86 = insertvalue %variant undef, ptr %taddr53, 0
+  %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
+  %88 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 0
  store %variant %87, ptr %88, align 16
-  %89 = call i64 @std.io.printfn(ptr %retparam55, ptr @.str.44, i64 8, ptr %varargslots56, i64 1)
-  store ptr @.str.47, ptr %taddr60, align 8
-  %90 = insertvalue %variant undef, ptr %taddr60, 0
-  %91 = insertvalue %variant %90, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
-  %92 = getelementptr inbounds [2 x %variant], ptr %varargslots59, i64 0, i64 0
-  store %variant %91, ptr %92, align 16
-  store ptr @.str.48, ptr %taddr61, align 8
-  %93 = insertvalue %variant undef, ptr %taddr61, 0
-  %94 = insertvalue %variant %93, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
-  %95 = getelementptr inbounds [2 x %variant], ptr %varargslots59, i64 0, i64 1
+  store ptr @.str.43, ptr %taddr54, align 8
+  %89 = insertvalue %variant undef, ptr %taddr54, 0
+  %90 = insertvalue %variant %89, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
+  %91 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 1
+  store %variant %90, ptr %91, align 16
+  %92 = call i64 @std.io.printfn(ptr %retparam51, ptr @.str.41, i64 6, ptr %varargslots52, i64 2)
+  store ptr @.str.45, ptr %taddr57, align 8
+  %93 = insertvalue %variant undef, ptr %taddr57, 0
+  %94 = insertvalue %variant %93, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
+  %95 = getelementptr inbounds [1 x %variant], ptr %varargslots56, i64 0, i64 0
  store %variant %94, ptr %95, align 16
-  %96 = call i64 @std.io.printfn(ptr %retparam58, ptr @.str.46, i64 6, ptr %varargslots59, i64 2)
-  store ptr @.str.50, ptr %taddr64, align 8
-  %97 = insertvalue %variant undef, ptr %taddr64, 0
+  %96 = call i64 @std.io.printfn(ptr %retparam55, ptr @.str.44, i64 8, ptr %varargslots56, i64 1)
+  store ptr @.str.47, ptr %taddr60, align 8
+  %97 = insertvalue %variant undef, ptr %taddr60, 0
  %98 = insertvalue %variant %97, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
-  %99 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 0
+  %99 = getelementptr inbounds [2 x %variant], ptr %varargslots59, i64 0, i64 0
  store %variant %98, ptr %99, align 16
-  store ptr @.str.51, ptr %taddr65, align 8
-  %100 = insertvalue %variant undef, ptr %taddr65, 0
-  %101 = insertvalue %variant %100, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
-  %102 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 1
+  store ptr @.str.48, ptr %taddr61, align 8
+  %100 = insertvalue %variant undef, ptr %taddr61, 0
+  %101 = insertvalue %variant %100, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
+  %102 = getelementptr inbounds [2 x %variant], ptr %varargslots59, i64 0, i64 1
  store %variant %101, ptr %102, align 16
-  %103 = call i64 @std.io.printfn(ptr %retparam62, ptr @.str.49, i64 6, ptr %varargslots63, i64 2)
+  %103 = call i64 @std.io.printfn(ptr %retparam58, ptr @.str.46, i64 6, ptr %varargslots59, i64 2)
+  store ptr @.str.50, ptr %taddr64, align 8
+  %104 = insertvalue %variant undef, ptr %taddr64, 0
+  %105 = insertvalue %variant %104, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
+  %106 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 0
+  store %variant %105, ptr %106, align 16
+  store ptr @.str.51, ptr %taddr65, align 8
+  %107 = insertvalue %variant undef, ptr %taddr65, 0
+  %108 = insertvalue %variant %107, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
+  %109 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 1
+  store %variant %108, ptr %109, align 16
+  %110 = call i64 @std.io.printfn(ptr %retparam62, ptr @.str.49, i64 6, ptr %varargslots63, i64 2)
  ret void
 }

--- a/test/test_suite/errors/general_error_regression.c3t
+++ b/test/test_suite/errors/general_error_regression.c3t
@@ -80,11 +80,13 @@ entry:
  store ptr @.str.12, ptr %x, 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)
+  %2 = load ptr, ptr %result, align 8
+  %3 = load ptr, ptr %x, align 8
+  %4 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %3, i64 14)
  ret void
 }

+; Function Attrs: nounwind
 define void @foo.Bar.hello(ptr %0) #0 {
 entry:
  %x = alloca ptr, align 8
@@ -93,11 +95,13 @@ entry:
  store ptr @.str.13, ptr %x, 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)
+  %2 = load ptr, ptr %result, align 8
+  %3 = load ptr, ptr %x, align 8
+  %4 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %3, i64 14)
  ret void
 }

+; Function Attrs: nounwind
 define void @foo.MyEnum.hello(ptr %0) #0 {
 entry:
  %x = alloca ptr, align 8
@@ -106,11 +110,13 @@ entry:
  store ptr @.str.14, ptr %x, 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)
+  %2 = load ptr, ptr %result, align 8
+  %3 = load ptr, ptr %x, align 8
+  %4 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %3, i64 17)
  ret void
 }

+; Function Attrs: nounwind
 define void @foo.main() #0 {
 entry:
  %f = alloca i64, align 8
--- a/test/test_suite/errors/or_and_rethrow.c3t
+++ b/test/test_suite/errors/or_and_rethrow.c3t
@@ -89,16 +89,18 @@ if.then:                                          ; preds = %or.phi
  store ptr @.str.2, ptr %x, 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 %retparam1, ptr %result, ptr %7, i64 3)
+  %7 = load ptr, ptr %result, align 8
+  %8 = load ptr, ptr %x, align 8
+  %9 = call i64 @std.io.File.printn(ptr %retparam1, ptr %7, ptr %8, i64 3)
  br label %if.exit

 if.exit:                                          ; preds = %if.then
  store ptr @.str.3, ptr %x2, align 8
-  %9 = call ptr @std.io.stdout()
-  store ptr %9, ptr %result4, align 8
-  %10 = load ptr, ptr %x2, align 8
-  %11 = call i64 @std.io.File.printn(ptr %retparam3, ptr %result4, ptr %10, i64 9)
+  %10 = call ptr @std.io.stdout()
+  store ptr %10, ptr %result4, align 8
+  %11 = load ptr, ptr %result4, align 8
+  %12 = load ptr, ptr %x2, align 8
+  %13 = call i64 @std.io.File.printn(ptr %retparam3, ptr %11, ptr %12, i64 9)
  store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var5, align 8
  br label %opt_block_cleanup7

@@ -107,15 +109,16 @@ opt_block_cleanup7:                               ; preds = %if.exit
  br label %guard_block8

 guard_block8:                                     ; preds = %opt_block_cleanup7
-  %12 = load i64, ptr %error_var5, align 8
-  ret i64 %12
+  %14 = load i64, ptr %error_var5, align 8
+  ret i64 %14

 if.exit13:                                        ; No predecessors!
  store ptr @.str.5, ptr %x14, align 8
-  %13 = call ptr @std.io.stdout()
-  store ptr %13, ptr %result16, align 8
-  %14 = load ptr, ptr %x14, align 8
-  %15 = call i64 @std.io.File.printn(ptr %retparam15, ptr %result16, ptr %14, i64 7)
+  %15 = call ptr @std.io.stdout()
+  store ptr %15, ptr %result16, align 8
+  %16 = load ptr, ptr %result16, align 8
+  %17 = load ptr, ptr %x14, align 8
+  %18 = call i64 @std.io.File.printn(ptr %retparam15, ptr %16, ptr %17, i64 7)
  ret i64 0
 }

@@ -164,8 +167,9 @@ if.exit:                                          ; preds = %and.phi
  store ptr @.str.7, ptr %x, 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 %retparam1, ptr %result, ptr %7, i64 9)
+  %7 = load ptr, ptr %result, align 8
+  %8 = load ptr, ptr %x, align 8
+  %9 = call i64 @std.io.File.printn(ptr %retparam1, ptr %7, ptr %8, i64 9)
  store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var2, align 8
  br label %opt_block_cleanup4

@@ -174,15 +178,16 @@ opt_block_cleanup4:                               ; preds = %if.exit
  br label %guard_block5

 guard_block5:                                     ; preds = %opt_block_cleanup4
-  %9 = load i64, ptr %error_var2, align 8
-  ret i64 %9
+  %10 = load i64, ptr %error_var2, align 8
+  ret i64 %10

 if.exit6:                                         ; No predecessors!
  store ptr @.str.8, ptr %x7, align 8
-  %10 = call ptr @std.io.stdout()
-  store ptr %10, ptr %result9, align 8
-  %11 = load ptr, ptr %x7, align 8
-  %12 = call i64 @std.io.File.printn(ptr %retparam8, ptr %result9, ptr %11, i64 7)
+  %11 = call ptr @std.io.stdout()
+  store ptr %11, ptr %result9, align 8
+  %12 = load ptr, ptr %result9, align 8
+  %13 = load ptr, ptr %x7, align 8
+  %14 = call i64 @std.io.File.printn(ptr %retparam8, ptr %12, ptr %13, i64 7)
  ret i64 0
 }

--- a/test/test_suite/from_docs/examples_defer.c3t
+++ b/test/test_suite/from_docs/examples_defer.c3t
@@ -32,12 +32,14 @@ if.then:                                          ; preds = %entry
  store ptr @.str, ptr %x, 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)
+  %2 = load ptr, ptr %result, align 8
+  %3 = load ptr, ptr %x, align 8
+  %4 = call i64 @std.io.File.print(ptr %retparam, ptr %2, ptr %3, i64 1)
  store ptr @.str.1, ptr %x1, align 8
-  %4 = call ptr @std.io.stdout()
-  store ptr %4, ptr %result3, align 8
-  %5 = call i64 @std.io.File.printn(ptr %retparam2, ptr %result3, ptr null, i64 0)
+  %5 = call ptr @std.io.stdout()
+  store ptr %5, ptr %result3, align 8
+  %6 = load ptr, ptr %result3, align 8
+  %7 = call i64 @std.io.File.printn(ptr %retparam2, ptr %6, ptr null, i64 0)
  ret void

 if.exit:                                          ; preds = %entry
@@ -46,41 +48,48 @@ if.exit:                                          ; preds = %entry

 if.then5:                                         ; preds = %if.exit
  store ptr @.str.2, ptr %x6, align 8
-  %6 = call ptr @std.io.stdout()
-  store ptr %6, ptr %result8, align 8
-  %7 = load ptr, ptr %x6, align 8
-  %8 = call i64 @std.io.File.print(ptr %retparam7, ptr %result8, ptr %7, i64 1)
+  %8 = call ptr @std.io.stdout()
+  store ptr %8, ptr %result8, align 8
+  %9 = load ptr, ptr %result8, align 8
+  %10 = load ptr, ptr %x6, align 8
+  %11 = call i64 @std.io.File.print(ptr %retparam7, ptr %9, ptr %10, i64 1)
  store ptr @.str.3, ptr %x9, align 8
-  %9 = call ptr @std.io.stdout()
-  store ptr %9, ptr %result11, align 8
-  %10 = load ptr, ptr %x9, align 8
-  %11 = call i64 @std.io.File.print(ptr %retparam10, ptr %result11, ptr %10, i64 1)
-  store ptr @.str.4, ptr %x12, align 8
  %12 = call ptr @std.io.stdout()
-  store ptr %12, ptr %result14, align 8
-  %13 = call i64 @std.io.File.printn(ptr %retparam13, ptr %result14, ptr null, i64 0)
+  store ptr %12, ptr %result11, align 8
+  %13 = load ptr, ptr %result11, align 8
+  %14 = load ptr, ptr %x9, align 8
+  %15 = call i64 @std.io.File.print(ptr %retparam10, ptr %13, ptr %14, i64 1)
+  store ptr @.str.4, ptr %x12, align 8
+  %16 = call ptr @std.io.stdout()
+  store ptr %16, ptr %result14, align 8
+  %17 = load ptr, ptr %result14, align 8
+  %18 = call i64 @std.io.File.printn(ptr %retparam13, ptr %17, ptr null, i64 0)
  ret void

 if.exit15:                                        ; preds = %if.exit
  store ptr @.str.5, ptr %x16, align 8
-  %14 = call ptr @std.io.stdout()
-  store ptr %14, ptr %result18, align 8
-  %15 = load ptr, ptr %x16, align 8
-  %16 = call i64 @std.io.File.print(ptr %retparam17, ptr %result18, ptr %15, i64 1)
+  %19 = call ptr @std.io.stdout()
+  store ptr %19, ptr %result18, align 8
+  %20 = load ptr, ptr %result18, align 8
+  %21 = load ptr, ptr %x16, align 8
+  %22 = call i64 @std.io.File.print(ptr %retparam17, ptr %20, ptr %21, i64 1)
  store ptr @.str.6, ptr %x19, align 8
-  %17 = call ptr @std.io.stdout()
-  store ptr %17, ptr %result21, align 8
-  %18 = load ptr, ptr %x19, align 8
-  %19 = call i64 @std.io.File.print(ptr %retparam20, ptr %result21, ptr %18, i64 1)
-  store ptr @.str.7, ptr %x22, align 8
-  %20 = call ptr @std.io.stdout()
-  store ptr %20, ptr %result24, align 8
-  %21 = load ptr, ptr %x22, align 8
-  %22 = call i64 @std.io.File.print(ptr %retparam23, ptr %result24, ptr %21, i64 1)
-  store ptr @.str.8, ptr %x25, align 8
  %23 = call ptr @std.io.stdout()
-  store ptr %23, ptr %result27, align 8
-  %24 = call i64 @std.io.File.printn(ptr %retparam26, ptr %result27, ptr null, i64 0)
+  store ptr %23, ptr %result21, align 8
+  %24 = load ptr, ptr %result21, align 8
+  %25 = load ptr, ptr %x19, align 8
+  %26 = call i64 @std.io.File.print(ptr %retparam20, ptr %24, ptr %25, i64 1)
+  store ptr @.str.7, ptr %x22, align 8
+  %27 = call ptr @std.io.stdout()
+  store ptr %27, ptr %result24, align 8
+  %28 = load ptr, ptr %result24, align 8
+  %29 = load ptr, ptr %x22, align 8
+  %30 = call i64 @std.io.File.print(ptr %retparam23, ptr %28, ptr %29, i64 1)
+  store ptr @.str.8, ptr %x25, align 8
+  %31 = call ptr @std.io.stdout()
+  store ptr %31, ptr %result27, align 8
+  %32 = load ptr, ptr %result27, align 8
+  %33 = call i64 @std.io.File.printn(ptr %retparam26, ptr %32, ptr null, i64 0)
  ret void
 }

--- a/test/test_suite/from_docs/examples_forswitch.c3t
+++ b/test/test_suite/from_docs/examples_forswitch.c3t
@@ -166,16 +166,18 @@ switch.case:                                      ; preds = %switch.entry, %swit
  store ptr @.str.1, ptr %x, 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)
+  %3 = load ptr, ptr %result, align 8
+  %4 = load ptr, ptr %x, align 8
+  %5 = call i64 @std.io.File.printn(ptr %retparam, ptr %3, ptr %4, i64 8)
  br label %switch.exit

 switch.case1:                                     ; preds = %switch.entry
  store ptr @.str.2, ptr %x2, align 8
-  %5 = call ptr @std.io.stdout()
-  store ptr %5, ptr %result4, align 8
-  %6 = load ptr, ptr %x2, align 8
-  %7 = call i64 @std.io.File.printn(ptr %retparam3, ptr %result4, ptr %6, i64 4)
+  %6 = call ptr @std.io.stdout()
+  store ptr %6, ptr %result4, align 8
+  %7 = load ptr, ptr %result4, align 8
+  %8 = load ptr, ptr %x2, align 8
+  %9 = call i64 @std.io.File.printn(ptr %retparam3, ptr %7, ptr %8, i64 4)
  br label %switch.exit

 switch.exit:                                      ; preds = %switch.case1, %switch.case, %switch.entry
@@ -183,8 +185,8 @@ switch.exit:                                      ; preds = %switch.case1, %swit
  br label %switch.entry6

 switch.entry6:                                    ; preds = %switch.exit
-  %8 = load i32, ptr %switch5, align 4
-  switch i32 %8, label %switch.exit15 [
+  %10 = load i32, ptr %switch5, align 4
+  switch i32 %10, label %switch.exit15 [
    i32 0, label %switch.case7
    i32 1, label %switch.case7
    i32 2, label %switch.case11
@@ -192,18 +194,20 @@ switch.entry6:                                    ; preds = %switch.exit

 switch.case7:                                     ; preds = %switch.entry6, %switch.entry6
  store ptr @.str.3, ptr %x8, align 8
-  %9 = call ptr @std.io.stdout()
-  store ptr %9, ptr %result10, align 8
-  %10 = load ptr, ptr %x8, align 8
-  %11 = call i64 @std.io.File.printn(ptr %retparam9, ptr %result10, ptr %10, i64 8)
+  %11 = call ptr @std.io.stdout()
+  store ptr %11, ptr %result10, align 8
+  %12 = load ptr, ptr %result10, align 8
+  %13 = load ptr, ptr %x8, align 8
+  %14 = call i64 @std.io.File.printn(ptr %retparam9, ptr %12, ptr %13, i64 8)
  br label %switch.exit15

 switch.case11:                                    ; preds = %switch.entry6
  store ptr @.str.4, ptr %x12, align 8
-  %12 = call ptr @std.io.stdout()
-  store ptr %12, ptr %result14, align 8
-  %13 = load ptr, ptr %x12, align 8
-  %14 = call i64 @std.io.File.printn(ptr %retparam13, ptr %result14, ptr %13, i64 4)
+  %15 = call ptr @std.io.stdout()
+  store ptr %15, ptr %result14, align 8
+  %16 = load ptr, ptr %result14, align 8
+  %17 = load ptr, ptr %x12, align 8
+  %18 = call i64 @std.io.File.printn(ptr %retparam13, ptr %16, ptr %17, i64 4)
  br label %switch.exit15

 switch.exit15:                                    ; preds = %switch.case11, %switch.case7, %switch.entry6
@@ -211,8 +215,8 @@ switch.exit15:                                    ; preds = %switch.case11, %swi
  br label %switch.entry17

 switch.entry17:                                   ; preds = %switch.exit15
-  %15 = load i32, ptr %switch16, align 4
-  switch i32 %15, label %switch.exit24 [
+  %19 = load i32, ptr %switch16, align 4
+  switch i32 %19, label %switch.exit24 [
    i32 0, label %switch.case18
    i32 1, label %switch.case19
    i32 2, label %switch.case23
@@ -223,10 +227,11 @@ switch.case18:                                    ; preds = %switch.entry17

 switch.case19:                                    ; preds = %switch.entry17
  store ptr @.str.5, ptr %x20, align 8
-  %16 = call ptr @std.io.stdout()
-  store ptr %16, ptr %result22, align 8
-  %17 = load ptr, ptr %x20, align 8
-  %18 = call i64 @std.io.File.printn(ptr %retparam21, ptr %result22, ptr %17, i64 6)
+  %20 = call ptr @std.io.stdout()
+  store ptr %20, ptr %result22, align 8
+  %21 = load ptr, ptr %result22, align 8
+  %22 = load ptr, ptr %x20, align 8
+  %23 = call i64 @std.io.File.printn(ptr %retparam21, ptr %21, ptr %22, i64 6)
  br label %switch.exit24

 switch.case23:                                    ; preds = %switch.entry17
@@ -237,8 +242,8 @@ switch.exit24:                                    ; preds = %switch.case23, %swi
  br label %switch.entry26

 switch.entry26:                                   ; preds = %switch.exit24
-  %19 = load i32, ptr %switch25, align 4
-  switch i32 %19, label %switch.default [
+  %24 = load i32, ptr %switch25, align 4
+  switch i32 %24, label %switch.default [
    i32 0, label %switch.case27
    i32 1, label %switch.case27
    i32 2, label %switch.case27
@@ -255,8 +260,8 @@ switch.exit28:                                    ; preds = %switch.default, %sw
  br label %switch.entry30

 switch.entry30:                                   ; preds = %switch.exit28
-  %20 = load i32, ptr %switch29, align 4
-  switch i32 %20, label %switch.exit44 [
+  %25 = load i32, ptr %switch29, align 4
+  switch i32 %25, label %switch.exit44 [
    i32 0, label %switch.case31
    i32 1, label %switch.case35
    i32 2, label %switch.case40
@@ -265,27 +270,30 @@ switch.entry30:                                   ; preds = %switch.exit28
 switch.case31:                                    ; preds = %switch.entry30
  store i32 1, ptr %a, align 4
  store ptr @.str.6, ptr %x32, align 8
-  %21 = call ptr @std.io.stdout()
-  store ptr %21, ptr %result34, align 8
-  %22 = load ptr, ptr %x32, align 8
-  %23 = call i64 @std.io.File.printn(ptr %retparam33, ptr %result34, ptr %22, i64 1)
+  %26 = call ptr @std.io.stdout()
+  store ptr %26, ptr %result34, align 8
+  %27 = load ptr, ptr %result34, align 8
+  %28 = load ptr, ptr %x32, align 8
+  %29 = call i64 @std.io.File.printn(ptr %retparam33, ptr %27, ptr %28, i64 1)
  br label %switch.case35

 switch.case35:                                    ; preds = %switch.entry30, %switch.case31
  store i32 2, ptr %a36, align 4
  store ptr @.str.7, ptr %x37, align 8
-  %24 = call ptr @std.io.stdout()
-  store ptr %24, ptr %result39, align 8
-  %25 = load ptr, ptr %x37, align 8
-  %26 = call i64 @std.io.File.printn(ptr %retparam38, ptr %result39, ptr %25, i64 1)
+  %30 = call ptr @std.io.stdout()
+  store ptr %30, ptr %result39, align 8
+  %31 = load ptr, ptr %result39, align 8
+  %32 = load ptr, ptr %x37, align 8
+  %33 = call i64 @std.io.File.printn(ptr %retparam38, ptr %31, ptr %32, i64 1)
  br label %switch.case40

 switch.case40:                                    ; preds = %switch.entry30, %switch.case35
  store ptr @.str.8, ptr %x41, align 8
-  %27 = call ptr @std.io.stdout()
-  store ptr %27, ptr %result43, align 8
-  %28 = load ptr, ptr %x41, align 8
-  %29 = call i64 @std.io.File.printn(ptr %retparam42, ptr %result43, ptr %28, i64 1)
+  %34 = call ptr @std.io.stdout()
+  store ptr %34, ptr %result43, align 8
+  %35 = load ptr, ptr %result43, align 8
+  %36 = load ptr, ptr %x41, align 8
+  %37 = call i64 @std.io.File.printn(ptr %retparam42, ptr %35, ptr %36, i64 1)
  br label %switch.exit44

 switch.exit44:                                    ; preds = %switch.case40, %switch.entry30
--- a/test/test_suite/initializer_lists/subarrays.c3t
+++ b/test/test_suite/initializer_lists/subarrays.c3t
@@ -114,57 +114,59 @@ entry:
  store ptr @.str.5, ptr %x3, 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)
-  %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)
+  %14 = load ptr, ptr %result, align 8
+  %15 = load ptr, ptr %x3, align 8
+  %16 = call i64 @std.io.File.printn(ptr %retparam, ptr %14, ptr %15, i64 6)
+  %17 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1
+  %18 = load i64, ptr %17, align 8
+  %uisitrunc = trunc i64 %18 to i32
+  %19 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0
+  %20 = load ptr, ptr %19, align 8
+  %ptroffset4 = getelementptr inbounds i32, ptr %20, i64 1
+  %21 = load i32, ptr %ptroffset4, align 4
+  %22 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %uisitrunc, i32 %21)
+  %23 = load ptr, ptr %y, align 8
+  %ptroffset5 = getelementptr inbounds i32, ptr %23, i64 1
+  %24 = load i32, ptr %ptroffset5, align 4
+  %25 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %24)
+  %26 = load ptr, ptr @subarrays.fofeo, align 8
+  %ptroffset6 = getelementptr inbounds i32, ptr %26, i64 1
+  %27 = load i32, ptr %ptroffset6, align 4
+  %28 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %27)
  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %ffe, ptr align 8 @.__const, i32 8, i1 false)
-  %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
+  %29 = getelementptr inbounds [1 x i32], ptr %azz, i64 0, i64 0
+  store i32 0, ptr %29, align 4
+  %30 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 0
+  store i32 1, ptr %30, align 4
+  %31 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 1
+  store i32 2, ptr %31, align 4
+  %32 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 2
+  store i32 3, ptr %32, align 4
+  %33 = insertvalue %"int[]" undef, ptr %literal7, 0
+  %34 = insertvalue %"int[]" %33, i64 3, 1
+  %35 = extractvalue %"int[]" %34, 1
+  %not = icmp eq i64 %35, 0
+  %36 = zext i1 %not to i8
+  store i8 %36, ptr %xy, align 1
+  %37 = load i8, ptr %xy, align 1
+  %38 = trunc i8 %37 to i1
+  %not8 = xor i1 %38, true
  br i1 %not8, label %if.then, label %if.exit

 if.then:                                          ; preds = %entry
  store ptr @.str.9, ptr %x9, align 8
-  %38 = call ptr @std.io.stdout()
-  store ptr %38, ptr %result11, align 8
-  %39 = load ptr, ptr %x9, align 8
-  %40 = call i64 @std.io.File.printn(ptr %retparam10, ptr %result11, ptr %39, i64 2)
+  %39 = call ptr @std.io.stdout()
+  store ptr %39, ptr %result11, align 8
+  %40 = load ptr, ptr %result11, align 8
+  %41 = load ptr, ptr %x9, align 8
+  %42 = call i64 @std.io.File.printn(ptr %retparam10, ptr %40, ptr %41, i64 2)
  br label %if.exit

 if.exit:                                          ; preds = %if.then, %entry
-  %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
+  %43 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 0
+  store i32 0, ptr %43, align 4
+  %44 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1
+  store i32 0, ptr %44, 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