diff --git a/lib/std/collections/linkedlist.c3 b/lib/std/collections/linkedlist.c3
index 23d77bd90..69307a3f1 100644
--- a/lib/std/collections/linkedlist.c3
+++ b/lib/std/collections/linkedlist.c3
@@ -28,12 +28,12 @@ fn void LinkedList.push_last(LinkedList* list, Type value)
 	list.link_last(value);
 }
 
-fn void LinkedList.init(LinkedList* list, Allocator* alloc = mem::current_allocator())
+fn void LinkedList.init(LinkedList* list, Allocator* alloc = mem::heap())
 {
 	*list = { .allocator = alloc };
 }
 
-fn void LinkedList.tinit(LinkedList* list) => list.init(mem::temp_allocator()) @inline;
+fn void LinkedList.tinit(LinkedList* list) => list.init(mem::temp()) @inline;
 
 /**
  * @require list.allocator
@@ -44,7 +44,7 @@ macro void LinkedList.@free_node(LinkedList &list, Node* node) @private
 }
 macro Node* LinkedList.@alloc_node(LinkedList &list) @private
 {
-	if (!list.allocator) list.allocator = mem::current_allocator();
+	if (!list.allocator) list.allocator = mem::heap();
 	return malloc(Node, .using = list.allocator);
 }
 
diff --git a/lib/std/collections/list.c3 b/lib/std/collections/list.c3
index 05184c29c..5e1852a28 100644
--- a/lib/std/collections/list.c3
+++ b/lib/std/collections/list.c3
@@ -15,7 +15,7 @@ struct List
 /**
  * @require allocator != null "A valid allocator must be provided"
  **/
