From 4b2019cf2036349f63c987deacc195c58be2ceea Mon Sep 17 00:00:00 2001
From: Christoffer Lerno <christoffer@aegik.com>
Date: Sun, 25 Aug 2024 21:53:42 +0200
Subject: [PATCH] Add "allocator-required" functions.

---
 lib/std/collections/anylist.c3       |  62 ++++++-
 lib/std/collections/elastic_array.c3 |  31 +++-
 lib/std/collections/enummap.c3       |   9 +-
 lib/std/collections/enumset.c3       |   7 +-
 lib/std/collections/hashmap.c3       |  63 ++++++-
 lib/std/collections/linkedlist.c3    |  12 +-
 lib/std/collections/list.c3          |   2 +-
 lib/std/collections/range.c3         |  20 ++-
 lib/std/core/dstring.c3              |   2 +-
 lib/std/core/string.c3               |  70 ++++----
 lib/std/io/formatter.c3              |   7 +-
 test/test_suite/stdlib/map_linux.c3t | 248 ++++++++++++++-------------
 test/test_suite/stdlib/map_macos.c3t | 248 ++++++++++++++-------------
 13 files changed, 476 insertions(+), 305 deletions(-)

diff --git a/lib/std/collections/anylist.c3 b/lib/std/collections/anylist.c3
index 90cb08bb8..18b091ddd 100644
--- a/lib/std/collections/anylist.c3
+++ b/lib/std/collections/anylist.c3
@@ -18,9 +18,18 @@ struct AnyList (Printable)
 
 /**
  * @param initial_capacity "The initial capacity to reserve"
- * @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
+ * Use `init` for to use a custom allocator.
  **/
-fn AnyList* AnyList.new_init(&self, usz initial_capacity = 16, Allocator allocator = allocator::heap())
+fn AnyList* AnyList.new_init(&self, usz initial_capacity = 16, Allocator allocator = null)
+{
+	return self.init(allocator ?: allocator::heap(), initial_capacity) @inline;
+}
+
+/**
+ * @param [&inout] allocator "The allocator to use"
+ * @param initial_capacity "The initial capacity to reserve"
+ **/
+fn AnyList* AnyList.init(&self, Allocator allocator, usz initial_capacity = 16)
 {
 	self.allocator = allocator;
 	self.size = 0;
@@ -44,7 +53,7 @@ fn AnyList* AnyList.new_init(&self, usz initial_capacity = 16, Allocator allocat
  **/
 fn AnyList* AnyList.temp_init(&self, usz initial_capacity = 16)
 {
-	return self.new_init(initial_capacity, allocator::temp()) @inline;
+	return self.init(allocator::temp(), initial_capacity) @inline;
 }
 
 fn usz! AnyList.to_format(&self, Formatter* formatter) @dynamic
@@ -67,16 +76,19 @@ fn usz! AnyList.to_format(&self, Formatter* formatter) @dynamic
 	}
 }
 
-fn String AnyList.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
+fn String AnyList.to_new_string(&self, Allocator allocator = null) @dynamic
 {
-	return string::new_format("%s", *self, .allocator = allocator);
+	return string::format("%s", *self, .allocator = allocator ?: allocator::heap());
 }
 
-fn String AnyList.to_tstring(&self)
+
+fn String AnyList.to_string(&self, Allocator allocator) @dynamic
 {
-	return string::tformat("%s", *self);
+	return string::format("%s", *self, .allocator = allocator);
 }
 
+fn String AnyList.to_tstring(&self) => string::tformat("%s", *self);
+
 /**
  * Push an element on the list by cloning it.
  **/
@@ -117,18 +129,35 @@ macro AnyList.pop(&self, $Type)
  * Pop the last value and allocate the copy using the given allocator.
  * @return! IteratorResult.NO_MORE_ELEMENT
  **/
-fn any! AnyList.new_pop(&self, Allocator allocator = allocator::heap())
+fn any! AnyList.copy_pop(&self, Allocator allocator = allocator::heap())
 {
 	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
 	defer self.free_element(self.entries[self.size]);
 	return allocator::clone_any(allocator, self.entries[--self.size]);
 }
 
+/**
+ * Pop the last value and allocate the copy using the given allocator.
+ * @return! IteratorResult.NO_MORE_ELEMENT
+ * @deprecated `use copy_pop`
+ **/
+fn any! AnyList.new_pop(&self, Allocator allocator = allocator::heap())
+{
+	return self.copy_pop(allocator);
+}
+
+/**
+ * Pop the last value and allocate the copy using the temp allocator
+ * @return! IteratorResult.NO_MORE_ELEMENT
+ * @deprecated `use tcopy_pop`
+ **/
+fn any! AnyList.temp_pop(&self) => self.copy_pop(allocator::temp());
+
 /**
  * Pop the last value and allocate the copy using the temp allocator
  * @return! IteratorResult.NO_MORE_ELEMENT
  **/
-fn any! AnyList.temp_pop(&self) => self.new_pop(allocator::temp());
+fn any! AnyList.tcopy_pop(&self) => self.copy_pop(allocator::temp());
 
 /**
  * Pop the last value. It must later be released using list.free_element()
@@ -171,8 +200,17 @@ fn any! AnyList.pop_first_retained(&self)
 
 /**
  * Same as new_pop() but pops the first value instead.
+ * @deprecated `use copy_pop_first`
  **/
 fn any! AnyList.new_pop_first(&self, Allocator allocator = allocator::heap())
