From 99d91ccd31366e78c7ec0e94b5e3d473806721ed Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Feb 2025 11:32:49 +0000
Subject: Work on making name mangling deterministic

---
 src/llvm_backend_general.cpp | 43 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 41 insertions(+), 2 deletions(-)

(limited to 'src/llvm_backend_general.cpp')

diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index 7425b9fd7..dc212e51d 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -1444,6 +1444,7 @@ gb_internal void lb_clone_struct_type(LLVMTypeRef dst, LLVMTypeRef src) {
 }
 
 gb_internal String lb_mangle_name(Entity *e) {
+#if 1
 	String name = e->token.string;
 
 	AstPackage *pkg = e->pkg;
@@ -1483,9 +1484,18 @@ gb_internal String lb_mangle_name(Entity *e) {
 
 	String mangled_name = make_string((u8 const *)new_name, new_name_len-1);
 	return mangled_name;
+#else
+	gbString w = gb_string_make(gb_heap_allocator(), "");
+	w = write_canonical_entity_name(w, e);
+	gb_printf_err(">> %s\n", w);
+
+	String mangled_name = make_string(cast(u8 const *)w, gb_string_length(w));
+	return mangled_name;
+#endif
 }
 
 gb_internal String lb_set_nested_type_name_ir_mangled_name(Entity *e, lbProcedure *p, lbModule *module) {
+#if 0
 	// NOTE(bill, 2020-03-08): A polymorphic procedure may take a nested type declaration
 	// and as a result, the declaration does not have time to determine what it should be
 
@@ -1516,6 +1526,7 @@ gb_internal String lb_set_nested_type_name_ir_mangled_name(Entity *e, lbProcedur
 		}
 	}
 
+
 	// NOTE(bill): Generate a new name
 	// parent_proc.name-guid
 	String ts_name = e->token.string;
@@ -1528,6 +1539,12 @@ gb_internal String lb_set_nested_type_name_ir_mangled_name(Entity *e, lbProcedur
 
 		String name = make_string(cast(u8 *)name_text, name_len-1);
 		e->TypeName.ir_mangled_name = name;
+
+		{
+			String s = type_to_canonical_string(temporary_allocator(), e->type);
+			gb_printf_err("1) %.*s\n", LIT(s));
+			gb_printf_err("2) %.*s\n", LIT(name));
+		}
 		return name;
 	} else {
 		// NOTE(bill): a nested type be required before its parameter procedure exists. Just give it a temp name for now
@@ -1538,11 +1555,18 @@ gb_internal String lb_set_nested_type_name_ir_mangled_name(Entity *e, lbProcedur
 
 		String name = make_string(cast(u8 *)name_text, name_len-1);
 		e->TypeName.ir_mangled_name = name;
+
+		{
+			String s = type_to_canonical_string(temporary_allocator(), e->type);
+			gb_printf_err("3) %.*s\n", LIT(s));
+			gb_printf_err("4) %.*s\n", LIT(name));
+		}
 		return name;
 	}
+#endif
 }
 
-gb_internal String lb_get_entity_name(lbModule *m, Entity *e, String default_name) {
+gb_internal String lb_get_entity_name(lbModule *m, Entity *e) {
 	GB_ASSERT(m != nullptr);
 	if (e != nullptr && e->kind == Entity_TypeName && e->TypeName.ir_mangled_name.len != 0) {
 		return e->TypeName.ir_mangled_name;
@@ -1553,6 +1577,13 @@ gb_internal String lb_get_entity_name(lbModule *m, Entity *e, String default_nam
 		return e->token.string;
 	}
 
+#if 1
+	gbString w = gb_string_make(heap_allocator(), "");
+	w = write_canonical_entity_name(w, e);
+	defer (gb_string_free(w));
+
+	String name = copy_string(permanent_allocator(), make_string(cast(u8 const *)w, gb_string_length(w)));
+#else
 	if (e->kind == Entity_TypeName && (e->scope->flags & ScopeFlag_File) == 0) {
 		return lb_set_nested_type_name_ir_mangled_name(e, nullptr, m);
 	}
@@ -1576,11 +1607,17 @@ gb_internal String lb_get_entity_name(lbModule *m, Entity *e, String default_nam
 
 	if (!no_name_mangle) {
 		name = lb_mangle_name(e);
+
+		gbString w = gb_string_make(gb_heap_allocator(), "");
+		w = write_canonical_entity_name(w, e);
+		if (w[0] == 0) {
+			gb_printf_err(">> %s %.*s\n", w, LIT(name));
+		}
 	}
 	if (name.len == 0) {
 		name = e->token.string;
 	}
-
+#endif
 	if (e->kind == Entity_TypeName) {
 		e->TypeName.ir_mangled_name = name;
 	} else if (e->kind == Entity_Procedure) {
@@ -2869,6 +2906,8 @@ gb_internal lbValue lb_generate_anonymous_proc_lit(lbModule *m, String const &pr
 	pl->decl->code_gen_module = m;
 	e->decl_info = pl->decl;
 	pl->decl->entity = e;
+	e->parent_proc_decl = pl->decl->parent;
+	e->Procedure.is_anonymous = true;
 	e->flags |= EntityFlag_ProcBodyChecked;
 
 	lbProcedure *p = lb_create_procedure(m, e);
-- 
cgit v1.2.3


From b5cf776830151870730d32323502084d069668c3 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Feb 2025 11:48:54 +0000
Subject: Use new name canonicalization approach

---
 src/llvm_backend_general.cpp  | 6 ++++--
 src/name_canonicalization.cpp | 2 +-
 2 files changed, 5 insertions(+), 3 deletions(-)

(limited to 'src/llvm_backend_general.cpp')

diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index dc212e51d..6ff166899 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -1568,10 +1568,12 @@ gb_internal String lb_set_nested_type_name_ir_mangled_name(Entity *e, lbProcedur
 
 gb_internal String lb_get_entity_name(lbModule *m, Entity *e) {
 	GB_ASSERT(m != nullptr);
-	if (e != nullptr && e->kind == Entity_TypeName && e->TypeName.ir_mangled_name.len != 0) {
+	GB_ASSERT(e != nullptr);
+	if (e->kind == Entity_TypeName && e->TypeName.ir_mangled_name.len != 0) {
 		return e->TypeName.ir_mangled_name;
+	} else if (e->kind == Entity_Procedure && e->Procedure.link_name.len != 0) {
+		return e->Procedure.link_name;
 	}
-	GB_ASSERT(e != nullptr);
 
 	if (e->pkg == nullptr) {
 		return e->token.string;
diff --git a/src/name_canonicalization.cpp b/src/name_canonicalization.cpp
index fa09f27c0..48f7a18cb 100644
--- a/src/name_canonicalization.cpp
+++ b/src/name_canonicalization.cpp
@@ -180,7 +180,7 @@ gb_internal gbString write_canonical_entity_name(gbString w, Entity *e) {
 			w = gb_string_appendc(w, gb_bprintf(".[%.*s].", LIT(file_name)));
 			goto write_base_name;
 		}
-		gb_printf_err("%s HERE %s %u %p\n", token_pos_to_string(e->token.pos), type_to_string(e->type), s->flags, s->decl_info);
+		gb_printf_err("%s WEIRD ENTITY TYPE %s %u %p\n", token_pos_to_string(e->token.pos), type_to_string(e->type), s->flags, s->decl_info);
 		print_scope_flags(s);
 		GB_PANIC("weird entity");
 	}
-- 
cgit v1.2.3


From 043f9aea614b7fe5e1f62014ea34c7d3c155b0cb Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Feb 2025 12:40:43 +0000
Subject: Clean up rules for name mangling

---
 src/llvm_backend_general.cpp  | 162 ++----------------------------------------
 src/name_canonicalization.cpp |  81 +++++++++++++++------
 2 files changed, 64 insertions(+), 179 deletions(-)

(limited to 'src/llvm_backend_general.cpp')

diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index 6ff166899..7fdfa0bb2 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -1443,129 +1443,6 @@ gb_internal void lb_clone_struct_type(LLVMTypeRef dst, LLVMTypeRef src) {
 	LLVMStructSetBody(dst, fields, field_count, LLVMIsPackedStruct(src));
 }
 
-gb_internal String lb_mangle_name(Entity *e) {
-#if 1
-	String name = e->token.string;
-
-	AstPackage *pkg = e->pkg;
-	GB_ASSERT_MSG(pkg != nullptr, "Missing package for '%.*s'", LIT(name));
-	String pkgn = pkg->name;
-	GB_ASSERT(!rune_is_digit(pkgn[0]));
-	if (pkgn == "llvm") {
-		pkgn = str_lit("llvm$");
-	}
-
-	isize max_len = pkgn.len + 1 + name.len + 1;
-	bool require_suffix_id = is_type_polymorphic(e->type, true);
-
-	if ((e->scope->flags & (ScopeFlag_File | ScopeFlag_Pkg)) == 0) {
-		require_suffix_id = true;
-	} else if (is_blank_ident(e->token)) {
-		require_suffix_id = true;
-	}if (e->flags & EntityFlag_NotExported) {
-		require_suffix_id = true;
-	}
-
-	if (require_suffix_id) {
-		max_len += 21;
-	}
-
-	char *new_name = gb_alloc_array(permanent_allocator(), char, max_len);
-	isize new_name_len = gb_snprintf(
-		new_name, max_len,
-		"%.*s" ABI_PKG_NAME_SEPARATOR "%.*s", LIT(pkgn), LIT(name)
-	);
-	if (require_suffix_id) {
-		char *str = new_name + new_name_len-1;
-		isize len = max_len-new_name_len;
-		isize extra = gb_snprintf(str, len, "-%llu", cast(unsigned long long)e->id);
-		new_name_len += extra-1;
-	}
-
-	String mangled_name = make_string((u8 const *)new_name, new_name_len-1);
-	return mangled_name;
-#else
-	gbString w = gb_string_make(gb_heap_allocator(), "");
-	w = write_canonical_entity_name(w, e);
-	gb_printf_err(">> %s\n", w);
-
-	String mangled_name = make_string(cast(u8 const *)w, gb_string_length(w));
-	return mangled_name;
-#endif
-}
-
-gb_internal String lb_set_nested_type_name_ir_mangled_name(Entity *e, lbProcedure *p, lbModule *module) {
-#if 0
-	// NOTE(bill, 2020-03-08): A polymorphic procedure may take a nested type declaration
-	// and as a result, the declaration does not have time to determine what it should be
-
-	GB_ASSERT(e != nullptr && e->kind == Entity_TypeName);
-	if (e->TypeName.ir_mangled_name.len != 0)  {
-		return e->TypeName.ir_mangled_name;
-	}
-	GB_ASSERT((e->scope->flags & ScopeFlag_File) == 0);
-
-	if (p == nullptr) {
-		Entity *proc = nullptr;
-		if (e->parent_proc_decl != nullptr) {
-			proc = e->parent_proc_decl->entity;
-		} else {
-			Scope *scope = e->scope;
-			while (scope != nullptr && (scope->flags & ScopeFlag_Proc) == 0) {
-				scope = scope->parent;
-			}
-			GB_ASSERT(scope != nullptr);
-			GB_ASSERT(scope->flags & ScopeFlag_Proc);
-			proc = scope->procedure_entity;
-		}
-		if (proc != nullptr) {
-			GB_ASSERT(proc->kind == Entity_Procedure);
-			if (proc->code_gen_procedure != nullptr) {
-				p = proc->code_gen_procedure;
-			}
-		}
-	}
-
-
-	// NOTE(bill): Generate a new name
-	// parent_proc.name-guid
-	String ts_name = e->token.string;
-
-	if (p != nullptr) {
-		isize name_len = p->name.len + 1 + ts_name.len + 1 + 10 + 1;
-		char *name_text = gb_alloc_array(permanent_allocator(), char, name_len);
-		u32 guid = 1+p->module->nested_type_name_guid.fetch_add(1);
-		name_len = gb_snprintf(name_text, name_len, "%.*s" ABI_PKG_NAME_SEPARATOR "%.*s-%u", LIT(p->name), LIT(ts_name), guid);
-
-		String name = make_string(cast(u8 *)name_text, name_len-1);
-		e->TypeName.ir_mangled_name = name;
-
-		{
-			String s = type_to_canonical_string(temporary_allocator(), e->type);
-			gb_printf_err("1) %.*s\n", LIT(s));
-			gb_printf_err("2) %.*s\n", LIT(name));
-		}
-		return name;
-	} else {
-		// NOTE(bill): a nested type be required before its parameter procedure exists. Just give it a temp name for now
-		isize name_len = 9 + 1 + ts_name.len + 1 + 10 + 1;
-		char *name_text = gb_alloc_array(permanent_allocator(), char, name_len);
-		static std::atomic<u32> guid;
-		name_len = gb_snprintf(name_text, name_len, "_internal" ABI_PKG_NAME_SEPARATOR "%.*s-%u", LIT(ts_name), 1+guid.fetch_add(1));
-
-		String name = make_string(cast(u8 *)name_text, name_len-1);
-		e->TypeName.ir_mangled_name = name;
-
-		{
-			String s = type_to_canonical_string(temporary_allocator(), e->type);
-			gb_printf_err("3) %.*s\n", LIT(s));
-			gb_printf_err("4) %.*s\n", LIT(name));
-		}
-		return name;
-	}
-#endif
-}
-
 gb_internal String lb_get_entity_name(lbModule *m, Entity *e) {
 	GB_ASSERT(m != nullptr);
 	GB_ASSERT(e != nullptr);
@@ -1579,51 +1456,20 @@ gb_internal String lb_get_entity_name(lbModule *m, Entity *e) {
 		return e->token.string;
 	}
 
-#if 1
 	gbString w = gb_string_make(heap_allocator(), "");
 	w = write_canonical_entity_name(w, e);
 	defer (gb_string_free(w));
 
-	String name = copy_string(permanent_allocator(), make_string(cast(u8 const *)w, gb_string_length(w)));
-#else
-	if (e->kind == Entity_TypeName && (e->scope->flags & ScopeFlag_File) == 0) {
-		return lb_set_nested_type_name_ir_mangled_name(e, nullptr, m);
-	}
-
-	String name = {};
+	gb_printf_err("%s\n", w);
 
-	bool no_name_mangle = false;
-
-	if (e->kind == Entity_Variable) {
-		bool is_foreign = e->Variable.is_foreign;
-		bool is_export  = e->Variable.is_export;
-		no_name_mangle = e->Variable.link_name.len > 0 || is_foreign || is_export;
-		if (e->Variable.link_name.len > 0) {
-			return e->Variable.link_name;
-		}
-	} else if (e->kind == Entity_Procedure && e->Procedure.link_name.len > 0) {
-		return e->Procedure.link_name;
-	} else if (e->kind == Entity_Procedure && e->Procedure.is_export) {
-		no_name_mangle = true;
-	}
-
-	if (!no_name_mangle) {
-		name = lb_mangle_name(e);
+	String name = copy_string(permanent_allocator(), make_string(cast(u8 const *)w, gb_string_length(w)));
 
-		gbString w = gb_string_make(gb_heap_allocator(), "");
-		w = write_canonical_entity_name(w, e);
-		if (w[0] == 0) {
-			gb_printf_err(">> %s %.*s\n", w, LIT(name));
-		}
-	}
-	if (name.len == 0) {
-		name = e->token.string;
-	}
-#endif
 	if (e->kind == Entity_TypeName) {
 		e->TypeName.ir_mangled_name = name;
 	} else if (e->kind == Entity_Procedure) {
 		e->Procedure.link_name = name;
+	} else if (e->kind == Entity_Variable) {
+		e->Variable.link_name = name;
 	}
 
 	return name;
diff --git a/src/name_canonicalization.cpp b/src/name_canonicalization.cpp
index 48f7a18cb..3910c573d 100644
--- a/src/name_canonicalization.cpp
+++ b/src/name_canonicalization.cpp
@@ -1,3 +1,43 @@
+/*
+	General Rules for canonical name mangling
+
+	* No spaces between any values
+
+	* normal declarations - pkg.name
+	* builtin names - just their normal name e.g. `i32` or `string`
+	* nested - pkg.parent1.parent2.name
+	* file private - pkg.[file_name].name
+		* Example: `foo.[bar.odin].Type`
+	* polymorphic procedure/type - pkg.foo::TYPE
+		* naming convention for parameters
+			* type
+			* $typeid_based_name
+			* $$constant_parameter
+		* Example: `foo.to_thing::proc(u64)->([]u8)`
+	* nested decl in polymorphic procedure - pkg.foo::TYPE.name
+	* anonymous procedures - pkg.foo.$anon123
+		* 123 is the file offset in bytes
+
+
+*/
+
+#define CANONICAL_TYPE_SEPARATOR  ":"
+#define CANONICAL_NAME_SEPARATOR  "."
+
+#define CANONICAL_PARAM_SEPARATOR ","
+
+#define CANONICAL_PARAM_TYPEID    "$"
+#define CANONICAL_PARAM_CONST     "$$"
+
+#define CANONICAL_PARAM_C_VARARG  "#c_vararg"
+#define CANONICAL_PARAM_VARARG    ".."
+
+#define CANONICAL_FIELD_SEPARATOR ","
+
+#define CANONICAL_ANON_PREFIX     "$anon"
+
+#define CANONICAL_NONE_TYPE       "<>"
+
 gb_internal gbString write_type_to_canonical_string(gbString w, Type *type);
 gb_internal gbString write_canonical_params(gbString w, Type *params) {
 	w = gb_string_appendc(w, "(");
@@ -6,25 +46,25 @@ gb_internal gbString write_canonical_params(gbString w, Type *params) {
 		for_array(i, params->Tuple.variables) {
 			Entity *v = params->Tuple.variables[i];
 			if (i > 0) {
-				w = gb_string_appendc(w, ",");
+				w = gb_string_appendc(w, CANONICAL_PARAM_SEPARATOR);
 			}
 			if (v->kind == Entity_Variable) {
 				if (v->flags&EntityFlag_CVarArg) {
-					w = gb_string_appendc(w, "#c_vararg");
+					w = gb_string_appendc(w, CANONICAL_PARAM_C_VARARG);
 				}
 				if (v->flags&EntityFlag_Ellipsis) {
 					Type *slice = base_type(v->type);
-					w = gb_string_appendc(w, "..");
+					w = gb_string_appendc(w, CANONICAL_PARAM_VARARG);
 					GB_ASSERT(v->type->kind == Type_Slice);
 					w = write_type_to_canonical_string(w, slice->Slice.elem);
 				} else {
 					w = write_type_to_canonical_string(w, v->type);
 				}
 			} else if (v->kind == Entity_TypeName) {
-				w = gb_string_appendc(w, "$");
+				w = gb_string_appendc(w, CANONICAL_PARAM_TYPEID);
 				w = write_type_to_canonical_string(w, v->type);
 			} else if (v->kind == Entity_Constant) {
-				w = gb_string_appendc(w, "$$");
+				w = gb_string_appendc(w, CANONICAL_PARAM_CONST);
 				w = write_exact_value_to_string(w, v->Constant.value);
 			} else {
 				GB_PANIC("TODO(bill): handle non type/const parapoly parameter values");
@@ -88,24 +128,24 @@ gb_internal gbString write_canonical_parent_prefix(gbString w, Entity *e, bool i
 			w = write_canonical_parent_prefix(w, p);
 			w = gb_string_append_length(w, p->token.string.text, p->token.string.len);
 			if (is_type_polymorphic(p->type)) {
-				w = gb_string_appendc(w, "::");
+				w = gb_string_appendc(w, CANONICAL_TYPE_SEPARATOR);
 				w = write_type_to_canonical_string(w, p->type);
 			}
-			w = gb_string_appendc(w, ".");
+			w = gb_string_appendc(w, CANONICAL_NAME_SEPARATOR);
 
 		} else if (e->pkg && (scope_lookup_current(e->pkg->scope, e->token.string) == e)) {
 			w = gb_string_append_length(w, e->pkg->name.text, e->pkg->name.len);
 			if (e->pkg->name == "llvm") {
 				gb_string_appendc(w, "$");
 			}
-			w = gb_string_appendc(w, ".");
+			w = gb_string_appendc(w, CANONICAL_NAME_SEPARATOR);
 		} else {
 			String file_name = filename_without_directory(e->file->fullpath);
 			w = gb_string_append_length(w, e->pkg->name.text, e->pkg->name.len);
 			if (e->pkg->name == "llvm") {
 				gb_string_appendc(w, "$");
 			}
-			w = gb_string_appendc(w, gb_bprintf(".[%.*s].", LIT(file_name)));
+			w = gb_string_appendc(w, gb_bprintf(CANONICAL_NAME_SEPARATOR "[%.*s]" CANONICAL_NAME_SEPARATOR, LIT(file_name)));
 		}
 	} else if (e->kind == Entity_Procedure) {
 		if (e->Procedure.is_export || e->Procedure.is_foreign) {
@@ -116,17 +156,17 @@ gb_internal gbString write_canonical_parent_prefix(gbString w, Entity *e, bool i
 	}
 
 	if (e->kind == Entity_Procedure && e->Procedure.is_anonymous) {
-		w = gb_string_appendc(w, gb_bprintf("$anon%d", e->token.pos.offset));
+		w = gb_string_appendc(w, gb_bprintf(CANONICAL_ANON_PREFIX "%d", e->token.pos.offset));
 	} else {
 		w = gb_string_append_length(w, e->token.string.text, e->token.string.len);
 	}
 
 	if (is_type_polymorphic(e->type)) {
-		w = gb_string_appendc(w, "::");
+		w = gb_string_appendc(w, CANONICAL_TYPE_SEPARATOR);
 		w = write_type_to_canonical_string(w, e->type);
 	}
 	if (!ignore_final_dot) {
-		w = gb_string_appendc(w, ".");
+		w = gb_string_appendc(w, CANONICAL_NAME_SEPARATOR);
 	}
 
 	return w;
@@ -177,7 +217,7 @@ gb_internal gbString write_canonical_entity_name(gbString w, Entity *e) {
 			if (e->pkg->name == "llvm") {
 				gb_string_appendc(w, "$");
 			}
-			w = gb_string_appendc(w, gb_bprintf(".[%.*s].", LIT(file_name)));
+			w = gb_string_appendc(w, gb_bprintf(CANONICAL_NAME_SEPARATOR "[%.*s]" CANONICAL_NAME_SEPARATOR, LIT(file_name)));
 			goto write_base_name;
 		}
 		gb_printf_err("%s WEIRD ENTITY TYPE %s %u %p\n", token_pos_to_string(e->token.pos), type_to_string(e->type), s->flags, s->decl_info);
@@ -186,7 +226,7 @@ gb_internal gbString write_canonical_entity_name(gbString w, Entity *e) {
 	}
 	if (e->pkg != nullptr) {
 		w = gb_string_append_length(w, e->pkg->name.text, e->pkg->name.len);
-		w = gb_string_appendc(w, ".");
+		w = gb_string_appendc(w, CANONICAL_NAME_SEPARATOR);
 	}
 
 write_base_name:
@@ -210,7 +250,7 @@ write_base_name:
 	case Entity_Variable:
 		w = gb_string_append_length(w, e->token.string.text, e->token.string.len);
 		if (is_type_polymorphic(e->type)) {
-			w = gb_string_appendc(w, "::");
+			w = gb_string_appendc(w, CANONICAL_TYPE_SEPARATOR);
 			w = write_type_to_canonical_string(w, e->type);
 		}
 		return w;
@@ -225,7 +265,7 @@ write_base_name:
 // NOTE(bill): This exists so that we deterministically hash a type by serializing it to a canonical string
 gb_internal gbString write_type_to_canonical_string(gbString w, Type *type) {
 	if (type == nullptr) {
-		return gb_string_appendc(w, "<>"); // none/void type
+		return gb_string_appendc(w, CANONICAL_NONE_TYPE); // none/void type
 	}
 
 	type = default_type(type);
@@ -287,7 +327,7 @@ gb_internal gbString write_type_to_canonical_string(gbString w, Type *type) {
 			Entity *f = type->Enum.fields[i];
 			GB_ASSERT(f->kind == Entity_Constant);
 			if (i > 0) {
-				w = gb_string_appendc(w, ",");
+				w = gb_string_appendc(w, CANONICAL_FIELD_SEPARATOR);
 			}
 			w = gb_string_append_length(w, f->token.string.text, f->token.string.len);
 			w = gb_string_appendc(w, "=");
@@ -324,7 +364,7 @@ gb_internal gbString write_type_to_canonical_string(gbString w, Type *type) {
 		w = gb_string_appendc(w, "{");
 		for_array(i, type->Union.variants) {
 			Type *t = type->Union.variants[i];
-			if (i > 0) w = gb_string_appendc(w, ", ");
+			if (i > 0) w = gb_string_appendc(w, CANONICAL_FIELD_SEPARATOR);
 			w = write_type_to_canonical_string(w, t);
 		}
 		return gb_string_appendc(w, "}");
@@ -351,7 +391,7 @@ gb_internal gbString write_type_to_canonical_string(gbString w, Type *type) {
 			Entity *f = type->Struct.fields[i];
 			GB_ASSERT(f->kind == Entity_Variable);
 			if (i > 0) {
-				w = gb_string_appendc(w, ",");
+				w = gb_string_appendc(w, CANONICAL_FIELD_SEPARATOR);
 			}
 			w = gb_string_append_length       (w, f->token.string.text, f->token.string.len);
 			w = gb_string_appendc             (w, ":");
@@ -372,7 +412,7 @@ gb_internal gbString write_type_to_canonical_string(gbString w, Type *type) {
 		for (isize i = 0; i < type->BitField.fields.count; i++) {
 			Entity *f = type->BitField.fields[i];
 			if (i > 0) {
-				w = gb_string_appendc(w, ",");
+				w = gb_string_appendc(w, CANONICAL_FIELD_SEPARATOR);
 			}
 			w = gb_string_append_length(w, f->token.string.text, f->token.string.len);
 			w = gb_string_appendc(w, ":");
@@ -407,7 +447,6 @@ gb_internal gbString write_type_to_canonical_string(gbString w, Type *type) {
 		} else {
 			w = gb_string_append_length(w, type->Named.name.text, type->Named.name.len);
 		}
-		// Handle parapoly stuff here?
 		return w;
 
 	default:
-- 
cgit v1.2.3


From 9b26bb2e6a1e32e17102550b481c6909549b87e5 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Mon, 17 Feb 2025 13:10:38 +0000
Subject: Begin work on hash types

---
 src/checker.cpp               | 44 +++++++++++++++++++++++++++++++++++++++++--
 src/checker.hpp               |  7 ++++++-
 src/llvm_backend.cpp          |  7 ++++---
 src/llvm_backend_general.cpp  |  2 --
 src/llvm_backend_type.cpp     |  6 +++---
 src/name_canonicalization.cpp | 25 +++++++++++++++++++-----
 src/ptr_set.cpp               | 10 +++++-----
 src/types.cpp                 | 36 +++++++++++++++++++++++++++++++++--
 8 files changed, 114 insertions(+), 23 deletions(-)

(limited to 'src/llvm_backend_general.cpp')

diff --git a/src/checker.cpp b/src/checker.cpp
index c74a72a14..054d6aeb0 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -3,7 +3,10 @@
 #include "entity.cpp"
 #include "types.cpp"
 
-String get_final_microarchitecture();
+
+gb_internal u64 type_hash_canonical_type(Type *type);
+
+gb_internal String get_final_microarchitecture();
 
 gb_internal void check_expr(CheckerContext *c, Operand *operand, Ast *expression);
 gb_internal void check_expr_or_type(CheckerContext *c, Operand *operand, Ast *expression, Type *type_hint=nullptr);
@@ -2037,7 +2040,8 @@ gb_internal void add_type_info_type_internal(CheckerContext *c, Type *t) {
 			// Unique entry
 			// NOTE(bill): map entries grow linearly and in order
 			ti_index = c->info->type_info_types.count;
-			array_add(&c->info->type_info_types, t);
+			Type_Info_Type tt = {t, type_hash_canonical_type(t)};
+			array_add(&c->info->type_info_types, tt);
 		}
 		map_set(&c->checker->info.type_info_map, t, ti_index);
 
@@ -6725,6 +6729,42 @@ gb_internal void check_parsed_files(Checker *c) {
 		add_type_and_value(&c->builtin_ctx, u.expr, u.info->mode, u.info->type, u.info->value);
 	}
 
+	TIME_SECTION("check for type hash collisions");
+	{
+		PtrSet<uintptr> found = {};
+		ptr_set_init(&found, c->info.type_info_types.count);
+		defer (ptr_set_destroy(&found));
+		for (auto const &tt : c->info.type_info_types) {
+			if (ptr_set_update(&found, cast(uintptr)tt.hash)) {
+				Type *other_type = nullptr;
+				for (auto const &other : c->info.type_info_types) {
+					if (&tt == &other) {
+						continue;
+					}
+					if (cast(uintptr)other.hash == cast(uintptr)tt.hash &&
+					    !are_types_identical(tt.type, other.type)) {
+						other_type = other.type;
+						break;
+					}
+				}
+				if (other_type != nullptr) {
+					String ts = type_to_canonical_string(temporary_allocator(), tt.type);
+					String os = type_to_canonical_string(temporary_allocator(), other_type);
+					if (ts != os) {
+						compiler_error("%s found type hash collision with %s (hash = %llu)\n"
+						               "%s vs %s\n",
+						               type_to_string(tt.type), type_to_string(other_type), cast(unsigned long long)tt.hash,
+						               temp_canonical_string(tt.type),
+						               temp_canonical_string(other_type)
+						);
+					}
+				}
+			}
+		}
+	}
+
+
+
 	TIME_SECTION("sort init and fini procedures");
 	check_sort_init_and_fini_procedures(c);
 
diff --git a/src/checker.hpp b/src/checker.hpp
index 472ab8e50..c9a0c3302 100644
--- a/src/checker.hpp
+++ b/src/checker.hpp
@@ -409,6 +409,11 @@ struct Defineable {
 	String pos_str;
 };
 
+struct Type_Info_Type {
+	Type *type;
+	u64   hash; // see: type_hash_canonical_type
+};
+
 // CheckerInfo stores all the symbol information for a type-checked program
 struct CheckerInfo {
 	Checker *checker;
@@ -453,7 +458,7 @@ struct CheckerInfo {
 	PtrMap<Type *, GenTypesData *> gen_types;
 
 	BlockingMutex type_info_mutex; // NOT recursive
-	Array<Type *> type_info_types;
+	Array<Type_Info_Type> type_info_types;
 	PtrMap<Type *, isize> type_info_map;
 
 	BlockingMutex foreign_mutex; // NOT recursive
diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index 0896ea8c7..8cb480dd4 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -24,7 +24,7 @@
 #include "llvm_backend_stmt.cpp"
 #include "llvm_backend_proc.cpp"
 
-String get_default_microarchitecture() {
+gb_internal String get_default_microarchitecture() {
 	String default_march = str_lit("generic");
 	if (build_context.metrics.arch == TargetArch_amd64) {
 		// NOTE(bill): x86-64-v2 is more than enough for everyone
@@ -47,7 +47,7 @@ String get_default_microarchitecture() {
 	return default_march;
 }
 
-String get_final_microarchitecture() {
+gb_internal String get_final_microarchitecture() {
 	BuildContext *bc = &build_context;
 
 	String microarch = bc->microarch;
@@ -3182,7 +3182,8 @@ gb_internal bool lb_generate_code(lbGenerator *gen) {
 			isize count = 0;
 			isize offsets_extra = 0;
 
-			for (Type *t : m->info->type_info_types) {
+			for (auto const &tt : m->info->type_info_types) {
+				Type *t = tt.type;
 				isize index = lb_type_info_index(m->info, t, false);
 				if (index < 0) {
 					continue;
diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index 7fdfa0bb2..b9ae3d254 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -1460,8 +1460,6 @@ gb_internal String lb_get_entity_name(lbModule *m, Entity *e) {
 	w = write_canonical_entity_name(w, e);
 	defer (gb_string_free(w));
 
-	gb_printf_err("%s\n", w);
-
 	String name = copy_string(permanent_allocator(), make_string(cast(u8 const *)w, gb_string_length(w)));
 
 	if (e->kind == Entity_TypeName) {
diff --git a/src/llvm_backend_type.cpp b/src/llvm_backend_type.cpp
index 6c12b37be..6f9f94fbd 100644
--- a/src/llvm_backend_type.cpp
+++ b/src/llvm_backend_type.cpp
@@ -12,7 +12,7 @@ gb_internal isize lb_type_info_index(CheckerInfo *info, Type *type, bool err_on_
 		gb_printf_err("NOT FOUND lb_type_info_index:\n\t%s\n\t@ index %td\n\tmax count: %u\nFound:\n", type_to_string(type), index, set->count);
 		for (auto const &entry : *set) {
 			isize type_info_index = entry.key;
-			gb_printf_err("\t%s\n", type_to_string(info->type_info_types[type_info_index]));
+			gb_printf_err("\t%s\n", type_to_string(info->type_info_types[type_info_index].type));
 		}
 		GB_PANIC("NOT FOUND");
 	}
@@ -280,7 +280,7 @@ gb_internal void lb_setup_type_info_data_giant_array(lbModule *m, i64 global_typ
 	LLVMTypeRef *modified_types = lb_setup_modified_types_for_type_info(m, global_type_info_data_entity_count);
 	defer (gb_free(heap_allocator(), modified_types));
 	for_array(type_info_type_index, info->type_info_types) {
-		Type *t = info->type_info_types[type_info_type_index];
+		Type *t = info->type_info_types[type_info_type_index].type;
 		if (t == nullptr || t == t_invalid) {
 			continue;
 		}
@@ -343,7 +343,7 @@ gb_internal void lb_setup_type_info_data_giant_array(lbModule *m, i64 global_typ
 	};
 
 	for_array(type_info_type_index, info->type_info_types) {
-		Type *t = info->type_info_types[type_info_type_index];
+		Type *t = info->type_info_types[type_info_type_index].type;
 		if (t == nullptr || t == t_invalid) {
 			continue;
 		}
diff --git a/src/name_canonicalization.cpp b/src/name_canonicalization.cpp
index 3910c573d..8edb5e968 100644
--- a/src/name_canonicalization.cpp
+++ b/src/name_canonicalization.cpp
@@ -7,7 +7,7 @@
 	* builtin names - just their normal name e.g. `i32` or `string`
 	* nested - pkg.parent1.parent2.name
 	* file private - pkg.[file_name].name
-		* Example: `foo.[bar.odin].Type`
+		* Example: `pkg.[file.odin].Type`
 	* polymorphic procedure/type - pkg.foo::TYPE
 		* naming convention for parameters
 			* type
@@ -15,7 +15,7 @@
 			* $$constant_parameter
 		* Example: `foo.to_thing::proc(u64)->([]u8)`
 	* nested decl in polymorphic procedure - pkg.foo::TYPE.name
-	* anonymous procedures - pkg.foo.$anon123
+	* anonymous procedures - pkg.foo.$anon[file.odin:123]
 		* 123 is the file offset in bytes
 
 
@@ -38,7 +38,12 @@
 
 #define CANONICAL_NONE_TYPE       "<>"
 
+
 gb_internal gbString write_type_to_canonical_string(gbString w, Type *type);
+gb_internal u64      type_hash_canonical_type(Type *type);
+gb_internal String   type_to_canonical_string(gbAllocator allocator, Type *type);
+gb_internal gbString temp_canonical_string(Type *type);
+
 gb_internal gbString write_canonical_params(gbString w, Type *params) {
 	w = gb_string_appendc(w, "(");
 	if (params) {
@@ -81,7 +86,7 @@ gb_internal u64 type_hash_canonical_type(Type *type) {
 	TEMPORARY_ALLOCATOR_GUARD();
 	gbString w = write_type_to_canonical_string(gb_string_make(temporary_allocator(), ""), type);
 	u64 hash = fnv64a(w, gb_string_length(w));
-	return hash;
+	return hash ? hash : 1;
 }
 
 gb_internal String type_to_canonical_string(gbAllocator allocator, Type *type) {
@@ -90,6 +95,11 @@ gb_internal String type_to_canonical_string(gbAllocator allocator, Type *type) {
 	return make_string(cast(u8 const *)w, gb_string_length(w));
 }
 
+gb_internal gbString temp_canonical_string(Type *type) {
+	gbString w = gb_string_make(temporary_allocator(), "");
+	return write_type_to_canonical_string(w, type);
+}
+
 gb_internal void print_scope_flags(Scope *s) {
 	if (s->flags & ScopeFlag_Pkg)             gb_printf_err("Pkg ");
 	if (s->flags & ScopeFlag_Builtin)         gb_printf_err("Builtin ");
@@ -156,7 +166,8 @@ gb_internal gbString write_canonical_parent_prefix(gbString w, Entity *e, bool i
 	}
 
 	if (e->kind == Entity_Procedure && e->Procedure.is_anonymous) {
-		w = gb_string_appendc(w, gb_bprintf(CANONICAL_ANON_PREFIX "%d", e->token.pos.offset));
+		String file_name = filename_without_directory(e->file->fullpath);
+		w = gb_string_appendc(w, gb_bprintf(CANONICAL_ANON_PREFIX "[%.*s:%d]", LIT(file_name), e->token.pos.offset));
 	} else {
 		w = gb_string_append_length(w, e->token.string.text, e->token.string.len);
 	}
@@ -449,8 +460,12 @@ gb_internal gbString write_type_to_canonical_string(gbString w, Type *type) {
 		}
 		return w;
 
+	case Type_Tuple:
+		w = gb_string_appendc(w, "params");
+		w = write_canonical_params(w, type);
+		return w;
 	default:
-		GB_PANIC("unknown type kind %d", type->kind);
+		GB_PANIC("unknown type kind %d %.*s", type->kind, LIT(type_strings[type->kind]));
 		break;
 	}
 
diff --git a/src/ptr_set.cpp b/src/ptr_set.cpp
index ff4befc37..5097e2bb6 100644
--- a/src/ptr_set.cpp
+++ b/src/ptr_set.cpp
@@ -42,7 +42,7 @@ gb_internal void ptr_set_destroy(PtrSet<T> *s) {
 
 template <typename T>
 gb_internal isize ptr_set__find(PtrSet<T> *s, T ptr) {
-	GB_ASSERT(ptr != nullptr);
+	GB_ASSERT(ptr != 0);
 	if (s->count != 0) {
 	#if 0
 		for (usize i = 0; i < s->capacity; i++) {
@@ -58,7 +58,7 @@ gb_internal isize ptr_set__find(PtrSet<T> *s, T ptr) {
 			T key = s->keys[hash_index];
 			if (key == ptr) {
 				return hash_index;
-			} else if (key == nullptr) {
+			} else if (key == 0) {
 				return -1;
 			}
 			hash_index = (hash_index+1)&mask;
@@ -122,7 +122,7 @@ gb_internal bool ptr_set_update(PtrSet<T> *s, T ptr) { // returns true if it pre
 	for (usize i = 0; i < s->capacity; i++) {
 		T *key = &s->keys[hash_index];
 		GB_ASSERT(*key != ptr);
-		if (*key == (T)PtrSet<T>::TOMBSTONE || *key == nullptr) {
+		if (*key == (T)PtrSet<T>::TOMBSTONE || *key == 0) {
 			*key = ptr;
 			s->count++;
 			return false;
@@ -169,7 +169,7 @@ struct PtrSetIterator {
 				return *this;
 			}
 			T key = set->keys[index];
-			if (key != nullptr && key != (T)PtrSet<T>::TOMBSTONE) {
+			if (key != 0 && key != (T)PtrSet<T>::TOMBSTONE) {
 				return *this;
 			}
 		}
@@ -191,7 +191,7 @@ gb_internal PtrSetIterator<T> begin(PtrSet<T> &set) noexcept {
 	usize index = 0;
 	while (index < set.capacity) {
 		T key = set.keys[index];
-		if (key != nullptr && key != (T)PtrSet<T>::TOMBSTONE) {
+		if (key != 0 && key != (T)PtrSet<T>::TOMBSTONE) {
 			break;
 		}
 		index++;
diff --git a/src/types.cpp b/src/types.cpp
index d6dea56ad..15e1bcf45 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -2774,7 +2774,37 @@ gb_internal bool are_types_identical_internal(Type *x, Type *y, bool check_tuple
 
 
 	case Type_Enum:
-		return x == y; // NOTE(bill): All enums are unique
+		if (x == y) {
+			return true;
+		}
+		if (x->Enum.fields.count != y->Enum.fields.count) {
+			return false;
+		}
+		if (!are_types_identical(x->Enum.base_type, y->Enum.base_type)) {
+			return false;
+		}
+		if (x->Enum.min_value_index != y->Enum.min_value_index) {
+			return false;
+		}
+		if (x->Enum.max_value_index != y->Enum.max_value_index) {
+			return false;
+		}
+
+		for (isize i = 0; i < x->Enum.fields.count; i++) {
+			Entity *a = x->Enum.fields[i];
+			Entity *b = y->Enum.fields[i];
+			if (a->token.string != b->token.string) {
+				return false;
+			}
+			GB_ASSERT(a->kind == b->kind);
+			GB_ASSERT(a->kind == Entity_Constant);
+			bool same = compare_exact_values(Token_CmpEq, a->Constant.value, b->Constant.value);
+			if (!same) {
+				return false;
+			}
+		}
+
+		return true;
 
 	case Type_Union:
 		if (x->Union.variants.count == y->Union.variants.count &&
@@ -2832,7 +2862,9 @@ gb_internal bool are_types_identical_internal(Type *x, Type *y, bool check_tuple
 					return false;
 				}
 			}
-			return are_types_identical(x->Struct.polymorphic_params, y->Struct.polymorphic_params);
+			// TODO(bill): Which is the correct logic here?
+			// return are_types_identical(x->Struct.polymorphic_params, y->Struct.polymorphic_params);
+			return true;
 		}
 		break;
 
-- 
cgit v1.2.3


From 23efd1bd02703e12a4d97c2d7194d1175a28d56c Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Tue, 18 Feb 2025 14:21:40 +0000
Subject: Add `TypeWriter` stream to allow for in-place hashing and string
 generation

---
 src/checker.hpp               |  56 +----
 src/common.cpp                |   4 +-
 src/llvm_backend_general.cpp  |   4 +-
 src/name_canonicalization.cpp | 480 +++++++++++++++++++++++-------------------
 src/name_canonicalization.hpp |  88 ++++++++
 5 files changed, 361 insertions(+), 271 deletions(-)
 create mode 100644 src/name_canonicalization.hpp

(limited to 'src/llvm_backend_general.cpp')

diff --git a/src/checker.hpp b/src/checker.hpp
index b8878d745..8850d5c3f 100644
--- a/src/checker.hpp
+++ b/src/checker.hpp
@@ -167,61 +167,7 @@ typedef DECL_ATTRIBUTE_PROC(DeclAttributeProc);
 
 gb_internal void check_decl_attributes(CheckerContext *c, Array<Ast *> const &attributes, DeclAttributeProc *proc, AttributeContext *ac);
 
-struct TypeInfoPair {
-	Type *type;
-	u64   hash; // see: type_hash_canonical_type
-};
-
-struct TypeSet {
-	TypeInfoPair *keys;
-	usize count;
-	usize capacity;
-};
-
-static constexpr u64 TYPE_SET_TOMBSTONE = ~(u64)(0ull);
-
-struct TypeSetIterator {
-	TypeSet *set;
-	usize index;
-
-	TypeSetIterator &operator++() noexcept {
-		for (;;) {
-			++index;
-			if (set->capacity == index) {
-				return *this;
-			}
-			TypeInfoPair key = set->keys[index];
-			if (key.hash != 0 && key.hash != TYPE_SET_TOMBSTONE) {
-				return *this;
-			}
-		}
-	}
-
-	bool operator==(TypeSetIterator const &other) const noexcept {
-		return this->set == other.set && this->index == other.index;
-	}
-
-
-	operator TypeInfoPair *() const {
-		return &set->keys[index];
-	}
-};
-
-
-gb_internal void  type_set_init   (TypeSet *s, isize capacity = 16);
-gb_internal void  type_set_destroy(TypeSet *s);
-gb_internal Type *type_set_add    (TypeSet *s, Type *ptr);
-gb_internal Type *type_set_add    (TypeSet *s, TypeInfoPair pair);
-gb_internal bool  type_set_update (TypeSet *s, Type *ptr); // returns true if it previously existed
-gb_internal bool  type_set_update (TypeSet *s, TypeInfoPair pair); // returns true if it previously existed
-gb_internal bool  type_set_exists (TypeSet *s, Type *ptr);
-gb_internal void  type_set_remove (TypeSet *s, Type *ptr);
-gb_internal void  type_set_clear  (TypeSet *s);
-gb_internal TypeInfoPair *type_set_retrieve(TypeSet *s, Type *ptr);
-
-gb_internal TypeSetIterator begin(TypeSet &set) noexcept;
-gb_internal TypeSetIterator end(TypeSet &set) noexcept;
-
+#include "name_canonicalization.hpp"
 
 enum ProcCheckedState : u8 {
 	ProcCheckedState_Unchecked,
diff --git a/src/common.cpp b/src/common.cpp
index 0ef39bd10..ad1e5a851 100644
--- a/src/common.cpp
+++ b/src/common.cpp
@@ -134,9 +134,9 @@ gb_internal u32 fnv32a(void const *data, isize len) {
 	return h;
 }
 
-gb_internal u64 fnv64a(void const *data, isize len) {
+gb_internal u64 fnv64a(void const *data, isize len, u64 seed=0xcbf29ce484222325ull) {
 	u8 const *bytes = cast(u8 const *)data;
-	u64 h = 0xcbf29ce484222325ull;
+	u64 h = seed;
 	
 	for (; len >= 8; len -= 8, bytes += 8) {
 		h = (h ^ bytes[0]) * 0x100000001b3ull;
diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index b9ae3d254..233448ece 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -1456,11 +1456,11 @@ gb_internal String lb_get_entity_name(lbModule *m, Entity *e) {
 		return e->token.string;
 	}
 
-	gbString w = gb_string_make(heap_allocator(), "");
-	w = write_canonical_entity_name(w, e);
+	gbString w = string_canonical_entity_name(heap_allocator(), e);
 	defer (gb_string_free(w));
 
 	String name = copy_string(permanent_allocator(), make_string(cast(u8 const *)w, gb_string_length(w)));
+	gb_printf_err("%.*s\n", LIT(name));
 
 	if (e->kind == Entity_TypeName) {
 		e->TypeName.ir_mangled_name = name;
diff --git a/src/name_canonicalization.cpp b/src/name_canonicalization.cpp
index ef0e23f38..9c2858170 100644
--- a/src/name_canonicalization.cpp
+++ b/src/name_canonicalization.cpp
@@ -21,33 +21,6 @@
 
 */
 
-#define CANONICAL_TYPE_SEPARATOR  ":"
-#define CANONICAL_NAME_SEPARATOR  "."
-
-#define CANONICAL_PARAM_SEPARATOR ","
-
-#define CANONICAL_PARAM_TYPEID    "$"
-#define CANONICAL_PARAM_CONST     "$$"
-
-#define CANONICAL_PARAM_C_VARARG  "#c_vararg"
-#define CANONICAL_PARAM_VARARG    ".."
-
-#define CANONICAL_FIELD_SEPARATOR ","
-
-#define CANONICAL_ANON_PREFIX     "$anon"
-
-#define CANONICAL_NONE_TYPE       "<>"
-
-
-gb_internal gbString write_type_to_canonical_string(gbString w, Type *type);
-gb_internal u64      type_hash_canonical_type(Type *type);
-gb_internal String   type_to_canonical_string(gbAllocator allocator, Type *type);
-gb_internal gbString temp_canonical_string(Type *type);
-
-
-struct TypeInfoPair;
-struct TypeSet;
-
 gb_internal GB_COMPARE_PROC(type_info_pair_cmp) {
 	TypeInfoPair *x = cast(TypeInfoPair *)a;
 	TypeInfoPair *y = cast(TypeInfoPair *)b;
@@ -57,16 +30,6 @@ gb_internal GB_COMPARE_PROC(type_info_pair_cmp) {
 	return x->hash < y->hash ? -1 : +1;
 }
 
-gb_internal void  type_set_init   (TypeSet *s, isize capacity);
-gb_internal void  type_set_destroy(TypeSet *s);
-gb_internal Type *type_set_add    (TypeSet *s, Type *ptr);
-gb_internal Type *type_set_add    (TypeSet *s, TypeInfoPair pair);
-gb_internal bool  type_set_update (TypeSet *s, Type *ptr); // returns true if it previously existed
-gb_internal bool  type_set_update (TypeSet *s, TypeInfoPair pair); // returns true if it previously existed
-gb_internal bool  type_set_exists (TypeSet *s, Type *ptr);
-gb_internal void  type_set_remove (TypeSet *s, Type *ptr);
-gb_internal void  type_set_clear  (TypeSet *s);
-gb_internal TypeInfoPair *type_set_retrieve(TypeSet *s, Type *ptr);
 
 gb_internal gbAllocator type_set_allocator(void) {
 	return heap_allocator();
@@ -251,63 +214,138 @@ gb_internal gb_inline void type_set_clear(TypeSet *s) {
 }
 
 
-gb_internal gbString write_canonical_params(gbString w, Type *params) {
-	w = gb_string_appendc(w, "(");
+#define TYPE_WRITER_PROC(name) bool name(TypeWriter *w, void const *ptr, isize len)
+typedef TYPE_WRITER_PROC(TypeWriterProc);
+
+
+struct TypeWriter {
+	TypeWriterProc *proc;
+	void *user_data;
+};
+
+bool type_writer_append(TypeWriter *w, void const *ptr, isize len) {
+	return w->proc(w, ptr, len);
+}
+
+bool type_writer_appendb(TypeWriter *w, char b) {
+	return w->proc(w, &b, 1);
+}
+
+bool type_writer_appendc(TypeWriter *w, char const *str) {
+	isize len = gb_strlen(str);
+	return w->proc(w, str, len);
+}
+
+bool type_writer_append_fmt(TypeWriter *w, char const *fmt, ...) {
+	va_list va;
+	char *str;
+	va_start(va, fmt);
+	str = gb_bprintf_va(fmt, va);
+	va_end(va);
+
+	return type_writer_appendc(w, str);
+}
+
+
+
+TYPE_WRITER_PROC(type_writer_string_writer_proc) {
+	gbString *s = cast(gbString *)&w->user_data;
+	*s = gb_string_append_length(*s, ptr, len);
+	return true;
+}
+
+void type_writer_make_string(TypeWriter *w, gbAllocator allocator) {
+	w->user_data = gb_string_make(allocator, "");
+	w->proc = type_writer_string_writer_proc;
+}
+
+void type_writer_destroy_string(TypeWriter *w) {
+	gb_string_free(cast(gbString)w->user_data);
+}
+
+
+TYPE_WRITER_PROC(type_writer_hasher_writer_proc) {
+	u64 *seed = cast(u64 *)w->user_data;
+	*seed = fnv64a(ptr, len, *seed);
+	return true;
+}
+
+void type_writer_make_hasher(TypeWriter *w, u64 *hash) {
+	w->user_data = hash;
+	w->proc = type_writer_hasher_writer_proc;
+}
+
+
+
+
+gb_internal void write_canonical_params(TypeWriter *w, Type *params) {
+	type_writer_appendc(w, "(");
 	if (params) {
 		GB_ASSERT(params->kind == Type_Tuple);
 		for_array(i, params->Tuple.variables) {
 			Entity *v = params->Tuple.variables[i];
 			if (i > 0) {
-				w = gb_string_appendc(w, CANONICAL_PARAM_SEPARATOR);
+				type_writer_appendc(w, CANONICAL_PARAM_SEPARATOR);
 			}
-			w = gb_string_append_length(w, v->token.string.text, v->token.string.len);
-			w = gb_string_appendc(w, CANONICAL_TYPE_SEPARATOR);
+			type_writer_append(w, v->token.string.text, v->token.string.len);
+			type_writer_appendc(w, CANONICAL_TYPE_SEPARATOR);
 
 			if (v->kind == Entity_Variable) {
 				if (v->flags&EntityFlag_CVarArg) {
-					w = gb_string_appendc(w, CANONICAL_PARAM_C_VARARG);
+					type_writer_appendc(w, CANONICAL_PARAM_C_VARARG);
 				}
 				if (v->flags&EntityFlag_Ellipsis) {
 					Type *slice = base_type(v->type);
-					w = gb_string_appendc(w, CANONICAL_PARAM_VARARG);
+					type_writer_appendc(w, CANONICAL_PARAM_VARARG);
 					GB_ASSERT(v->type->kind == Type_Slice);
-					w = write_type_to_canonical_string(w, slice->Slice.elem);
+					write_type_to_canonical_string(w, slice->Slice.elem);
 				} else {
-					w = write_type_to_canonical_string(w, v->type);
+					write_type_to_canonical_string(w, v->type);
 				}
 			} else if (v->kind == Entity_TypeName) {
-				w = gb_string_appendc(w, CANONICAL_PARAM_TYPEID);
-				w = write_type_to_canonical_string(w, v->type);
+				type_writer_appendc(w, CANONICAL_PARAM_TYPEID);
+				write_type_to_canonical_string(w, v->type);
 			} else if (v->kind == Entity_Constant) {
-				w = gb_string_appendc(w, CANONICAL_PARAM_CONST);
-				w = write_exact_value_to_string(w, v->Constant.value);
+				type_writer_appendc(w, CANONICAL_PARAM_CONST);
+				gbString s = exact_value_to_string(v->Constant.value, 1<<16);
+				type_writer_append(w, s, gb_string_length(s));
+				gb_string_free(s);
 			} else {
 				GB_PANIC("TODO(bill): handle non type/const parapoly parameter values");
 			}
 		}
 	}
-	return gb_string_appendc(w, ")");
+	type_writer_appendc(w, ")");
+	return;
 }
 
 gb_internal u64 type_hash_canonical_type(Type *type) {
 	if (type == nullptr) {
 		return 0;
 	}
-	TEMPORARY_ALLOCATOR_GUARD();
-	gbString w = write_type_to_canonical_string(gb_string_make(temporary_allocator(), ""), type);
-	u64 hash = fnv64a(w, gb_string_length(w));
+	u64 hash = fnv64a(nullptr, 0);
+	TypeWriter w = {};
+	type_writer_make_hasher(&w, &hash);
+	write_type_to_canonical_string(&w, type);
+
 	return hash ? hash : 1;
 }
 
 gb_internal String type_to_canonical_string(gbAllocator allocator, Type *type) {
-	gbString w = gb_string_make(allocator, "");
-	w = write_type_to_canonical_string(w, type);
-	return make_string(cast(u8 const *)w, gb_string_length(w));
+	TypeWriter w = {};
+	type_writer_make_string(&w, allocator);
+	write_type_to_canonical_string(&w, type);
+
+	gbString s = cast(gbString)w.user_data;
+	return make_string(cast(u8 const *)s, gb_string_length(s));
 }
 
 gb_internal gbString temp_canonical_string(Type *type) {
-	gbString w = gb_string_make(temporary_allocator(), "");
-	return write_type_to_canonical_string(w, type);
+	TypeWriter w = {};
+	type_writer_make_string(&w, temporary_allocator());
+	write_type_to_canonical_string(&w, type);
+
+	return cast(gbString)w.user_data;
 }
 
 gb_internal void print_scope_flags(Scope *s) {
@@ -323,77 +361,74 @@ gb_internal void print_scope_flags(Scope *s) {
 	gb_printf_err("\n");
 }
 
+gb_internal gbString string_canonical_entity_name(gbAllocator allocator, Entity *e) {
+	TypeWriter w = {};
+	type_writer_make_string(&w, allocator);
+	write_canonical_entity_name(&w, e);
+	return cast(gbString)w.user_data;
+}
+
 
 
-gb_internal gbString write_canonical_parent_prefix(gbString w, Entity *e, bool ignore_final_dot=false) {
+gb_internal void write_canonical_parent_prefix(TypeWriter *w, Entity *e, bool ignore_final_dot=false) {
 	GB_ASSERT(e != nullptr);
 
-	// auto const &parent_entity = [](Scope *s) -> Entity* {
-	// 	while ((s->flags & (ScopeFlag_Proc|ScopeFlag_File)) == 0 && s->decl_info == nullptr) {
-	// 		s = s->parent;
-	// 	}
-	// 	if (s->decl_info && s->decl_info->entity) {
-	// 		return s->decl_info->entity;
-	// 	}
-	// 	return nullptr;
-	// };
-
 	if (e->kind == Entity_Procedure) {
 		if (e->Procedure.is_export || e->Procedure.is_foreign) {
 			// no prefix
-			return w;
+			return;
 		}
 		if (e->parent_proc_decl) {
 			Entity *p = e->parent_proc_decl->entity;
-			w = write_canonical_parent_prefix(w, p);
-			w = gb_string_append_length(w, p->token.string.text, p->token.string.len);
+			write_canonical_parent_prefix(w, p);
+			type_writer_append(w, p->token.string.text, p->token.string.len);
 			if (is_type_polymorphic(p->type)) {
-				w = gb_string_appendc(w, CANONICAL_TYPE_SEPARATOR);
-				w = write_type_to_canonical_string(w, p->type);
+				type_writer_appendc(w, CANONICAL_TYPE_SEPARATOR);
+				write_type_to_canonical_string(w, p->type);
 			}
-			w = gb_string_appendc(w, CANONICAL_NAME_SEPARATOR);
+			type_writer_appendc(w, CANONICAL_NAME_SEPARATOR);
 
 		} else if (e->pkg && (scope_lookup_current(e->pkg->scope, e->token.string) == e)) {
-			w = gb_string_append_length(w, e->pkg->name.text, e->pkg->name.len);
+			type_writer_append(w, e->pkg->name.text, e->pkg->name.len);
 			if (e->pkg->name == "llvm") {
-				gb_string_appendc(w, "$");
+				type_writer_appendc(w, "$");
 			}
-			w = gb_string_appendc(w, CANONICAL_NAME_SEPARATOR);
+			type_writer_appendc(w, CANONICAL_NAME_SEPARATOR);
 		} else {
 			String file_name = filename_without_directory(e->file->fullpath);
-			w = gb_string_append_length(w, e->pkg->name.text, e->pkg->name.len);
+			type_writer_append(w, e->pkg->name.text, e->pkg->name.len);
 			if (e->pkg->name == "llvm") {
-				gb_string_appendc(w, "$");
+				type_writer_appendc(w, "$");
 			}
-			w = gb_string_appendc(w, gb_bprintf(CANONICAL_NAME_SEPARATOR "[%.*s]" CANONICAL_NAME_SEPARATOR, LIT(file_name)));
+			type_writer_appendc(w, gb_bprintf(CANONICAL_NAME_SEPARATOR "[%.*s]" CANONICAL_NAME_SEPARATOR, LIT(file_name)));
 		}
 	} else if (e->kind == Entity_Procedure) {
 		if (e->Procedure.is_export || e->Procedure.is_foreign) {
 			// no prefix
-			return w;
+			return;
 		}
 		GB_PANIC("TODO(bill): handle entity kind: %d", e->kind);
 	}
 
 	if (e->kind == Entity_Procedure && e->Procedure.is_anonymous) {
 		String file_name = filename_without_directory(e->file->fullpath);
-		w = gb_string_appendc(w, gb_bprintf(CANONICAL_ANON_PREFIX "[%.*s:%d]", LIT(file_name), e->token.pos.offset));
+		type_writer_appendc(w, gb_bprintf(CANONICAL_ANON_PREFIX "[%.*s:%d]", LIT(file_name), e->token.pos.offset));
 	} else {
-		w = gb_string_append_length(w, e->token.string.text, e->token.string.len);
+		type_writer_append(w, e->token.string.text, e->token.string.len);
 	}
 
 	if (is_type_polymorphic(e->type)) {
-		w = gb_string_appendc(w, CANONICAL_TYPE_SEPARATOR);
-		w = write_type_to_canonical_string(w, e->type);
+		type_writer_appendc(w, CANONICAL_TYPE_SEPARATOR);
+		write_type_to_canonical_string(w, e->type);
 	}
 	if (!ignore_final_dot) {
-		w = gb_string_appendc(w, CANONICAL_NAME_SEPARATOR);
+		type_writer_appendc(w, CANONICAL_NAME_SEPARATOR);
 	}
 
-	return w;
+	return;
 }
 
-gb_internal gbString write_canonical_entity_name(gbString w, Entity *e) {
+gb_internal void write_canonical_entity_name(TypeWriter *w, Entity *e) {
 	GB_ASSERT(e != nullptr);
 
 	if (e->token.string == "_") {
@@ -407,18 +442,18 @@ gb_internal gbString write_canonical_entity_name(gbString w, Entity *e) {
 		bool is_foreign = e->Variable.is_foreign;
 		bool is_export  = e->Variable.is_export;
 		if (e->Variable.link_name.len > 0) {
-			w = gb_string_append_length(w, e->Variable.link_name.text, e->Variable.link_name.len);
-			return w;
+			type_writer_append(w, e->Variable.link_name.text, e->Variable.link_name.len);
+			return;
 		} else if (is_foreign || is_export) {
-			w = gb_string_append_length(w, e->token.string.text, e->token.string.len);
-			return w;
+			type_writer_append(w, e->token.string.text, e->token.string.len);
+			return;
 		}
 	} else if (e->kind == Entity_Procedure && e->Procedure.link_name.len > 0) {
-		w = gb_string_append_length(w, e->Procedure.link_name.text, e->Procedure.link_name.len);
-		return w;
+		type_writer_append(w, e->Procedure.link_name.text, e->Procedure.link_name.len);
+		return;
 	} else if (e->kind == Entity_Procedure && e->Procedure.is_export) {
-		w = gb_string_append_length(w, e->token.string.text, e->token.string.len);
-		return w;
+		type_writer_append(w, e->token.string.text, e->token.string.len);
+		return;
 	}
 
 	if ((e->scope->flags & (ScopeFlag_File | ScopeFlag_Pkg)) == 0 ||
@@ -430,15 +465,15 @@ gb_internal gbString write_canonical_entity_name(gbString w, Entity *e) {
 		}
 
 		if (s->decl_info != nullptr && s->decl_info->entity)  {
-			w = write_canonical_parent_prefix(w, s->decl_info->entity);
+			write_canonical_parent_prefix(w, s->decl_info->entity);
 			goto write_base_name;
 		} else if ((s->flags & ScopeFlag_File) && s->file != nullptr) {
 			String file_name = filename_without_directory(s->file->fullpath);
-			w = gb_string_append_length(w, e->pkg->name.text, e->pkg->name.len);
+			type_writer_append(w, e->pkg->name.text, e->pkg->name.len);
 			if (e->pkg->name == "llvm") {
-				gb_string_appendc(w, "$");
+				type_writer_appendc(w, "$");
 			}
-			w = gb_string_appendc(w, gb_bprintf(CANONICAL_NAME_SEPARATOR "[%.*s]" CANONICAL_NAME_SEPARATOR, LIT(file_name)));
+			type_writer_appendc(w, gb_bprintf(CANONICAL_NAME_SEPARATOR "[%.*s]" CANONICAL_NAME_SEPARATOR, LIT(file_name)));
 			goto write_base_name;
 		}
 		gb_printf_err("%s WEIRD ENTITY TYPE %s %u %p\n", token_pos_to_string(e->token.pos), type_to_string(e->type), s->flags, s->decl_info);
@@ -446,8 +481,8 @@ gb_internal gbString write_canonical_entity_name(gbString w, Entity *e) {
 		GB_PANIC("weird entity");
 	}
 	if (e->pkg != nullptr) {
-		w = gb_string_append_length(w, e->pkg->name.text, e->pkg->name.len);
-		w = gb_string_appendc(w, CANONICAL_NAME_SEPARATOR);
+		type_writer_append(w, e->pkg->name.text, e->pkg->name.len);
+		type_writer_appendc(w, CANONICAL_NAME_SEPARATOR);
 	}
 
 write_base_name:
@@ -459,37 +494,38 @@ write_base_name:
 			Type *params = nullptr;
 			Entity *parent = type_get_polymorphic_parent(e->type, &params);
 			if (parent && (parent->token.string == e->token.string)) {
-				w = gb_string_append_length(w, parent->token.string.text, parent->token.string.len);
-				w = write_canonical_params(w, params);
+				type_writer_append(w, parent->token.string.text, parent->token.string.len);
+				write_canonical_params(w, params);
 			} else {
-				w = gb_string_append_length(w, e->token.string.text, e->token.string.len);
+				type_writer_append(w, e->token.string.text, e->token.string.len);
 			}
 			gb_unused(parent);
 
 		}
 		// Handle parapoly stuff here?
-		return w;
+		return;
 
 	case Entity_Procedure:
 	case Entity_Variable:
-		w = gb_string_append_length(w, e->token.string.text, e->token.string.len);
+		type_writer_append(w, e->token.string.text, e->token.string.len);
 		if (is_type_polymorphic(e->type)) {
-			w = gb_string_appendc(w, CANONICAL_TYPE_SEPARATOR);
-			w = write_type_to_canonical_string(w, e->type);
+			type_writer_appendc(w, CANONICAL_TYPE_SEPARATOR);
+			write_type_to_canonical_string(w, e->type);
 		}
-		return w;
+		return;
 
 	default:
 		GB_PANIC("TODO(bill): entity kind %d", e->kind);
 		break;
 	}
-	return w;
+	return;
 }
 
 // NOTE(bill): This exists so that we deterministically hash a type by serializing it to a canonical string
-gb_internal gbString write_type_to_canonical_string(gbString w, Type *type) {
+gb_internal void write_type_to_canonical_string(TypeWriter *w, Type *type) {
 	if (type == nullptr) {
-		return gb_string_appendc(w, CANONICAL_NONE_TYPE); // none/void type
+		type_writer_appendc(w, CANONICAL_NONE_TYPE); // none/void type
+		return;
 	}
 
 	type = default_type(type);
@@ -497,190 +533,210 @@ gb_internal gbString write_type_to_canonical_string(gbString w, Type *type) {
 
 	switch (type->kind) {
 	case Type_Basic:
-		return gb_string_append_length(w, type->Basic.name.text, type->Basic.name.len);
+		type_writer_append(w, type->Basic.name.text, type->Basic.name.len);
+		return;
 	case Type_Pointer:
-		w = gb_string_append_rune(w, '^');
-		return write_type_to_canonical_string(w, type->Pointer.elem);
+		type_writer_appendb(w, '^');
+		write_type_to_canonical_string(w, type->Pointer.elem);
+		return;
 	case Type_MultiPointer:
-		w = gb_string_appendc(w, "[^]");
-		return write_type_to_canonical_string(w, type->Pointer.elem);
+		type_writer_appendc(w, "[^]");
+		write_type_to_canonical_string(w, type->Pointer.elem);
+		return;
 	case Type_SoaPointer:
-		w = gb_string_appendc(w, "#soa^");
-		return write_type_to_canonical_string(w, type->Pointer.elem);
+		type_writer_appendc(w, "#soa^");
+		write_type_to_canonical_string(w, type->Pointer.elem);
+		return;
 	case Type_EnumeratedArray:
 		if (type->EnumeratedArray.is_sparse) {
-			w = gb_string_appendc(w, "#sparse");
+			type_writer_appendc(w, "#sparse");
 		}
-		w = gb_string_append_rune(w, '[');
-		w = write_type_to_canonical_string(w, type->EnumeratedArray.index);
-		w = gb_string_append_rune(w, ']');
-		return write_type_to_canonical_string(w, type->EnumeratedArray.elem);
+		type_writer_appendb(w, '[');
+		write_type_to_canonical_string(w, type->EnumeratedArray.index);
+		type_writer_appendb(w, ']');
+		write_type_to_canonical_string(w, type->EnumeratedArray.elem);
+		return;
 	case Type_Array:
-		w = gb_string_appendc(w, gb_bprintf("[%lld]", cast(long long)type->Array.count));
-		return write_type_to_canonical_string(w, type->Array.elem);
+		type_writer_append_fmt(w, "[%lld]", cast(long long)type->Array.count);
+		write_type_to_canonical_string(w, type->Array.elem);
+		return;
 	case Type_Slice:
-		w = gb_string_appendc(w, "[]");
-		return write_type_to_canonical_string(w, type->Array.elem);
+		type_writer_appendc(w, "[]");
+		write_type_to_canonical_string(w, type->Array.elem);
+		return;
 	case Type_DynamicArray:
-		w = gb_string_appendc(w, "[dynamic]");
-		return write_type_to_canonical_string(w, type->DynamicArray.elem);
+		type_writer_appendc(w, "[dynamic]");
+		write_type_to_canonical_string(w, type->DynamicArray.elem);
+		return;
 	case Type_SimdVector:
-		w = gb_string_appendc(w, gb_bprintf("#simd[%lld]", cast(long long)type->SimdVector.count));
-		return write_type_to_canonical_string(w, type->SimdVector.elem);
+		type_writer_append_fmt(w, "#simd[%lld]", cast(long long)type->SimdVector.count);
+		write_type_to_canonical_string(w, type->SimdVector.elem);
+		return;
 	case Type_Matrix:
 		if (type->Matrix.is_row_major) {
-			w = gb_string_appendc(w, "#row_major ");
+			type_writer_appendc(w, "#row_major ");
 		}
-		w = gb_string_appendc(w, gb_bprintf("matrix[%lld, %lld]", cast(long long)type->Matrix.row_count, cast(long long)type->Matrix.column_count));
-		return write_type_to_canonical_string(w, type->Matrix.elem);
+		type_writer_append_fmt(w, "matrix[%lld, %lld]", cast(long long)type->Matrix.row_count, cast(long long)type->Matrix.column_count);
+		write_type_to_canonical_string(w, type->Matrix.elem);
+		return;
 	case Type_Map:
-		w = gb_string_appendc(w, "map[");
-		w = write_type_to_canonical_string(w, type->Map.key);
-		w = gb_string_appendc(w, "]");
-		return write_type_to_canonical_string(w, type->Map.value);
+		type_writer_appendc(w, "map[");
+		write_type_to_canonical_string(w, type->Map.key);
+		type_writer_appendc(w, "]");
+		write_type_to_canonical_string(w, type->Map.value);
+		return;
 
 	case Type_Enum:
-		w = gb_string_appendc(w, "enum");
+		type_writer_appendc(w, "enum");
 		if (type->Enum.base_type != nullptr) {
-			w = gb_string_append_rune(w, ' ');
-			w = write_type_to_canonical_string(w, type->Enum.base_type);
-			w = gb_string_append_rune(w, ' ');
+			type_writer_appendb(w, ' ');
+			write_type_to_canonical_string(w, type->Enum.base_type);
+			type_writer_appendb(w, ' ');
 		}
-		w = gb_string_append_rune(w, '{');
+		type_writer_appendb(w, '{');
 		for_array(i, type->Enum.fields) {
 			Entity *f = type->Enum.fields[i];
 			GB_ASSERT(f->kind == Entity_Constant);
 			if (i > 0) {
-				w = gb_string_appendc(w, CANONICAL_FIELD_SEPARATOR);
+				type_writer_appendc(w, CANONICAL_FIELD_SEPARATOR);
 			}
-			w = gb_string_append_length(w, f->token.string.text, f->token.string.len);
-			w = gb_string_appendc(w, "=");
-			w = write_exact_value_to_string(w, f->Constant.value);
+			type_writer_append(w, f->token.string.text, f->token.string.len);
+			type_writer_appendc(w, "=");
+
+			gbString s = exact_value_to_string(f->Constant.value, 1<<16);
+			type_writer_append(w, s, gb_string_length(s));
+			gb_string_free(s);
 		}
-		return gb_string_append_rune(w, '}');
+		type_writer_appendb(w, '}');
+		return;
 	case Type_BitSet:
-		w = gb_string_appendc(w, "bit_set[");
+		type_writer_appendc(w, "bit_set[");
 		if (type->BitSet.elem == nullptr) {
-			w = write_type_to_canonical_string(w, type->BitSet.elem);
+			type_writer_appendc(w, CANONICAL_NONE_TYPE);
 		} else if (is_type_enum(type->BitSet.elem)) {
-			w = write_type_to_canonical_string(w, type->BitSet.elem);
+			write_type_to_canonical_string(w, type->BitSet.elem);
 		} else {
-			w = gb_string_append_fmt(w, "%lld", type->BitSet.lower);
-			w = gb_string_append_fmt(w, "..=");
-			w = gb_string_append_fmt(w, "%lld", type->BitSet.upper);
+			type_writer_append_fmt(w, "%lld", type->BitSet.lower);
+			type_writer_append_fmt(w, CANONICAL_RANGE_OPERATOR);
+			type_writer_append_fmt(w, "%lld", type->BitSet.upper);
 		}
 		if (type->BitSet.underlying != nullptr) {
-			w = gb_string_appendc(w, ";");
-			w = write_type_to_canonical_string(w, type->BitSet.underlying);
+			type_writer_appendc(w, ";");
+			write_type_to_canonical_string(w, type->BitSet.underlying);
 		}
-		return gb_string_appendc(w, "]");
+		type_writer_appendc(w, "]");
+		return;
 
 	case Type_Union:
-		w = gb_string_appendc(w, "union");
+		type_writer_appendc(w, "union");
 
 		switch (type->Union.kind) {
-		case UnionType_no_nil:     w = gb_string_appendc(w, "#no_nil");     break;
-		case UnionType_shared_nil: w = gb_string_appendc(w, "#shared_nil"); break;
+		case UnionType_no_nil:     type_writer_appendc(w, "#no_nil");     break;
+		case UnionType_shared_nil: type_writer_appendc(w, "#shared_nil"); break;
 		}
 		if (type->Union.custom_align != 0) {
-			w = gb_string_append_fmt(w, "#align(%lld)", cast(long long)type->Union.custom_align);
+			type_writer_append_fmt(w, "#align(%lld)", cast(long long)type->Union.custom_align);
 		}
-		w = gb_string_appendc(w, "{");
+		type_writer_appendc(w, "{");
 		for_array(i, type->Union.variants) {
 			Type *t = type->Union.variants[i];
-			if (i > 0) w = gb_string_appendc(w, CANONICAL_FIELD_SEPARATOR);
-			w = write_type_to_canonical_string(w, t);
+			if (i > 0) type_writer_appendc(w, CANONICAL_FIELD_SEPARATOR);
+			write_type_to_canonical_string(w, t);
 		}
-		return gb_string_appendc(w, "}");
+		type_writer_appendc(w, "}");
+		return;
 	case Type_Struct:
 		if (type->Struct.soa_kind != StructSoa_None) {
 			switch (type->Struct.soa_kind) {
-			case StructSoa_Fixed:   w = gb_string_append_fmt(w, "#soa[%lld]", cast(long long)type->Struct.soa_count); break;
-			case StructSoa_Slice:   w = gb_string_appendc(w,    "#soa[]");                                    break;
-			case StructSoa_Dynamic: w = gb_string_appendc(w,    "#soa[dynamic]");                             break;
+			case StructSoa_Fixed:   type_writer_append_fmt(w, "#soa[%lld]", cast(long long)type->Struct.soa_count); break;
+			case StructSoa_Slice:   type_writer_appendc(w,    "#soa[]");                                    break;
+			case StructSoa_Dynamic: type_writer_appendc(w,    "#soa[dynamic]");                             break;
 			default: GB_PANIC("Unknown StructSoaKind"); break;
 			}
 			return write_type_to_canonical_string(w, type->Struct.soa_elem);
 		}
 
-		w = gb_string_appendc(w, "struct");
-		if (type->Struct.is_packed)    w = gb_string_appendc(w, "#packed");
-		if (type->Struct.is_raw_union) w = gb_string_appendc(w, "#raw_union");
-		if (type->Struct.is_no_copy)   w = gb_string_appendc(w, "#no_copy");
-		if (type->Struct.custom_min_field_align != 0) w = gb_string_append_fmt(w, "#min_field_align(%lld)", cast(long long)type->Struct.custom_min_field_align);
-		if (type->Struct.custom_max_field_align != 0) w = gb_string_append_fmt(w, "#max_field_align(%lld)", cast(long long)type->Struct.custom_max_field_align);
-		if (type->Struct.custom_align != 0)           w = gb_string_append_fmt(w, "#align(%lld)",           cast(long long)type->Struct.custom_align);
-		w = gb_string_appendc(w, "{");
+		type_writer_appendc(w, "struct");
+		if (type->Struct.is_packed)    type_writer_appendc(w, "#packed");
+		if (type->Struct.is_raw_union) type_writer_appendc(w, "#raw_union");
+		if (type->Struct.is_no_copy)   type_writer_appendc(w, "#no_copy");
+		if (type->Struct.custom_min_field_align != 0) type_writer_append_fmt(w, "#min_field_align(%lld)", cast(long long)type->Struct.custom_min_field_align);
+		if (type->Struct.custom_max_field_align != 0) type_writer_append_fmt(w, "#max_field_align(%lld)", cast(long long)type->Struct.custom_max_field_align);
+		if (type->Struct.custom_align != 0)           type_writer_append_fmt(w, "#align(%lld)",           cast(long long)type->Struct.custom_align);
+		type_writer_appendb(w, '{');
 		for_array(i, type->Struct.fields) {
 			Entity *f = type->Struct.fields[i];
 			GB_ASSERT(f->kind == Entity_Variable);
 			if (i > 0) {
-				w = gb_string_appendc(w, CANONICAL_FIELD_SEPARATOR);
+				type_writer_appendc(w, CANONICAL_FIELD_SEPARATOR);
 			}
-			w = gb_string_append_length       (w, f->token.string.text, f->token.string.len);
-			w = gb_string_appendc             (w, ":");
-			w = write_type_to_canonical_string(w, f->type);
+			type_writer_append(w, f->token.string.text, f->token.string.len);
+			type_writer_appendc(w, CANONICAL_TYPE_SEPARATOR);
+			write_type_to_canonical_string(w, f->type);
 			String tag = type->Struct.tags[i];
 			if (tag.len != 0) {
 				String s = quote_to_ascii(heap_allocator(), tag);
-				w = gb_string_append_length(w, s.text, s.len);
+				type_writer_append(w, s.text, s.len);
 				gb_free(heap_allocator(), s.text);
 			}
 		}
-		return gb_string_appendc(w, "}");
+		type_writer_appendb(w, '}');
+		return;
 
 	case Type_BitField:
-		w = gb_string_appendc(w, "bit_field");
-		w = write_type_to_canonical_string(w, type->BitField.backing_type);
-		w = gb_string_appendc(w, " {");
+		type_writer_appendc(w, "bit_field");
+		write_type_to_canonical_string(w, type->BitField.backing_type);
+		type_writer_appendc(w, " {");
 		for (isize i = 0; i < type->BitField.fields.count; i++) {
 			Entity *f = type->BitField.fields[i];
 			if (i > 0) {
-				w = gb_string_appendc(w, CANONICAL_FIELD_SEPARATOR);
+				type_writer_appendc(w, CANONICAL_FIELD_SEPARATOR);
 			}
-			w = gb_string_append_length(w, f->token.string.text, f->token.string.len);
-			w = gb_string_appendc(w, ":");
-			w = write_type_to_canonical_string(w, f->type);
-			w = gb_string_appendc(w, "|");
-			w = gb_string_appendc(w, gb_bprintf("%u", type->BitField.bit_sizes[i]));
+			type_writer_append(w, f->token.string.text, f->token.string.len);
+			type_writer_appendc(w, CANONICAL_TYPE_SEPARATOR);
+			write_type_to_canonical_string(w, f->type);
+			type_writer_appendc(w, CANONICAL_BIT_FIELD_SEPARATOR);
+			type_writer_append_fmt(w, "%u", type->BitField.bit_sizes[i]);
 		}
-		return gb_string_appendc(w, " }");
+		type_writer_appendc(w, " }");
+		return;
 
 	case Type_Proc:
-		w = gb_string_appendc(w, "proc");
+		type_writer_appendc(w, "proc");
 		if (default_calling_convention() != type->Proc.calling_convention) {
-			w = gb_string_appendc(w, "\"");
-			w = gb_string_appendc(w, proc_calling_convention_strings[type->Proc.calling_convention]);
-			w = gb_string_appendc(w, "\"");
+			type_writer_appendc(w, "\"");
+			type_writer_appendc(w, proc_calling_convention_strings[type->Proc.calling_convention]);
+			type_writer_appendc(w, "\"");
 		}
 
-		w = write_canonical_params(w, type->Proc.params);
+		write_canonical_params(w, type->Proc.params);
 		if (type->Proc.result_count > 0) {
-			w = gb_string_appendc(w, "->");
-			w = write_canonical_params(w, type->Proc.results);
+			type_writer_appendc(w, "->");
+			write_canonical_params(w, type->Proc.results);
 		}
-		return w;
+		return;
 
 	case Type_Generic:
 		GB_PANIC("Type_Generic should never be hit");
-		return w;
+		return;
 
 	case Type_Named:
 		if (type->Named.type_name != nullptr) {
-			return write_canonical_entity_name(w, type->Named.type_name);
+			write_canonical_entity_name(w, type->Named.type_name);
+			return;
 		} else {
-			w = gb_string_append_length(w, type->Named.name.text, type->Named.name.len);
+			type_writer_append(w, type->Named.name.text, type->Named.name.len);
 		}
-		return w;
+		return;
 
 	case Type_Tuple:
-		w = gb_string_appendc(w, "params");
-		w = write_canonical_params(w, type);
-		return w;
+		type_writer_appendc(w, "params");
+		write_canonical_params(w, type);
+		return;
 	default:
 		GB_PANIC("unknown type kind %d %.*s", type->kind, LIT(type_strings[type->kind]));
 		break;
 	}
 
-	return w;
+	return;
 }
\ No newline at end of file
diff --git a/src/name_canonicalization.hpp b/src/name_canonicalization.hpp
new file mode 100644
index 000000000..620665cd2
--- /dev/null
+++ b/src/name_canonicalization.hpp
@@ -0,0 +1,88 @@
+
+#define CANONICAL_TYPE_SEPARATOR  ":"
+#define CANONICAL_NAME_SEPARATOR  "::"
+
+#define CANONICAL_BIT_FIELD_SEPARATOR "|"
+
+#define CANONICAL_PARAM_SEPARATOR ","
+
+#define CANONICAL_PARAM_TYPEID    "$"
+#define CANONICAL_PARAM_CONST     "$$"
+
+#define CANONICAL_PARAM_C_VARARG  "#c_vararg"
+#define CANONICAL_PARAM_VARARG    ".."
+
+#define CANONICAL_FIELD_SEPARATOR ","
+
+#define CANONICAL_ANON_PREFIX     "$anon"
+
+#define CANONICAL_NONE_TYPE       "<>"
+
+#define CANONICAL_RANGE_OPERATOR  "..="
+
+struct TypeWriter;
+
+gb_internal void     write_type_to_canonical_string(TypeWriter *w, Type *type);
+gb_internal void     write_canonical_entity_name(TypeWriter *w, Entity *e);
+gb_internal u64      type_hash_canonical_type(Type *type);
+gb_internal String   type_to_canonical_string(gbAllocator allocator, Type *type);
+gb_internal gbString temp_canonical_string(Type *type);
+
+
+gb_internal GB_COMPARE_PROC(type_info_pair_cmp);
+
+
+struct TypeInfoPair {
+	Type *type;
+	u64   hash; // see: type_hash_canonical_type
+};
+
+struct TypeSet {
+	TypeInfoPair *keys;
+	usize count;
+	usize capacity;
+};
+
+static constexpr u64 TYPE_SET_TOMBSTONE = ~(u64)(0ull);
+
+struct TypeSetIterator {
+	TypeSet *set;
+	usize index;
+
+	TypeSetIterator &operator++() noexcept {
+		for (;;) {
+			++index;
+			if (set->capacity == index) {
+				return *this;
+			}
+			TypeInfoPair key = set->keys[index];
+			if (key.hash != 0 && key.hash != TYPE_SET_TOMBSTONE) {
+				return *this;
+			}
+		}
+	}
+
+	bool operator==(TypeSetIterator const &other) const noexcept {
+		return this->set == other.set && this->index == other.index;
+	}
+
+
+	operator TypeInfoPair *() const {
+		return &set->keys[index];
+	}
+};
+
+
+gb_internal void  type_set_init   (TypeSet *s, isize capacity = 16);
+gb_internal void  type_set_destroy(TypeSet *s);
+gb_internal Type *type_set_add    (TypeSet *s, Type *ptr);
+gb_internal Type *type_set_add    (TypeSet *s, TypeInfoPair pair);
+gb_internal bool  type_set_update (TypeSet *s, Type *ptr); // returns true if it previously existed
+gb_internal bool  type_set_update (TypeSet *s, TypeInfoPair pair); // returns true if it previously existed
+gb_internal bool  type_set_exists (TypeSet *s, Type *ptr);
+gb_internal void  type_set_remove (TypeSet *s, Type *ptr);
+gb_internal void  type_set_clear  (TypeSet *s);
+gb_internal TypeInfoPair *type_set_retrieve(TypeSet *s, Type *ptr);
+
+gb_internal TypeSetIterator begin(TypeSet &set) noexcept;
+gb_internal TypeSetIterator end(TypeSet &set) noexcept;
-- 
cgit v1.2.3


From 481745784f82c36b8233985768570b5a992656f5 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Tue, 18 Feb 2025 15:04:02 +0000
Subject: Remove debug print

---
 src/llvm_backend_general.cpp | 1 -
 1 file changed, 1 deletion(-)

(limited to 'src/llvm_backend_general.cpp')

diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index 233448ece..4f6fcb88e 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -1460,7 +1460,6 @@ gb_internal String lb_get_entity_name(lbModule *m, Entity *e) {
 	defer (gb_string_free(w));
 
 	String name = copy_string(permanent_allocator(), make_string(cast(u8 const *)w, gb_string_length(w)));
-	gb_printf_err("%.*s\n", LIT(name));
 
 	if (e->kind == Entity_TypeName) {
 		e->TypeName.ir_mangled_name = name;
-- 
cgit v1.2.3