-fn void List.init(List* list, usz initial_capacity = 16, Allocator* allocator = mem::current_allocator())
+fn void List.init(List* list, usz initial_capacity = 16, Allocator* allocator = mem::heap())
 {
 	list.allocator = allocator;
 	list.size = 0;
@@ -33,7 +33,7 @@ fn void List.init(List* list, usz initial_capacity = 16, Allocator* allocator =
 
 fn void List.tinit(List* list, usz initial_capacity = 16)
 {
-	list.init(initial_capacity, mem::temp_allocator()) @inline;
+	list.init(initial_capacity, mem::temp()) @inline;
 }
 
 fn void List.push(List* list, Type element) @inline
@@ -151,7 +151,7 @@ fn void List.reserve(List* list, usz min_capacity)
 {
 	if (!min_capacity) return;
 	if (list.capacity >= min_capacity) return;
-	if (!list.allocator) list.allocator = mem::current_allocator();
+	if (!list.allocator) list.allocator = mem::heap();
 	min_capacity = math::next_power_of_2(min_capacity);
     list.entries = realloc_aligned(list.entries, Type.sizeof * min_capacity, .alignment = Type[1].alignof, .using = list.allocator) ?? null;
 	list.capacity = min_capacity;
diff --git a/lib/std/collections/map.c3 b/lib/std/collections/map.c3
index 5871a333c..08e9633d6 100644
--- a/lib/std/collections/map.c3
+++ b/lib/std/collections/map.c3
@@ -22,7 +22,7 @@ struct HashMap
  * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
  * @require allocator != null "The allocator must be non-null"
  **/
-fn void HashMap.init(HashMap* map, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator* allocator = mem::current_allocator())
+fn void HashMap.init(HashMap* map, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator* allocator = mem::heap())
 {
 	capacity = math::next_power_of_2(capacity);
 	map.allocator = allocator;
@@ -39,10 +39,10 @@ fn void HashMap.init(HashMap* map, uint capacity = DEFAULT_INITIAL_CAPACITY, flo
  **/
 fn void HashMap.tinit(HashMap* map, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
 {
-	map.init(capacity, load_factor, mem::temp_allocator());
+	map.init(capacity, load_factor, mem::temp());
 }
 
-fn void HashMap.init_from_map(HashMap* map, HashMap* other_map, Allocator* allocator = mem::current_allocator())
+fn void HashMap.init_from_map(HashMap* map, HashMap* other_map, Allocator* allocator = mem::heap())
 {
 	map.init(other_map.table.len, other_map.load_factor, allocator);
 	map.put_all_for_create(other_map);
@@ -50,7 +50,7 @@ fn void HashMap.init_from_map(HashMap* map, HashMap* other_map, Allocator* alloc
 
 fn void HashMap.tinit_from_map(HashMap* map, HashMap* other_map)
 {
-	map.init_from_map(other_map, mem::temp_allocator()) @inline;
+	map.init_from_map(other_map, mem::temp()) @inline;
 }
 
 fn bool HashMap.is_empty(HashMap* map) @inline
@@ -161,10 +161,10 @@ fn void HashMap.free(HashMap* map)
 
 fn Key[] HashMap.key_tlist(HashMap* map)
 {
-	return map.key_list(mem::temp_allocator()) @inline;
+	return map.key_list(mem::temp()) @inline;
 }
 
-fn Key[] HashMap.key_list(HashMap* map, Allocator* allocator = mem::current_allocator())
+fn Key[] HashMap.key_list(HashMap* map, Allocator* allocator = mem::heap())
 {
 	if (!map.count) return Key[] {};
 
@@ -183,10 +183,10 @@ fn Key[] HashMap.key_list(HashMap* map, Allocator* allocator = mem::current_allo
 
 fn Value[] HashMap.value_tlist(HashMap* map)
 {
-	return map.value_list(mem::temp_allocator()) @inline;
+	return map.value_list(mem::temp()) @inline;
 }
 
-fn Value[] HashMap.value_list(HashMap* map, Allocator* allocator = mem::current_allocator())
+fn Value[] HashMap.value_list(HashMap* map, Allocator* allocator = mem::heap())
 {
 	if (!map.count) return Value[] {};
 	Value[] list = calloc(Value, map.count, .using = allocator);
diff --git a/lib/std/core/allocators/dynamic_arena.c3 b/lib/std/core/allocators/dynamic_arena.c3
index 56e02b222..cb2331fdb 100644
--- a/lib/std/core/allocators/dynamic_arena.c3
+++ b/lib/std/core/allocators/dynamic_arena.c3
@@ -13,7 +13,7 @@ struct DynamicArenaAllocator
  * @require page_size >= 128
  * @require this != null
  **/
-fn void DynamicArenaAllocator.init(DynamicArenaAllocator* this, usz page_size, Allocator* backing_allocator = mem::current_allocator())
+fn void DynamicArenaAllocator.init(DynamicArenaAllocator* this, usz page_size, Allocator* backing_allocator = mem::heap())
 {
 	this.function = &dynamic_arena_allocator_function;
 	this.page = null;
diff --git a/lib/std/core/dstring.c3 b/lib/std/core/dstring.c3
index e6923f0d5..25d8ffd64 100644
--- a/lib/std/core/dstring.c3
+++ b/lib/std/core/dstring.c3
@@ -7,7 +7,7 @@ const usz MIN_CAPACITY @private = 16;
 /**
  * @require !str.data() "String already initialized"
  **/
-fn void DString.init(DString *str, usz capacity = MIN_CAPACITY, Allocator* allocator = mem::current_allocator())
+fn void DString.init(DString *str, usz capacity = MIN_CAPACITY, Allocator* allocator = mem::heap())
 {
 	if (capacity < MIN_CAPACITY) capacity = MIN_CAPACITY;
 	StringData* data = malloc(StringData, 1, .using = allocator, .end_padding = capacity);
@@ -20,18 +20,18 @@ fn void DString.init(DString *str, usz capacity = MIN_CAPACITY, Allocator* alloc
 /**
  * @require !str.data() "String already initialized"
  **/
-fn void DString.tinit(DString *str, usz capacity = MIN_CAPACITY) => str.init(capacity, mem::temp_allocator()) @inline;
+fn void DString.tinit(DString *str, usz capacity = MIN_CAPACITY) => str.init(capacity, mem::temp()) @inline;
 
-fn DString new_with_capacity(usz capacity, Allocator* allocator = mem::current_allocator())
+fn DString new_with_capacity(usz capacity, Allocator* allocator = mem::heap())
 {
 	DString dstr;
 	dstr.init(capacity, allocator);
 	return dstr;
 }
 
-fn DString tnew_with_capacity(usz capacity) => new_with_capacity(capacity, mem::temp_allocator()) @inline;
+fn DString tnew_with_capacity(usz capacity) => new_with_capacity(capacity, mem::temp()) @inline;
 
-fn DString new(String c = "", Allocator* allocator = mem::current_allocator())
+fn DString new(String c = "", Allocator* allocator = mem::heap())
 {
 	usz len = c.len;
 	StringData* data = (StringData*)new_with_capacity(len, allocator);
@@ -43,9 +43,9 @@ fn DString new(String c = "", Allocator* allocator = mem::current_allocator())
 	return (DString)data;
 }
 
-fn DString tnew(String s = "") => new(s, mem::temp_allocator()) @inline;
+fn DString tnew(String s = "") => new(s, mem::temp()) @inline;
 
-fn DString DString.new_concat(DString a, DString b, Allocator* allocator = mem::current_allocator())
+fn DString DString.new_concat(DString a, DString b, Allocator* allocator = mem::heap())
 {
 	DString string;
 	string.init(a.len() + b.len(), allocator);
@@ -54,7 +54,7 @@ fn DString DString.new_concat(DString a, DString b, Allocator* allocator = mem::
 	return string;
 }
 
-fn DString DString.new_tconcat(DString a, DString b) => a.new_concat(b, mem::temp_allocator());
+fn DString DString.new_tconcat(DString a, DString b) => a.new_concat(b, mem::temp());
 
 fn ZString DString.zstr(DString str)
 {
@@ -165,7 +165,7 @@ fn void DString.append_char32(DString* str, Char32 c)
     data.chars[data.len++] = (char)(0x80 | (c & 0x3F));
 }
 
-fn DString DString.tcopy(DString* str) => str.copy(mem::temp_allocator());
+fn DString DString.tcopy(DString* str) => str.copy(mem::temp());
 
 fn DString DString.copy(DString* str, Allocator* allocator = null)
 {
@@ -174,14 +174,14 @@ fn DString DString.copy(DString* str, Allocator* allocator = null)
 		if (allocator) return new_with_capacity(0, allocator);
 		return (DString)null;
 	}
-	if (!allocator) allocator = mem::current_allocator();
+	if (!allocator) allocator = mem::heap();
 	StringData* data = str.data();
 	DString new_string = new_with_capacity(data.capacity, allocator);
 	mem::copy((char*)new_string.data(), (char*)data, StringData.sizeof + data.len);
 	return new_string;
 }
 
-fn ZString DString.copy_zstr(DString* str, Allocator* allocator = mem::current_allocator())
+fn ZString DString.copy_zstr(DString* str, Allocator* allocator = mem::heap())
 {
 	usz str_len = str.len();
 	if (!str_len)
@@ -195,12 +195,12 @@ fn ZString DString.copy_zstr(DString* str, Allocator* allocator = mem::current_a
 	return (ZString)zstr;
 }
 
-fn String DString.copy_str(DString* str, Allocator* allocator = mem::current_allocator())
+fn String DString.copy_str(DString* str, Allocator* allocator = mem::heap())
 {
 	return (String)str.copy_zstr(allocator)[:str.len()];
 }
 
-fn String DString.tcopy_str(DString* str) => str.copy_str(mem::temp_allocator()) @inline;
+fn String DString.tcopy_str(DString* str) => str.copy_str(mem::temp()) @inline;
 
 fn bool DString.equals(DString str, DString other_string)
 {
@@ -259,7 +259,7 @@ fn void DString.append_chars(DString* this, String str)
 	data.len += other_len;
 }
 
-fn Char32[] DString.copy_utf32(DString* this, Allocator* allocator = mem::current_allocator())
+fn Char32[] DString.copy_utf32(DString* this, Allocator* allocator = mem::heap())
 {
 	return str::utf8to32(this.str(), allocator) @inline!!;
 }
@@ -329,7 +329,7 @@ fn usz! DString.printfn(DString* str, String format, args...) @maydiscard
 	return len + 1;
 }
 
-fn DString new_join(String[] s, String joiner, Allocator* allocator = mem::current_allocator())
+fn DString new_join(String[] s, String joiner, Allocator* allocator = mem::heap())
 {
 	if (!s.len) return (DString)null;
 	usz total_size = joiner.len * s.len;
diff --git a/lib/std/core/mem.c3 b/lib/std/core/mem.c3
index 18b49a006..ce55c7b6b 100644
--- a/lib/std/core/mem.c3
+++ b/lib/std/core/mem.c3
@@ -195,7 +195,7 @@ macro type_alloc_must_be_aligned($Type)
  * @require $vacount > 0 && $vacount < 3 "Expected size, type, or type + len"
  * @require $vacount != 2 || $checks($vatype(0).sizeof) "Expected 'malloc(Foo, 12)'"
  **/
-macro malloc(..., Allocator* using = mem::thread_allocator, usz end_padding = 0) @builtin
+macro malloc(..., Allocator* using = mem::heap(), usz end_padding = 0) @builtin
 {
 	return malloc_checked($vasplat(), .using = using, .end_padding = end_padding)!!;
 }
@@ -204,7 +204,7 @@ macro malloc(..., Allocator* using = mem::thread_allocator, usz end_padding = 0)
  * @require $vacount > 0 && $vacount < 3 "Expected size, type, or type + len"
  * @require $vacount != 2 || $checks($vatype(0).sizeof) "Expected 'malloc(Foo, 12)'"
  **/
-macro malloc_checked(..., Allocator* using = mem::thread_allocator, usz end_padding = 0) @builtin
+macro malloc_checked(..., Allocator* using = mem::heap(), usz end_padding = 0) @builtin
 {
 	$if ($checks($vatype(0).sizeof)):
 		var $Type = $vatype(0);
@@ -226,7 +226,7 @@ macro malloc_checked(..., Allocator* using = mem::thread_allocator, usz end_padd
  * @require $vacount != 2 || $checks($vatype(0).sizeof) "Expected 'malloc(Foo, 12)'"
  * @require alignment && math::is_power_of_2(alignment)
  **/
-macro malloc_aligned(..., usz alignment = 0, usz end_padding = 0, Allocator* using = mem::thread_allocator) @builtin
+macro malloc_aligned(..., usz alignment = 0, usz end_padding = 0, Allocator* using = mem::heap()) @builtin
 {
 	$if ($checks($vatype(0).sizeof)):
 		var $Type = $vatype(0);
@@ -249,7 +249,7 @@ macro char[] alloc_bytes(usz bytes) @deprecated => malloc(char, bytes);
  * @require $vacount > 0 && $vacount < 3 "Expected size, type, or type + len"
  * @require $vacount != 2 || $checks($vatype(0).sizeof) "Expected 'malloc(Foo, 12)'"
  **/
-macro calloc(..., Allocator* using = mem::thread_allocator, usz end_padding = 0) @builtin
+macro calloc(..., Allocator* using = mem::heap(), usz end_padding = 0) @builtin
 {
 	return calloc_checked($vasplat(), .using = using, .end_padding = end_padding)!!;
 }
@@ -258,7 +258,7 @@ macro calloc(..., Allocator* using = mem::thread_allocator, usz end_padding = 0)
  * @require $vacount > 0 && $vacount < 3 "Expected size, type, or type + len"
  * @require $vacount != 2 || $checks($vatype(0).sizeof) "Expected 'malloc(Foo, 12)'"
  **/
-macro calloc_checked(..., Allocator* using = mem::thread_allocator, usz end_padding = 0) @builtin
+macro calloc_checked(..., Allocator* using = mem::heap(), usz end_padding = 0) @builtin
 {
 	$if ($checks($vatype(0).sizeof)):
 		var $Type = $vatype(0);
@@ -280,7 +280,7 @@ macro calloc_checked(..., Allocator* using = mem::thread_allocator, usz end_padd
  * @require $vacount != 2 || $checks($vatype(0).sizeof) "Expected 'malloc(Foo, 12)'"
  * @require alignment && math::is_power_of_2(alignment)
  **/
-macro calloc_aligned(..., usz alignment = 0, Allocator* using = mem::thread_allocator, usz end_padding = 0) @builtin
+macro calloc_aligned(..., usz alignment = 0, Allocator* using = mem::heap(), usz end_padding = 0) @builtin
 {
 	$if ($checks($vatype(0).sizeof)):
 		var $Type = $vatype(0);
@@ -295,12 +295,12 @@ macro calloc_aligned(..., usz alignment = 0, Allocator* using = mem::thread_allo
 	$endif;
 }
 
-fn void* realloc(void *ptr, usz new_size, Allocator* using = mem::thread_allocator) @builtin @inline
+fn void* realloc(void *ptr, usz new_size, Allocator* using = mem::heap()) @builtin @inline
 {
 	return using.realloc(ptr, new_size)!!;
 }
 
-fn void*! realloc_checked(void *ptr, usz new_size, Allocator* using = mem::thread_allocator) @builtin @inline
+fn void*! realloc_checked(void *ptr, usz new_size, Allocator* using = mem::heap()) @builtin @inline
 {
 	return using.realloc(ptr, new_size);
 }
@@ -308,15 +308,15 @@ fn void*! realloc_checked(void *ptr, usz new_size, Allocator* using = mem::threa
 /**
  * @require alignment && math::is_power_of_2(alignment)
  */
-fn void*! realloc_aligned(void *ptr, usz new_size, usz alignment, Allocator* using = mem::thread_allocator) @builtin @inline
+fn void*! realloc_aligned(void *ptr, usz new_size, usz alignment, Allocator* using = mem::heap()) @builtin @inline
 {
 	return using.realloc_aligned(ptr, new_size, alignment);
 }
 
-macro void free(void* ptr, Allocator* using = mem::thread_allocator) @builtin => using.free(ptr)!!;
-macro void! free_checked(void* ptr, Allocator* using = mem::thread_allocator) @builtin => using.free(ptr);
-macro void free_aligned(void* ptr, Allocator* using = mem::thread_allocator) @builtin => using.free_aligned(ptr)!!;
-macro void! free_aligned_checked(void* ptr, Allocator* using = mem::thread_allocator) @builtin => using.free_aligned(ptr);
+macro void free(void* ptr, Allocator* using = mem::heap()) @builtin => using.free(ptr)!!;
+macro void! free_checked(void* ptr, Allocator* using = mem::heap()) @builtin => using.free(ptr);
+macro void free_aligned(void* ptr, Allocator* using = mem::heap()) @builtin => using.free_aligned(ptr)!!;
+macro void! free_aligned_checked(void* ptr, Allocator* using = mem::heap()) @builtin => using.free_aligned(ptr);
 
 /**
  * Run with a specific allocator inside of the macro body.
@@ -385,7 +385,9 @@ macro void @pool(;@body) @builtin
 tlocal Allocator* thread_allocator @private = allocator::LIBC_ALLOCATOR;
 tlocal TempAllocator* thread_temp_allocator @private = null;
 
-macro TempAllocator* temp_allocator()
+macro TempAllocator* temp_allocator() => temp();
+
+macro TempAllocator* temp()
 {
 	if (!thread_temp_allocator)
 	{
@@ -403,10 +405,8 @@ macro TempAllocator* temp_allocator()
 	return thread_temp_allocator;
 }
 
-macro Allocator* current_allocator()
-{
-	return thread_allocator;
-}
+macro Allocator* current_allocator() => thread_allocator;
+macro Allocator* heap() => thread_allocator;
 
 $if (!env::COMPILER_LIBC_AVAILABLE && env::ARCH_TYPE == ArchType.WASM32 || env::ARCH_TYPE == ArchType.WASM64):
 
diff --git a/lib/std/core/mem_array.c3 b/lib/std/core/mem_array.c3
index fd2418d67..85ad1e0fe 100644
--- a/lib/std/core/mem_array.c3
+++ b/lib/std/core/mem_array.c3
@@ -17,7 +17,7 @@ macro talloc($Type, usz elements) @deprecated => tmalloc($Type, elements);
 /**
  * @require (usz.max / elements > $Type.sizeof)
  **/
-macro make($Type, usz elements, Allocator* allocator = mem::current_allocator()) @deprecated
+macro make($Type, usz elements, Allocator* allocator = mem::heap()) @deprecated
 {
 	return calloc($Type, elements, .using = allocator);
 }
diff --git a/lib/std/core/str.c3 b/lib/std/core/str.c3
index d386d5338..c0c84271e 100644
--- a/lib/std/core/str.c3
+++ b/lib/std/core/str.c3
@@ -161,9 +161,9 @@ fn bool starts_with(String s, String needle)
 	return true;
 }
 
-fn String[] tsplit(String s, String needle) => split(s, needle, mem::temp_allocator()) @inline;
+fn String[] tsplit(String s, String needle) => split(s, needle, mem::temp()) @inline;
 
-fn String[] split(String s, String needle, Allocator* allocator = mem::current_allocator())
+fn String[] split(String s, String needle, Allocator* allocator = mem::heap())
 {
 	usz capacity = 16;
 	usz i = 0;
@@ -244,12 +244,12 @@ 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 String.zstrcopy(String s, Allocator* allocator = mem::heap()) => copy_zstring(s, allocator) @inline;
+fn ZString String.zstrtcopy(String s) => copy_zstring(s, mem::temp()) @inline;
+fn String String.copyz(String s, Allocator* allocator = mem::heap()) => copyz(s, allocator) @inline;
+fn String String.tcopyz(String s) => copyz(s, mem::temp()) @inline;
 
-fn ZString copy_zstring(String s, Allocator* allocator = mem::current_allocator())
+fn ZString copy_zstring(String s, Allocator* allocator = mem::heap())
 {
     usz len = s.len;
     char* str = malloc(len + 1, .using = allocator);
@@ -259,7 +259,7 @@ fn ZString copy_zstring(String s, Allocator* allocator = mem::current_allocator(
 }
 
 
-fn String copyz(String s, Allocator* allocator = mem::current_allocator())
+fn String copyz(String s, Allocator* allocator = mem::heap())
 {
     usz len = s.len;
     char* str = malloc(len + 1, .using = allocator);
@@ -270,7 +270,7 @@ fn String copyz(String s, Allocator* allocator = mem::current_allocator())
 
 fn ZString tcopy_zstring(String s)
 {
-	return copy_zstring(s, mem::temp_allocator());
+	return copy_zstring(s, mem::temp());
 }
 
 fn bool compare(String a, String b)
@@ -299,7 +299,7 @@ fn usz utf8_codepoints(String utf8)
 	return len;
 }
 
-fn Char32[]! utf8to32(String utf8, Allocator* allocator = mem::current_allocator())
+fn Char32[]! utf8to32(String utf8, Allocator* allocator = mem::heap())
 {
 	usz codepoints = conv::utf8_codepoints(utf8);
 	Char32* data = malloc_checked(Char32, codepoints + 1, .using = allocator)?;
@@ -308,7 +308,7 @@ fn Char32[]! utf8to32(String utf8, Allocator* allocator = mem::current_allocator
 	return data[:codepoints];
 }
 
-fn String utf32to8(Char32[] utf32, Allocator* allocator = mem::current_allocator())
+fn String utf32to8(Char32[] utf32, Allocator* allocator = mem::heap())
 {
 	usz len = conv::utf8len_for_utf32(utf32);
 	char* data = malloc_checked(len + 1, .using = allocator)!!;
@@ -317,7 +317,7 @@ fn String utf32to8(Char32[] utf32, Allocator* allocator = mem::current_allocator
 	return data[:len];
 }
 
-fn Char16[]! utf8to16(String utf8, Allocator* allocator = mem::current_allocator())
+fn Char16[]! utf8to16(String utf8, Allocator* allocator = mem::heap())
 {
 	usz len16 = conv::utf16len_for_utf8(utf8);
 	Char16* data = malloc_checked(Char16, len16 + 1, .using = allocator)?;
@@ -327,7 +327,7 @@ fn Char16[]! utf8to16(String utf8, Allocator* allocator = mem::current_allocator
 }
 
 
-fn String! utf16to8(Char16[] utf16, Allocator* allocator = mem::current_allocator())
+fn String! utf16to8(Char16[] utf16, Allocator* allocator = mem::heap())
 {
 	usz len = conv::utf8len_for_utf16(utf16);
 	char* data = malloc_checked(len + 1, .using = allocator)?;
@@ -336,7 +336,7 @@ fn String! utf16to8(Char16[] utf16, Allocator* allocator = mem::current_allocato
 	return data[:len];
 }
 
-	fn String copy(String s, Allocator* allocator = mem::current_allocator())
+	fn String copy(String s, Allocator* allocator = mem::heap())
 {
     usz len = s.len;
     ZString str_copy = copy_zstring(s, allocator) @inline;
diff --git a/lib/std/core/string.c3 b/lib/std/core/string.c3
index a995c240d..d12c5a2ad 100644
--- a/lib/std/core/string.c3
+++ b/lib/std/core/string.c3
@@ -9,7 +9,7 @@ typedef Text = VarString;
 
 const usz MIN_CAPACITY = 16;
 
-fn VarString new_with_capacity(usz capacity, Allocator* allocator = mem::current_allocator())
+fn VarString new_with_capacity(usz capacity, Allocator* allocator = mem::heap())
 {
 	if (capacity < MIN_CAPACITY) capacity = MIN_CAPACITY;
 	StringData* data = malloc(StringData, 1, .using = allocator, .end_padding = capacity);
@@ -141,7 +141,7 @@ fn void VarString.append_char32(VarString* str, Char32 c)
     data.chars[data.len++] = (char)(0x80 | (c & 0x3F));
 }
 
-fn VarString VarString.tcopy(VarString* str) => str.copy(mem::temp_allocator());
+fn VarString VarString.tcopy(VarString* str) => str.copy(mem::temp());
 
 fn VarString VarString.copy(VarString* str, Allocator* allocator = null)
 {
@@ -150,14 +150,14 @@ fn VarString VarString.copy(VarString* str, Allocator* allocator = null)
 		if (allocator) return new_with_capacity(0, allocator);
 		return (VarString)null;
 	}
-	if (!allocator) allocator = mem::current_allocator();
+	if (!allocator) allocator = mem::heap();
 	StringData* data = str.data();
 	VarString new_string = new_with_capacity(data.capacity, allocator);
 	mem::copy((char*)new_string.data(), (char*)data, StringData.sizeof + data.len);
 	return new_string;
 }
 
-fn ZString VarString.copy_zstr(VarString* str, Allocator* allocator = mem::current_allocator())
+fn ZString VarString.copy_zstr(VarString* str, Allocator* allocator = mem::heap())
 {
 	usz str_len = str.len();
 	if (!str_len)
@@ -171,12 +171,12 @@ fn ZString VarString.copy_zstr(VarString* str, Allocator* allocator = mem::curre
 	return (ZString)zstr;
 }
 
-fn String VarString.copy_str(VarString* str, Allocator* allocator = mem::current_allocator())
+fn String VarString.copy_str(VarString* str, Allocator* allocator = mem::heap())
 {
 	return (String)str.copy_zstr(allocator)[:str.len()];
 }
 
-fn String VarString.tcopy_str(VarString* str) => str.copy_str(mem::temp_allocator()) @inline;
+fn String VarString.tcopy_str(VarString* str) => str.copy_str(mem::temp()) @inline;
 
 fn bool VarString.equals(VarString str, VarString other_string)
 {
@@ -235,7 +235,7 @@ fn void VarString.append_chars(VarString* this, String str)
 	data.len += other_len;
 }
 
-fn Char32[] VarString.copy_utf32(VarString* this, Allocator* allocator = mem::current_allocator())
+fn Char32[] VarString.copy_utf32(VarString* this, Allocator* allocator = mem::heap())
 {
 	return str::utf8to32(this.str(), allocator) @inline!!;
 }
@@ -309,7 +309,7 @@ fn void VarString.reserve(VarString* str, usz addition) @private
 	*str = (VarString)realloc(data, StringData.sizeof + new_capacity, .using = data.allocator);
 }
 
-fn VarString VarString.new_concat(VarString a, VarString b, Allocator* allocator = mem::current_allocator())
+fn VarString VarString.new_concat(VarString a, VarString b, Allocator* allocator = mem::heap())
 {
 	VarString string = new_with_capacity(a.len() + b.len(), allocator);
 	string.append(a);
diff --git a/lib/std/io/dir.c3 b/lib/std/io/dir.c3
index 30420bcf3..8c412b5ab 100644
--- a/lib/std/io/dir.c3
+++ b/lib/std/io/dir.c3
@@ -17,7 +17,7 @@ fn String! getcwd(Allocator* allocator = mem::default_allocator())
 
 fn String! tgetcwd()
 {
-	return getcwd(mem::temp_allocator()) @inline;
+	return getcwd(mem::temp()) @inline;
 }
 
 macro bool is_separator(char c)
diff --git a/lib/std/io/io_file.c3 b/lib/std/io/io_file.c3
index 3010af629..38720170e 100644
--- a/lib/std/io/io_file.c3
+++ b/lib/std/io/io_file.c3
@@ -131,7 +131,7 @@ fn usz! File.println(File file, String string) => file.printn(string);
  * @param [&in] file
  * @require file.file `File must be initialized`
  */
-fn DString File.getline(File* file, Allocator* allocator = mem::current_allocator())
+fn DString File.getline(File* file, Allocator* allocator = mem::heap())
 {
 	DString s = dstring::new_with_capacity(120, allocator);
 	while (!file.eof())
@@ -151,7 +151,7 @@ fn DString File.getline(File* file, Allocator* allocator = mem::current_allocato
  */
 fn String File.tgetline(File* file)
 {
-	return file.getline(mem::temp_allocator()).zstr().as_str();
+	return file.getline(mem::temp()).zstr().as_str();
 }
 
 fn char! File.getc(File* file)
diff --git a/lib/std/io/io_printf.c3 b/lib/std/io/io_printf.c3
index cb9492313..887072efa 100644
--- a/lib/std/io/io_printf.c3
+++ b/lib/std/io/io_printf.c3
@@ -193,7 +193,7 @@ macro bool! Formatter.print_with_function(Formatter* this, variant arg)
 		}
 		@pool()
 		{
-			this.out_substr(to_string(arg.ptr, mem::temp_allocator()))?;
+			this.out_substr(to_string(arg.ptr, mem::temp()))?;
 			return true;
 		};
     }
diff --git a/lib/std/io/os/file.c3 b/lib/std/io/os/file.c3
index 26555e495..6fd8bec74 100644
--- a/lib/std/io/os/file.c3
+++ b/lib/std/io/os/file.c3
@@ -46,8 +46,8 @@ $else:
 	{
 	$if (env::os_is_win32()):
 		CFile file = (CFile)_wfopen(
-			str::utf8to16(filename, mem::temp_allocator())!!,
-			str::utf8to16(mode, mem::temp_allocator())!!);
+			str::utf8to16(filename, mem::temp())!!,
+			str::utf8to16(mode, mem::temp())!!);
 	$else:
 		CFile file = libc::fopen(filename.zstrtcopy(), mode.zstrtcopy());
 	$endif;
@@ -70,8 +70,8 @@ $else:
 	{
 	$if (env::os_is_win32()):
 		file = (CFile)_wfreopen(
-			str::utf8to16(filename, mem::temp_allocator())!!,
-			str::utf8to16(mode, mem::temp_allocator())!!,
+			str::utf8to16(filename, mem::temp())!!,
+			str::utf8to16(mode, mem::temp())!!,
 			file);
 	$else:
 		file = libc::freopen(filename.zstrtcopy(), mode.zstrtcopy(), file);
diff --git a/lib/std/io/stream/bytewriter.c3 b/lib/std/io/stream/bytewriter.c3
index fe1c9d1c4..12a8bd93d 100644
--- a/lib/std/io/stream/bytewriter.c3
+++ b/lib/std/io/stream/bytewriter.c3
@@ -13,7 +13,7 @@ struct ByteWriter
  * @require writer.bytes.len == 0 "Init may not run on on already initialized data"
  * @ensure allocator != null, index == 0
  **/
-fn void ByteWriter.init(ByteWriter* writer, Allocator* allocator = mem::current_allocator())
+fn void ByteWriter.init(ByteWriter* writer, Allocator* allocator = mem::heap())
 {
 	*writer = { .bytes = {}, .allocator = allocator };
 }
@@ -25,7 +25,7 @@ fn void ByteWriter.init(ByteWriter* writer, Allocator* allocator = mem::current_
  **/
 fn void ByteWriter.tinit(ByteWriter* writer)
 {
-	*writer = { .bytes = {}, .allocator = mem::temp_allocator() };
+	*writer = { .bytes = {}, .allocator = mem::temp() };
 }
 
 fn Stream ByteWriter.as_stream(ByteWriter* writer)
diff --git a/lib/std/net/inetaddr.c3 b/lib/std/net/inetaddr.c3
index aa21e300d..b739efea7 100644
--- a/lib/std/net/inetaddr.c3
+++ b/lib/std/net/inetaddr.c3
@@ -54,7 +54,7 @@ fn void! InetAddress.to_format(InetAddress* addr, Formatter* formatter)
 	formatter.printf("%d.%d.%d.%d", addr.ipv4.a, addr.ipv4.b, addr.ipv4.c, addr.ipv4.d)?;
 }
 
-fn String! InetAddress.to_string(InetAddress* addr, Allocator* allocator = mem::current_allocator())
+fn String! InetAddress.to_string(InetAddress* addr, Allocator* allocator = mem::heap())
 {
 	if (addr.is_ipv6)
 	{
diff --git a/lib/std/net/net.c3 b/lib/std/net/net.c3
index 8ad8b4761..e12f8372b 100644
--- a/lib/std/net/net.c3
+++ b/lib/std/net/net.c3
@@ -37,7 +37,7 @@ fn uint! ipv4toint(String s)
 	return out;
 }
 
-fn String! inttoipv4(uint val, Allocator* allocator = mem::current_allocator())
+fn String! inttoipv4(uint val, Allocator* allocator = mem::heap())
 {
 	char[3 * 4 + 3 + 1] buffer;
 	String res = (String)io::bprintf(&buffer, "%d.%d.%d.%d", val >> 24, (val >> 16) & 0xFF, (val >> 8) & 0xFF, val & 0xFF)?;
diff --git a/lib/std/os/macos/objc.c3 b/lib/std/os/macos/objc.c3
index 2b53922e5..085b66e8f 100644
--- a/lib/std/os/macos/objc.c3
+++ b/lib/std/os/macos/objc.c3
@@ -28,7 +28,7 @@ macro Class! class_by_name(char* c)
 	return cls;
 }
 
-macro Class[] class_get_list(Allocator *allocator = mem::current_allocator())
+macro Class[] class_get_list(Allocator *allocator = mem::heap())
 {
 	int num_classes = _macos_objc_getClassList(null, 0);
 	if (!num_classes) return {};
diff --git a/resources/testfragments/allocators_testing.c3 b/resources/testfragments/allocators_testing.c3
index 4259a9ca4..d04efda13 100644
--- a/resources/testfragments/allocators_testing.c3
+++ b/resources/testfragments/allocators_testing.c3
@@ -9,7 +9,7 @@ enum Foo
 
 fn void print_pages()
 {
-	mem::temp_allocator().print_pages(io::stdout());
+	mem::temp().print_pages(io::stdout());
 }
 
 fn void setstring(char* dst, String str)
@@ -73,8 +73,8 @@ fn void main()
 	{
 		io::printf("Talloc: %p\n", (void*)tmalloc(22));
 	};
-	testAllocator(mem::temp_allocator(), 126);
-	testAllocator(mem::temp_allocator(), 12600);
+	testAllocator(mem::temp(), 126);
+	testAllocator(mem::temp(), 12600);
 	ArenaAllocator aa;
 	aa.init(&&char[1024] {});
 	testAllocator(&aa, 126);
diff --git a/src/version.h b/src/version.h
index 5b12e8168..406170cd8 100644
--- a/src/version.h
+++ b/src/version.h
@@ -1 +1 @@
-#define COMPILER_VERSION "0.4.98"
\ No newline at end of file
+#define COMPILER_VERSION "0.4.99"
\ No newline at end of file
diff --git a/test/test_suite/errors/error_regression_2.c3t b/test/test_suite/errors/error_regression_2.c3t
index 2ccdecc7f..5ec61fb1a 100644
--- a/test/test_suite/errors/error_regression_2.c3t
+++ b/test/test_suite/errors/error_regression_2.c3t
@@ -273,72 +273,72 @@ entry:
   %temp = alloca ptr, align 8
   %using = alloca ptr, align 8
   %end_padding = alloca i64, align 8
-  %error_var12 = alloca i64, align 8
-  %using13 = alloca ptr, align 8
-  %end_padding14 = alloca i64, align 8
+  %error_var13 = alloca i64, align 8
+  %using14 = alloca ptr, align 8
+  %end_padding15 = alloca i64, align 8
   %.anon = alloca i64, align 8
-  %blockret15 = alloca ptr, align 8
+  %blockret16 = alloca ptr, align 8
   %retparam = alloca ptr, align 8
-  %reterr23 = alloca i64, align 8
-  %literal24 = alloca %Doc, align 8
-  %error_var25 = alloca i64, align 8
-  %value26 = alloca %Head, align 8
-  %literal27 = alloca %Head, align 8
-  %error_var28 = alloca i64, align 8
-  %value29 = alloca %"char[]", align 8
-  %temp30 = alloca ptr, align 8
-  %using31 = alloca ptr, align 8
-  %end_padding32 = alloca i64, align 8
-  %error_var34 = alloca i64, align 8
-  %using35 = alloca ptr, align 8
-  %end_padding36 = alloca i64, align 8
-  %.anon37 = alloca i64, align 8
-  %blockret38 = alloca ptr, align 8
-  %retparam39 = alloca ptr, align 8
-  %temp52 = alloca ptr, align 8
-  %using53 = alloca ptr, align 8
-  %end_padding54 = alloca i64, align 8
-  %error_var56 = alloca i64, align 8
-  %using57 = alloca ptr, align 8
-  %end_padding58 = alloca i64, align 8
-  %.anon59 = alloca i64, align 8
-  %blockret60 = alloca ptr, align 8
-  %retparam61 = alloca ptr, align 8
+  %reterr24 = alloca i64, align 8
+  %literal25 = alloca %Doc, align 8
+  %error_var26 = alloca i64, align 8
+  %value27 = alloca %Head, align 8
+  %literal28 = alloca %Head, align 8
+  %error_var29 = alloca i64, align 8
+  %value30 = alloca %"char[]", align 8
+  %temp31 = alloca ptr, align 8
+  %using32 = alloca ptr, align 8
+  %end_padding34 = alloca i64, align 8
+  %error_var36 = alloca i64, align 8
+  %using37 = alloca ptr, align 8
+  %end_padding38 = alloca i64, align 8
+  %.anon39 = alloca i64, align 8
+  %blockret40 = alloca ptr, align 8
+  %retparam41 = alloca ptr, align 8
+  %temp54 = alloca ptr, align 8
+  %using55 = alloca ptr, align 8
+  %end_padding57 = alloca i64, align 8
+  %error_var59 = alloca i64, align 8
+  %using60 = alloca ptr, align 8
+  %end_padding61 = alloca i64, align 8
+  %.anon62 = alloca i64, align 8
+  %blockret63 = alloca ptr, align 8
+  %retparam64 = alloca ptr, align 8
   %len = alloca i32, align 4
   %str = alloca ptr, align 8
-  %using75 = alloca ptr, align 8
-  %end_padding76 = alloca i64, align 8
-  %error_var77 = alloca i64, align 8
   %using78 = alloca ptr, align 8
   %end_padding79 = alloca i64, align 8
-  %.anon80 = alloca i32, align 4
-  %blockret82 = alloca ptr, align 8
-  %retparam83 = alloca ptr, align 8
-  %reterr97 = alloca i64, align 8
-  %literal98 = alloca %Doc, align 8
-  %error_var99 = alloca i64, align 8
-  %value100 = alloca %Head, align 8
-  %literal101 = alloca %Head, align 8
+  %error_var80 = alloca i64, align 8
+  %using81 = alloca ptr, align 8
+  %end_padding82 = alloca i64, align 8
+  %.anon83 = alloca i32, align 4
+  %blockret85 = alloca ptr, align 8
+  %retparam86 = alloca ptr, align 8
+  %reterr100 = alloca i64, align 8
+  %literal101 = alloca %Doc, align 8
   %error_var102 = alloca i64, align 8
-  %value103 = alloca %"char[]", align 8
-  %temp106 = alloca ptr, align 8
-  %using107 = alloca ptr, align 8
-  %end_padding108 = alloca i64, align 8
-  %error_var110 = alloca i64, align 8
-  %using111 = alloca ptr, align 8
+  %value103 = alloca %Head, align 8
+  %literal104 = alloca %Head, align 8
+  %error_var105 = alloca i64, align 8
+  %value106 = alloca %"char[]", align 8
+  %temp109 = alloca ptr, align 8
+  %using110 = alloca ptr, align 8
   %end_padding112 = alloca i64, align 8
-  %.anon113 = alloca i64, align 8
-  %blockret114 = alloca ptr, align 8
-  %retparam115 = alloca ptr, align 8
-  %temp128 = alloca ptr, align 8
-  %using129 = alloca ptr, align 8
-  %end_padding130 = alloca i64, align 8
-  %error_var132 = alloca i64, align 8
+  %error_var114 = alloca i64, align 8
+  %using115 = alloca ptr, align 8
+  %end_padding116 = alloca i64, align 8
+  %.anon117 = alloca i64, align 8
+  %blockret118 = alloca ptr, align 8
+  %retparam119 = alloca ptr, align 8
+  %temp132 = alloca ptr, align 8
   %using133 = alloca ptr, align 8
-  %end_padding134 = alloca i64, align 8
-  %.anon135 = alloca i64, align 8
-  %blockret136 = alloca ptr, align 8
-  %retparam137 = alloca ptr, align 8
+  %end_padding135 = alloca i64, align 8
+  %error_var137 = alloca i64, align 8
+  %using138 = alloca ptr, align 8
+  %end_padding139 = alloca i64, align 8
+  %.anon140 = alloca i64, align 8
+  %blockret141 = alloca ptr, align 8
+  %retparam142 = alloca ptr, align 8
   store ptr %1, ptr %url, align 8
   %ptroffset = getelementptr inbounds i64, ptr %url, i64 1
   store i64 %2, ptr %ptroffset, align 8
@@ -375,7 +375,7 @@ if.exit4:                                         ; preds = %if.exit
   %hi6 = load i64, ptr %13, align 8
   %14 = call i8 @test.contains(ptr %lo5, i64 %hi6, ptr @.str.4, i64 13)
   %15 = trunc i8 %14 to i1
-  br i1 %15, label %if.then7, label %if.exit19
+  br i1 %15, label %if.then7, label %if.exit20
 
 if.then7:                                         ; preds = %if.exit4
   %16 = getelementptr inbounds %Doc, ptr %literal9, i32 0, i32 0
@@ -386,13 +386,13 @@ if.then7:                                         ; preds = %if.exit4
   store ptr %18, ptr %using, align 8
   store i64 0, ptr %end_padding, align 8
   %19 = load ptr, ptr %using, align 8
-  store ptr %19, ptr %using13, align 8
+  store ptr %19, ptr %using14, align 8
   %20 = load i64, ptr %end_padding, align 8
-  store i64 %20, ptr %end_padding14, align 8
+  store i64 %20, ptr %end_padding15, align 8
   store i64 8, ptr %.anon, align 8
-  %21 = load ptr, ptr %using13, align 8
+  %21 = load ptr, ptr %using14, align 8
   %22 = load i64, ptr %.anon, align 8
-  %23 = load i64, ptr %end_padding14, align 8
+  %23 = load i64, ptr %end_padding15, align 8
   %add = add i64 %22, %23
   %24 = call i64 @std.core.mem.allocator.Allocator.alloc(ptr %retparam, ptr %21, i64 %add) #3
   %not_err = icmp eq i64 %24, 0
@@ -400,16 +400,16 @@ if.then7:                                         ; preds = %if.exit4
   br i1 %25, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %if.then7
-  store i64 %24, ptr %error_var12, align 8
+  store i64 %24, ptr %error_var13, align 8
   br label %panic_block
 
 after_check:                                      ; preds = %if.then7
   %26 = load ptr, ptr %retparam, align 8
-  store ptr %26, ptr %blockret15, align 8
+  store ptr %26, ptr %blockret16, align 8
   br label %expr_block.exit
 
 expr_block.exit:                                  ; preds = %after_check
-  %27 = load ptr, ptr %blockret15, align 8
+  %27 = load ptr, ptr %blockret16, align 8
   br label %noerr_block
 
 panic_block:                                      ; preds = %assign_optional
@@ -421,160 +421,160 @@ noerr_block:                                      ; preds = %expr_block.exit
   store ptr %27, ptr %temp, align 8
   %29 = load ptr, ptr %temp, align 8
   %not = icmp eq ptr %29, null
-  br i1 %not, label %if.then16, label %if.exit17
+  br i1 %not, label %if.then17, label %if.exit18
 
-if.then16:                                        ; preds = %noerr_block
+if.then17:                                        ; preds = %noerr_block
   store i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64), ptr %error_var, align 8
   br label %guard_block
 
-if.exit17:                                        ; preds = %noerr_block
+if.exit18:                                        ; preds = %noerr_block
   %30 = load ptr, ptr %temp, align 8
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %30, ptr align 8 %value, i32 8, i1 false)
-  br label %noerr_block18
+  br label %noerr_block19
 
-guard_block:                                      ; preds = %if.then16
+guard_block:                                      ; preds = %if.then17
   %31 = load i64, ptr %error_var, align 8
   ret i64 %31
 
-noerr_block18:                                    ; preds = %if.exit17
+noerr_block19:                                    ; preds = %if.exit18
   %32 = load ptr, ptr %temp, align 8
   store ptr %32, ptr %16, align 8
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal9, i32 8, i1 false)
   ret i64 0
 
-if.exit19:                                        ; preds = %if.exit4
+if.exit20:                                        ; preds = %if.exit4
   %33 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0
-  %lo20 = load ptr, ptr %33, align 8
+  %lo21 = load ptr, ptr %33, align 8
   %34 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1
-  %hi21 = load i64, ptr %34, align 8
-  %35 = call i8 @test.contains(ptr %lo20, i64 %hi21, ptr @.str.5, i64 11)
+  %hi22 = load i64, ptr %34, align 8
+  %35 = call i8 @test.contains(ptr %lo21, i64 %hi22, ptr @.str.5, i64 11)
   %36 = trunc i8 %35 to i1
-  br i1 %36, label %if.then22, label %if.exit74
+  br i1 %36, label %if.then23, label %if.exit77
 
-if.then22:                                        ; preds = %if.exit19
-  %37 = getelementptr inbounds %Doc, ptr %literal24, i32 0, i32 0
-  store ptr null, ptr %literal27, align 8
-  %38 = getelementptr inbounds %Head, ptr %literal27, i32 0, i32 0
-  store %"char[]" zeroinitializer, ptr %value29, align 8
+if.then23:                                        ; preds = %if.exit20
+  %37 = getelementptr inbounds %Doc, ptr %literal25, i32 0, i32 0
+  store ptr null, ptr %literal28, align 8
+  %38 = getelementptr inbounds %Head, ptr %literal28, i32 0, i32 0
+  store %"char[]" zeroinitializer, ptr %value30, align 8
   %39 = load ptr, ptr @std.core.mem.thread_allocator, align 8
-  store ptr %39, ptr %using31, align 8
-  store i64 0, ptr %end_padding32, align 8
-  %40 = load ptr, ptr %using31, align 8
-  store ptr %40, ptr %using35, align 8
-  %41 = load i64, ptr %end_padding32, align 8
-  store i64 %41, ptr %end_padding36, align 8
-  store i64 16, ptr %.anon37, align 8
-  %42 = load ptr, ptr %using35, align 8
-  %43 = load i64, ptr %.anon37, align 8
-  %44 = load i64, ptr %end_padding36, align 8
-  %add40 = add i64 %43, %44
-  %45 = call i64 @std.core.mem.allocator.Allocator.alloc(ptr %retparam39, ptr %42, i64 %add40) #3
-  %not_err41 = icmp eq i64 %45, 0
-  %46 = call i1 @llvm.expect.i1(i1 %not_err41, i1 true)
-  br i1 %46, label %after_check43, label %assign_optional42
+  store ptr %39, ptr %using32, align 8
+  store i64 0, ptr %end_padding34, align 8
+  %40 = load ptr, ptr %using32, align 8
+  store ptr %40, ptr %using37, align 8
+  %41 = load i64, ptr %end_padding34, align 8
+  store i64 %41, ptr %end_padding38, align 8
+  store i64 16, ptr %.anon39, align 8
+  %42 = load ptr, ptr %using37, align 8
+  %43 = load i64, ptr %.anon39, align 8
+  %44 = load i64, ptr %end_padding38, align 8
+  %add42 = add i64 %43, %44
+  %45 = call i64 @std.core.mem.allocator.Allocator.alloc(ptr %retparam41, ptr %42, i64 %add42) #3
+  %not_err43 = icmp eq i64 %45, 0
+  %46 = call i1 @llvm.expect.i1(i1 %not_err43, i1 true)
+  br i1 %46, label %after_check45, label %assign_optional44
 
-assign_optional42:                                ; preds = %if.then22
-  store i64 %45, ptr %error_var34, align 8
-  br label %panic_block45
+assign_optional44:                                ; preds = %if.then23
+  store i64 %45, ptr %error_var36, align 8
+  br label %panic_block47
 
-after_check43:                                    ; preds = %if.then22
-  %47 = load ptr, ptr %retparam39, align 8
-  store ptr %47, ptr %blockret38, align 8
-  br label %expr_block.exit44
+after_check45:                                    ; preds = %if.then23
+  %47 = load ptr, ptr %retparam41, align 8
+  store ptr %47, ptr %blockret40, align 8
+  br label %expr_block.exit46
 
-expr_block.exit44:                                ; preds = %after_check43
-  %48 = load ptr, ptr %blockret38, align 8
-  br label %noerr_block46
+expr_block.exit46:                                ; preds = %after_check45
+  %48 = load ptr, ptr %blockret40, align 8
+  br label %noerr_block48
 
-panic_block45:                                    ; preds = %assign_optional42
+panic_block47:                                    ; preds = %assign_optional44
   %49 = load ptr, ptr @std.core.builtin.panic, align 8
   call void %49(ptr @.panic_msg.7, i64 27, ptr @.file.8, i64 6, ptr @.func.9, i64 7
   unreachable
 
-noerr_block46:                                    ; preds = %expr_block.exit44
-  store ptr %48, ptr %temp30, align 8
-  %50 = load ptr, ptr %temp30, align 8
-  %not47 = icmp eq ptr %50, null
-  br i1 %not47, label %if.then48, label %if.exit49
+noerr_block48:                                    ; preds = %expr_block.exit46
+  store ptr %48, ptr %temp31, align 8
+  %50 = load ptr, ptr %temp31, align 8
+  %not49 = icmp eq ptr %50, null
+  br i1 %not49, label %if.then50, label %if.exit51
 
-if.then48:                                        ; preds = %noerr_block46
-  store i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64), ptr %error_var28, align 8
-  br label %guard_block50
+if.then50:                                        ; preds = %noerr_block48
+  store i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64), ptr %error_var29, align 8
+  br label %guard_block52
 
-if.exit49:                                        ; preds = %noerr_block46
-  %51 = load ptr, ptr %temp30, align 8
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %51, ptr align 8 %value29, i32 16, i1 false)
-  br label %noerr_block51
+if.exit51:                                        ; preds = %noerr_block48
+  %51 = load ptr, ptr %temp31, align 8
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %51, ptr align 8 %value30, i32 16, i1 false)
+  br label %noerr_block53
 
-guard_block50:                                    ; preds = %if.then48
-  %52 = load i64, ptr %error_var28, align 8
+guard_block52:                                    ; preds = %if.then50
+  %52 = load i64, ptr %error_var29, align 8
   ret i64 %52
 
-noerr_block51:                                    ; preds = %if.exit49
-  %53 = load ptr, ptr %temp30, align 8
+noerr_block53:                                    ; preds = %if.exit51
+  %53 = load ptr, ptr %temp31, align 8
   store ptr %53, ptr %38, align 8
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value26, ptr align 8 %literal27, i32 8, i1 false)
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value27, ptr align 8 %literal28, i32 8, i1 false)
   %54 = load ptr, ptr @std.core.mem.thread_allocator, align 8
-  store ptr %54, ptr %using53, align 8
-  store i64 0, ptr %end_padding54, align 8
-  %55 = load ptr, ptr %using53, align 8
-  store ptr %55, ptr %using57, align 8
-  %56 = load i64, ptr %end_padding54, align 8
-  store i64 %56, ptr %end_padding58, align 8
-  store i64 8, ptr %.anon59, align 8
-  %57 = load ptr, ptr %using57, align 8
-  %58 = load i64, ptr %.anon59, align 8
-  %59 = load i64, ptr %end_padding58, align 8
-  %add62 = add i64 %58, %59
-  %60 = call i64 @std.core.mem.allocator.Allocator.alloc(ptr %retparam61, ptr %57, i64 %add62) #3
-  %not_err63 = icmp eq i64 %60, 0
-  %61 = call i1 @llvm.expect.i1(i1 %not_err63, i1 true)
-  br i1 %61, label %after_check65, label %assign_optional64
+  store ptr %54, ptr %using55, align 8
+  store i64 0, ptr %end_padding57, align 8
+  %55 = load ptr, ptr %using55, align 8
+  store ptr %55, ptr %using60, align 8
+  %56 = load i64, ptr %end_padding57, align 8
+  store i64 %56, ptr %end_padding61, align 8
+  store i64 8, ptr %.anon62, align 8
+  %57 = load ptr, ptr %using60, align 8
+  %58 = load i64, ptr %.anon62, align 8
+  %59 = load i64, ptr %end_padding61, align 8
+  %add65 = add i64 %58, %59
+  %60 = call i64 @std.core.mem.allocator.Allocator.alloc(ptr %retparam64, ptr %57, i64 %add65) #3
+  %not_err66 = icmp eq i64 %60, 0
+  %61 = call i1 @llvm.expect.i1(i1 %not_err66, i1 true)
+  br i1 %61, label %after_check68, label %assign_optional67
 
-assign_optional64:                                ; preds = %noerr_block51
-  store i64 %60, ptr %error_var56, align 8
-  br label %panic_block67
+assign_optional67:                                ; preds = %noerr_block53
+  store i64 %60, ptr %error_var59, align 8
+  br label %panic_block70
 
-after_check65:                                    ; preds = %noerr_block51
-  %62 = load ptr, ptr %retparam61, align 8
-  store ptr %62, ptr %blockret60, align 8
-  br label %expr_block.exit66
+after_check68:                                    ; preds = %noerr_block53
+  %62 = load ptr, ptr %retparam64, align 8
+  store ptr %62, ptr %blockret63, align 8
+  br label %expr_block.exit69
 
-expr_block.exit66:                                ; preds = %after_check65
-  %63 = load ptr, ptr %blockret60, align 8
-  br label %noerr_block68
+expr_block.exit69:                                ; preds = %after_check68
+  %63 = load ptr, ptr %blockret63, align 8
+  br label %noerr_block71
 
-panic_block67:                                    ; preds = %assign_optional64
+panic_block70:                                    ; preds = %assign_optional67
   %64 = load ptr, ptr @std.core.builtin.panic, align 8
   call void %64(ptr @.panic_msg.10, i64 27, ptr @.file.11, i64 6, ptr @.func.12, i64 7
   unreachable
 
-noerr_block68:                                    ; preds = %expr_block.exit66
-  store ptr %63, ptr %temp52, align 8
-  %65 = load ptr, ptr %temp52, align 8
-  %not69 = icmp eq ptr %65, null
-  br i1 %not69, label %if.then70, label %if.exit71
+noerr_block71:                                    ; preds = %expr_block.exit69
+  store ptr %63, ptr %temp54, align 8
+  %65 = load ptr, ptr %temp54, align 8
+  %not72 = icmp eq ptr %65, null
+  br i1 %not72, label %if.then73, label %if.exit74
 
-if.then70:                                        ; preds = %noerr_block68
-  store i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64), ptr %error_var25, align 8
-  br label %guard_block72
+if.then73:                                        ; preds = %noerr_block71
+  store i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64), ptr %error_var26, align 8
+  br label %guard_block75
 
-if.exit71:                                        ; preds = %noerr_block68
-  %66 = load ptr, ptr %temp52, align 8
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %66, ptr align 8 %value26, i32 8, i1 false)
-  br label %noerr_block73
+if.exit74:                                        ; preds = %noerr_block71
+  %66 = load ptr, ptr %temp54, align 8
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %66, ptr align 8 %value27, i32 8, i1 false)
+  br label %noerr_block76
 
-guard_block72:                                    ; preds = %if.then70
-  %67 = load i64, ptr %error_var25, align 8
+guard_block75:                                    ; preds = %if.then73
+  %67 = load i64, ptr %error_var26, align 8
   ret i64 %67
 
-noerr_block73:                                    ; preds = %if.exit71
-  %68 = load ptr, ptr %temp52, align 8
+noerr_block76:                                    ; preds = %if.exit74
+  %68 = load ptr, ptr %temp54, align 8
   store ptr %68, ptr %37, align 8
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal24, i32 8, i1 false)
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal25, i32 8, i1 false)
   ret i64 0
 
-if.exit74:                                        ; preds = %if.exit19
+if.exit77:                                        ; preds = %if.exit20
   %69 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1
   %70 = load i64, ptr %69, align 8
   %trunc = trunc i64 %70 to i32
@@ -583,192 +583,192 @@ if.exit74:                                        ; preds = %if.exit19
   %73 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr null, i64 0, ptr @.str.13, i32 %trunc, ptr %72)
   store i32 %73, ptr %len, align 4
   %74 = load ptr, ptr @std.core.mem.thread_allocator, align 8
-  store ptr %74, ptr %using75, align 8
-  store i64 0, ptr %end_padding76, align 8
-  %75 = load ptr, ptr %using75, align 8
-  store ptr %75, ptr %using78, align 8
-  %76 = load i64, ptr %end_padding76, align 8
-  store i64 %76, ptr %end_padding79, align 8
+  store ptr %74, ptr %using78, align 8
+  store i64 0, ptr %end_padding79, align 8
+  %75 = load ptr, ptr %using78, align 8
+  store ptr %75, ptr %using81, align 8
+  %76 = load i64, ptr %end_padding79, align 8
+  store i64 %76, ptr %end_padding82, align 8
   %77 = load i32, ptr %len, align 4
-  %add81 = add i32 %77, 1
-  store i32 %add81, ptr %.anon80, align 4
-  %78 = load ptr, ptr %using78, align 8
-  %79 = load i32, ptr %.anon80, align 4
+  %add84 = add i32 %77, 1
+  store i32 %add84, ptr %.anon83, align 4
+  %78 = load ptr, ptr %using81, align 8
+  %79 = load i32, ptr %.anon83, align 4
   %sext = sext i32 %79 to i64
-  %80 = load i64, ptr %end_padding79, align 8
-  %add84 = add i64 %sext, %80
-  %81 = call i64 @std.core.mem.allocator.Allocator.alloc(ptr %retparam83, ptr %78, i64 %add84) #3
-  %not_err85 = icmp eq i64 %81, 0
-  %82 = call i1 @llvm.expect.i1(i1 %not_err85, i1 true)
-  br i1 %82, label %after_check87, label %assign_optional86
+  %80 = load i64, ptr %end_padding82, align 8
+  %add87 = add i64 %sext, %80
+  %81 = call i64 @std.core.mem.allocator.Allocator.alloc(ptr %retparam86, ptr %78, i64 %add87) #3
+  %not_err88 = icmp eq i64 %81, 0
+  %82 = call i1 @llvm.expect.i1(i1 %not_err88, i1 true)
+  br i1 %82, label %after_check90, label %assign_optional89
 
-assign_optional86:                                ; preds = %if.exit74
-  store i64 %81, ptr %error_var77, align 8
-  br label %panic_block89
+assign_optional89:                                ; preds = %if.exit77
+  store i64 %81, ptr %error_var80, align 8
+  br label %panic_block92
 
-after_check87:                                    ; preds = %if.exit74
-  %83 = load ptr, ptr %retparam83, align 8
-  store ptr %83, ptr %blockret82, align 8
-  br label %expr_block.exit88
+after_check90:                                    ; preds = %if.exit77
+  %83 = load ptr, ptr %retparam86, align 8
+  store ptr %83, ptr %blockret85, align 8
+  br label %expr_block.exit91
 
-expr_block.exit88:                                ; preds = %after_check87
-  %84 = load ptr, ptr %blockret82, align 8
-  br label %noerr_block90
+expr_block.exit91:                                ; preds = %after_check90
+  %84 = load ptr, ptr %blockret85, align 8
+  br label %noerr_block93
 
-panic_block89:                                    ; preds = %assign_optional86
+panic_block92:                                    ; preds = %assign_optional89
   %85 = load ptr, ptr @std.core.builtin.panic, align 8
   call void %85(ptr @.panic_msg.14, i64 27, ptr @.file.15, i64 6, ptr @.func.16
   unreachable
 
-noerr_block90:                                    ; preds = %expr_block.exit88
+noerr_block93:                                    ; preds = %expr_block.exit91
   store ptr %84, ptr %str, align 8
   %86 = load ptr, ptr %str, align 8
-  %not91 = icmp eq ptr %86, null
-  br i1 %not91, label %if.then92, label %if.exit93
+  %not94 = icmp eq ptr %86, null
+  br i1 %not94, label %if.then95, label %if.exit96
 
-if.then92:                                        ; preds = %noerr_block90
+if.then95:                                        ; preds = %noerr_block93
   ret i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64)
 
-if.exit93:                                        ; preds = %noerr_block90
+if.exit96:                                        ; preds = %noerr_block93
   %87 = load ptr, ptr %str, align 8
   %88 = load i32, ptr %len, align 4
-  %sext94 = sext i32 %88 to i64
-  %add95 = add i64 %sext94, 1
+  %sext97 = sext i32 %88 to i64
+  %add98 = add i64 %sext97, 1
   %89 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1
   %90 = load i64, ptr %89, align 8
-  %trunc96 = trunc i64 %90 to i32
+  %trunc99 = trunc i64 %90 to i32
   %91 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0
   %92 = load ptr, ptr %91, align 8
-  %93 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %87, i64 %add95, ptr @.str.17, i32 %trunc96, ptr %92)
-  %94 = getelementptr inbounds %Doc, ptr %literal98, i32 0, i32 0
-  store ptr null, ptr %literal101, align 8
-  %95 = getelementptr inbounds %Head, ptr %literal101, i32 0, i32 0
+  %93 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %87, i64 %add98, ptr @.str.17, i32 %trunc99, ptr %92)
+  %94 = getelementptr inbounds %Doc, ptr %literal101, i32 0, i32 0
+  store ptr null, ptr %literal104, align 8
+  %95 = getelementptr inbounds %Head, ptr %literal104, i32 0, i32 0
   %96 = load ptr, ptr %str, align 8
   %97 = load i32, ptr %len, align 4
   %sub = sub i32 %97, 1
-  %sext104 = sext i32 %sub to i64
-  %98 = add i64 %sext104, 1
+  %sext107 = sext i32 %sub to i64
+  %98 = add i64 %sext107, 1
   %size = sub i64 %98, 0
-  %ptroffset105 = getelementptr inbounds i8, ptr %96, i64 0
-  %99 = insertvalue %"char[]" undef, ptr %ptroffset105, 0
+  %ptroffset108 = getelementptr inbounds i8, ptr %96, i64 0
+  %99 = insertvalue %"char[]" undef, ptr %ptroffset108, 0
   %100 = insertvalue %"char[]" %99, i64 %size, 1
-  store %"char[]" %100, ptr %value103, align 8
+  store %"char[]" %100, ptr %value106, align 8
   %101 = load ptr, ptr @std.core.mem.thread_allocator, align 8
-  store ptr %101, ptr %using107, align 8
-  store i64 0, ptr %end_padding108, align 8
-  %102 = load ptr, ptr %using107, align 8
-  store ptr %102, ptr %using111, align 8
-  %103 = load i64, ptr %end_padding108, align 8
-  store i64 %103, ptr %end_padding112, align 8
-  store i64 16, ptr %.anon113, align 8
-  %104 = load ptr, ptr %using111, align 8
-  %105 = load i64, ptr %.anon113, align 8
-  %106 = load i64, ptr %end_padding112, align 8
-  %add116 = add i64 %105, %106
-  %107 = call i64 @std.core.mem.allocator.Allocator.alloc(ptr %retparam115, ptr %104, i64 %add116) #3
-  %not_err117 = icmp eq i64 %107, 0
-  %108 = call i1 @llvm.expect.i1(i1 %not_err117, i1 true)
-  br i1 %108, label %after_check119, label %assign_optional118
+  store ptr %101, ptr %using110, align 8
+  store i64 0, ptr %end_padding112, align 8
+  %102 = load ptr, ptr %using110, align 8
+  store ptr %102, ptr %using115, align 8
+  %103 = load i64, ptr %end_padding112, align 8
+  store i64 %103, ptr %end_padding116, align 8
+  store i64 16, ptr %.anon117, align 8
+  %104 = load ptr, ptr %using115, align 8
+  %105 = load i64, ptr %.anon117, align 8
+  %106 = load i64, ptr %end_padding116, align 8
+  %add120 = add i64 %105, %106
+  %107 = call i64 @std.core.mem.allocator.Allocator.alloc(ptr %retparam119, ptr %104, i64 %add120) #3
+  %not_err121 = icmp eq i64 %107, 0
+  %108 = call i1 @llvm.expect.i1(i1 %not_err121, i1 true)
+  br i1 %108, label %after_check123, label %assign_optional122
 
-assign_optional118:                               ; preds = %if.exit93
-  store i64 %107, ptr %error_var110, align 8
-  br label %panic_block121
+assign_optional122:                               ; preds = %if.exit96
+  store i64 %107, ptr %error_var114, align 8
+  br label %panic_block125
 
-after_check119:                                   ; preds = %if.exit93
-  %109 = load ptr, ptr %retparam115, align 8
-  store ptr %109, ptr %blockret114, align 8
-  br label %expr_block.exit120
+after_check123:                                   ; preds = %if.exit96
+  %109 = load ptr, ptr %retparam119, align 8
+  store ptr %109, ptr %blockret118, align 8
+  br label %expr_block.exit124
 
-expr_block.exit120:                               ; preds = %after_check119
-  %110 = load ptr, ptr %blockret114, align 8
-  br label %noerr_block122
+expr_block.exit124:                               ; preds = %after_check123
+  %110 = load ptr, ptr %blockret118, align 8
+  br label %noerr_block126
 
-panic_block121:                                   ; preds = %assign_optional118
+panic_block125:                                   ; preds = %assign_optional122
   %111 = load ptr, ptr @std.core.builtin.panic, align 8
   call void %111(ptr @.panic_msg.18, i64 27, ptr @.file.19, i64 6, ptr @.func.20
   unreachable
 
-noerr_block122:                                   ; preds = %expr_block.exit120
-  store ptr %110, ptr %temp106, align 8
-  %112 = load ptr, ptr %temp106, align 8
-  %not123 = icmp eq ptr %112, null
-  br i1 %not123, label %if.then124, label %if.exit125
+noerr_block126:                                   ; preds = %expr_block.exit124
+  store ptr %110, ptr %temp109, align 8
+  %112 = load ptr, ptr %temp109, align 8
+  %not127 = icmp eq ptr %112, null
+  br i1 %not127, label %if.then128, label %if.exit129
 
-if.then124:                                       ; preds = %noerr_block122
-  store i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64), ptr %error_var102, align 8
-  br label %guard_block126
+if.then128:                                       ; preds = %noerr_block126
+  store i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64), ptr %error_var105, align 8
+  br label %guard_block130
 
-if.exit125:                                       ; preds = %noerr_block122
-  %113 = load ptr, ptr %temp106, align 8
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %113, ptr align 8 %value103, i32 16, i1 false)
-  br label %noerr_block127
+if.exit129:                                       ; preds = %noerr_block126
+  %113 = load ptr, ptr %temp109, align 8
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %113, ptr align 8 %value106, i32 16, i1 false)
+  br label %noerr_block131
 
-guard_block126:                                   ; preds = %if.then124
-  %114 = load i64, ptr %error_var102, align 8
+guard_block130:                                   ; preds = %if.then128
+  %114 = load i64, ptr %error_var105, align 8
   ret i64 %114
 
-noerr_block127:                                   ; preds = %if.exit125
-  %115 = load ptr, ptr %temp106, align 8
+noerr_block131:                                   ; preds = %if.exit129
+  %115 = load ptr, ptr %temp109, align 8
   store ptr %115, ptr %95, align 8
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value100, ptr align 8 %literal101, i32 8, i1 false)
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value103, ptr align 8 %literal104, i32 8, i1 false)
   %116 = load ptr, ptr @std.core.mem.thread_allocator, align 8
-  store ptr %116, ptr %using129, align 8
-  store i64 0, ptr %end_padding130, align 8
-  %117 = load ptr, ptr %using129, align 8
-  store ptr %117, ptr %using133, align 8
-  %118 = load i64, ptr %end_padding130, align 8
-  store i64 %118, ptr %end_padding134, align 8
-  store i64 8, ptr %.anon135, align 8
-  %119 = load ptr, ptr %using133, align 8
-  %120 = load i64, ptr %.anon135, align 8
-  %121 = load i64, ptr %end_padding134, align 8
-  %add138 = add i64 %120, %121
-  %122 = call i64 @std.core.mem.allocator.Allocator.alloc(ptr %retparam137, ptr %119, i64 %add138) #3
-  %not_err139 = icmp eq i64 %122, 0
-  %123 = call i1 @llvm.expect.i1(i1 %not_err139, i1 true)
-  br i1 %123, label %after_check141, label %assign_optional140
+  store ptr %116, ptr %using133, align 8
+  store i64 0, ptr %end_padding135, align 8
+  %117 = load ptr, ptr %using133, align 8
+  store ptr %117, ptr %using138, align 8
+  %118 = load i64, ptr %end_padding135, align 8
+  store i64 %118, ptr %end_padding139, align 8
+  store i64 8, ptr %.anon140, align 8
+  %119 = load ptr, ptr %using138, align 8
+  %120 = load i64, ptr %.anon140, align 8
+  %121 = load i64, ptr %end_padding139, align 8
+  %add143 = add i64 %120, %121
+  %122 = call i64 @std.core.mem.allocator.Allocator.alloc(ptr %retparam142, ptr %119, i64 %add143) #3
+  %not_err144 = icmp eq i64 %122, 0
+  %123 = call i1 @llvm.expect.i1(i1 %not_err144, i1 true)
+  br i1 %123, label %after_check146, label %assign_optional145
 
-assign_optional140:                               ; preds = %noerr_block127
-  store i64 %122, ptr %error_var132, align 8
-  br label %panic_block143
+assign_optional145:                               ; preds = %noerr_block131
+  store i64 %122, ptr %error_var137, align 8
+  br label %panic_block148
 
-after_check141:                                   ; preds = %noerr_block127
-  %124 = load ptr, ptr %retparam137, align 8
-  store ptr %124, ptr %blockret136, align 8
-  br label %expr_block.exit142
+after_check146:                                   ; preds = %noerr_block131
+  %124 = load ptr, ptr %retparam142, align 8
+  store ptr %124, ptr %blockret141, align 8
+  br label %expr_block.exit147
 
-expr_block.exit142:                               ; preds = %after_check141
-  %125 = load ptr, ptr %blockret136, align 8
-  br label %noerr_block144
+expr_block.exit147:                               ; preds = %after_check146
+  %125 = load ptr, ptr %blockret141, align 8
+  br label %noerr_block149
 
-panic_block143:                                   ; preds = %assign_optional140
+panic_block148:                                   ; preds = %assign_optional145
   %126 = load ptr, ptr @std.core.builtin.panic, align 8
   call void %126(ptr @.panic_msg.21, i64 27, ptr @.file.22, i64 6, ptr @.func.23
   unreachable
 
-noerr_block144:                                   ; preds = %expr_block.exit142
-  store ptr %125, ptr %temp128, align 8
-  %127 = load ptr, ptr %temp128, align 8
-  %not145 = icmp eq ptr %127, null
-  br i1 %not145, label %if.then146, label %if.exit147
+noerr_block149:                                   ; preds = %expr_block.exit147
+  store ptr %125, ptr %temp132, align 8
+  %127 = load ptr, ptr %temp132, align 8
+  %not150 = icmp eq ptr %127, null
+  br i1 %not150, label %if.then151, label %if.exit152
 
-if.then146:                                       ; preds = %noerr_block144
-  store i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64), ptr %error_var99, align 8
-  br label %guard_block148
+if.then151:                                       ; preds = %noerr_block149
+  store i64 ptrtoint (ptr @"test.ReadError$OUT_OF_MEMORY" to i64), ptr %error_var102, align 8
+  br label %guard_block153
 
-if.exit147:                                       ; preds = %noerr_block144
-  %128 = load ptr, ptr %temp128, align 8
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %128, ptr align 8 %value100, i32 8, i1 false)
-  br label %noerr_block149
+if.exit152:                                       ; preds = %noerr_block149
+  %128 = load ptr, ptr %temp132, align 8
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %128, ptr align 8 %value103, i32 8, i1 false)
+  br label %noerr_block154
 
-guard_block148:                                   ; preds = %if.then146
-  %129 = load i64, ptr %error_var99, align 8
+guard_block153:                                   ; preds = %if.then151
+  %129 = load i64, ptr %error_var102, align 8
   ret i64 %129
 
-noerr_block149:                                   ; preds = %if.exit147
-  %130 = load ptr, ptr %temp128, align 8
+noerr_block154:                                   ; preds = %if.exit152
+  %130 = load ptr, ptr %temp132, align 8
   store ptr %130, ptr %94, align 8
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal98, i32 8, i1 false)
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal101, i32 8, i1 false)
   ret i64 0
 }
 
diff --git a/test/test_suite/stdlib/map.c3t b/test/test_suite/stdlib/map.c3t
index ec760636d..42b7b33e9 100644
--- a/test/test_suite/stdlib/map.c3t
+++ b/test/test_suite/stdlib/map.c3t
@@ -9,7 +9,7 @@ struct Foo { int x; void* bar; }
 typedef IntFooMap = HashMap<int, Foo>;
 typedef IntDoubleMap = HashMap<int, double>;
 
-fn char[] Foo.to_string(Foo* foo, Allocator* allocator = mem::current_allocator())
+fn char[] Foo.to_string(Foo* foo, Allocator* allocator = mem::heap())
 {
 	VarString s = string::new_with_capacity(128, allocator);
 	s.printf("{%s, %p}", foo.x, foo.bar);
@@ -139,12 +139,12 @@ entry:
   %result46 = alloca %"double[]", align 8
   %temp = alloca ptr, align 8
   %error_var = alloca i64, align 8
-  %retparam49 = alloca ptr, align 8
+  %retparam50 = alloca ptr, align 8
   %mark = alloca i64, align 8
   %map3 = alloca %HashMap.2, align 8
-  %retparam52 = alloca i64, align 8
-  %varargslots53 = alloca [1 x %variant], align 16
-  %result54 = alloca %"int[]", align 8
+  %retparam53 = alloca i64, align 8
+  %varargslots54 = alloca [1 x %variant], align 16
+  %result55 = alloca %"int[]", align 8
   call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 40, i1 false)
   %0 = load ptr, ptr @std.core.mem.thread_allocator, align 8
   call void @"std.collections.map$int$test.Foo$.HashMap.init"(ptr %map, i32 16, float 7.500000e-01, ptr %0)
@@ -273,17 +273,17 @@ after_check12:                                    ; preds = %entry, %after_check
 
 if.then:                                          ; preds = %after_check12
   %81 = load ptr, ptr @std.core.mem.thread_allocator, align 8
-  %82 = call i64 @std.core.mem.allocator.new_temp(ptr %retparam49, i64 262144, ptr %81)
-  %not_err50 = icmp eq i64 %82, 0
-  %83 = call i1 @llvm.expect.i1(i1 %not_err50, i1 true)
-  br i1 %83, label %after_check51, label %assign_optional
+  %82 = call i64 @std.core.mem.allocator.new_temp(ptr %retparam50, i64 262144, ptr %81)
+  %not_err51 = icmp eq i64 %82, 0
+  %83 = call i1 @llvm.expect.i1(i1 %not_err51, i1 true)
+  br i1 %83, label %after_check52, label %assign_optional
 
 assign_optional:                                  ; preds = %if.then
   store i64 %82, ptr %error_var, align 8
   br label %panic_block
 
-after_check51:                                    ; preds = %if.then
-  %84 = load ptr, ptr %retparam49, align 8
+after_check52:                                    ; preds = %if.then
+  %84 = load ptr, ptr %retparam50, align 8
   br label %noerr_block
 
 panic_block:                                      ; preds = %assign_optional
@@ -291,7 +291,7 @@ panic_block:                                      ; preds = %assign_optional
   call void %85(ptr @.panic_msg, i64 27, ptr @.file, i64 6, ptr @.func
   unreachable
 
-noerr_block:                                      ; preds = %after_check51
+noerr_block:                                      ; preds = %after_check52
   store ptr %84, ptr @std.core.mem.thread_temp_allocator, align 8
   br label %if.exit
 
@@ -309,12 +309,12 @@ if.exit:                                          ; preds = %noerr_block, %after
   %92 = call i8 @"std.collections.map$int$double$.HashMap.set"(ptr %map3, i32 7, double 5.200000e+00)
   %93 = load ptr, ptr @std.core.mem.thread_allocator, align 8
   %94 = call { ptr, i64 } @"std.collections.map$int$double$.HashMap.key_list"(ptr %map3, ptr %93)
-  store { ptr, i64 } %94, ptr %result54, align 8
-  %95 = insertvalue %variant undef, ptr %result54, 0
+  store { ptr, i64 } %94, ptr %result55, align 8
+  %95 = insertvalue %variant undef, ptr %result55, 0
   %96 = insertvalue %variant %95, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
-  %97 = getelementptr inbounds [1 x %variant], ptr %varargslots53, i64 0, i64 0
+  %97 = getelementptr inbounds [1 x %variant], ptr %varargslots54, i64 0, i64 0
   store %variant %96, ptr %97, align 16
-  %98 = call i64 @std.io.printfn(ptr %retparam52, ptr @.str.11, i64 2, ptr %varargslots53, i64 1)
+  %98 = call i64 @std.io.printfn(ptr %retparam53, ptr @.str.11, i64 2, ptr %varargslots54, i64 1)
   %99 = load ptr, ptr %temp, align 8
   %100 = getelementptr inbounds %TempAllocator, ptr %99, i32 0, i32 0
   %101 = load i64, ptr %mark, align 8