+{
+	return self.copy_pop_first(allocator) @inline;
+}
+
+/**
+ * Same as new_pop() but pops the first value instead.
+ **/
+fn any! AnyList.copy_pop_first(&self, Allocator allocator = allocator::heap())
 {
 	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
 	defer self.free_element(self.entries[self.size]);
@@ -183,6 +221,12 @@ fn any! AnyList.new_pop_first(&self, Allocator allocator = allocator::heap())
 /**
  * Same as temp_pop() but pops the first value instead.
  **/
+fn any! AnyList.tcopy_pop_first(&self) => self.copy_pop_first(allocator::temp());
+
+/**
+ * Same as temp_pop() but pops the first value instead.
+ * @deprecated `use tcopy_pop_first`
+ **/
 fn any! AnyList.temp_pop_first(&self) => self.new_pop_first(allocator::temp());
 
 /**
diff --git a/lib/std/collections/elastic_array.c3 b/lib/std/collections/elastic_array.c3
index c94e6384c..d03665c2d 100644
--- a/lib/std/collections/elastic_array.c3
+++ b/lib/std/collections/elastic_array.c3
@@ -41,7 +41,12 @@ fn usz! ElasticArray.to_format(&self, Formatter* formatter) @dynamic
 
 fn String ElasticArray.to_string(&self, Allocator allocator) @dynamic
 {
-	return string::new_format("%s", *self, .allocator = allocator);
+	return string::format("%s", *self, .allocator = allocator);
+}
+
+fn String ElasticArray.to_new_string(&self, Allocator allocator = nul) @dynamic
+{
+	return string::format("%s", *self, .allocator = allocator ?: allocator::heap());
 }
 
 fn String ElasticArray.to_tstring(&self)
@@ -158,7 +163,15 @@ fn void ElasticArray.add_array(&self, Type[] array)
 /**
  * IMPORTANT The returned array must be freed using free_aligned.
  **/
-fn Type[] ElasticArray.to_new_aligned_array(&self, Allocator allocator = allocator::heap())
+fn Type[] ElasticArray.to_new_aligned_array(&self)
+{
+	return list_common::list_to_new_aligned_array(Type, self, allocator::heap());
+}
+
+/**
+ * IMPORTANT The returned array must be freed using free_aligned.
+ **/
+fn Type[] ElasticArray.to_aligned_array(&self, Allocator allocator)
 {
 	return list_common::list_to_new_aligned_array(Type, self, allocator);
 }
@@ -166,7 +179,15 @@ fn Type[] ElasticArray.to_new_aligned_array(&self, Allocator allocator = allocat
 /**
  * @require !type_is_overaligned() : "This function is not available on overaligned types"
  **/
-macro Type[] ElasticArray.to_new_array(&self, Allocator allocator = allocator::heap())
+macro Type[] ElasticArray.to_new_array(&self)
+{
+	return list_common::list_to_array(Type, self, allocator::heap());
+}
+
+/**
+ * @require !type_is_overaligned() : "This function is not available on overaligned types"
+ **/
+macro Type[] ElasticArray.to_array(&self, Allocator allocator)
 {
 	return list_common::list_to_new_array(Type, self, allocator);
 }
@@ -174,9 +195,9 @@ macro Type[] ElasticArray.to_new_array(&self, Allocator allocator = allocator::h
 fn Type[] ElasticArray.to_tarray(&self)
 {
 	$if type_is_overaligned():
-	return self.to_new_aligned_array(allocator::temp());
+	return self.to_aligned_array(allocator::temp());
 	$else
-	return self.to_new_array(allocator::temp());
+	return self.to_array(allocator::temp());
 	$endif;
 }
 
diff --git a/lib/std/collections/enummap.c3 b/lib/std/collections/enummap.c3
index 0b254e8b4..cf8fda36b 100644
--- a/lib/std/collections/enummap.c3
+++ b/lib/std/collections/enummap.c3
@@ -25,9 +25,14 @@ fn usz! EnumMap.to_format(&self, Formatter* formatter) @dynamic
 	return n;
 }
 
-fn String EnumMap.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
+fn String EnumMap.to_string(&self, Allocator allocator) @dynamic
 {
-	return string::new_format("%s", *self, .allocator = allocator);
+	return string::format("%s", *self, .allocator = allocator);
+}
+
+fn String EnumMap.to_new_string(&self, Allocator allocator = null) @dynamic
+{
+	return string::format("%s", *self, .allocator = allocator ?: allocator::heap());
 }
 
 fn String EnumMap.to_tstring(&self) @dynamic
diff --git a/lib/std/collections/enumset.c3 b/lib/std/collections/enumset.c3
index 7f207694d..3181d1ea7 100644
--- a/lib/std/collections/enumset.c3
+++ b/lib/std/collections/enumset.c3
@@ -143,7 +143,12 @@ fn usz! EnumSet.to_format(&set, Formatter* formatter) @dynamic
 
 fn String EnumSet.to_new_string(&set, Allocator allocator = allocator::heap()) @dynamic
 {
-	return string::new_format("%s", *set, .allocator = allocator);
+	return string::format("%s", *set, .allocator = allocator);
+}
+
+fn String EnumSet.to_string(&set, Allocator allocator) @dynamic
+{
+	return string::format("%s", *set, .allocator = allocator);
 }
 
 fn String EnumSet.to_tstring(&set) @dynamic
diff --git a/lib/std/collections/hashmap.c3 b/lib/std/collections/hashmap.c3
index 01b456e2d..8e31d48ca 100644
--- a/lib/std/collections/hashmap.c3
+++ b/lib/std/collections/hashmap.c3
@@ -20,7 +20,19 @@ struct HashMap
  * @require !self.allocator "Map was already initialized"
  * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
  **/
-fn HashMap* HashMap.new_init(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
+fn HashMap* HashMap.new_init(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = null)
+{
+	return self.init(allocator ?: allocator::heap(), capacity, load_factor);
+}
+
+/**
+ * @param [&inout] allocator "The allocator to use"
+ * @require capacity > 0 "The capacity must be 1 or higher"
+ * @require load_factor > 0.0 "The load factor must be higher than 0"
+ * @require !self.allocator "Map was already initialized"
+ * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ **/
+fn HashMap* HashMap.init(&self, Allocator allocator, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
 {
 	capacity = math::next_power_of_2(capacity);
 	self.allocator = allocator;
@@ -38,7 +50,7 @@ fn HashMap* HashMap.new_init(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, fl
  **/
 fn HashMap* HashMap.temp_init(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
 {
-	return self.new_init(capacity, load_factor, allocator::temp()) @inline;
+	return self.init(allocator::temp(), capacity, load_factor) @inline;
 }
 
 
@@ -53,11 +65,19 @@ fn bool HashMap.is_initialized(&map)
 	return (bool)map.allocator;
 }
 
+/**
+ * @param [&in] other_map "The map to copy from."
+ **/
+fn HashMap* HashMap.new_init_from_map(&self, HashMap* other_map)
+{
+	return self.init_from_map(other_map, allocator::heap()) @inline;
+}
+
 /**
  * @param [&inout] allocator "The allocator to use"
  * @param [&in] other_map "The map to copy from."
  **/
-fn HashMap* HashMap.new_init_from_map(&self, HashMap* other_map, Allocator allocator = allocator::heap())
+fn HashMap* HashMap.init_from_map(&self, HashMap* other_map, Allocator allocator)
 {
 	self.new_init(other_map.table.len, other_map.load_factor, allocator);
 	self.put_all_for_create(other_map);
@@ -69,7 +89,7 @@ fn HashMap* HashMap.new_init_from_map(&self, HashMap* other_map, Allocator alloc
  **/
 fn HashMap* HashMap.temp_init_from_map(&map, HashMap* other_map)
 {
-	return map.new_init_from_map(other_map, allocator::temp()) @inline;
+	return map.init_from_map(other_map, allocator::temp()) @inline;
 }
 
 fn bool HashMap.is_empty(&map) @inline
@@ -191,12 +211,25 @@ fn void HashMap.free(&map)
 	map.table = {};
 }
 
-fn Key[] HashMap.key_tlist(&map)
+fn Key[] HashMap.tcopy_keys(&map)
 {
-	return map.key_new_list(allocator::temp()) @inline;
+	return map.copy_keys(allocator::temp()) @inline;
 }
 
+fn Key[] HashMap.key_tlist(&map) @deprecated("Use 'tcopy_keys'")
+{
+	return map.copy_keys(allocator::temp()) @inline;
+}
+
+/**
+ * @deprecated "use copy_keys"
+ **/
 fn Key[] HashMap.key_new_list(&map, Allocator allocator = allocator::heap())
+{
+	return map.copy_keys() @inline;
+}
+
+fn Key[] HashMap.copy_keys(&map, Allocator allocator = allocator::heap())
 {
 	if (!map.count) return {};
 
@@ -235,12 +268,28 @@ macro HashMap.@each_entry(map; @body(entry))
 	}
 }
 
+/**
+ * @deprecated `use tcopy_values`
+ **/
 fn Value[] HashMap.value_tlist(&map)
 {
-	return map.value_new_list(allocator::temp()) @inline;
+	return map.copy_values(allocator::temp()) @inline;
 }
 
+fn Value[] HashMap.tcopy_values(&map)
+{
+	return map.copy_values(allocator::temp()) @inline;
+}
+
+/**
+ * @deprecated `use copy_values`
+ **/
 fn Value[] HashMap.value_new_list(&map, Allocator allocator = allocator::heap())
+{
+	return map.copy_values(allocator);
+}
+
+fn Value[] HashMap.copy_values(&map, Allocator allocator = allocator::heap())
 {
 	if (!map.count) return {};
 	Value[] list = allocator::alloc_array(allocator, Value, map.count);
diff --git a/lib/std/collections/linkedlist.c3 b/lib/std/collections/linkedlist.c3
index 9b48ac97b..ec20551bd 100644
--- a/lib/std/collections/linkedlist.c3
+++ b/lib/std/collections/linkedlist.c3
@@ -24,16 +24,24 @@ struct LinkedList
  * @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
  * @return "the initialized list"
  **/
-fn LinkedList* LinkedList.new_init(&self, Allocator allocator = allocator::heap())
+fn LinkedList* LinkedList.init(&self, Allocator allocator)
 {
 	*self = { .allocator = allocator };
 	return self;
 }
 
+/**
+ * @return "the initialized list"
+ **/
+fn LinkedList* LinkedList.new_init(&self)
+{
+	return self.init(allocator::heap()) @inline;
+}
+
 
 fn LinkedList* LinkedList.temp_init(&self)
 {
-	return self.new_init(allocator::temp()) @inline;
+	return self.init(allocator::temp()) @inline;
 }
 
 /**
diff --git a/lib/std/collections/list.c3 b/lib/std/collections/list.c3
index f32fdc1f3..e23d48294 100644
--- a/lib/std/collections/list.c3
+++ b/lib/std/collections/list.c3
@@ -102,7 +102,7 @@ fn usz! List.to_format(&self, Formatter* formatter) @dynamic
 
 fn String List.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
 {
-	return string::new_format("%s", *self, .allocator = allocator);
+	return string::format("%s", *self, .allocator = allocator);
 }
 
 fn String List.to_tstring(&self)
diff --git a/lib/std/collections/range.c3 b/lib/std/collections/range.c3
index e09a45534..102828141 100644
--- a/lib/std/collections/range.c3
+++ b/lib/std/collections/range.c3
@@ -29,14 +29,19 @@ fn Type Range.get(&self, usz index) @operator([])
 	return (Type)(self.start + (usz)index);
 }
 
-fn String Range.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
+fn String Range.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic @deprecated
 {
-	return string::new_format("[%s..%s]", self.start, self.end, .allocator = allocator);
+	return string::format("[%s..%s]", self.start, self.end, .allocator = allocator);
+}
+
+fn String Range.to_string(&self, Allocator allocator) @dynamic
+{
+	return string::format("[%s..%s]", self.start, self.end, .allocator = allocator);
 }
 
 fn String Range.to_tstring(&self)
 {
-	return self.to_new_string(allocator::temp());
+	return self.to_string(allocator::temp());
 }
 
 fn usz! Range.to_format(&self, Formatter* formatter) @dynamic
@@ -66,9 +71,14 @@ fn usz! ExclusiveRange.to_format(&self, Formatter* formatter) @dynamic
 	return formatter.printf("[%s..<%s]", self.start, self.end)!;
 }
 
-fn String ExclusiveRange.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
+fn String ExclusiveRange.to_new_string(&self, Allocator allocator = null) @dynamic
 {
-	return string::new_format("[%s..<%s]", self.start, self.end, .allocator = allocator);
+	return self.to_string(allocator ?: allocator::heap());
+}
+
+fn String ExclusiveRange.to_string(&self, Allocator allocator) @dynamic
+{
+	return string::format("[%s..<%s]", self.start, self.end, .allocator = allocator);
 }
 
 fn String ExclusiveRange.to_tstring(&self)
diff --git a/lib/std/core/dstring.c3 b/lib/std/core/dstring.c3
index 577a572b9..f369e9d28 100644
--- a/lib/std/core/dstring.c3
+++ b/lib/std/core/dstring.c3
@@ -292,7 +292,7 @@ fn void DString.append_chars(&self, String str)
 
 fn Char32[] DString.copy_utf32(&self, Allocator allocator = allocator::heap())
 {
-	return self.str_view().to_new_utf32(allocator) @inline!!;
+	return self.str_view().to_utf32(allocator) @inline!!;
 }
 
 fn void DString.append_string(&self, DString str)
diff --git a/lib/std/core/string.c3 b/lib/std/core/string.c3
index 61a764017..917ba8fd5 100644
--- a/lib/std/core/string.c3
+++ b/lib/std/core/string.c3
@@ -32,17 +32,6 @@ fault NumberConversion
 	FLOAT_OUT_OF_RANGE,
 }
 
-/**
- * Return a temporary String created using the formatting function.
- *
- * @param [in] fmt `The formatting string`
- **/
-macro String tformat(String fmt, ...)
-{
-	DString str = dstring::temp_with_capacity(fmt.len + $vacount * 8);
-	str.appendf(fmt, $vasplat);
-	return str.str_view();
-}
 
 /**
  * Return a temporary ZString created using the formatting function.
@@ -59,10 +48,10 @@ macro ZString tformat_zstr(String fmt, ...)
 /**
  * Return a new String created using the formatting function.
  *
- * @param [in] fmt `The formatting string`
  * @param [inout] allocator `The allocator to use`
+ * @param [in] fmt `The formatting string`
  **/
-macro String new_format(String fmt, ..., Allocator allocator = allocator::heap())
+macro String format(String fmt, ..., Allocator allocator)
 {
 	@pool(allocator)
 	{
@@ -72,6 +61,25 @@ macro String new_format(String fmt, ..., Allocator allocator = allocator::heap()
 	};
 }
 
+/**
+ * Return a heap allocated String created using the formatting function.
+ *
+ * @param [in] fmt `The formatting string`
+ **/
+macro String new_format(String fmt, ..., Allocator allocator = null) => format(fmt, $vasplat, .allocator = allocator ?: allocator::heap());
+
+/**
+ * Return a temporary String created using the formatting function.
+ *
+ * @param [in] fmt `The formatting string`
+ **/
+macro String tformat(String fmt, ...)
+{
+	DString str = dstring::temp_with_capacity(fmt.len + $vacount * 8);
+	str.appendf(fmt, $vasplat);
+	return str.str_view();
+}
+
 /**
  * Return a new ZString created using the formatting function.
  *
@@ -205,13 +213,12 @@ fn String String.strip_end(string, String needle)
 	return string[:(string.len - needle.len)];
 }
 
-
 /**
  * Split a string into parts, e.g "a|b|c" split with "|" yields { "a", "b", "c" }
  *
  * @param [in] s
  * @param [in] needle
- * @param [&inout] allocator "The allocator, defaults to the heap allocator"
+ * @param [&inout] allocator "The allocator to use for the String[]"
  * @param max "Max number of elements, 0 means no limit, defaults to 0"
  * @require needle.len > 0 "The needle must be at least 1 character long"
  * @ensure return.len > 0
@@ -246,6 +253,18 @@ fn String[] String.split(s, String needle, usz max = 0, Allocator allocator = al
 	return holder[:i];
 }
 
+/**
+ * Split a string into parts, e.g "a|b|c" split with "|" yields { "a", "b", "c" }, using the heap allocator
+ * to store the parts.
+ *
+ * @param [in] s
+ * @param [in] needle
+ * @param max "Max number of elements, 0 means no limit, defaults to 0"
+ * @require needle.len > 0 "The needle must be at least 1 character long"
+ * @ensure return.len > 0
+ **/
+fn String[] String.new_split(s, String needle, usz max = 0) => s.split(needle, max, allocator::heap()) @inline;
+
 /**
  * This function is identical to String.split, but implicitly uses the
  * temporary allocator.
@@ -254,10 +273,7 @@ fn String[] String.split(s, String needle, usz max = 0, Allocator allocator = al
  * @param [in] needle
  * @param max "Max number of elements, 0 means no limit, defaults to 0"
  **/
-fn String[] String.tsplit(s, String needle, usz max = 0)
-{
-	return s.split(needle, max, allocator::temp()) @inline;
-}
+fn String[] String.tsplit(s, String needle, usz max = 0) => s.split(needle, max, allocator::temp()) @inline;
 
 /**
  * Check if a substring is found in the string.
@@ -486,17 +502,15 @@ fn Char16[]! String.to_temp_utf16(s)
 	return s.to_new_utf16(allocator::temp());
 }
 
-fn WString! String.to_new_wstring(s, Allocator allocator = allocator::heap())
+fn WString! String.to_wstring(s, Allocator allocator)
 {
 	return (WString)s.to_new_utf16(allocator).ptr;
 }
 
-fn WString! String.to_temp_wstring(s)
-{
-	return (WString)s.to_temp_utf16().ptr;
-}
+fn WString! String.to_temp_wstring(s) => s.to_wstring(allocator::temp());
+fn WString! String.to_new_wstring(s) => s.to_wstring(allocator::heap());
 
-fn Char32[]! String.to_new_utf32(s, Allocator allocator = allocator::heap())
+fn Char32[]! String.to_utf32(s, Allocator allocator)
 {
 	usz codepoints = conv::utf8_codepoints(s);
 	Char32* data = allocator::alloc_array_try(allocator, Char32, codepoints + 1)!;
@@ -505,10 +519,8 @@ fn Char32[]! String.to_new_utf32(s, Allocator allocator = allocator::heap())
 	return data[:codepoints];
 }
 
-fn Char32[]! String.to_temp_utf32(s)
-{
-	return s.to_new_utf32(allocator::temp());
-}
+fn Char32[]! String.to_new_utf32(s) => s.to_utf32(allocator::heap()) @inline;
+fn Char32[]! String.to_temp_utf32(s) => s.to_utf32(allocator::temp()) @inline;
 
 /**
  * Convert a string to ASCII lower case.
diff --git a/lib/std/io/formatter.c3 b/lib/std/io/formatter.c3
index 4d5e740bd..857c34bf2 100644
--- a/lib/std/io/formatter.c3
+++ b/lib/std/io/formatter.c3
@@ -6,7 +6,8 @@ const int PRINTF_NTOA_BUFFER_SIZE = 256;
 
 interface Printable
 {
-	fn String to_new_string(Allocator allocator) @optional;
+	fn String to_string(Allocator allocator) @optional;
+	fn String to_new_string(Allocator allocator) @optional @deprecated("Use to_string");
 	fn usz! to_format(Formatter* formatter) @optional;
 }
 
@@ -88,7 +89,7 @@ fn usz! Formatter.print_with_function(&self, Printable arg)
 		if (!arg) return self.out_substr("(null)");
 		return arg.to_format(self);
 	}
-	if (&arg.to_new_string)
+	if (&arg.to_string)
 	{
 		PrintFlags old = self.flags;
 		uint old_width = self.width;
@@ -102,7 +103,7 @@ fn usz! Formatter.print_with_function(&self, Printable arg)
 		if (!arg) return self.out_substr("(null)");
 		@stack_mem(1024; Allocator mem)
 		{
-			return self.out_substr(arg.to_new_string(mem));
+			return self.out_substr(arg.to_string(mem));
 		};
 	}
 	return SearchResult.MISSING?;
diff --git a/test/test_suite/stdlib/map_linux.c3t b/test/test_suite/stdlib/map_linux.c3t
index 1168b6c79..d3a63b679 100644
--- a/test/test_suite/stdlib/map_linux.c3t
+++ b/test/test_suite/stdlib/map_linux.c3t
@@ -86,182 +86,190 @@ entry:
   ret { ptr, i64 } %11
 }
 
-; Function Attrs:
 define void @test.main() #0 {
 entry:
   %map = alloca %HashMap, align 8
+  %taddr = alloca %any, align 8
   %varargslots = alloca [1 x %any], align 16
   %retparam = alloca i64, align 8
   %literal = alloca %Foo, align 8
-  %varargslots4 = alloca [1 x %any], align 16
-  %retparam6 = alloca i64, align 8
-  %literal7 = alloca %Foo, align 8
-  %varargslots11 = alloca [1 x %any], align 16
-  %retparam13 = alloca i64, align 8
-  %varargslots14 = alloca [1 x %any], align 16
-  %retparam15 = alloca %Foo, align 8
-  %retparam16 = alloca i64, align 8
-  %varargslots19 = alloca [1 x %any], align 16
-  %taddr = alloca i8, align 1
-  %retparam20 = alloca i64, align 8
-  %varargslots23 = alloca [1 x %any], align 16
-  %taddr24 = alloca i8, align 1
-  %retparam25 = alloca i64, align 8
-  %literal28 = alloca %Foo, align 8
-  %varargslots32 = alloca [1 x %any], align 16
+  %varargslots5 = alloca [1 x %any], align 16
+  %retparam7 = alloca i64, align 8
+  %literal8 = alloca %Foo, align 8
+  %varargslots12 = alloca [1 x %any], align 16
+  %retparam14 = alloca i64, align 8
+  %varargslots15 = alloca [1 x %any], align 16
+  %retparam16 = alloca %Foo, align 8
+  %retparam17 = alloca i64, align 8
+  %varargslots20 = alloca [1 x %any], align 16
+  %taddr21 = alloca i8, align 1
+  %retparam22 = alloca i64, align 8
+  %varargslots25 = alloca [1 x %any], align 16
+  %taddr26 = alloca i8, align 1
+  %retparam27 = alloca i64, align 8
+  %literal30 = alloca %Foo, align 8
+  %varargslots34 = alloca [1 x %any], align 16
   %result = alloca %"Foo[]", align 8
-  %retparam35 = alloca i64, align 8
+  %retparam37 = alloca i64, align 8
   %map2 = alloca %HashMap.0, align 8
-  %varargslots40 = alloca [1 x %any], align 16
-  %taddr41 = alloca i8, align 1
-  %retparam42 = alloca i64, align 8
-  %varargslots45 = alloca [1 x %any], align 16
-  %taddr46 = alloca i8, align 1
-  %retparam47 = alloca i64, align 8
-  %varargslots50 = alloca [1 x %any], align 16
-  %result53 = alloca %"int[]", align 8
-  %retparam54 = alloca i64, align 8
-  %varargslots57 = alloca [1 x %any], align 16
-  %result60 = alloca %"double[]", align 8
-  %retparam61 = alloca i64, align 8
+  %taddr40 = alloca %any, align 8
+  %varargslots44 = alloca [1 x %any], align 16
+  %taddr45 = alloca i8, align 1
+  %retparam46 = alloca i64, align 8
+  %varargslots49 = alloca [1 x %any], align 16
+  %taddr50 = alloca i8, align 1
+  %retparam51 = alloca i64, align 8
+  %varargslots54 = alloca [1 x %any], align 16
+  %result57 = alloca %"int[]", align 8
+  %retparam58 = alloca i64, align 8
+  %varargslots61 = alloca [1 x %any], align 16
+  %result64 = alloca %"double[]", align 8
+  %retparam65 = alloca i64, align 8
   %current = alloca ptr, align 8
   %mark = alloca i64, align 8
   %map3 = alloca %HashMap.0, align 8
-  %varargslots67 = alloca [1 x %any], align 16
-  %result70 = alloca %"int[]", align 8
-  %retparam71 = alloca i64, align 8
+  %taddr69 = alloca %any, align 8
+  %varargslots73 = alloca [1 x %any], align 16
+  %result76 = alloca %"int[]", align 8
+  %retparam77 = alloca i64, align 8
   call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 48, i1 false)
-  %lo = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
-  %hi = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
+  store %any { ptr null, i64 ptrtoint (ptr @"$ct.void" to i64) }, ptr %taddr, align 8
+  %lo = load i64, ptr %taddr, align 8
+  %ptradd = getelementptr inbounds i8, ptr %taddr, i64 8
+  %hi = load ptr, ptr %ptradd, align 8
   %0 = call ptr @"std_collections_map$int$test.Foo$.HashMap.new_init"(ptr %map, i32 16, float 7.500000e-01, i64 %lo, ptr %hi)
-  %ptradd = getelementptr inbounds i8, ptr %map, i64 32
-  %1 = insertvalue %any undef, ptr %ptradd, 0
+  %ptradd1 = getelementptr inbounds i8, ptr %map, i64 32
+  %1 = insertvalue %any undef, ptr %ptradd1, 0
   %2 = insertvalue %any %1, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   store %any %2, ptr %varargslots, align 16
   %3 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 12, ptr %varargslots, i64 1)
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal, ptr align 8 @.__const, i32 16, i1 false)
-  %lo1 = load i32, ptr %literal, align 8
-  %ptradd2 = getelementptr inbounds i8, ptr %literal, i64 8
-  %hi3 = load ptr, ptr %ptradd2, align 8
-  %4 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo1, ptr %hi3)
-  %ptradd5 = getelementptr inbounds i8, ptr %map, i64 32
-  %5 = insertvalue %any undef, ptr %ptradd5, 0
+  %lo2 = load i32, ptr %literal, align 8
+  %ptradd3 = getelementptr inbounds i8, ptr %literal, i64 8
+  %hi4 = load ptr, ptr %ptradd3, align 8
+  %4 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo2, ptr %hi4)
+  %ptradd6 = getelementptr inbounds i8, ptr %map, i64 32
+  %5 = insertvalue %any undef, ptr %ptradd6, 0
   %6 = insertvalue %any %5, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
-  store %any %6, ptr %varargslots4, align 16
-  %7 = call i64 @std.io.printfn(ptr %retparam6, ptr @.str.1, i64 12, ptr %varargslots4, i64 1)
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal7, ptr align 8 @.__const.2, i32 16, i1 false)
-  %lo8 = load i32, ptr %literal7, align 8
-  %ptradd9 = getelementptr inbounds i8, ptr %literal7, i64 8
-  %hi10 = load ptr, ptr %ptradd9, align 8
-  %8 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo8, ptr %hi10)
-  %ptradd12 = getelementptr inbounds i8, ptr %map, i64 32
-  %9 = insertvalue %any undef, ptr %ptradd12, 0
+  store %any %6, ptr %varargslots5, align 16
+  %7 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.1, i64 12, ptr %varargslots5, i64 1)
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal8, ptr align 8 @.__const.2, i32 16, i1 false)
+  %lo9 = load i32, ptr %literal8, align 8
+  %ptradd10 = getelementptr inbounds i8, ptr %literal8, i64 8
+  %hi11 = load ptr, ptr %ptradd10, align 8
+  %8 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo9, ptr %hi11)
+  %ptradd13 = getelementptr inbounds i8, ptr %map, i64 32
+  %9 = insertvalue %any undef, ptr %ptradd13, 0
   %10 = insertvalue %any %9, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
-  store %any %10, ptr %varargslots11, align 16
-  %11 = call i64 @std.io.printfn(ptr %retparam13, ptr @.str.3, i64 12, ptr %varargslots11, i64 1)
-  %12 = call i64 @"std_collections_map$int$test.Foo$.HashMap.get"(ptr %retparam15, ptr %map, i32 1)
+  store %any %10, ptr %varargslots12, align 16
+  %11 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.3, i64 12, ptr %varargslots12, i64 1)
+  %12 = call i64 @"std_collections_map$int$test.Foo$.HashMap.get"(ptr %retparam16, ptr %map, i32 1)
   %not_err = icmp eq i64 %12, 0
   %13 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
-  br i1 %13, label %after_check, label %after_check18
+  br i1 %13, label %after_check, label %after_check19
 
 after_check:                                      ; preds = %entry
-  %14 = insertvalue %any undef, ptr %retparam15, 0
+  %14 = insertvalue %any undef, ptr %retparam16, 0
   %15 = insertvalue %any %14, i64 ptrtoint (ptr @"$ct.int" to i64), 1
-  store %any %15, ptr %varargslots14, align 16
-  %16 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.4, i64 7, ptr %varargslots14, i64 1)
-  %not_err17 = icmp eq i64 %16, 0
-  %17 = call i1 @llvm.expect.i1(i1 %not_err17, i1 true)
-  br i1 %17, label %after_check18, label %after_check18
+  store %any %15, ptr %varargslots15, align 16
+  %16 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.4, i64 7, ptr %varargslots15, i64 1)
+  %not_err18 = icmp eq i64 %16, 0
+  %17 = call i1 @llvm.expect.i1(i1 %not_err18, i1 true)
+  br i1 %17, label %after_check19, label %after_check19
 
-after_check18:                                    ; preds = %entry, %after_check, %after_check
+after_check19:                                    ; preds = %entry, %after_check, %after_check
   %18 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 1)
-  store i8 %18, ptr %taddr, align 1
-  %19 = insertvalue %any undef, ptr %taddr, 0
+  store i8 %18, ptr %taddr21, align 1
+  %19 = insertvalue %any undef, ptr %taddr21, 0
   %20 = insertvalue %any %19, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  store %any %20, ptr %varargslots19, align 16
-  %21 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.5, i64 9, ptr %varargslots19, i64 1)
+  store %any %20, ptr %varargslots20, align 16
+  %21 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.5, i64 9, ptr %varargslots20, i64 1)
   %22 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 2)
-  store i8 %22, ptr %taddr24, align 1
-  %23 = insertvalue %any undef, ptr %taddr24, 0
+  store i8 %22, ptr %taddr26, align 1
+  %23 = insertvalue %any undef, ptr %taddr26, 0
   %24 = insertvalue %any %23, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  store %any %24, ptr %varargslots23, align 16
-  %25 = call i64 @std.io.printfn(ptr %retparam25, ptr @.str.6, i64 9, ptr %varargslots23, i64 1)
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal28, ptr align 8 @.__const.7, i32 16, i1 false)
-  %lo29 = load i32, ptr %literal28, align 8
-  %ptradd30 = getelementptr inbounds i8, ptr %literal28, i64 8
-  %hi31 = load ptr, ptr %ptradd30, align 8
-  %26 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i32 %lo29, ptr %hi31)
-  %lo33 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
-  %hi34 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
-  %27 = call { ptr, i64 } @"std_collections_map$int$test.Foo$.HashMap.value_new_list"(ptr %map, i64 %lo33, ptr %hi34)
+  store %any %24, ptr %varargslots25, align 16
+  %25 = call i64 @std.io.printfn(ptr %retparam27, ptr @.str.6, i64 9, ptr %varargslots25, i64 1)
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal30, ptr align 8 @.__const.7, i32 16, i1 false)
+  %lo31 = load i32, ptr %literal30, align 8
+  %ptradd32 = getelementptr inbounds i8, ptr %literal30, i64 8
+  %hi33 = load ptr, ptr %ptradd32, align 8
+  %26 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i32 %lo31, ptr %hi33)
+  %lo35 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
+  %hi36 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
+  %27 = call { ptr, i64 } @"std_collections_map$int$test.Foo$.HashMap.value_new_list"(ptr %map, i64 %lo35, ptr %hi36)
   store { ptr, i64 } %27, ptr %result, align 8
   %28 = insertvalue %any undef, ptr %result, 0
   %29 = insertvalue %any %28, i64 ptrtoint (ptr @"$ct.sa$test.Foo" to i64), 1
-  store %any %29, ptr %varargslots32, align 16
-  %30 = call i64 @std.io.printfn(ptr %retparam35, ptr @.str.8, i64 10, ptr %varargslots32, i64 1)
+  store %any %29, ptr %varargslots34, align 16
+  %30 = call i64 @std.io.printfn(ptr %retparam37, ptr @.str.8, i64 10, ptr %varargslots34, i64 1)
   call void @llvm.memset.p0.i64(ptr align 8 %map2, i8 0, i64 48, i1 false)
-  %lo38 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
-  %hi39 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
-  %31 = call ptr @"std_collections_map$int$double$.HashMap.new_init"(ptr %map2, i32 16, float 7.500000e-01, i64 %lo38, ptr %hi39)
+  store %any { ptr null, i64 ptrtoint (ptr @"$ct.void" to i64) }, ptr %taddr40, align 8
+  %lo41 = load i64, ptr %taddr40, align 8
+  %ptradd42 = getelementptr inbounds i8, ptr %taddr40, i64 8
+  %hi43 = load ptr, ptr %ptradd42, align 8
+  %31 = call ptr @"std_collections_map$int$double$.HashMap.new_init"(ptr %map2, i32 16, float 7.500000e-01, i64 %lo41, ptr %hi43)
   %32 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 4, double 1.300000e+00)
   %33 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.300000e+00)
-  store i8 %33, ptr %taddr41, align 1
-  %34 = insertvalue %any undef, ptr %taddr41, 0
+  store i8 %33, ptr %taddr45, align 1
+  %34 = insertvalue %any undef, ptr %taddr45, 0
   %35 = insertvalue %any %34, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  store %any %35, ptr %varargslots40, align 16
-  %36 = call i64 @std.io.printfn(ptr %retparam42, ptr @.str.9, i64 12, ptr %varargslots40, i64 1)
+  store %any %35, ptr %varargslots44, align 16
+  %36 = call i64 @std.io.printfn(ptr %retparam46, ptr @.str.9, i64 12, ptr %varargslots44, i64 1)
   %37 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.200000e+00)
-  store i8 %37, ptr %taddr46, align 1
-  %38 = insertvalue %any undef, ptr %taddr46, 0
+  store i8 %37, ptr %taddr50, align 1
+  %38 = insertvalue %any undef, ptr %taddr50, 0
   %39 = insertvalue %any %38, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  store %any %39, ptr %varargslots45, align 16
-  %40 = call i64 @std.io.printfn(ptr %retparam47, ptr @.str.10, i64 12, ptr %varargslots45, i64 1)
+  store %any %39, ptr %varargslots49, align 16
+  %40 = call i64 @std.io.printfn(ptr %retparam51, ptr @.str.10, i64 12, ptr %varargslots49, i64 1)
   %41 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 100, double 3.400000e+00)
-  %lo51 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
-  %hi52 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
-  %42 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.key_new_list"(ptr %map2, i64 %lo51, ptr %hi52)
-  store { ptr, i64 } %42, ptr %result53, align 8
-  %43 = insertvalue %any undef, ptr %result53, 0
+  %lo55 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
+  %hi56 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
+  %42 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.key_new_list"(ptr %map2, i64 %lo55, ptr %hi56)
+  store { ptr, i64 } %42, ptr %result57, align 8
+  %43 = insertvalue %any undef, ptr %result57, 0
   %44 = insertvalue %any %43, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
-  store %any %44, ptr %varargslots50, align 16
-  %45 = call i64 @std.io.printfn(ptr %retparam54, ptr @.str.11, i64 2, ptr %varargslots50, i64 1)
-  %lo58 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
-  %hi59 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
-  %46 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.value_new_list"(ptr %map2, i64 %lo58, ptr %hi59)
-  store { ptr, i64 } %46, ptr %result60, align 8
-  %47 = insertvalue %any undef, ptr %result60, 0
+  store %any %44, ptr %varargslots54, align 16
+  %45 = call i64 @std.io.printfn(ptr %retparam58, ptr @.str.11, i64 2, ptr %varargslots54, i64 1)
+  %lo62 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
+  %hi63 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
+  %46 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.value_new_list"(ptr %map2, i64 %lo62, ptr %hi63)
+  store { ptr, i64 } %46, ptr %result64, align 8
+  %47 = insertvalue %any undef, ptr %result64, 0
   %48 = insertvalue %any %47, i64 ptrtoint (ptr @"$ct.sa$double" to i64), 1
-  store %any %48, ptr %varargslots57, align 16
-  %49 = call i64 @std.io.printfn(ptr %retparam61, ptr @.str.12, i64 2, ptr %varargslots57, i64 1)
+  store %any %48, ptr %varargslots61, align 16
+  %49 = call i64 @std.io.printfn(ptr %retparam65, ptr @.str.12, i64 2, ptr %varargslots61, i64 1)
   %50 = load ptr, ptr @std.core.mem.allocator.thread_temp_allocator, align 8
   %not = icmp eq ptr %50, null
   br i1 %not, label %if.then, label %if.exit
 
-if.then:                                          ; preds = %after_check18
+if.then:                                          ; preds = %after_check19
   call void @std.core.mem.allocator.init_default_temp_allocators()
   br label %if.exit
 
-if.exit:                                          ; preds = %if.then, %after_check18
+if.exit:                                          ; preds = %if.then, %after_check19
   %51 = load ptr, ptr @std.core.mem.allocator.thread_temp_allocator, align 8
   store ptr %51, ptr %current, align 8
   %52 = load ptr, ptr %current, align 8
-  %ptradd64 = getelementptr inbounds i8, ptr %52, i64 24
-  %53 = load i64, ptr %ptradd64, align 8
+  %ptradd68 = getelementptr inbounds i8, ptr %52, i64 24
+  %53 = load i64, ptr %ptradd68, align 8
   store i64 %53, ptr %mark, align 8
   call void @llvm.memset.p0.i64(ptr align 8 %map3, i8 0, i64 48, i1 false)
-  %lo65 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
-  %hi66 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
-  %54 = call ptr @"std_collections_map$int$double$.HashMap.new_init"(ptr %map3, i32 16, float 7.500000e-01, i64 %lo65, ptr %hi66)
+  store %any { ptr null, i64 ptrtoint (ptr @"$ct.void" to i64) }, ptr %taddr69, align 8
+  %lo70 = load i64, ptr %taddr69, align 8
+  %ptradd71 = getelementptr inbounds i8, ptr %taddr69, i64 8
+  %hi72 = load ptr, ptr %ptradd71, align 8
+  %54 = call ptr @"std_collections_map$int$double$.HashMap.new_init"(ptr %map3, i32 16, float 7.500000e-01, i64 %lo70, ptr %hi72)
   %55 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 5, double 3.200000e+00)
   %56 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 7, double 5.200000e+00)
-  %lo68 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
-  %hi69 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
-  %57 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.key_new_list"(ptr %map3, i64 %lo68, ptr %hi69)
-  store { ptr, i64 } %57, ptr %result70, align 8
-  %58 = insertvalue %any undef, ptr %result70, 0
+  %lo74 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
+  %hi75 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
+  %57 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.key_new_list"(ptr %map3, i64 %lo74, ptr %hi75)
+  store { ptr, i64 } %57, ptr %result76, align 8
+  %58 = insertvalue %any undef, ptr %result76, 0
   %59 = insertvalue %any %58, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
-  store %any %59, ptr %varargslots67, align 16
-  %60 = call i64 @std.io.printfn(ptr %retparam71, ptr @.str.13, i64 2, ptr %varargslots67, i64 1)
+  store %any %59, ptr %varargslots73, align 16
+  %60 = call i64 @std.io.printfn(ptr %retparam77, ptr @.str.13, i64 2, ptr %varargslots73, i64 1)
   %61 = load ptr, ptr %current, align 8
   %62 = load i64, ptr %mark, align 8
   call void @std.core.mem.allocator.TempAllocator.reset(ptr %61, i64 %62)
diff --git a/test/test_suite/stdlib/map_macos.c3t b/test/test_suite/stdlib/map_macos.c3t
index 67cec9a4f..352abcf67 100644
--- a/test/test_suite/stdlib/map_macos.c3t
+++ b/test/test_suite/stdlib/map_macos.c3t
@@ -86,182 +86,190 @@ entry:
   ret { ptr, i64 } %11
 }
 
-; Function Attrs:
 define void @test.main() #0 {
 entry:
   %map = alloca %HashMap, align 8
+  %taddr = alloca %any, align 8
   %varargslots = alloca [1 x %any], align 16
   %retparam = alloca i64, align 8
   %literal = alloca %Foo, align 8
-  %varargslots4 = alloca [1 x %any], align 16
-  %retparam6 = alloca i64, align 8
-  %literal7 = alloca %Foo, align 8
-  %varargslots11 = alloca [1 x %any], align 16
-  %retparam13 = alloca i64, align 8
-  %varargslots14 = alloca [1 x %any], align 16
-  %retparam15 = alloca %Foo, align 8
-  %retparam16 = alloca i64, align 8
-  %varargslots19 = alloca [1 x %any], align 16
-  %taddr = alloca i8, align 1
-  %retparam20 = alloca i64, align 8
-  %varargslots23 = alloca [1 x %any], align 16
-  %taddr24 = alloca i8, align 1
-  %retparam25 = alloca i64, align 8
-  %literal28 = alloca %Foo, align 8
-  %varargslots32 = alloca [1 x %any], align 16
+  %varargslots5 = alloca [1 x %any], align 16
+  %retparam7 = alloca i64, align 8
+  %literal8 = alloca %Foo, align 8
+  %varargslots12 = alloca [1 x %any], align 16
+  %retparam14 = alloca i64, align 8
+  %varargslots15 = alloca [1 x %any], align 16
+  %retparam16 = alloca %Foo, align 8
+  %retparam17 = alloca i64, align 8
+  %varargslots20 = alloca [1 x %any], align 16
+  %taddr21 = alloca i8, align 1
+  %retparam22 = alloca i64, align 8
+  %varargslots25 = alloca [1 x %any], align 16
+  %taddr26 = alloca i8, align 1
+  %retparam27 = alloca i64, align 8
+  %literal30 = alloca %Foo, align 8
+  %varargslots34 = alloca [1 x %any], align 16
   %result = alloca %"Foo[]", align 8
-  %retparam35 = alloca i64, align 8
+  %retparam37 = alloca i64, align 8
   %map2 = alloca %HashMap.0, align 8
-  %varargslots40 = alloca [1 x %any], align 16
-  %taddr41 = alloca i8, align 1
-  %retparam42 = alloca i64, align 8
-  %varargslots45 = alloca [1 x %any], align 16
-  %taddr46 = alloca i8, align 1
-  %retparam47 = alloca i64, align 8
-  %varargslots50 = alloca [1 x %any], align 16
-  %result53 = alloca %"int[]", align 8
-  %retparam54 = alloca i64, align 8
-  %varargslots57 = alloca [1 x %any], align 16
-  %result60 = alloca %"double[]", align 8
-  %retparam61 = alloca i64, align 8
+  %taddr40 = alloca %any, align 8
+  %varargslots44 = alloca [1 x %any], align 16
+  %taddr45 = alloca i8, align 1
+  %retparam46 = alloca i64, align 8
+  %varargslots49 = alloca [1 x %any], align 16
+  %taddr50 = alloca i8, align 1
+  %retparam51 = alloca i64, align 8
+  %varargslots54 = alloca [1 x %any], align 16
+  %result57 = alloca %"int[]", align 8
+  %retparam58 = alloca i64, align 8
+  %varargslots61 = alloca [1 x %any], align 16
+  %result64 = alloca %"double[]", align 8
+  %retparam65 = alloca i64, align 8
   %current = alloca ptr, align 8
   %mark = alloca i64, align 8
   %map3 = alloca %HashMap.0, align 8
-  %varargslots67 = alloca [1 x %any], align 16
-  %result70 = alloca %"int[]", align 8
-  %retparam71 = alloca i64, align 8
+  %taddr69 = alloca %any, align 8
+  %varargslots73 = alloca [1 x %any], align 16
+  %result76 = alloca %"int[]", align 8
+  %retparam77 = alloca i64, align 8
   call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 48, i1 false)
-  %lo = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
-  %hi = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
+  store %any { ptr null, i64 ptrtoint (ptr @"$ct.void" to i64) }, ptr %taddr, align 8
+  %lo = load i64, ptr %taddr, align 8
+  %ptradd = getelementptr inbounds i8, ptr %taddr, i64 8
+  %hi = load ptr, ptr %ptradd, align 8
   %0 = call ptr @"std_collections_map$int$test.Foo$.HashMap.new_init"(ptr %map, i32 16, float 7.500000e-01, i64 %lo, ptr %hi)
-  %ptradd = getelementptr inbounds i8, ptr %map, i64 32
-  %1 = insertvalue %any undef, ptr %ptradd, 0
+  %ptradd1 = getelementptr inbounds i8, ptr %map, i64 32
+  %1 = insertvalue %any undef, ptr %ptradd1, 0
   %2 = insertvalue %any %1, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   store %any %2, ptr %varargslots, align 16
   %3 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 12, ptr %varargslots, i64 1)
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal, ptr align 8 @.__const, i32 16, i1 false)
-  %lo1 = load i32, ptr %literal, align 8
-  %ptradd2 = getelementptr inbounds i8, ptr %literal, i64 8
-  %hi3 = load ptr, ptr %ptradd2, align 8
-  %4 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo1, ptr %hi3)
-  %ptradd5 = getelementptr inbounds i8, ptr %map, i64 32
-  %5 = insertvalue %any undef, ptr %ptradd5, 0
+  %lo2 = load i32, ptr %literal, align 8
+  %ptradd3 = getelementptr inbounds i8, ptr %literal, i64 8
+  %hi4 = load ptr, ptr %ptradd3, align 8
+  %4 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo2, ptr %hi4)
+  %ptradd6 = getelementptr inbounds i8, ptr %map, i64 32
+  %5 = insertvalue %any undef, ptr %ptradd6, 0
   %6 = insertvalue %any %5, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
-  store %any %6, ptr %varargslots4, align 16
-  %7 = call i64 @std.io.printfn(ptr %retparam6, ptr @.str.1, i64 12, ptr %varargslots4, i64 1)
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal7, ptr align 8 @.__const.2, i32 16, i1 false)
-  %lo8 = load i32, ptr %literal7, align 8
-  %ptradd9 = getelementptr inbounds i8, ptr %literal7, i64 8
-  %hi10 = load ptr, ptr %ptradd9, align 8
-  %8 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo8, ptr %hi10)
-  %ptradd12 = getelementptr inbounds i8, ptr %map, i64 32
-  %9 = insertvalue %any undef, ptr %ptradd12, 0
+  store %any %6, ptr %varargslots5, align 16
+  %7 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.1, i64 12, ptr %varargslots5, i64 1)
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal8, ptr align 8 @.__const.2, i32 16, i1 false)
+  %lo9 = load i32, ptr %literal8, align 8
+  %ptradd10 = getelementptr inbounds i8, ptr %literal8, i64 8
+  %hi11 = load ptr, ptr %ptradd10, align 8
+  %8 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo9, ptr %hi11)
+  %ptradd13 = getelementptr inbounds i8, ptr %map, i64 32
+  %9 = insertvalue %any undef, ptr %ptradd13, 0
   %10 = insertvalue %any %9, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
-  store %any %10, ptr %varargslots11, align 16
-  %11 = call i64 @std.io.printfn(ptr %retparam13, ptr @.str.3, i64 12, ptr %varargslots11, i64 1)
-  %12 = call i64 @"std_collections_map$int$test.Foo$.HashMap.get"(ptr %retparam15, ptr %map, i32 1)
+  store %any %10, ptr %varargslots12, align 16
+  %11 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.3, i64 12, ptr %varargslots12, i64 1)
+  %12 = call i64 @"std_collections_map$int$test.Foo$.HashMap.get"(ptr %retparam16, ptr %map, i32 1)
   %not_err = icmp eq i64 %12, 0
   %13 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
-  br i1 %13, label %after_check, label %after_check18
+  br i1 %13, label %after_check, label %after_check19
 
 after_check:                                      ; preds = %entry
-  %14 = insertvalue %any undef, ptr %retparam15, 0
+  %14 = insertvalue %any undef, ptr %retparam16, 0
   %15 = insertvalue %any %14, i64 ptrtoint (ptr @"$ct.int" to i64), 1
-  store %any %15, ptr %varargslots14, align 16
-  %16 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.4, i64 7, ptr %varargslots14, i64 1)
-  %not_err17 = icmp eq i64 %16, 0
-  %17 = call i1 @llvm.expect.i1(i1 %not_err17, i1 true)
-  br i1 %17, label %after_check18, label %after_check18
+  store %any %15, ptr %varargslots15, align 16
+  %16 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.4, i64 7, ptr %varargslots15, i64 1)
+  %not_err18 = icmp eq i64 %16, 0
+  %17 = call i1 @llvm.expect.i1(i1 %not_err18, i1 true)
+  br i1 %17, label %after_check19, label %after_check19
 
-after_check18:                                    ; preds = %entry, %after_check, %after_check
+after_check19:                                    ; preds = %entry, %after_check, %after_check
   %18 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 1)
-  store i8 %18, ptr %taddr, align 1
-  %19 = insertvalue %any undef, ptr %taddr, 0
+  store i8 %18, ptr %taddr21, align 1
+  %19 = insertvalue %any undef, ptr %taddr21, 0
   %20 = insertvalue %any %19, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  store %any %20, ptr %varargslots19, align 16
-  %21 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.5, i64 9, ptr %varargslots19, i64 1)
+  store %any %20, ptr %varargslots20, align 16
+  %21 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.5, i64 9, ptr %varargslots20, i64 1)
   %22 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 2)
-  store i8 %22, ptr %taddr24, align 1
-  %23 = insertvalue %any undef, ptr %taddr24, 0
+  store i8 %22, ptr %taddr26, align 1
+  %23 = insertvalue %any undef, ptr %taddr26, 0
   %24 = insertvalue %any %23, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  store %any %24, ptr %varargslots23, align 16
-  %25 = call i64 @std.io.printfn(ptr %retparam25, ptr @.str.6, i64 9, ptr %varargslots23, i64 1)
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal28, ptr align 8 @.__const.7, i32 16, i1 false)
-  %lo29 = load i32, ptr %literal28, align 8
-  %ptradd30 = getelementptr inbounds i8, ptr %literal28, i64 8
-  %hi31 = load ptr, ptr %ptradd30, align 8
-  %26 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i32 %lo29, ptr %hi31)
-  %lo33 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
-  %hi34 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
-  %27 = call { ptr, i64 } @"std_collections_map$int$test.Foo$.HashMap.value_new_list"(ptr %map, i64 %lo33, ptr %hi34)
+  store %any %24, ptr %varargslots25, align 16
+  %25 = call i64 @std.io.printfn(ptr %retparam27, ptr @.str.6, i64 9, ptr %varargslots25, i64 1)
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal30, ptr align 8 @.__const.7, i32 16, i1 false)
+  %lo31 = load i32, ptr %literal30, align 8
+  %ptradd32 = getelementptr inbounds i8, ptr %literal30, i64 8
+  %hi33 = load ptr, ptr %ptradd32, align 8
+  %26 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i32 %lo31, ptr %hi33)
+  %lo35 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
+  %hi36 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
+  %27 = call { ptr, i64 } @"std_collections_map$int$test.Foo$.HashMap.value_new_list"(ptr %map, i64 %lo35, ptr %hi36)
   store { ptr, i64 } %27, ptr %result, align 8
   %28 = insertvalue %any undef, ptr %result, 0
   %29 = insertvalue %any %28, i64 ptrtoint (ptr @"$ct.sa$test.Foo" to i64), 1
-  store %any %29, ptr %varargslots32, align 16
-  %30 = call i64 @std.io.printfn(ptr %retparam35, ptr @.str.8, i64 10, ptr %varargslots32, i64 1)
+  store %any %29, ptr %varargslots34, align 16
+  %30 = call i64 @std.io.printfn(ptr %retparam37, ptr @.str.8, i64 10, ptr %varargslots34, i64 1)
   call void @llvm.memset.p0.i64(ptr align 8 %map2, i8 0, i64 48, i1 false)
-  %lo38 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
-  %hi39 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
-  %31 = call ptr @"std_collections_map$int$double$.HashMap.new_init"(ptr %map2, i32 16, float 7.500000e-01, i64 %lo38, ptr %hi39)
+  store %any { ptr null, i64 ptrtoint (ptr @"$ct.void" to i64) }, ptr %taddr40, align 8
+  %lo41 = load i64, ptr %taddr40, align 8
+  %ptradd42 = getelementptr inbounds i8, ptr %taddr40, i64 8
+  %hi43 = load ptr, ptr %ptradd42, align 8
+  %31 = call ptr @"std_collections_map$int$double$.HashMap.new_init"(ptr %map2, i32 16, float 7.500000e-01, i64 %lo41, ptr %hi43)
   %32 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 4, double 1.300000e+00)
   %33 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.300000e+00)
-  store i8 %33, ptr %taddr41, align 1
-  %34 = insertvalue %any undef, ptr %taddr41, 0
+  store i8 %33, ptr %taddr45, align 1
+  %34 = insertvalue %any undef, ptr %taddr45, 0
   %35 = insertvalue %any %34, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  store %any %35, ptr %varargslots40, align 16
-  %36 = call i64 @std.io.printfn(ptr %retparam42, ptr @.str.9, i64 12, ptr %varargslots40, i64 1)
+  store %any %35, ptr %varargslots44, align 16
+  %36 = call i64 @std.io.printfn(ptr %retparam46, ptr @.str.9, i64 12, ptr %varargslots44, i64 1)
   %37 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.200000e+00)
-  store i8 %37, ptr %taddr46, align 1
-  %38 = insertvalue %any undef, ptr %taddr46, 0
+  store i8 %37, ptr %taddr50, align 1
+  %38 = insertvalue %any undef, ptr %taddr50, 0
   %39 = insertvalue %any %38, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
-  store %any %39, ptr %varargslots45, align 16
-  %40 = call i64 @std.io.printfn(ptr %retparam47, ptr @.str.10, i64 12, ptr %varargslots45, i64 1)
+  store %any %39, ptr %varargslots49, align 16
+  %40 = call i64 @std.io.printfn(ptr %retparam51, ptr @.str.10, i64 12, ptr %varargslots49, i64 1)
   %41 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 100, double 3.400000e+00)
-  %lo51 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
-  %hi52 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
-  %42 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.key_new_list"(ptr %map2, i64 %lo51, ptr %hi52)
-  store { ptr, i64 } %42, ptr %result53, align 8
-  %43 = insertvalue %any undef, ptr %result53, 0
+  %lo55 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
+  %hi56 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
+  %42 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.key_new_list"(ptr %map2, i64 %lo55, ptr %hi56)
+  store { ptr, i64 } %42, ptr %result57, align 8
+  %43 = insertvalue %any undef, ptr %result57, 0
   %44 = insertvalue %any %43, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
-  store %any %44, ptr %varargslots50, align 16
-  %45 = call i64 @std.io.printfn(ptr %retparam54, ptr @.str.11, i64 2, ptr %varargslots50, i64 1)
-  %lo58 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
-  %hi59 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
-  %46 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.value_new_list"(ptr %map2, i64 %lo58, ptr %hi59)
-  store { ptr, i64 } %46, ptr %result60, align 8
-  %47 = insertvalue %any undef, ptr %result60, 0
+  store %any %44, ptr %varargslots54, align 16
+  %45 = call i64 @std.io.printfn(ptr %retparam58, ptr @.str.11, i64 2, ptr %varargslots54, i64 1)
+  %lo62 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
+  %hi63 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
+  %46 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.value_new_list"(ptr %map2, i64 %lo62, ptr %hi63)
+  store { ptr, i64 } %46, ptr %result64, align 8
+  %47 = insertvalue %any undef, ptr %result64, 0
   %48 = insertvalue %any %47, i64 ptrtoint (ptr @"$ct.sa$double" to i64), 1
-  store %any %48, ptr %varargslots57, align 16
-  %49 = call i64 @std.io.printfn(ptr %retparam61, ptr @.str.12, i64 2, ptr %varargslots57, i64 1)
+  store %any %48, ptr %varargslots61, align 16
+  %49 = call i64 @std.io.printfn(ptr %retparam65, ptr @.str.12, i64 2, ptr %varargslots61, i64 1)
   %50 = load ptr, ptr @std.core.mem.allocator.thread_temp_allocator, align 8
   %not = icmp eq ptr %50, null
   br i1 %not, label %if.then, label %if.exit
 
-if.then:                                          ; preds = %after_check18
+if.then:                                          ; preds = %after_check19
   call void @std.core.mem.allocator.init_default_temp_allocators()
   br label %if.exit
 
-if.exit:                                          ; preds = %if.then, %after_check18
+if.exit:                                          ; preds = %if.then, %after_check19
   %51 = load ptr, ptr @std.core.mem.allocator.thread_temp_allocator, align 8
   store ptr %51, ptr %current, align 8
   %52 = load ptr, ptr %current, align 8
-  %ptradd64 = getelementptr inbounds i8, ptr %52, i64 24
-  %53 = load i64, ptr %ptradd64, align 8
+  %ptradd68 = getelementptr inbounds i8, ptr %52, i64 24
+  %53 = load i64, ptr %ptradd68, align 8
   store i64 %53, ptr %mark, align 8
   call void @llvm.memset.p0.i64(ptr align 8 %map3, i8 0, i64 48, i1 false)
-  %lo65 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
-  %hi66 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
-  %54 = call ptr @"std_collections_map$int$double$.HashMap.new_init"(ptr %map3, i32 16, float 7.500000e-01, i64 %lo65, ptr %hi66)
+  store %any { ptr null, i64 ptrtoint (ptr @"$ct.void" to i64) }, ptr %taddr69, align 8
+  %lo70 = load i64, ptr %taddr69, align 8
+  %ptradd71 = getelementptr inbounds i8, ptr %taddr69, i64 8
+  %hi72 = load ptr, ptr %ptradd71, align 8
+  %54 = call ptr @"std_collections_map$int$double$.HashMap.new_init"(ptr %map3, i32 16, float 7.500000e-01, i64 %lo70, ptr %hi72)
   %55 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 5, double 3.200000e+00)
   %56 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 7, double 5.200000e+00)
-  %lo68 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
-  %hi69 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
-  %57 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.key_new_list"(ptr %map3, i64 %lo68, ptr %hi69)
-  store { ptr, i64 } %57, ptr %result70, align 8
-  %58 = insertvalue %any undef, ptr %result70, 0
+  %lo74 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
+  %hi75 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
+  %57 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.key_new_list"(ptr %map3, i64 %lo74, ptr %hi75)
+  store { ptr, i64 } %57, ptr %result76, align 8
+  %58 = insertvalue %any undef, ptr %result76, 0
   %59 = insertvalue %any %58, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
-  store %any %59, ptr %varargslots67, align 16
-  %60 = call i64 @std.io.printfn(ptr %retparam71, ptr @.str.13, i64 2, ptr %varargslots67, i64 1)
+  store %any %59, ptr %varargslots73, align 16
+  %60 = call i64 @std.io.printfn(ptr %retparam77, ptr @.str.13, i64 2, ptr %varargslots73, i64 1)
   %61 = load ptr, ptr %current, align 8
   %62 = load i64, ptr %mark, align 8
   call void @std.core.mem.allocator.TempAllocator.reset(ptr %61, i64 %62)