From afa41f0c10173d28f0e04d1d722664f35a3d3430 Mon Sep 17 00:00:00 2001
From: Christoffer Lerno <christoffer@aegik.com>
Date: Mon, 20 Feb 2023 17:48:47 +0100
Subject: [PATCH] Updated name mangling.

---
 src/compiler/ast.c                            |   2 +-
 src/compiler/llvm_codegen_type.c              |   2 +-
 src/compiler/sema_decls.c                     |  22 ++-
 src/version.h                                 |   2 +-
 test/test_suite/abi/small_struct_x64.c3t      |   2 +-
 .../test_suite/arrays/complex_array_const.c3t |   2 +-
 test/test_suite/arrays/global_init.c3t        |   8 +-
 test/test_suite/assert/unreachable.c3t        |   2 +-
 .../attributes/user_defined_attributes.c3t    |   2 +-
 test/test_suite/bitstruct/bitstruct_be.c3t    |  44 ++---
 .../bitstruct/bitstruct_initializer.c3t       |  48 +++---
 test/test_suite/bitstruct/bitstruct_ops.c3t   |  48 +++---
 .../compile_time_access_subscript.c3t         |   4 +-
 .../compile_time/ct_builtin_time_date.c3t     |  28 +--
 test/test_suite/compile_time/ct_funcptr.c3t   |   4 +-
 test/test_suite/compile_time/ct_memberof.c3t  | 160 +++++++++---------
 .../compile_time/untyped_conversions.c3t      |  36 ++--
 .../compile_time_introspection/qnameof.c3t    |   2 +-
 .../enumerations/enum_associated_value.c3t    |   4 +-
 .../enum_associated_values_other.c3t          |  22 +--
 test/test_suite/errors/error_introspect.c3t   |  28 +--
 test/test_suite/errors/error_regression_2.c3t |  16 +-
 .../errors/general_error_regression.c3t       |  24 +--
 .../errors/optional_chained_init.c3t          |  48 +++---
 .../errors/optional_taddr_and_access.c3t      |   6 +-
 .../errors/optional_with_optional.c3t         |  32 ++--
 test/test_suite/errors/or_and_rethrow.c3t     |  28 +--
 test/test_suite/errors/printing_errors.c3t    |   6 +-
 .../expressions/optional_ternary.c3t          |  12 +-
 .../test_suite/expressions/pointer_access.c3t |   8 +-
 test/test_suite/from_docs/examples_defer.c3t  |  36 ++--
 .../from_docs/examples_forswitch.c3t          |  34 ++--
 .../func_ptr_conversions_and_names.c3t        |  54 +++---
 test/test_suite/functions/test_regression.c3t |  72 ++++----
 .../functions/test_regression_mingw.c3t       | 116 +++++++------
 .../test_suite/functions/typeless_varargs.c3t |   6 +-
 .../functions/varargs_followed_by_named.c3t   |   8 +-
 test/test_suite/generic/enum_set_test.c3t     |  38 ++---
 test/test_suite/generic/generic_idents.c3t    |  14 +-
 test/test_suite/generic/generic_num.c3t       |   6 +-
 .../initializer_lists/general_tests.c3t       |   4 +-
 test/test_suite/initializer_lists/statics.c3t |   4 +-
 .../initializer_lists/subarrays.c3t           |  12 +-
 test/test_suite/literals/bin_literal.c3t      |  14 +-
 .../test_suite/macros/macro_typed_varargs.c3t |  16 +-
 .../macros/macro_untyped_varargs_2.c3t        |  44 ++---
 test/test_suite/macros/macro_vasplat.c3t      |  72 ++++----
 test/test_suite/macros/macro_with_body.c3t    |   4 +-
 test/test_suite/macros/userland_bitcast.c3t   |   2 +-
 .../methods/enum_distinct_err_methods.c3t     |  12 +-
 test/test_suite/methods/extension_method.c3t  |   4 +-
 .../extension_method_in_other_modules.c3t     |   8 +-
 test/test_suite/overloading/set_overload.c3t  |   4 +-
 .../pointers/subarray_variant_to_ptr.c3t      |   4 +-
 test/test_suite/safe/deref.c3t                |   2 +-
 .../slices/slice_to_slice_assign.c3t          |  24 +--
 .../slices/slice_to_slice_vector_assign.c3t   |  24 +--
 .../statements/custom_foreach_with_ref.c3t    |   2 +-
 .../statements/foreach_custom_macro.c3t       |   2 +-
 .../foreach_more_implementations.c3t          |   8 +-
 .../statements/various_switching.c3t          |   8 +-
 test/test_suite/stdlib/map.c3t                | 134 +++++++--------
 test/test_suite/struct/nested_struct_init.c3t |  12 +-
 test/test_suite/struct/struct_as_value.c3t    |   2 +-
 test/test_suite/struct/struct_codegen.c3t     |   2 +-
 .../struct/struct_const_construct_simple.c3t  |   2 +-
 test/test_suite/variant/variant_assign.c3t    |  38 ++---
 test/test_suite/variant/variant_switch.c3t    |  18 +-
 test/test_suite/variant/variant_test.c3t      |  46 ++---
 test/test_suite/vector/vector_ops2.c3t        |   2 +-
 70 files changed, 790 insertions(+), 776 deletions(-)

diff --git a/src/compiler/ast.c b/src/compiler/ast.c
index 8ee09d1b9..d82c3b246 100644
--- a/src/compiler/ast.c
+++ b/src/compiler/ast.c
@@ -242,7 +242,7 @@ void decl_set_external_name(Decl *decl)
 		switch (c)
 		{
 			case ':':
-				scratch_buffer_append_char('_');
+				scratch_buffer_append_char('.');
 				module_name++;
 				break;
 			default:
diff --git a/src/compiler/llvm_codegen_type.c b/src/compiler/llvm_codegen_type.c
index ce32cf5fb..772ac332b 100644
--- a/src/compiler/llvm_codegen_type.c
+++ b/src/compiler/llvm_codegen_type.c
@@ -447,7 +447,7 @@ static inline LLVMValueRef llvm_generate_introspection_global(GenContext *c, LLV
 	};
 	LLVMValueRef global_name;
 	scratch_buffer_clear();
-	scratch_buffer_append("ct$");
+	scratch_buffer_append("$ct.");
 	type_mangle_introspect_name_to_buffer(type);
 	if (additional)
 	{
diff --git a/src/compiler/sema_decls.c b/src/compiler/sema_decls.c
index 91d77a051..3c460a2ce 100644
--- a/src/compiler/sema_decls.c
+++ b/src/compiler/sema_decls.c
@@ -1307,16 +1307,20 @@ INLINE void sema_set_method_ext_name(CompilationUnit *unit, const char *parent_n
 {
 	if (method_like->has_extname) return;
 	scratch_buffer_clear();
+	if (method_like->is_export)
+	{
+		scratch_buffer_append(parent_name);
+		scratch_buffer_append("_");
+		scratch_buffer_append(method_like->name);
+		method_like->extname = scratch_buffer_copy();
+		return;
+	}
 	switch (method_like->visibility)
 	{
 		case VISIBLE_PUBLIC:
-			scratch_buffer_append(parent_name);
-			scratch_buffer_append("_");
-			scratch_buffer_append(method_like->name);
-			break;
 		case VISIBLE_PRIVATE:
 			scratch_buffer_append(parent_name);
-			scratch_buffer_append_char('$');
+			scratch_buffer_append_char('.');
 			scratch_buffer_append(method_like->name);
 			break;
 		case VISIBLE_LOCAL:
@@ -1326,6 +1330,8 @@ INLINE void sema_set_method_ext_name(CompilationUnit *unit, const char *parent_n
 			scratch_buffer_append_char('.');
 			scratch_buffer_append(method_like->name);
 			break;
+		default:
+			UNREACHABLE
 	}
 	method_like->extname = scratch_buffer_copy();
 }
@@ -2823,7 +2829,7 @@ static bool sema_append_generate_parameterized_name(SemaContext *c, Module *modu
 	if (mangled)
 	{
 		scratch_buffer_append_len(module->name->module, module->name->len);
-		scratch_buffer_append("$$");
+		scratch_buffer_append("$");
 	}
 	else
 	{
@@ -2832,7 +2838,7 @@ static bool sema_append_generate_parameterized_name(SemaContext *c, Module *modu
 	FOREACH_BEGIN_IDX(i, Expr *param, decl->define_decl.generic_params)
 		if (i != 0)
 		{
-			scratch_buffer_append(mangled ? "." : ", ");
+			scratch_buffer_append(mangled ? "$" : ", ");
 		}
 		if (param->expr_kind == EXPR_TYPEINFO)
 		{
@@ -2906,7 +2912,7 @@ static bool sema_append_generate_parameterized_name(SemaContext *c, Module *modu
 			}
 		}
 	FOREACH_END();
-	if (!mangled) scratch_buffer_append_char('>');
+	scratch_buffer_append_char(mangled ? '$' : '>');
 	return true;
 }
 static bool sema_analyse_parameterized_define(SemaContext *c, Decl *decl)
diff --git a/src/version.h b/src/version.h
index d3707bcf1..6ebc08eba 100644
--- a/src/version.h
+++ b/src/version.h
@@ -1 +1 @@
-#define COMPILER_VERSION "0.4.78"
\ No newline at end of file
+#define COMPILER_VERSION "0.4.79"
\ No newline at end of file
diff --git a/test/test_suite/abi/small_struct_x64.c3t b/test/test_suite/abi/small_struct_x64.c3t
index 1c729bca4..be9686e91 100644
--- a/test/test_suite/abi/small_struct_x64.c3t
+++ b/test/test_suite/abi/small_struct_x64.c3t
@@ -23,7 +23,7 @@ fn Foo getFoo(Foo f)
 %.introspect = type { i8, i64, i64, i64, [0 x i64] }
 %Foo = type { i8, i8, i8 }
 
-@"ct$test.Foo" = linkonce constant %.introspect { i8 10, i64 3, i64 0, i64 3, [0 x i64] zeroinitializer }, align 8
+@"$ct.test.Foo" = linkonce constant %.introspect { i8 10, i64 3, i64 0, i64 3, [0 x i64] zeroinitializer }, align 8
 
 ; Function Attrs: nounwind
 define i32 @test.testing() #0 {
diff --git a/test/test_suite/arrays/complex_array_const.c3t b/test/test_suite/arrays/complex_array_const.c3t
index bc1dda804..b471af181 100644
--- a/test/test_suite/arrays/complex_array_const.c3t
+++ b/test/test_suite/arrays/complex_array_const.c3t
@@ -15,7 +15,7 @@ Connection[3] link @private
 
 /* #expect: test.ll
 
-@"ct$test.Connection" = linkonce constant %.introspect { i8 10, i64 24, i64 0, i64 3, [0 x i64] zeroinitializer }, align 8
+@"$ct.test.Connection" = linkonce constant %.introspect { i8 10, i64 24, i64 0, i64 3, [0 x i64] zeroinitializer }, align 8
 @.str = private unnamed_addr constant [6 x i8] c"link1\00", align 1
 @.str.1 = private unnamed_addr constant [6 x i8] c"link2\00", align 1
 @.str.2 = private unnamed_addr constant [6 x i8] c"link3\00", align 1
diff --git a/test/test_suite/arrays/global_init.c3t b/test/test_suite/arrays/global_init.c3t
index 872d6f44c..6e345d562 100644
--- a/test/test_suite/arrays/global_init.c3t
+++ b/test/test_suite/arrays/global_init.c3t
@@ -33,7 +33,7 @@ fn void main() {
 @.taddr.9 = private global i32 42, align 4
 @.taddr.10 = private global i8 99, align 1
 @.taddr.11 = private global ptr @.str, align 8
-@"main$x" = internal unnamed_addr global [3 x %variant] [%variant { ptr @.taddr.9, i64 ptrtoint (ptr @"ct$int" to i64) }, %variant { ptr @.taddr.10, i64 ptrtoint (ptr @"ct$char" to i64) }, %variant { ptr @.taddr.11, i64 ptrtoint (ptr @"ct$p$a3$char" to i64) }], align 16
+@"main$x" = internal unnamed_addr global [3 x %variant] [%variant { ptr @.taddr.9, i64 ptrtoint (ptr @"$ct.int" to i64) }, %variant { ptr @.taddr.10, i64 ptrtoint (ptr @"$ct.char" to i64) }, %variant { ptr @.taddr.11, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64) }], align 16
 
 define void @test.main() #0 {
 entry:
@@ -46,17 +46,17 @@ entry:
   %0 = getelementptr inbounds [3 x %variant], ptr %y, i64 0, i64 0
   store i32 42, ptr %taddr, align 4
   %1 = insertvalue %variant undef, ptr %taddr, 0
-  %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   store %variant %2, ptr %0, align 16
   %3 = getelementptr inbounds [3 x %variant], ptr %y, i64 0, i64 1
   store i8 99, ptr %taddr1, align 1
   %4 = insertvalue %variant undef, ptr %taddr1, 0
-  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$char" to i64), 1
+  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"$ct.char" to i64), 1
   store %variant %5, ptr %3, align 16
   %6 = getelementptr inbounds [3 x %variant], ptr %y, i64 0, i64 2
   store ptr @.str.12, ptr %taddr2, align 8
   %7 = insertvalue %variant undef, ptr %taddr2, 0
-  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
+  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
   store %variant %8, ptr %6, align 16
   ret void
 }
diff --git a/test/test_suite/assert/unreachable.c3t b/test/test_suite/assert/unreachable.c3t
index 6fa672e11..5d289ac2b 100644
--- a/test/test_suite/assert/unreachable.c3t
+++ b/test/test_suite/assert/unreachable.c3t
@@ -28,7 +28,7 @@ if.then:                                          ; preds = %entry
   ret void
 
 if.exit:                                          ; preds = %entry
-  %2 = load ptr, ptr @std_core_builtin.panic, align 8
+  %2 = load ptr, ptr @std.core.builtin.panic, align 8
   call void %2(ptr @.str, i64 30, ptr @.str.1, i64 14, ptr @.str.2, i64 4, i32 10)
   unreachable
 
diff --git a/test/test_suite/attributes/user_defined_attributes.c3t b/test/test_suite/attributes/user_defined_attributes.c3t
index 3aa1549db..fc8d08887 100644
--- a/test/test_suite/attributes/user_defined_attributes.c3t
+++ b/test/test_suite/attributes/user_defined_attributes.c3t
@@ -32,7 +32,7 @@ fn void main() @TestZero
 /* #expect: test.ll
 
 %Foo = type { i32, [1020 x i8], i32, [1020 x i8] }
-@"ct$test.Foo" = linkonce constant %.introspect { i8 10, i64 2048, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.test.Foo" = linkonce constant %.introspect { i8 10, i64 2048, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
 @test.f = local_unnamed_addr global %Foo zeroinitializer, align 1024
 
 define weak void @test.testme2() #0 {
diff --git a/test/test_suite/bitstruct/bitstruct_be.c3t b/test/test_suite/bitstruct/bitstruct_be.c3t
index f2339d7ff..a960abe75 100644
--- a/test/test_suite/bitstruct/bitstruct_be.c3t
+++ b/test/test_suite/bitstruct/bitstruct_be.c3t
@@ -47,17 +47,17 @@ fn void main()
   %1 = call i32 @llvm.bswap.i32(i32 %0)
   store i32 2063597568, ptr %x, align 4
   %2 = insertvalue %variant undef, ptr %x, 0
-  %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %4 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %3, ptr %4, align 16
   %5 = load i32, ptr %x, align 4
   %6 = call i32 @llvm.bswap.i32(i32 %5)
   store i32 %6, ptr %taddr, align 4
   %7 = insertvalue %variant undef, ptr %taddr, 0
-  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %9 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %8, ptr %9, align 16
-  %10 = call i64 @std_io.printf(ptr %retparam, ptr @.str, i64 18, ptr %varargslots, i64 2)
+  %10 = call i64 @std.io.printf(ptr %retparam, ptr @.str, i64 18, ptr %varargslots, i64 2)
   store i32 873625686, ptr %abc, align 4
   store [4 x i8] c"\124Vx", ptr %abc2, align 1
   store ptr %abc, ptr %z, align 8
@@ -79,10 +79,10 @@ loop.body:                                        ; preds = %loop.cond
   %16 = load i8, ptr %15, align 1
   store i8 %16, ptr %d, align 1
   %17 = insertvalue %variant undef, ptr %d, 0
-  %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"ct$char" to i64), 1
+  %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"$ct.char" to i64), 1
   %19 = getelementptr inbounds [1 x %variant], ptr %varargslots3, i64 0, i64 0
   store %variant %18, ptr %19, align 16
-  %20 = call i64 @std_io.printf(ptr %retparam2, ptr @.str.1, i64 3, ptr %varargslots3, i64 1)
+  %20 = call i64 @std.io.printf(ptr %retparam2, ptr @.str.1, i64 3, ptr %varargslots3, i64 1)
   %21 = load i64, ptr %.anon1, align 8
   %add = add i64 %21, 1
   store i64 %add, ptr %.anon1, align 8
@@ -90,9 +90,9 @@ loop.body:                                        ; preds = %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
   store ptr @.str.2, ptr %x4, align 8
-  %22 = call ptr @std_io.stdout()
+  %22 = call ptr @std.io.stdout()
   store ptr %22, ptr %result, align 8
-  %23 = call i64 @std_io.File_printn(ptr %retparam5, ptr %result, ptr null, i64 0)
+  %23 = call i64 @std.io.File.printn(ptr %retparam5, ptr %result, ptr null, i64 0)
   %24 = load ptr, ptr %z, align 8
   store ptr %24, ptr %.anon6, align 8
   store i64 0, ptr %.anon7, align 8
@@ -110,10 +110,10 @@ loop.body10:                                      ; preds = %loop.cond8
   %29 = load i8, ptr %28, align 1
   store i8 %29, ptr %d11, align 1
   %30 = insertvalue %variant undef, ptr %d11, 0
-  %31 = insertvalue %variant %30, i64 ptrtoint (ptr @"ct$char" to i64), 1
+  %31 = insertvalue %variant %30, i64 ptrtoint (ptr @"$ct.char" to i64), 1
   %32 = getelementptr inbounds [1 x %variant], ptr %varargslots13, i64 0, i64 0
   store %variant %31, ptr %32, align 16
-  %33 = call i64 @std_io.printf(ptr %retparam12, ptr @.str.3, i64 3, ptr %varargslots13, i64 1)
+  %33 = call i64 @std.io.printf(ptr %retparam12, ptr @.str.3, i64 3, ptr %varargslots13, i64 1)
   %34 = load i64, ptr %.anon7, align 8
   %add14 = add i64 %34, 1
   store i64 %add14, ptr %.anon7, align 8
@@ -121,19 +121,19 @@ loop.body10:                                      ; preds = %loop.cond8
 
 loop.exit15:                                      ; preds = %loop.cond8
   store ptr @.str.4, ptr %x16, align 8
-  %35 = call ptr @std_io.stdout()
+  %35 = call ptr @std.io.stdout()
   store ptr %35, ptr %result18, align 8
-  %36 = call i64 @std_io.File_printn(ptr %retparam17, ptr %result18, ptr null, i64 0)
+  %36 = call i64 @std.io.File.printn(ptr %retparam17, ptr %result18, ptr null, i64 0)
   %37 = load i32, ptr %abc, align 4
   %38 = call i32 @llvm.bswap.i32(i32 %37)
   %39 = and i32 65535, %38
   %ztrunc = trunc i32 %39 to i16
   store i16 %ztrunc, ptr %taddr21, align 2
   %40 = insertvalue %variant undef, ptr %taddr21, 0
-  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
+  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
   %42 = getelementptr inbounds [1 x %variant], ptr %varargslots20, i64 0, i64 0
   store %variant %41, ptr %42, align 16
-  %43 = call i64 @std_io.printfn(ptr %retparam19, ptr @.str.5, i64 10, ptr %varargslots20, i64 1)
+  %43 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.5, i64 10, ptr %varargslots20, i64 1)
   %44 = load i32, ptr %abc, align 4
   %45 = call i32 @llvm.bswap.i32(i32 %44)
   %46 = and i32 %45, -65536
@@ -152,10 +152,10 @@ loop.exit15:                                      ; preds = %loop.cond8
   %ztrunc24 = trunc i32 %56 to i16
   store i16 %ztrunc24, ptr %taddr25, align 2
   %57 = insertvalue %variant undef, ptr %taddr25, 0
-  %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
+  %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
   %59 = getelementptr inbounds [1 x %variant], ptr %varargslots23, i64 0, i64 0
   store %variant %58, ptr %59, align 16
-  %60 = call i64 @std_io.printfn(ptr %retparam22, ptr @.str.6, i64 12, ptr %varargslots23, i64 1)
+  %60 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.6, i64 12, ptr %varargslots23, i64 1)
   %61 = load ptr, ptr %z, align 8
   store ptr %61, ptr %.anon26, align 8
   store i64 0, ptr %.anon27, align 8
@@ -173,10 +173,10 @@ loop.body30:                                      ; preds = %loop.cond28
   %66 = load i8, ptr %65, align 1
   store i8 %66, ptr %d31, align 1
   %67 = insertvalue %variant undef, ptr %d31, 0
-  %68 = insertvalue %variant %67, i64 ptrtoint (ptr @"ct$char" to i64), 1
+  %68 = insertvalue %variant %67, i64 ptrtoint (ptr @"$ct.char" to i64), 1
   %69 = getelementptr inbounds [1 x %variant], ptr %varargslots33, i64 0, i64 0
   store %variant %68, ptr %69, align 16
-  %70 = call i64 @std_io.printf(ptr %retparam32, ptr @.str.7, i64 3, ptr %varargslots33, i64 1)
+  %70 = call i64 @std.io.printf(ptr %retparam32, ptr @.str.7, i64 3, ptr %varargslots33, i64 1)
   %71 = load i64, ptr %.anon27, align 8
   %add34 = add i64 %71, 1
   store i64 %add34, ptr %.anon27, align 8
@@ -184,22 +184,22 @@ loop.body30:                                      ; preds = %loop.cond28
 
 loop.exit35:                                      ; preds = %loop.cond28
   store ptr @.str.8, ptr %x36, align 8
-  %72 = call ptr @std_io.stdout()
+  %72 = call ptr @std.io.stdout()
   store ptr %72, ptr %result38, align 8
-  %73 = call i64 @std_io.File_printn(ptr %retparam37, ptr %result38, ptr null, i64 0)
+  %73 = call i64 @std.io.File.printn(ptr %retparam37, ptr %result38, ptr null, i64 0)
   store i32 0, ptr %y, align 4
   %74 = load i32, ptr %y, align 4
   store i32 123, ptr %y, align 4
   %75 = insertvalue %variant undef, ptr %y, 0
-  %76 = insertvalue %variant %75, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %76 = insertvalue %variant %75, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %77 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 0
   store %variant %76, ptr %77, align 16
   %78 = load i32, ptr %y, align 4
   store i32 %78, ptr %taddr41, align 4
   %79 = insertvalue %variant undef, ptr %taddr41, 0
-  %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %81 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1
   store %variant %80, ptr %81, align 16
-  %82 = call i64 @std_io.printf(ptr %retparam39, ptr @.str.9, i64 18, ptr %varargslots40, i64 2)
+  %82 = call i64 @std.io.printf(ptr %retparam39, ptr @.str.9, i64 18, ptr %varargslots40, i64 2)
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/bitstruct/bitstruct_initializer.c3t b/test/test_suite/bitstruct/bitstruct_initializer.c3t
index 1ba9f3152..a31a8b839 100644
--- a/test/test_suite/bitstruct/bitstruct_initializer.c3t
+++ b/test/test_suite/bitstruct/bitstruct_initializer.c3t
@@ -158,7 +158,7 @@ entry:
   %ztrunc10 = trunc i64 %32 to i32
   store i32 %ztrunc10, ptr %taddr, align 4
   %33 = insertvalue %variant undef, ptr %taddr, 0
-  %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   %35 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %34, ptr %35, align 16
   %36 = load i64, ptr %x, align 8
@@ -167,7 +167,7 @@ entry:
   %ztrunc12 = trunc i64 %37 to i32
   store i32 %ztrunc12, ptr %taddr13, align 4
   %38 = insertvalue %variant undef, ptr %taddr13, 0
-  %39 = insertvalue %variant %38, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %39 = insertvalue %variant %38, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   %40 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %39, ptr %40, align 16
   %41 = load i64, ptr %x, align 8
@@ -176,17 +176,17 @@ entry:
   %ztrunc15 = trunc i64 %42 to i8
   store i8 %ztrunc15, ptr %taddr16, align 1
   %43 = insertvalue %variant undef, ptr %taddr16, 0
-  %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %45 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 2
   store %variant %44, ptr %45, align 16
-  %46 = call i64 @std_io.printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 3)
+  %46 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 3)
   %47 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
   %48 = load i64, ptr %47, align 8
   %49 = and i64 4294967295, %48
   %ztrunc19 = trunc i64 %49 to i32
   store i32 %ztrunc19, ptr %taddr20, align 4
   %50 = insertvalue %variant undef, ptr %taddr20, 0
-  %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   %52 = getelementptr inbounds [3 x %variant], ptr %varargslots18, i64 0, i64 0
   store %variant %51, ptr %52, align 16
   %53 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
@@ -196,7 +196,7 @@ entry:
   %ztrunc22 = trunc i64 %55 to i32
   store i32 %ztrunc22, ptr %taddr23, align 4
   %56 = insertvalue %variant undef, ptr %taddr23, 0
-  %57 = insertvalue %variant %56, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %57 = insertvalue %variant %56, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   %58 = getelementptr inbounds [3 x %variant], ptr %varargslots18, i64 0, i64 1
   store %variant %57, ptr %58, align 16
   %59 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
@@ -206,10 +206,10 @@ entry:
   %ztrunc25 = trunc i64 %61 to i8
   store i8 %ztrunc25, ptr %taddr26, align 1
   %62 = insertvalue %variant undef, ptr %taddr26, 0
-  %63 = insertvalue %variant %62, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %63 = insertvalue %variant %62, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %64 = getelementptr inbounds [3 x %variant], ptr %varargslots18, i64 0, i64 2
   store %variant %63, ptr %64, align 16
-  %65 = call i64 @std_io.printfn(ptr %retparam17, ptr @.str.2, i64 8, ptr %varargslots18, i64 3)
+  %65 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.2, i64 8, ptr %varargslots18, i64 3)
   %66 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
   %67 = load i8, ptr %66, align 1
   %zext29 = zext i8 %67 to i32
@@ -230,7 +230,7 @@ entry:
   %76 = or i32 %shl35, %73
   store i32 %76, ptr %taddr36, align 4
   %77 = insertvalue %variant undef, ptr %taddr36, 0
-  %78 = insertvalue %variant %77, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %78 = insertvalue %variant %77, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   %79 = getelementptr inbounds [3 x %variant], ptr %varargslots28, i64 0, i64 0
   store %variant %78, ptr %79, align 16
   %80 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
@@ -254,7 +254,7 @@ entry:
   %91 = and i32 2147483647, %90
   store i32 %91, ptr %taddr44, align 4
   %92 = insertvalue %variant undef, ptr %taddr44, 0
-  %93 = insertvalue %variant %92, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %93 = insertvalue %variant %92, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   %94 = getelementptr inbounds [3 x %variant], ptr %varargslots28, i64 0, i64 1
   store %variant %93, ptr %94, align 16
   %95 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
@@ -264,10 +264,10 @@ entry:
   %98 = zext i1 %97 to i8
   store i8 %98, ptr %taddr46, align 1
   %99 = insertvalue %variant undef, ptr %taddr46, 0
-  %100 = insertvalue %variant %99, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %100 = insertvalue %variant %99, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %101 = getelementptr inbounds [3 x %variant], ptr %varargslots28, i64 0, i64 2
   store %variant %100, ptr %101, align 16
-  %102 = call i64 @std_io.printfn(ptr %retparam27, ptr @.str.3, i64 8, ptr %varargslots28, i64 3)
+  %102 = call i64 @std.io.printfn(ptr %retparam27, ptr @.str.3, i64 8, ptr %varargslots28, i64 3)
   %add = add i32 %0, 1
   %zext47 = zext i32 %add to i64
   %103 = and i64 %zext47, 4294967295
@@ -339,7 +339,7 @@ entry:
   %ztrunc63 = trunc i64 %135 to i32
   store i32 %ztrunc63, ptr %taddr64, align 4
   %136 = insertvalue %variant undef, ptr %taddr64, 0
-  %137 = insertvalue %variant %136, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %137 = insertvalue %variant %136, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   %138 = getelementptr inbounds [3 x %variant], ptr %varargslots62, i64 0, i64 0
   store %variant %137, ptr %138, align 16
   %139 = load i64, ptr %x, align 8
@@ -348,7 +348,7 @@ entry:
   %ztrunc66 = trunc i64 %140 to i32
   store i32 %ztrunc66, ptr %taddr67, align 4
   %141 = insertvalue %variant undef, ptr %taddr67, 0
-  %142 = insertvalue %variant %141, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %142 = insertvalue %variant %141, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   %143 = getelementptr inbounds [3 x %variant], ptr %varargslots62, i64 0, i64 1
   store %variant %142, ptr %143, align 16
   %144 = load i64, ptr %x, align 8
@@ -357,17 +357,17 @@ entry:
   %ztrunc69 = trunc i64 %145 to i8
   store i8 %ztrunc69, ptr %taddr70, align 1
   %146 = insertvalue %variant undef, ptr %taddr70, 0
-  %147 = insertvalue %variant %146, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %147 = insertvalue %variant %146, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %148 = getelementptr inbounds [3 x %variant], ptr %varargslots62, i64 0, i64 2
   store %variant %147, ptr %148, align 16
-  %149 = call i64 @std_io.printfn(ptr %retparam61, ptr @.str.4, i64 8, ptr %varargslots62, i64 3)
+  %149 = call i64 @std.io.printfn(ptr %retparam61, ptr @.str.4, i64 8, ptr %varargslots62, i64 3)
   %150 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
   %151 = load i64, ptr %150, align 8
   %152 = and i64 4294967295, %151
   %ztrunc73 = trunc i64 %152 to i32
   store i32 %ztrunc73, ptr %taddr74, align 4
   %153 = insertvalue %variant undef, ptr %taddr74, 0
-  %154 = insertvalue %variant %153, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %154 = insertvalue %variant %153, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   %155 = getelementptr inbounds [3 x %variant], ptr %varargslots72, i64 0, i64 0
   store %variant %154, ptr %155, align 16
   %156 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
@@ -377,7 +377,7 @@ entry:
   %ztrunc76 = trunc i64 %158 to i32
   store i32 %ztrunc76, ptr %taddr77, align 4
   %159 = insertvalue %variant undef, ptr %taddr77, 0
-  %160 = insertvalue %variant %159, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %160 = insertvalue %variant %159, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   %161 = getelementptr inbounds [3 x %variant], ptr %varargslots72, i64 0, i64 1
   store %variant %160, ptr %161, align 16
   %162 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
@@ -387,10 +387,10 @@ entry:
   %ztrunc79 = trunc i64 %164 to i8
   store i8 %ztrunc79, ptr %taddr80, align 1
   %165 = insertvalue %variant undef, ptr %taddr80, 0
-  %166 = insertvalue %variant %165, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %166 = insertvalue %variant %165, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %167 = getelementptr inbounds [3 x %variant], ptr %varargslots72, i64 0, i64 2
   store %variant %166, ptr %167, align 16
-  %168 = call i64 @std_io.printfn(ptr %retparam71, ptr @.str.5, i64 8, ptr %varargslots72, i64 3)
+  %168 = call i64 @std.io.printfn(ptr %retparam71, ptr @.str.5, i64 8, ptr %varargslots72, i64 3)
   %169 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
   %170 = load i8, ptr %169, align 1
   %zext83 = zext i8 %170 to i32
@@ -411,7 +411,7 @@ entry:
   %179 = or i32 %shl89, %176
   store i32 %179, ptr %taddr90, align 4
   %180 = insertvalue %variant undef, ptr %taddr90, 0
-  %181 = insertvalue %variant %180, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %181 = insertvalue %variant %180, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   %182 = getelementptr inbounds [3 x %variant], ptr %varargslots82, i64 0, i64 0
   store %variant %181, ptr %182, align 16
   %183 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
@@ -435,7 +435,7 @@ entry:
   %194 = and i32 2147483647, %193
   store i32 %194, ptr %taddr98, align 4
   %195 = insertvalue %variant undef, ptr %taddr98, 0
-  %196 = insertvalue %variant %195, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %196 = insertvalue %variant %195, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   %197 = getelementptr inbounds [3 x %variant], ptr %varargslots82, i64 0, i64 1
   store %variant %196, ptr %197, align 16
   %198 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
@@ -445,10 +445,10 @@ entry:
   %201 = zext i1 %200 to i8
   store i8 %201, ptr %taddr100, align 1
   %202 = insertvalue %variant undef, ptr %taddr100, 0
-  %203 = insertvalue %variant %202, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %203 = insertvalue %variant %202, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %204 = getelementptr inbounds [3 x %variant], ptr %varargslots82, i64 0, i64 2
   store %variant %203, ptr %204, align 16
-  %205 = call i64 @std_io.printfn(ptr %retparam81, ptr @.str.6, i64 8, ptr %varargslots82, i64 3)
+  %205 = call i64 @std.io.printfn(ptr %retparam81, ptr @.str.6, i64 8, ptr %varargslots82, i64 3)
   ret void
 }
 
diff --git a/test/test_suite/bitstruct/bitstruct_ops.c3t b/test/test_suite/bitstruct/bitstruct_ops.c3t
index 8bfbe5329..866cb0b5e 100644
--- a/test/test_suite/bitstruct/bitstruct_ops.c3t
+++ b/test/test_suite/bitstruct/bitstruct_ops.c3t
@@ -98,7 +98,7 @@ entry:
   %ztrunc = trunc i32 %6 to i8
   store i8 %ztrunc, ptr %taddr, align 1
   %7 = insertvalue %variant undef, ptr %taddr, 0
-  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %9 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %8, ptr %9, align 16
   %10 = load i32, ptr %f3, align 4
@@ -107,10 +107,10 @@ entry:
   %ztrunc1 = trunc i32 %11 to i8
   store i8 %ztrunc1, ptr %taddr2, align 1
   %12 = insertvalue %variant undef, ptr %taddr2, 0
-  %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %14 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %13, ptr %14, align 16
-  %15 = call i64 @std_io.printfn(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2)
+  %15 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2)
   %16 = load i32, ptr %f1, align 4
   %17 = load i32, ptr %f2, align 4
   %bnot = xor i32 %17, -1
@@ -123,7 +123,7 @@ entry:
   %ztrunc5 = trunc i32 %20 to i8
   store i8 %ztrunc5, ptr %taddr6, align 1
   %21 = insertvalue %variant undef, ptr %taddr6, 0
-  %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %23 = getelementptr inbounds [2 x %variant], ptr %varargslots4, i64 0, i64 0
   store %variant %22, ptr %23, align 16
   %24 = load i32, ptr %f4, align 4
@@ -132,17 +132,17 @@ entry:
   %ztrunc8 = trunc i32 %25 to i8
   store i8 %ztrunc8, ptr %taddr9, align 1
   %26 = insertvalue %variant undef, ptr %taddr9, 0
-  %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %28 = getelementptr inbounds [2 x %variant], ptr %varargslots4, i64 0, i64 1
   store %variant %27, ptr %28, align 16
-  %29 = call i64 @std_io.printfn(ptr %retparam3, ptr @.str.1, i64 5, ptr %varargslots4, i64 2)
+  %29 = call i64 @std.io.printfn(ptr %retparam3, ptr @.str.1, i64 5, ptr %varargslots4, i64 2)
   store i32 3, ptr %f5, align 4
   %30 = load i32, ptr %f5, align 4
   %31 = and i32 1, %30
   %ztrunc12 = trunc i32 %31 to i8
   store i8 %ztrunc12, ptr %taddr13, align 1
   %32 = insertvalue %variant undef, ptr %taddr13, 0
-  %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %34 = getelementptr inbounds [2 x %variant], ptr %varargslots11, i64 0, i64 0
   store %variant %33, ptr %34, align 16
   %35 = load i32, ptr %f5, align 4
@@ -151,10 +151,10 @@ entry:
   %ztrunc15 = trunc i32 %36 to i8
   store i8 %ztrunc15, ptr %taddr16, align 1
   %37 = insertvalue %variant undef, ptr %taddr16, 0
-  %38 = insertvalue %variant %37, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %38 = insertvalue %variant %37, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %39 = getelementptr inbounds [2 x %variant], ptr %varargslots11, i64 0, i64 1
   store %variant %38, ptr %39, align 16
-  %40 = call i64 @std_io.printfn(ptr %retparam10, ptr @.str.2, i64 5, ptr %varargslots11, i64 2)
+  %40 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.2, i64 5, ptr %varargslots11, i64 2)
   %41 = load i32, ptr %f5, align 4
   %42 = load i32, ptr %f2, align 4
   %and17 = and i32 %41, %42
@@ -164,7 +164,7 @@ entry:
   %ztrunc20 = trunc i32 %44 to i8
   store i8 %ztrunc20, ptr %taddr21, align 1
   %45 = insertvalue %variant undef, ptr %taddr21, 0
-  %46 = insertvalue %variant %45, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %46 = insertvalue %variant %45, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %47 = getelementptr inbounds [2 x %variant], ptr %varargslots19, i64 0, i64 0
   store %variant %46, ptr %47, align 16
   %48 = load i32, ptr %f5, align 4
@@ -173,10 +173,10 @@ entry:
   %ztrunc23 = trunc i32 %49 to i8
   store i8 %ztrunc23, ptr %taddr24, align 1
   %50 = insertvalue %variant undef, ptr %taddr24, 0
-  %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %52 = getelementptr inbounds [2 x %variant], ptr %varargslots19, i64 0, i64 1
   store %variant %51, ptr %52, align 16
-  %53 = call i64 @std_io.printfn(ptr %retparam18, ptr @.str.3, i64 5, ptr %varargslots19, i64 2)
+  %53 = call i64 @std.io.printfn(ptr %retparam18, ptr @.str.3, i64 5, ptr %varargslots19, i64 2)
   store [13 x i8] c"\03\00\00\02\00\00\00\00\00\00\00\00\00", ptr %b1, align 1
   store [13 x i8] c"\01\00\00\00\00\00\00\00\00\00\00\00\00", ptr %b2, align 1
   %54 = load i104, ptr %b1, align 1
@@ -190,7 +190,7 @@ entry:
   %59 = zext i1 %58 to i8
   store i8 %59, ptr %taddr28, align 1
   %60 = insertvalue %variant undef, ptr %taddr28, 0
-  %61 = insertvalue %variant %60, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %61 = insertvalue %variant %60, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %62 = getelementptr inbounds [3 x %variant], ptr %varargslots27, i64 0, i64 0
   store %variant %61, ptr %62, align 16
   %63 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
@@ -200,7 +200,7 @@ entry:
   %66 = zext i1 %65 to i8
   store i8 %66, ptr %taddr30, align 1
   %67 = insertvalue %variant undef, ptr %taddr30, 0
-  %68 = insertvalue %variant %67, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %68 = insertvalue %variant %67, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %69 = getelementptr inbounds [3 x %variant], ptr %varargslots27, i64 0, i64 1
   store %variant %68, ptr %69, align 16
   %70 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 3
@@ -210,10 +210,10 @@ entry:
   %73 = zext i1 %72 to i8
   store i8 %73, ptr %taddr32, align 1
   %74 = insertvalue %variant undef, ptr %taddr32, 0
-  %75 = insertvalue %variant %74, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %75 = insertvalue %variant %74, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %76 = getelementptr inbounds [3 x %variant], ptr %varargslots27, i64 0, i64 2
   store %variant %75, ptr %76, align 16
-  %77 = call i64 @std_io.printfn(ptr %retparam26, ptr @.str.4, i64 8, ptr %varargslots27, i64 3)
+  %77 = call i64 @std.io.printfn(ptr %retparam26, ptr @.str.4, i64 8, ptr %varargslots27, i64 3)
   %78 = load i104, ptr %b3, align 1
   %bnot33 = xor i104 %78, -1
   store i104 %bnot33, ptr %1, align 8
@@ -224,7 +224,7 @@ entry:
   %82 = zext i1 %81 to i8
   store i8 %82, ptr %taddr36, align 1
   %83 = insertvalue %variant undef, ptr %taddr36, 0
-  %84 = insertvalue %variant %83, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %84 = insertvalue %variant %83, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %85 = getelementptr inbounds [3 x %variant], ptr %varargslots35, i64 0, i64 0
   store %variant %84, ptr %85, align 16
   %86 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
@@ -234,7 +234,7 @@ entry:
   %89 = zext i1 %88 to i8
   store i8 %89, ptr %taddr38, align 1
   %90 = insertvalue %variant undef, ptr %taddr38, 0
-  %91 = insertvalue %variant %90, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %91 = insertvalue %variant %90, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %92 = getelementptr inbounds [3 x %variant], ptr %varargslots35, i64 0, i64 1
   store %variant %91, ptr %92, align 16
   %93 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 3
@@ -244,10 +244,10 @@ entry:
   %96 = zext i1 %95 to i8
   store i8 %96, ptr %taddr40, align 1
   %97 = insertvalue %variant undef, ptr %taddr40, 0
-  %98 = insertvalue %variant %97, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %98 = insertvalue %variant %97, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %99 = getelementptr inbounds [3 x %variant], ptr %varargslots35, i64 0, i64 2
   store %variant %98, ptr %99, align 16
-  %100 = call i64 @std_io.printfn(ptr %retparam34, ptr @.str.5, i64 8, ptr %varargslots35, i64 3)
+  %100 = call i64 @std.io.printfn(ptr %retparam34, ptr @.str.5, i64 8, ptr %varargslots35, i64 3)
   store [13 x i8] c"\03\00\00\00\00\00\00\00\00\00\00\00\00", ptr %taddr41, align 1
   %101 = load i104, ptr %b3, align 1
   %102 = load i104, ptr %taddr41, align 1
@@ -260,7 +260,7 @@ entry:
   %106 = zext i1 %105 to i8
   store i8 %106, ptr %taddr45, align 1
   %107 = insertvalue %variant undef, ptr %taddr45, 0
-  %108 = insertvalue %variant %107, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %108 = insertvalue %variant %107, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %109 = getelementptr inbounds [3 x %variant], ptr %varargslots44, i64 0, i64 0
   store %variant %108, ptr %109, align 16
   %110 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
@@ -270,7 +270,7 @@ entry:
   %113 = zext i1 %112 to i8
   store i8 %113, ptr %taddr47, align 1
   %114 = insertvalue %variant undef, ptr %taddr47, 0
-  %115 = insertvalue %variant %114, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %115 = insertvalue %variant %114, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %116 = getelementptr inbounds [3 x %variant], ptr %varargslots44, i64 0, i64 1
   store %variant %115, ptr %116, align 16
   %117 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 3
@@ -280,9 +280,9 @@ entry:
   %120 = zext i1 %119 to i8
   store i8 %120, ptr %taddr49, align 1
   %121 = insertvalue %variant undef, ptr %taddr49, 0
-  %122 = insertvalue %variant %121, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %122 = insertvalue %variant %121, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %123 = getelementptr inbounds [3 x %variant], ptr %varargslots44, i64 0, i64 2
   store %variant %122, ptr %123, align 16
-  %124 = call i64 @std_io.printfn(ptr %retparam43, ptr @.str.6, i64 8, ptr %varargslots44, i64 3)
+  %124 = call i64 @std.io.printfn(ptr %retparam43, ptr @.str.6, i64 8, ptr %varargslots44, i64 3)
   ret void
 }
diff --git a/test/test_suite/compile_time/compile_time_access_subscript.c3t b/test/test_suite/compile_time/compile_time_access_subscript.c3t
index 9ce9e5595..72f5b1133 100644
--- a/test/test_suite/compile_time/compile_time_access_subscript.c3t
+++ b/test/test_suite/compile_time/compile_time_access_subscript.c3t
@@ -95,9 +95,9 @@ fn void main()
   %13 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 3
   store float 0.000000e+00, ptr %13, align 4
   %14 = insertvalue %variant undef, ptr %literal, 0
-  %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$test.Abc" to i64), 1
+  %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"$ct.test.Abc" to i64), 1
   %16 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %15, ptr %16, align 16
-  %17 = call i64 @std_io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
+  %17 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
   ret void
 }
diff --git a/test/test_suite/compile_time/ct_builtin_time_date.c3t b/test/test_suite/compile_time/ct_builtin_time_date.c3t
index b4a14a041..ae04e40d5 100644
--- a/test/test_suite/compile_time/ct_builtin_time_date.c3t
+++ b/test/test_suite/compile_time/ct_builtin_time_date.c3t
@@ -52,10 +52,10 @@ entry:
   %result16 = alloca %File, align 8
   store i32 %0, ptr %taddr, align 4
   %1 = insertvalue %variant undef, ptr %taddr, 0
-  %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %2, ptr %3, align 16
-  %4 = call i64 @std_io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
+  %4 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
   %gt = icmp sgt i32 %0, 0
   br i1 %gt, label %if.then, label %if.exit
 
@@ -66,36 +66,36 @@ if.then:                                          ; preds = %entry
 
 if.exit:                                          ; preds = %if.then, %entry
   store ptr @.str.1, ptr %x, align 8
-  %5 = call ptr @std_io.stdout()
+  %5 = call ptr @std.io.stdout()
   store ptr %5, ptr %result, align 8
   %6 = load ptr, ptr %x, align 8
-  %7 = call i64 @std_io.File_printn(ptr %retparam1, ptr %result, ptr %6, i64 8)
+  %7 = call i64 @std.io.File.printn(ptr %retparam1, ptr %result, ptr %6, i64 8)
   store ptr @.str.2, ptr %x2, align 8
-  %8 = call ptr @std_io.stdout()
+  %8 = call ptr @std.io.stdout()
   store ptr %8, ptr %result4, align 8
   %9 = load ptr, ptr %x2, align 8
-  %10 = call i64 @std_io.File_printn(ptr %retparam3, ptr %result4, ptr %9, i64 10)
+  %10 = call i64 @std.io.File.printn(ptr %retparam3, ptr %result4, ptr %9, i64 10)
   store i64 14, ptr %taddr7, align 8
   %11 = insertvalue %variant undef, ptr %taddr7, 0
-  %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$long" to i64), 1
+  %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"$ct.long" to i64), 1
   %13 = getelementptr inbounds [1 x %variant], ptr %varargslots6, i64 0, i64 0
   store %variant %12, ptr %13, align 16
-  %14 = call i64 @std_io.printfn(ptr %retparam5, ptr @.str.3, i64 2, ptr %varargslots6, i64 1)
+  %14 = call i64 @std.io.printfn(ptr %retparam5, ptr @.str.3, i64 2, ptr %varargslots6, i64 1)
   store i64 6, ptr %taddr10, align 8
   %15 = insertvalue %variant undef, ptr %taddr10, 0
-  %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$long" to i64), 1
+  %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"$ct.long" to i64), 1
   %17 = getelementptr inbounds [1 x %variant], ptr %varargslots9, i64 0, i64 0
   store %variant %16, ptr %17, align 16
-  %18 = call i64 @std_io.printfn(ptr %retparam8, ptr @.str.4, i64 2, ptr %varargslots9, i64 1)
+  %18 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.4, i64 2, ptr %varargslots9, i64 1)
   store ptr @.str.5, ptr %x11, align 8
-  %19 = call ptr @std_io.stdout()
+  %19 = call ptr @std.io.stdout()
   store ptr %19, ptr %result13, align 8
   %20 = load ptr, ptr %x11, align 8
-  %21 = call i64 @std_io.File_printn(ptr %retparam12, ptr %result13, ptr %20, i64 23)
+  %21 = call i64 @std.io.File.printn(ptr %retparam12, ptr %result13, ptr %20, i64 23)
   store ptr @.str.6, ptr %x14, align 8
-  %22 = call ptr @std_io.stdout()
+  %22 = call ptr @std.io.stdout()
   store ptr %22, ptr %result16, align 8
   %23 = load ptr, ptr %x14, align 8
-  %24 = call i64 @std_io.File_printn(ptr %retparam15, ptr %result16, ptr %23, i64 4)
+  %24 = call i64 @std.io.File.printn(ptr %retparam15, ptr %result16, ptr %23, i64 4)
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/compile_time/ct_funcptr.c3t b/test/test_suite/compile_time/ct_funcptr.c3t
index d8df3cab9..28897e2eb 100644
--- a/test/test_suite/compile_time/ct_funcptr.c3t
+++ b/test/test_suite/compile_time/ct_funcptr.c3t
@@ -25,10 +25,10 @@ entry:
   store ptr @test.test, ptr %ptr, align 8
   store i32 %0, ptr %taddr, align 4
   %1 = insertvalue %variant undef, ptr %taddr, 0
-  %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %2, ptr %3, align 16
-  %4 = call i64 @std_io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
+  %4 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
   %gt = icmp sgt i32 %0, 0
   br i1 %gt, label %if.then, label %if.exit
 
diff --git a/test/test_suite/compile_time/ct_memberof.c3t b/test/test_suite/compile_time/ct_memberof.c3t
index 84a193796..71d1995f7 100644
--- a/test/test_suite/compile_time/ct_memberof.c3t
+++ b/test/test_suite/compile_time/ct_memberof.c3t
@@ -188,168 +188,168 @@ entry:
   %taddr64 = alloca ptr, align 8
   %taddr65 = alloca ptr, align 8
   store ptr @.str, ptr %x, align 8
-  %1 = call ptr @std_io.stdout()
+  %1 = call ptr @std.io.stdout()
   store ptr %1, ptr %result, align 8
   %2 = load ptr, ptr %x, align 8
-  %3 = call i64 @std_io.File_printn(ptr %retparam, ptr %result, ptr %2, i64 3)
+  %3 = call i64 @std.io.File.printn(ptr %retparam, ptr %result, ptr %2, i64 3)
   store ptr @.str.10, ptr %x1, align 8
-  %4 = call ptr @std_io.stdout()
+  %4 = call ptr @std.io.stdout()
   store ptr %4, ptr %result3, align 8
   %5 = load ptr, ptr %x1, align 8
-  %6 = call i64 @std_io.File_printn(ptr %retparam2, ptr %result3, ptr %5, i64 3)
+  %6 = call i64 @std.io.File.printn(ptr %retparam2, ptr %result3, ptr %5, i64 3)
   store ptr @.str.11, ptr %x4, align 8
-  %7 = call ptr @std_io.stdout()
+  %7 = call ptr @std.io.stdout()
   store ptr %7, ptr %result6, align 8
   %8 = load ptr, ptr %x4, align 8
-  %9 = call i64 @std_io.File_printn(ptr %retparam5, ptr %result6, ptr %8, i64 6)
+  %9 = call i64 @std.io.File.printn(ptr %retparam5, ptr %result6, ptr %8, i64 6)
   store ptr @.str.12, ptr %x7, align 8
-  %10 = call ptr @std_io.stdout()
+  %10 = call ptr @std.io.stdout()
   store ptr %10, ptr %result9, align 8
   %11 = load ptr, ptr %x7, align 8
-  %12 = call i64 @std_io.File_printn(ptr %retparam8, ptr %result9, ptr %11, i64 6)
+  %12 = call i64 @std.io.File.printn(ptr %retparam8, ptr %result9, ptr %11, i64 6)
   store ptr @.str.13, ptr %x10, align 8
-  %13 = call ptr @std_io.stdout()
+  %13 = call ptr @std.io.stdout()
   store ptr %13, ptr %result12, align 8
   %14 = load ptr, ptr %x10, align 8
-  %15 = call i64 @std_io.File_printn(ptr %retparam11, ptr %result12, ptr %14, i64 9)
+  %15 = call i64 @std.io.File.printn(ptr %retparam11, ptr %result12, ptr %14, i64 9)
   store ptr @.str.14, ptr %x13, align 8
-  %16 = call ptr @std_io.stdout()
+  %16 = call ptr @std.io.stdout()
   store ptr %16, ptr %result15, align 8
   %17 = load ptr, ptr %x13, align 8
-  %18 = call i64 @std_io.File_printn(ptr %retparam14, ptr %result15, ptr %17, i64 4)
+  %18 = call i64 @std.io.File.printn(ptr %retparam14, ptr %result15, ptr %17, i64 4)
   store ptr @.str.15, ptr %x16, align 8
-  %19 = call ptr @std_io.stdout()
+  %19 = call ptr @std.io.stdout()
   store ptr %19, ptr %result18, align 8
   %20 = load ptr, ptr %x16, align 8
-  %21 = call i64 @std_io.File_printn(ptr %retparam17, ptr %result18, ptr %20, i64 3)
+  %21 = call i64 @std.io.File.printn(ptr %retparam17, ptr %result18, ptr %20, i64 3)
   store ptr @.str.17, ptr %taddr, align 8
   %22 = insertvalue %variant undef, ptr %taddr, 0
-  %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
+  %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
   %24 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %23, ptr %24, align 16
-  %25 = call i64 @std_io.printfn(ptr %retparam19, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
+  %25 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
   store ptr @.str.19, ptr %taddr22, align 8
   %26 = insertvalue %variant undef, ptr %taddr22, 0
-  %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
+  %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
   %28 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 0
   store %variant %27, ptr %28, align 16
   store ptr @.str.20, ptr %taddr23, align 8
   %29 = insertvalue %variant undef, ptr %taddr23, 0
-  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
+  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
   %31 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 1
   store %variant %30, ptr %31, align 16
-  %32 = call i64 @std_io.printfn(ptr %retparam20, ptr @.str.18, i64 6, ptr %varargslots21, i64 2)
+  %32 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.18, i64 6, ptr %varargslots21, i64 2)
   store ptr @.str.22, ptr %taddr26, align 8
   %33 = insertvalue %variant undef, ptr %taddr26, 0
-  %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
+  %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
   %35 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 0
   store %variant %34, ptr %35, align 16
   store ptr @.str.23, ptr %taddr27, align 8
   %36 = insertvalue %variant undef, ptr %taddr27, 0
-  %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
+  %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
   %38 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 1
   store %variant %37, ptr %38, align 16
-  %39 = call i64 @std_io.printfn(ptr %retparam24, ptr @.str.21, i64 6, ptr %varargslots25, i64 2)
+  %39 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.21, i64 6, ptr %varargslots25, i64 2)
   store ptr @.str.25, ptr %taddr30, align 8
   %40 = insertvalue %variant undef, ptr %taddr30, 0
-  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1
+  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"$ct.p$a0$char" to i64), 1
   %42 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 0
   store %variant %41, ptr %42, align 16
   store ptr @.str.26, ptr %taddr31, align 8
   %43 = insertvalue %variant undef, ptr %taddr31, 0
-  %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
+  %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
   %45 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 1
   store %variant %44, ptr %45, align 16
-  %46 = call i64 @std_io.printfn(ptr %retparam28, ptr @.str.24, i64 6, ptr %varargslots29, i64 2)
+  %46 = call i64 @std.io.printfn(ptr %retparam28, ptr @.str.24, i64 6, ptr %varargslots29, i64 2)
   store ptr @.str.28, ptr %taddr34, align 8
   %47 = insertvalue %variant undef, ptr %taddr34, 0
-  %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
+  %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
   %49 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 0
   store %variant %48, ptr %49, align 16
   store ptr @.str.29, ptr %taddr35, align 8
   %50 = insertvalue %variant undef, ptr %taddr35, 0
-  %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1
+  %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.p$a6$char" to i64), 1
   %52 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 1
   store %variant %51, ptr %52, align 16
-  %53 = call i64 @std_io.printfn(ptr %retparam32, ptr @.str.27, i64 6, ptr %varargslots33, i64 2)
+  %53 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.27, i64 6, ptr %varargslots33, i64 2)
   store ptr @.str.31, ptr %taddr38, align 8
   %54 = insertvalue %variant undef, ptr %taddr38, 0
-  %55 = insertvalue %variant %54, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
+  %55 = insertvalue %variant %54, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
   %56 = getelementptr inbounds [1 x %variant], ptr %varargslots37, i64 0, i64 0
   store %variant %55, ptr %56, align 16
-  %57 = call i64 @std_io.printfn(ptr %retparam36, ptr @.str.30, i64 8, ptr %varargslots37, i64 1)
+  %57 = call i64 @std.io.printfn(ptr %retparam36, ptr @.str.30, i64 8, ptr %varargslots37, i64 1)
   store ptr @.str.33, ptr %taddr41, align 8
   %58 = insertvalue %variant undef, ptr %taddr41, 0
-  %59 = insertvalue %variant %58, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
+  %59 = insertvalue %variant %58, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
   %60 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 0
   store %variant %59, ptr %60, align 16
   store ptr @.str.34, ptr %taddr42, align 8
   %61 = insertvalue %variant undef, ptr %taddr42, 0
-  %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
+  %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
   %63 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1
   store %variant %62, ptr %63, align 16
-  %64 = call i64 @std_io.printfn(ptr %retparam39, ptr @.str.32, i64 6, ptr %varargslots40, i64 2)
+  %64 = call i64 @std.io.printfn(ptr %retparam39, ptr @.str.32, i64 6, ptr %varargslots40, i64 2)
   store ptr @.str.36, ptr %taddr45, align 8
   %65 = insertvalue %variant undef, ptr %taddr45, 0
-  %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
+  %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
   %67 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 0
   store %variant %66, ptr %67, align 16
   store ptr @.str.37, ptr %taddr46, align 8
   %68 = insertvalue %variant undef, ptr %taddr46, 0
-  %69 = insertvalue %variant %68, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
+  %69 = insertvalue %variant %68, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
   %70 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 1
   store %variant %69, ptr %70, align 16
-  %71 = call i64 @std_io.printfn(ptr %retparam43, ptr @.str.35, i64 6, ptr %varargslots44, i64 2)
+  %71 = call i64 @std.io.printfn(ptr %retparam43, ptr @.str.35, i64 6, ptr %varargslots44, i64 2)
   store ptr @.str.39, ptr %taddr49, align 8
   %72 = insertvalue %variant undef, ptr %taddr49, 0
-  %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1
+  %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"$ct.p$a0$char" to i64), 1
   %74 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 0
   store %variant %73, ptr %74, align 16
   store ptr @.str.40, ptr %taddr50, align 8
   %75 = insertvalue %variant undef, ptr %taddr50, 0
-  %76 = insertvalue %variant %75, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
+  %76 = insertvalue %variant %75, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
   %77 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 1
   store %variant %76, ptr %77, align 16
-  %78 = call i64 @std_io.printfn(ptr %retparam47, ptr @.str.38, i64 6, ptr %varargslots48, i64 2)
+  %78 = call i64 @std.io.printfn(ptr %retparam47, ptr @.str.38, i64 6, ptr %varargslots48, i64 2)
   store ptr @.str.42, ptr %taddr53, align 8
   %79 = insertvalue %variant undef, ptr %taddr53, 0
-  %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
+  %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
   %81 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 0
   store %variant %80, ptr %81, align 16
   store ptr @.str.43, ptr %taddr54, align 8
   %82 = insertvalue %variant undef, ptr %taddr54, 0
-  %83 = insertvalue %variant %82, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
+  %83 = insertvalue %variant %82, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
   %84 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 1
   store %variant %83, ptr %84, align 16
-  %85 = call i64 @std_io.printfn(ptr %retparam51, ptr @.str.41, i64 6, ptr %varargslots52, i64 2)
+  %85 = call i64 @std.io.printfn(ptr %retparam51, ptr @.str.41, i64 6, ptr %varargslots52, i64 2)
   store ptr @.str.45, ptr %taddr57, align 8
   %86 = insertvalue %variant undef, ptr %taddr57, 0
-  %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
+  %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1
   %88 = getelementptr inbounds [1 x %variant], ptr %varargslots56, i64 0, i64 0
   store %variant %87, ptr %88, align 16
-  %89 = call i64 @std_io.printfn(ptr %retparam55, ptr @.str.44, i64 8, ptr %varargslots56, i64 1)
+  %89 = call i64 @std.io.printfn(ptr %retparam55, ptr @.str.44, i64 8, ptr %varargslots56, i64 1)
   store ptr @.str.47, ptr %taddr60, align 8
   %90 = insertvalue %variant undef, ptr %taddr60, 0
-  %91 = insertvalue %variant %90, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
+  %91 = insertvalue %variant %90, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
   %92 = getelementptr inbounds [2 x %variant], ptr %varargslots59, i64 0, i64 0
   store %variant %91, ptr %92, align 16
   store ptr @.str.48, ptr %taddr61, align 8
   %93 = insertvalue %variant undef, ptr %taddr61, 0
-  %94 = insertvalue %variant %93, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
+  %94 = insertvalue %variant %93, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
   %95 = getelementptr inbounds [2 x %variant], ptr %varargslots59, i64 0, i64 1
   store %variant %94, ptr %95, align 16
-  %96 = call i64 @std_io.printfn(ptr %retparam58, ptr @.str.46, i64 6, ptr %varargslots59, i64 2)
+  %96 = call i64 @std.io.printfn(ptr %retparam58, ptr @.str.46, i64 6, ptr %varargslots59, i64 2)
   store ptr @.str.50, ptr %taddr64, align 8
   %97 = insertvalue %variant undef, ptr %taddr64, 0
-  %98 = insertvalue %variant %97, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
+  %98 = insertvalue %variant %97, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1
   %99 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 0
   store %variant %98, ptr %99, align 16
   store ptr @.str.51, ptr %taddr65, align 8
   %100 = insertvalue %variant undef, ptr %taddr65, 0
-  %101 = insertvalue %variant %100, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
+  %101 = insertvalue %variant %100, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
   %102 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 1
   store %variant %101, ptr %102, align 16
-  %103 = call i64 @std_io.printfn(ptr %retparam62, ptr @.str.49, i64 6, ptr %varargslots63, i64 2)
+  %103 = call i64 @std.io.printfn(ptr %retparam62, ptr @.str.49, i64 6, ptr %varargslots63, i64 2)
   ret void
 }
 
@@ -399,110 +399,110 @@ entry:
   %taddr38 = alloca i64, align 8
   store i64 4, ptr %taddr, align 8
   %0 = insertvalue %variant undef, ptr %taddr, 0
-  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"ct$long" to i64), 1
+  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"$ct.long" to i64), 1
   %2 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %1, ptr %2, align 16
-  %3 = call i64 @std_io.printfn(ptr %retparam, ptr @.str.52, i64 7, ptr %varargslots, i64 1)
+  %3 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.52, i64 7, ptr %varargslots, i64 1)
   store i64 1, ptr %taddr3, align 8
   %4 = insertvalue %variant undef, ptr %taddr3, 0
-  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$long" to i64), 1
+  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"$ct.long" to i64), 1
   %6 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0
   store %variant %5, ptr %6, align 16
-  %7 = call i64 @std_io.printfn(ptr %retparam1, ptr @.str.53, i64 7, ptr %varargslots2, i64 1)
+  %7 = call i64 @std.io.printfn(ptr %retparam1, ptr @.str.53, i64 7, ptr %varargslots2, i64 1)
   store i64 0, ptr %taddr6, align 8
   %8 = insertvalue %variant undef, ptr %taddr6, 0
-  %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %10 = getelementptr inbounds [2 x %variant], ptr %varargslots5, i64 0, i64 0
   store %variant %9, ptr %10, align 16
   store i64 4, ptr %taddr7, align 8
   %11 = insertvalue %variant undef, ptr %taddr7, 0
-  %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %13 = getelementptr inbounds [2 x %variant], ptr %varargslots5, i64 0, i64 1
   store %variant %12, ptr %13, align 16
-  %14 = call i64 @std_io.printfn(ptr %retparam4, ptr @.str.54, i64 8, ptr %varargslots5, i64 2)
+  %14 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.54, i64 8, ptr %varargslots5, i64 2)
   store i64 2, ptr %taddr10, align 8
   %15 = insertvalue %variant undef, ptr %taddr10, 0
-  %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %17 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 0
   store %variant %16, ptr %17, align 16
   store i64 2, ptr %taddr11, align 8
   %18 = insertvalue %variant undef, ptr %taddr11, 0
-  %19 = insertvalue %variant %18, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %19 = insertvalue %variant %18, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %20 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 1
   store %variant %19, ptr %20, align 16
-  %21 = call i64 @std_io.printfn(ptr %retparam8, ptr @.str.55, i64 8, ptr %varargslots9, i64 2)
+  %21 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.55, i64 8, ptr %varargslots9, i64 2)
   store i64 4, ptr %taddr14, align 8
   %22 = insertvalue %variant undef, ptr %taddr14, 0
-  %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %24 = getelementptr inbounds [2 x %variant], ptr %varargslots13, i64 0, i64 0
   store %variant %23, ptr %24, align 16
   store i64 4, ptr %taddr15, align 8
   %25 = insertvalue %variant undef, ptr %taddr15, 0
-  %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %27 = getelementptr inbounds [2 x %variant], ptr %varargslots13, i64 0, i64 1
   store %variant %26, ptr %27, align 16
-  %28 = call i64 @std_io.printfn(ptr %retparam12, ptr @.str.56, i64 8, ptr %varargslots13, i64 2)
+  %28 = call i64 @std.io.printfn(ptr %retparam12, ptr @.str.56, i64 8, ptr %varargslots13, i64 2)
   store i64 4, ptr %taddr18, align 8
   %29 = insertvalue %variant undef, ptr %taddr18, 0
-  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %31 = getelementptr inbounds [2 x %variant], ptr %varargslots17, i64 0, i64 0
   store %variant %30, ptr %31, align 16
   store i64 4, ptr %taddr19, align 8
   %32 = insertvalue %variant undef, ptr %taddr19, 0
-  %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %34 = getelementptr inbounds [2 x %variant], ptr %varargslots17, i64 0, i64 1
   store %variant %33, ptr %34, align 16
-  %35 = call i64 @std_io.printfn(ptr %retparam16, ptr @.str.57, i64 8, ptr %varargslots17, i64 2)
+  %35 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.57, i64 8, ptr %varargslots17, i64 2)
   store i64 4, ptr %taddr22, align 8
   %36 = insertvalue %variant undef, ptr %taddr22, 0
-  %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %38 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 0
   store %variant %37, ptr %38, align 16
   store i64 4, ptr %taddr23, align 8
   %39 = insertvalue %variant undef, ptr %taddr23, 0
-  %40 = insertvalue %variant %39, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %40 = insertvalue %variant %39, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %41 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 1
   store %variant %40, ptr %41, align 16
-  %42 = call i64 @std_io.printfn(ptr %retparam20, ptr @.str.58, i64 9, ptr %varargslots21, i64 2)
+  %42 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.58, i64 9, ptr %varargslots21, i64 2)
   store i64 5, ptr %taddr26, align 8
   %43 = insertvalue %variant undef, ptr %taddr26, 0
-  %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %45 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 0
   store %variant %44, ptr %45, align 16
   store i64 1, ptr %taddr27, align 8
   %46 = insertvalue %variant undef, ptr %taddr27, 0
-  %47 = insertvalue %variant %46, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %47 = insertvalue %variant %46, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %48 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 1
   store %variant %47, ptr %48, align 16
-  %49 = call i64 @std_io.printfn(ptr %retparam24, ptr @.str.59, i64 9, ptr %varargslots25, i64 2)
+  %49 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.59, i64 9, ptr %varargslots25, i64 2)
   store i64 8, ptr %taddr30, align 8
   %50 = insertvalue %variant undef, ptr %taddr30, 0
-  %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %52 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 0
   store %variant %51, ptr %52, align 16
   store i64 4, ptr %taddr31, align 8
   %53 = insertvalue %variant undef, ptr %taddr31, 0
-  %54 = insertvalue %variant %53, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %54 = insertvalue %variant %53, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %55 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 1
   store %variant %54, ptr %55, align 16
-  %56 = call i64 @std_io.printfn(ptr %retparam28, ptr @.str.60, i64 10, ptr %varargslots29, i64 2)
+  %56 = call i64 @std.io.printfn(ptr %retparam28, ptr @.str.60, i64 10, ptr %varargslots29, i64 2)
   store i64 4, ptr %taddr34, align 8
   %57 = insertvalue %variant undef, ptr %taddr34, 0
-  %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %59 = getelementptr inbounds [1 x %variant], ptr %varargslots33, i64 0, i64 0
   store %variant %58, ptr %59, align 16
-  %60 = call i64 @std_io.printfn(ptr %retparam32, ptr @.str.61, i64 7, ptr %varargslots33, i64 1)
+  %60 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.61, i64 7, ptr %varargslots33, i64 1)
   store i64 8, ptr %taddr37, align 8
   %61 = insertvalue %variant undef, ptr %taddr37, 0
-  %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %63 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 0
   store %variant %62, ptr %63, align 16
   store i64 4, ptr %taddr38, align 8
   %64 = insertvalue %variant undef, ptr %taddr38, 0
-  %65 = insertvalue %variant %64, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %65 = insertvalue %variant %64, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %66 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 1
   store %variant %65, ptr %66, align 16
-  %67 = call i64 @std_io.printfn(ptr %retparam35, ptr @.str.62, i64 10, ptr %varargslots36, i64 2)
+  %67 = call i64 @std.io.printfn(ptr %retparam35, ptr @.str.62, i64 10, ptr %varargslots36, i64 2)
   call void @test.test(i32 10)
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/compile_time/untyped_conversions.c3t b/test/test_suite/compile_time/untyped_conversions.c3t
index 20d4a8a52..0c73ef12f 100644
--- a/test/test_suite/compile_time/untyped_conversions.c3t
+++ b/test/test_suite/compile_time/untyped_conversions.c3t
@@ -29,21 +29,21 @@ fn void main()
 %"int[]" = type { ptr, i64 }
 %variant = type { ptr, i64 }
 
-@"ct$test.Foo" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.test.Foo" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
 @.str = private unnamed_addr constant [9 x i8] c"%s %s %s\00", align 1
-@"ct$int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$a2$int" = linkonce constant %.introspect { i8 15, i64 8, i64 ptrtoint (ptr @"ct$int" to i64), i64 2, [0 x i64] zeroinitializer }, align 8
-@"ct$sa$int" = linkonce constant %.introspect { i8 16, i64 16, i64 ptrtoint (ptr @"ct$int" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$v2$int" = linkonce constant %.introspect { i8 17, i64 8, i64 ptrtoint (ptr @"ct$int" to i64), i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.a2$int" = linkonce constant %.introspect { i8 15, i64 8, i64 ptrtoint (ptr @"$ct.int" to i64), i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.sa$int" = linkonce constant %.introspect { i8 16, i64 16, i64 ptrtoint (ptr @"$ct.int" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.v2$int" = linkonce constant %.introspect { i8 17, i64 8, i64 ptrtoint (ptr @"$ct.int" to i64), i64 2, [0 x i64] zeroinitializer }, align 8
 @.__const = private unnamed_addr constant [1 x %Foo] [%Foo { i32 1, i32 2 }], align 4
 @.__const.1 = private unnamed_addr constant %Foo { i32 1, i32 2 }, align 4
 @.__const.2 = private unnamed_addr constant [1 x [2 x i32]] [[2 x i32] [i32 1, i32 2]], align 4
 @.__const.3 = private unnamed_addr constant [1 x [2 x double]] [[2 x double] [double 1.000000e+00, double 2.000000e+00]], align 16
 @.str.4 = private unnamed_addr constant [15 x i8] c"%s %s {%s, %s}\00", align 1
-@"ct$a1$a2$int" = linkonce constant %.introspect { i8 15, i64 8, i64 ptrtoint (ptr @"ct$a2$int" to i64), i64 1, [0 x i64] zeroinitializer }, align 8
-@"ct$double" = linkonce constant %.introspect { i8 4, i64 8, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$a2$double" = linkonce constant %.introspect { i8 15, i64 16, i64 ptrtoint (ptr @"ct$double" to i64), i64 2, [0 x i64] zeroinitializer }, align 8
-@"ct$a1$a2$double" = linkonce constant %.introspect { i8 15, i64 16, i64 ptrtoint (ptr @"ct$a2$double" to i64), i64 1, [0 x i64] zeroinitializer }, align 8
+@"$ct.a1$a2$int" = linkonce constant %.introspect { i8 15, i64 8, i64 ptrtoint (ptr @"$ct.a2$int" to i64), i64 1, [0 x i64] zeroinitializer }, align 8
+@"$ct.double" = linkonce constant %.introspect { i8 4, i64 8, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.a2$double" = linkonce constant %.introspect { i8 15, i64 16, i64 ptrtoint (ptr @"$ct.double" to i64), i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.a1$a2$double" = linkonce constant %.introspect { i8 15, i64 16, i64 ptrtoint (ptr @"$ct.a2$double" to i64), i64 1, [0 x i64] zeroinitializer }, align 8
 
 ; Function Attrs: nounwind
 define void @test.test(i64 %0, ptr %1, i64 %2, double %3) #0 {
@@ -59,18 +59,18 @@ entry:
   store i64 %2, ptr %ptroffset, align 8
   store double %3, ptr %c, align 8
   %4 = insertvalue %variant undef, ptr %a, 0
-  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$a2$int" to i64), 1
+  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"$ct.a2$int" to i64), 1
   %6 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %5, ptr %6, align 16
   %7 = insertvalue %variant undef, ptr %b, 0
-  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1
+  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
   %9 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %8, ptr %9, align 16
   %10 = insertvalue %variant undef, ptr %c, 0
-  %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"ct$v2$int" to i64), 1
+  %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"$ct.v2$int" to i64), 1
   %12 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 2
   store %variant %11, ptr %12, align 16
-  %13 = call i64 @std_io.printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 3)
+  %13 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 3)
   ret void
 }
 
@@ -94,24 +94,24 @@ entry:
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %y, ptr align 4 @.__const.2, i32 8, i1 false)
   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %y2, ptr align 16 @.__const.3, i32 16, i1 false)
   %0 = insertvalue %variant undef, ptr %y, 0
-  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"ct$a1$a2$int" to i64), 1
+  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"$ct.a1$a2$int" to i64), 1
   %2 = getelementptr inbounds [4 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %1, ptr %2, align 16
   %3 = insertvalue %variant undef, ptr %y2, 0
-  %4 = insertvalue %variant %3, i64 ptrtoint (ptr @"ct$a1$a2$double" to i64), 1
+  %4 = insertvalue %variant %3, i64 ptrtoint (ptr @"$ct.a1$a2$double" to i64), 1
   %5 = getelementptr inbounds [4 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %4, ptr %5, align 16
   %6 = getelementptr inbounds %Foo, ptr %def, i32 0, i32 0
   %7 = insertvalue %variant undef, ptr %6, 0
-  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %9 = getelementptr inbounds [4 x %variant], ptr %varargslots, i64 0, i64 2
   store %variant %8, ptr %9, align 16
   %10 = getelementptr inbounds %Foo, ptr %def, i32 0, i32 1
   %11 = insertvalue %variant undef, ptr %10, 0
-  %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %13 = getelementptr inbounds [4 x %variant], ptr %varargslots, i64 0, i64 3
   store %variant %12, ptr %13, align 16
-  %14 = call i64 @std_io.printfn(ptr %retparam, ptr @.str.4, i64 14, ptr %varargslots, i64 4)
+  %14 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.4, i64 14, ptr %varargslots, i64 4)
   %15 = getelementptr inbounds [2 x i32], ptr %literal, i64 0, i64 0
   store i32 1, ptr %15, align 4
   %16 = getelementptr inbounds [2 x i32], ptr %literal, i64 0, i64 1
diff --git a/test/test_suite/compile_time_introspection/qnameof.c3t b/test/test_suite/compile_time_introspection/qnameof.c3t
index 90d2bb3b5..4d9d6f466 100644
--- a/test/test_suite/compile_time_introspection/qnameof.c3t
+++ b/test/test_suite/compile_time_introspection/qnameof.c3t
@@ -22,7 +22,7 @@ fn void main()
 
 /* #expect: qnametest.ll
 
-@"ct$qnametest.Blob" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.qnametest.Blob" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
 @qnametest.x = local_unnamed_addr global i32 0, align 4
 @.str = private unnamed_addr constant [12 x i8] c"printf: %s\0A\00", align 1
 @.str.1 = private unnamed_addr constant [7 x i8] c"printf\00", align 1
diff --git a/test/test_suite/enumerations/enum_associated_value.c3t b/test/test_suite/enumerations/enum_associated_value.c3t
index 570bf822e..6ee0bb6fc 100644
--- a/test/test_suite/enumerations/enum_associated_value.c3t
+++ b/test/test_suite/enumerations/enum_associated_value.c3t
@@ -18,8 +18,8 @@ fn void main()
 
 /* #expect: test.ll
 
-@"ct$uint" = linkonce constant %.introspect { i8 3, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$test.Foo" = linkonce constant { i8, i64, i64, i64, [2 x %"char[]"] } { i8 8, i64 4, i64 ptrtoint (ptr @"ct$uint" to i64), i64 2, [2 x %"char[]"] [%"char[]" { ptr @.enum.0, i64 1 }, %"char[]" { ptr @.enum.1, i64 1 }] }, align 8
+@"$ct.uint" = linkonce constant %.introspect { i8 3, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.test.Foo" = linkonce constant { i8, i64, i64, i64, [2 x %"char[]"] } { i8 8, i64 4, i64 ptrtoint (ptr @"$ct.uint" to i64), i64 2, [2 x %"char[]"] [%"char[]" { ptr @.enum.0, i64 1 }, %"char[]" { ptr @.enum.1, i64 1 }] }, align 8
 @"test.Foo$val" = linkonce constant [2 x i32] [i32 123, i32 333], align 4
 @.str = private unnamed_addr constant [9 x i8] c"Number A\00", align 1
 @.str.1 = private unnamed_addr constant [9 x i8] c"Number B\00", align 1
diff --git a/test/test_suite/enumerations/enum_associated_values_other.c3t b/test/test_suite/enumerations/enum_associated_values_other.c3t
index a307bb496..7d8c5517b 100644
--- a/test/test_suite/enumerations/enum_associated_values_other.c3t
+++ b/test/test_suite/enumerations/enum_associated_values_other.c3t
@@ -24,11 +24,11 @@ enum Foo : int(String val)
 
 /* #expect: abc.ll
 
-@"ct$abc.Abc" = linkonce constant %.introspect { i8 10, i64 4, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
+@"$ct.abc.Abc" = linkonce constant %.introspect { i8 10, i64 4, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
 @.enum.0 = internal constant [4 x i8] c"ABC\00", align 1
 @.enum.1 = internal constant [4 x i8] c"DEF\00", align 1
-@"ct$int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$abc.Foo" = linkonce constant { i8, i64, i64, i64, [2 x %"char[]"] } { i8 8, i64 4, i64 ptrtoint (ptr @"ct$int" to i64), i64 2, [2 x %"char[]"] [%"char[]" { ptr @.enum.0, i64 3 }, %"char[]" { ptr @.enum.1, i64 3 }] }, align 8
+@"$ct.int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.abc.Foo" = linkonce constant { i8, i64, i64, i64, [2 x %"char[]"] } { i8 8, i64 4, i64 ptrtoint (ptr @"$ct.int" to i64), i64 2, [2 x %"char[]"] [%"char[]" { ptr @.enum.0, i64 3 }, %"char[]" { ptr @.enum.1, i64 3 }] }, align 8
 @.str = private unnamed_addr constant [6 x i8] c"hello\00", align 1
 @.str.1 = private unnamed_addr constant [6 x i8] c"world\00", align 1
 @"abc.Foo$val" = linkonce constant [2 x %"char[]"] [%"char[]" { ptr @.str, i64 5 }, %"char[]" { ptr @.str.1, i64 5 }], align 8
@@ -37,18 +37,18 @@ enum Foo : int(String val)
 
 // #expect: test.ll
 
-@"ct$abc.Abc" = linkonce constant %.introspect { i8 10, i64 4, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
+@"$ct.abc.Abc" = linkonce constant %.introspect { i8 10, i64 4, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
 @abc.dabc = external global i32, align 4
 @.enum.0 = internal constant [4 x i8] c"ABC\00", align 1
 @.enum.1 = internal constant [4 x i8] c"DEF\00", align 1
-@"ct$int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$abc.Foo" = linkonce constant { i8, i64, i64, i64, [2 x %"char[]"] } { i8 8, i64 4, i64 ptrtoint (ptr @"ct$int" to i64), i64 2, [2 x %"char[]"] [%"char[]" { ptr @.enum.0, i64 3 }, %"char[]" { ptr @.enum.1, i64 3 }] }, align 8
+@"$ct.int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.abc.Foo" = linkonce constant { i8, i64, i64, i64, [2 x %"char[]"] } { i8 8, i64 4, i64 ptrtoint (ptr @"$ct.int" to i64), i64 2, [2 x %"char[]"] [%"char[]" { ptr @.enum.0, i64 3 }, %"char[]" { ptr @.enum.1, i64 3 }] }, align 8
 @.str = private unnamed_addr constant [6 x i8] c"hello\00", align 1
 @.str.1 = private unnamed_addr constant [6 x i8] c"world\00", align 1
 @"abc.Foo$val" = linkonce constant [2 x %"char[]"] [%"char[]" { ptr @.str, i64 5 }, %"char[]" { ptr @.str.1, i64 5 }], align 8
 @.str.2 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
-@"ct$char" = linkonce constant %.introspect { i8 3, i64 1, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$sa$char" = linkonce constant %.introspect { i8 16, i64 16, i64 ptrtoint (ptr @"ct$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.char" = linkonce constant %.introspect { i8 3, i64 1, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.sa$char" = linkonce constant %.introspect { i8 16, i64 16, i64 ptrtoint (ptr @"$ct.char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
 
 define void @test.main(ptr %0, i64 %1) #0 {
 entry:
@@ -62,16 +62,16 @@ entry:
   store ptr %0, ptr %args, align 8
   %ptroffset = getelementptr inbounds i64, ptr %args, i64 1
   store i64 %1, ptr %ptroffset, align 8
-  store i64 ptrtoint (ptr @"ct$abc.Abc" to i64), ptr %y, align 8
+  store i64 ptrtoint (ptr @"$ct.abc.Abc" to i64), ptr %y, align 8
   store ptr @abc.dabc, ptr %x, align 8
   store i32 1, ptr %a, align 4
   %2 = load i32, ptr %a, align 4
   %3 = getelementptr inbounds [2 x %"char[]"], ptr @"abc.Foo$val", i32 0, i32 %2
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %z, ptr align 8 %3, i32 16, i1 false)
   %4 = insertvalue %variant undef, ptr %z, 0
-  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$sa$char" to i64), 1
+  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
   %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %5, ptr %6, align 16
-  %7 = call i64 @std_io.printfn(ptr %retparam, ptr @.str.2, i64 2, ptr %varargslots, i64 1)
+  %7 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.2, i64 2, ptr %varargslots, i64 1)
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/errors/error_introspect.c3t b/test/test_suite/errors/error_introspect.c3t
index 85e15491f..56a9c1151 100644
--- a/test/test_suite/errors/error_introspect.c3t
+++ b/test/test_suite/errors/error_introspect.c3t
@@ -18,21 +18,21 @@ fn void main()
 
 /* #expect: foo.ll
 
-@"foo.Foo$BAR" = linkonce constant %.fault { i64 ptrtoint (ptr @"ct$foo.Foo" to i64), %"char[]" { ptr @.fault, i64 3 } }, align 8
+@"foo.Foo$BAR" = linkonce constant %.fault { i64 ptrtoint (ptr @"$ct.foo.Foo" to i64), %"char[]" { ptr @.fault, i64 3 } }, align 8
 @.fault = internal constant [4 x i8] c"BAR\00", align 1
-@"foo.Foo$BAZ" = linkonce constant %.fault { i64 ptrtoint (ptr @"ct$foo.Foo" to i64), %"char[]" { ptr @.fault.1, i64 3 } }, align 8
+@"foo.Foo$BAZ" = linkonce constant %.fault { i64 ptrtoint (ptr @"$ct.foo.Foo" to i64), %"char[]" { ptr @.fault.1, i64 3 } }, align 8
 @.fault.1 = internal constant [4 x i8] c"BAZ\00", align 1
-@"ct$foo.Foo" = linkonce constant %.introspect { i8 9, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.foo.Foo" = linkonce constant %.introspect { i8 9, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
 @.str = private unnamed_addr constant [4 x i8] c"BAR\00", align 1
 @.str.2 = private unnamed_addr constant [4 x i8] c"BAZ\00", align 1
 @.str.3 = private unnamed_addr constant [14 x i8] c"Foo.names: %s\00", align 1
-@"ct$char" = linkonce constant %.introspect { i8 3, i64 1, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$sa$char" = linkonce constant %.introspect { i8 16, i64 16, i64 ptrtoint (ptr @"ct$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$sa$sa$char" = linkonce constant %.introspect { i8 16, i64 16, i64 ptrtoint (ptr @"ct$sa$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.char" = linkonce constant %.introspect { i8 3, i64 1, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.sa$char" = linkonce constant %.introspect { i8 16, i64 16, i64 ptrtoint (ptr @"$ct.char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.sa$sa$char" = linkonce constant %.introspect { i8 16, i64 16, i64 ptrtoint (ptr @"$ct.sa$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
 @.str.4 = private unnamed_addr constant [15 x i8] c"Foo.values: %s\00", align 1
-@"ct$a2$foo.Foo" = linkonce constant %.introspect { i8 15, i64 16, i64 ptrtoint (ptr @"ct$foo.Foo" to i64), i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.a2$foo.Foo" = linkonce constant %.introspect { i8 15, i64 16, i64 ptrtoint (ptr @"$ct.foo.Foo" to i64), i64 2, [0 x i64] zeroinitializer }, align 8
 @.str.5 = private unnamed_addr constant [17 x i8] c"Foo.elements: %s\00", align 1
-@"ct$long" = linkonce constant %.introspect { i8 2, i64 8, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.long" = linkonce constant %.introspect { i8 2, i64 8, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
 
 entry:
   %x = alloca %"char[][]", align 8
@@ -53,24 +53,24 @@ entry:
   %3 = insertvalue %"char[][]" %2, i64 2, 1
   store %"char[][]" %3, ptr %x, align 8
   %4 = insertvalue %variant undef, ptr %x, 0
-  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$sa$sa$char" to i64), 1
+  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"$ct.sa$sa$char" to i64), 1
   %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %5, ptr %6, align 16
-  %7 = call i64 @std_io.printfn(ptr %retparam, ptr @.str.3, i64 13, ptr %varargslots, i64 1)
+  %7 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.3, i64 13, ptr %varargslots, i64 1)
   %8 = getelementptr inbounds [2 x i64], ptr %literal3, i64 0, i64 0
   store i64 ptrtoint (ptr @"foo.Foo$BAR" to i64), ptr %8, align 8
   %9 = getelementptr inbounds [2 x i64], ptr %literal3, i64 0, i64 1
   store i64 ptrtoint (ptr @"foo.Foo$BAZ" to i64), ptr %9, align 8
   %10 = insertvalue %variant undef, ptr %literal3, 0
-  %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"ct$a2$foo.Foo" to i64), 1
+  %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"$ct.a2$foo.Foo" to i64), 1
   %12 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0
   store %variant %11, ptr %12, align 16
-  %13 = call i64 @std_io.printfn(ptr %retparam1, ptr @.str.4, i64 14, ptr %varargslots2, i64 1)
+  %13 = call i64 @std.io.printfn(ptr %retparam1, ptr @.str.4, i64 14, ptr %varargslots2, i64 1)
   store i64 2, ptr %taddr, align 8
   %14 = insertvalue %variant undef, ptr %taddr, 0
-  %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$long" to i64), 1
+  %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"$ct.long" to i64), 1
   %16 = getelementptr inbounds [1 x %variant], ptr %varargslots5, i64 0, i64 0
   store %variant %15, ptr %16, align 16
-  %17 = call i64 @std_io.printfn(ptr %retparam4, ptr @.str.5, i64 16, ptr %varargslots5, i64 1)
+  %17 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.5, i64 16, ptr %varargslots5, i64 1)
   ret void
 }
diff --git a/test/test_suite/errors/error_regression_2.c3t b/test/test_suite/errors/error_regression_2.c3t
index 84ef981c6..0ad5bc8af 100644
--- a/test/test_suite/errors/error_regression_2.c3t
+++ b/test/test_suite/errors/error_regression_2.c3t
@@ -150,7 +150,7 @@ fn void main()
 
 /* #expect: test.ll
 
-define void @test.Summary_print(ptr %0, ptr %1) #0 {
+define void @test.Summary.print(ptr %0, ptr %1) #0 {
 entry:
   %title = alloca %"char[]", align 8
   %2 = getelementptr inbounds %Summary, ptr %0, i32 0, i32 0
@@ -334,7 +334,7 @@ if.then7:                                         ; preds = %if.exit4
   %17 = getelementptr inbounds %Head, ptr %literal10, i32 0, i32 0
   store ptr null, ptr %17, align 8
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value, ptr align 8 %literal10, i32 8, i1 false)
-  %18 = call ptr @std_core_mem.malloc(i64 8) #3
+  %18 = call ptr @std.core.mem.malloc(i64 8) #3
   store ptr %18, ptr %temp, align 8
   %19 = load ptr, ptr %temp, align 8
   %not = icmp eq ptr %19, null
@@ -373,7 +373,7 @@ if.then16:                                        ; preds = %if.exit13
   store ptr null, ptr %literal21, align 8
   %28 = getelementptr inbounds %Head, ptr %literal21, i32 0, i32 0
   store %"char[]" zeroinitializer, ptr %value23, align 8
-  %29 = call ptr @std_core_mem.malloc(i64 16) #3
+  %29 = call ptr @std.core.mem.malloc(i64 16) #3
   store ptr %29, ptr %temp24, align 8
   %30 = load ptr, ptr %temp24, align 8
   %not25 = icmp eq ptr %30, null
@@ -396,7 +396,7 @@ noerr_block29:                                    ; preds = %if.exit27
   %33 = load ptr, ptr %temp24, align 8
   store ptr %33, ptr %28, align 8
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value20, ptr align 8 %literal21, i32 8, i1 false)
-  %34 = call ptr @std_core_mem.malloc(i64 8) #3
+  %34 = call ptr @std.core.mem.malloc(i64 8) #3
   store ptr %34, ptr %temp30, align 8
   %35 = load ptr, ptr %temp30, align 8
   %not31 = icmp eq ptr %35, null
@@ -432,7 +432,7 @@ if.exit36:                                        ; preds = %if.exit13
   %44 = load i32, ptr %len, align 4
   %siuiext = sext i32 %44 to i64
   %add = add i64 %siuiext, 1
-  %45 = call ptr @std_core_mem.malloc(i64 %add) #3
+  %45 = call ptr @std.core.mem.malloc(i64 %add) #3
   store ptr %45, ptr %str, align 8
   %46 = load ptr, ptr %str, align 8
   %not37 = icmp eq ptr %46, null
@@ -465,7 +465,7 @@ if.exit39:                                        ; preds = %if.exit36
   %59 = insertvalue %"char[]" undef, ptr %ptroffset50, 0
   %60 = insertvalue %"char[]" %59, i64 %size, 1
   store %"char[]" %60, ptr %value49, align 8
-  %61 = call ptr @std_core_mem.malloc(i64 16) #3
+  %61 = call ptr @std.core.mem.malloc(i64 16) #3
   store ptr %61, ptr %temp51, align 8
   %62 = load ptr, ptr %temp51, align 8
   %not52 = icmp eq ptr %62, null
@@ -488,7 +488,7 @@ noerr_block56:                                    ; preds = %if.exit54
   %65 = load ptr, ptr %temp51, align 8
   store ptr %65, ptr %55, align 8
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value46, ptr align 8 %literal47, i32 8, i1 false)
-  %66 = call ptr @std_core_mem.malloc(i64 8) #3
+  %66 = call ptr @std.core.mem.malloc(i64 8) #3
   store ptr %66, ptr %temp57, align 8
   %67 = load ptr, ptr %temp57, align 8
   %not58 = icmp eq ptr %67, null
@@ -778,7 +778,7 @@ loop.body:                                        ; preds = %loop.cond
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %summary, ptr align 8 %result, i32 16, i1 false)
   %22 = call i32 (ptr, ...) @printf(ptr @.str.21)
   %23 = load ptr, ptr @__stdoutp, align 8
-  call void @test.Summary_print(ptr %summary, ptr %23)
+  call void @test.Summary.print(ptr %summary, ptr %23)
   %24 = call i32 (ptr, ...) @printf(ptr @.str.22)
   %25 = getelementptr inbounds %Summary, ptr %summary, i32 0, i32 0
   %26 = load ptr, ptr %25, align 8
diff --git a/test/test_suite/errors/general_error_regression.c3t b/test/test_suite/errors/general_error_regression.c3t
index 19d295633..d9a167ba4 100644
--- a/test/test_suite/errors/general_error_regression.c3t
+++ b/test/test_suite/errors/general_error_regression.c3t
@@ -72,42 +72,42 @@ fn void main()
 
 /* #expect: foo.ll
 
-define void @foo.Foo_hello(ptr %0) #0 {
+define void @foo.Foo.hello(ptr %0) #0 {
 entry:
   %x = alloca ptr, align 8
   %retparam = alloca i64, align 8
   %result = alloca %File, align 8
   store ptr @.str.12, ptr %x, align 8
-  %1 = call ptr @std_io.stdout()
+  %1 = call ptr @std.io.stdout()
   store ptr %1, ptr %result, align 8
   %2 = load ptr, ptr %x, align 8
-  %3 = call i64 @std_io.File_printn(ptr %retparam, ptr %result, ptr %2, i64 14)
+  %3 = call i64 @std.io.File.printn(ptr %retparam, ptr %result, ptr %2, i64 14)
   ret void
 }
 
-define void @foo.Bar_hello(ptr %0) #0 {
+define void @foo.Bar.hello(ptr %0) #0 {
 entry:
   %x = alloca ptr, align 8
   %retparam = alloca i64, align 8
   %result = alloca %File, align 8
   store ptr @.str.13, ptr %x, align 8
-  %1 = call ptr @std_io.stdout()
+  %1 = call ptr @std.io.stdout()
   store ptr %1, ptr %result, align 8
   %2 = load ptr, ptr %x, align 8
-  %3 = call i64 @std_io.File_printn(ptr %retparam, ptr %result, ptr %2, i64 14)
+  %3 = call i64 @std.io.File.printn(ptr %retparam, ptr %result, ptr %2, i64 14)
   ret void
 }
 
-define void @foo.MyEnum_hello(ptr %0) #0 {
+define void @foo.MyEnum.hello(ptr %0) #0 {
 entry:
   %x = alloca ptr, align 8
   %retparam = alloca i64, align 8
   %result = alloca %File, align 8
   store ptr @.str.14, ptr %x, align 8
-  %1 = call ptr @std_io.stdout()
+  %1 = call ptr @std.io.stdout()
   store ptr %1, ptr %result, align 8
   %2 = load ptr, ptr %x, align 8
-  %3 = call i64 @std_io.File_printn(ptr %retparam, ptr %result, ptr %2, i64 17)
+  %3 = call i64 @std.io.File.printn(ptr %retparam, ptr %result, ptr %2, i64 17)
   ret void
 }
 
@@ -155,8 +155,8 @@ entry:
   %19 = call i32 (ptr, ...) @printf(ptr @.str.11, i64 %18)
   store i32 0, ptr %b, align 4
   store i32 0, ptr %a, align 4
-  call void @foo.Foo_hello(ptr %f)
-  call void @foo.Bar_hello(ptr %b)
-  call void @foo.MyEnum_hello(ptr %a)
+  call void @foo.Foo.hello(ptr %f)
+  call void @foo.Bar.hello(ptr %b)
+  call void @foo.MyEnum.hello(ptr %a)
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/errors/optional_chained_init.c3t b/test/test_suite/errors/optional_chained_init.c3t
index 790319e40..7dddb3698 100644
--- a/test/test_suite/errors/optional_chained_init.c3t
+++ b/test/test_suite/errors/optional_chained_init.c3t
@@ -92,10 +92,10 @@ end_block:                                        ; preds = %after_check, %assig
 
 if.then:                                          ; preds = %end_block
   %2 = insertvalue %variant undef, ptr %err, 0
-  %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
+  %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"$ct.anyerr" to i64), 1
   %4 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %3, ptr %4, align 16
-  %5 = call i64 @std_io.printfn(ptr %retparam, ptr @.str, i64 13, ptr %varargslots, i64 1)
+  %5 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 13, ptr %varargslots, i64 1)
   br label %if.exit
 
 if.exit:                                          ; preds = %if.then, %end_block
@@ -122,10 +122,10 @@ end_block9:                                       ; preds = %after_check8, %assi
 
 if.then11:                                        ; preds = %end_block9
   %8 = insertvalue %variant undef, ptr %err3, 0
-  %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
+  %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"$ct.anyerr" to i64), 1
   %10 = getelementptr inbounds [1 x %variant], ptr %varargslots13, i64 0, i64 0
   store %variant %9, ptr %10, align 16
-  %11 = call i64 @std_io.printfn(ptr %retparam12, ptr @.str.1, i64 13, ptr %varargslots13, i64 1)
+  %11 = call i64 @std.io.printfn(ptr %retparam12, ptr @.str.1, i64 13, ptr %varargslots13, i64 1)
   br label %if.exit16
 
 if.exit16:                                        ; preds = %if.then11, %end_block9
@@ -136,10 +136,10 @@ if.exit16:                                        ; preds = %if.then11, %end_blo
 
 after_check21:                                    ; preds = %if.exit16
   %13 = insertvalue %variant undef, ptr %a, 0
-  %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %15 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0
   store %variant %14, ptr %15, align 16
-  %16 = call i64 @std_io.printfn(ptr %retparam17, ptr @.str.2, i64 9, ptr %varargslots18, i64 1)
+  %16 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.2, i64 9, ptr %varargslots18, i64 1)
   %not_err22 = icmp eq i64 %16, 0
   %17 = call i1 @llvm.expect.i1(i1 %not_err22, i1 true)
   br i1 %17, label %after_check23, label %after_check23
@@ -152,10 +152,10 @@ after_check23:                                    ; preds = %if.exit16, %after_c
 
 after_check28:                                    ; preds = %after_check23
   %19 = insertvalue %variant undef, ptr %b, 0
-  %20 = insertvalue %variant %19, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %20 = insertvalue %variant %19, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %21 = getelementptr inbounds [1 x %variant], ptr %varargslots25, i64 0, i64 0
   store %variant %20, ptr %21, align 16
-  %22 = call i64 @std_io.printfn(ptr %retparam24, ptr @.str.3, i64 9, ptr %varargslots25, i64 1)
+  %22 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.3, i64 9, ptr %varargslots25, i64 1)
   %not_err29 = icmp eq i64 %22, 0
   %23 = call i1 @llvm.expect.i1(i1 %not_err29, i1 true)
   br i1 %23, label %after_check30, label %after_check30
@@ -235,10 +235,10 @@ end_block:                                        ; preds = %after_check5, %assi
 
 if.then:                                          ; preds = %end_block
   %4 = insertvalue %variant undef, ptr %err, 0
-  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
+  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"$ct.anyerr" to i64), 1
   %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %5, ptr %6, align 16
-  %7 = call i64 @std_io.printfn(ptr %retparam, ptr @.str.4, i64 13, ptr %varargslots, i64 1)
+  %7 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.4, i64 13, ptr %varargslots, i64 1)
   br label %if.exit
 
 if.exit:                                          ; preds = %if.then, %end_block
@@ -265,10 +265,10 @@ end_block14:                                      ; preds = %after_check13, %ass
 
 if.then16:                                        ; preds = %end_block14
   %10 = insertvalue %variant undef, ptr %err8, 0
-  %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
+  %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"$ct.anyerr" to i64), 1
   %12 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0
   store %variant %11, ptr %12, align 16
-  %13 = call i64 @std_io.printfn(ptr %retparam17, ptr @.str.5, i64 13, ptr %varargslots18, i64 1)
+  %13 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.5, i64 13, ptr %varargslots18, i64 1)
   br label %if.exit21
 
 if.exit21:                                        ; preds = %if.then16, %end_block14
@@ -279,10 +279,10 @@ if.exit21:                                        ; preds = %if.then16, %end_blo
 
 after_check26:                                    ; preds = %if.exit21
   %15 = insertvalue %variant undef, ptr %a, 0
-  %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %17 = getelementptr inbounds [1 x %variant], ptr %varargslots23, i64 0, i64 0
   store %variant %16, ptr %17, align 16
-  %18 = call i64 @std_io.printfn(ptr %retparam22, ptr @.str.6, i64 9, ptr %varargslots23, i64 1)
+  %18 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.6, i64 9, ptr %varargslots23, i64 1)
   %not_err27 = icmp eq i64 %18, 0
   %19 = call i1 @llvm.expect.i1(i1 %not_err27, i1 true)
   br i1 %19, label %after_check28, label %after_check28
@@ -295,10 +295,10 @@ after_check28:                                    ; preds = %if.exit21, %after_c
 
 after_check33:                                    ; preds = %after_check28
   %21 = insertvalue %variant undef, ptr %b, 0
-  %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %23 = getelementptr inbounds [1 x %variant], ptr %varargslots30, i64 0, i64 0
   store %variant %22, ptr %23, align 16
-  %24 = call i64 @std_io.printfn(ptr %retparam29, ptr @.str.7, i64 9, ptr %varargslots30, i64 1)
+  %24 = call i64 @std.io.printfn(ptr %retparam29, ptr @.str.7, i64 9, ptr %varargslots30, i64 1)
   %not_err34 = icmp eq i64 %24, 0
   %25 = call i1 @llvm.expect.i1(i1 %not_err34, i1 true)
   br i1 %25, label %after_check35, label %after_check35
@@ -379,10 +379,10 @@ end_block:                                        ; preds = %after_check5, %assi
 
 if.then:                                          ; preds = %end_block
   %4 = insertvalue %variant undef, ptr %err, 0
-  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
+  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"$ct.anyerr" to i64), 1
   %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %5, ptr %6, align 16
-  %7 = call i64 @std_io.printfn(ptr %retparam, ptr @.str.8, i64 13, ptr %varargslots, i64 1)
+  %7 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.8, i64 13, ptr %varargslots, i64 1)
   br label %if.exit
 
 if.exit:                                          ; preds = %if.then, %end_block
@@ -409,10 +409,10 @@ end_block14:                                      ; preds = %after_check13, %ass
 
 if.then16:                                        ; preds = %end_block14
   %10 = insertvalue %variant undef, ptr %err8, 0
-  %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
+  %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"$ct.anyerr" to i64), 1
   %12 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0
   store %variant %11, ptr %12, align 16
-  %13 = call i64 @std_io.printfn(ptr %retparam17, ptr @.str.9, i64 13, ptr %varargslots18, i64 1)
+  %13 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.9, i64 13, ptr %varargslots18, i64 1)
   br label %if.exit21
 
 if.exit21:                                        ; preds = %if.then16, %end_block14
@@ -423,10 +423,10 @@ if.exit21:                                        ; preds = %if.then16, %end_blo
 
 after_check26:                                    ; preds = %if.exit21
   %15 = insertvalue %variant undef, ptr %a, 0
-  %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %17 = getelementptr inbounds [1 x %variant], ptr %varargslots23, i64 0, i64 0
   store %variant %16, ptr %17, align 16
-  %18 = call i64 @std_io.printfn(ptr %retparam22, ptr @.str.10, i64 9, ptr %varargslots23, i64 1)
+  %18 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.10, i64 9, ptr %varargslots23, i64 1)
   %not_err27 = icmp eq i64 %18, 0
   %19 = call i1 @llvm.expect.i1(i1 %not_err27, i1 true)
   br i1 %19, label %after_check28, label %after_check28
@@ -439,10 +439,10 @@ after_check28:                                    ; preds = %if.exit21, %after_c
 
 after_check33:                                    ; preds = %after_check28
   %21 = insertvalue %variant undef, ptr %b, 0
-  %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %23 = getelementptr inbounds [1 x %variant], ptr %varargslots30, i64 0, i64 0
   store %variant %22, ptr %23, align 16
-  %24 = call i64 @std_io.printfn(ptr %retparam29, ptr @.str.11, i64 9, ptr %varargslots30, i64 1)
+  %24 = call i64 @std.io.printfn(ptr %retparam29, ptr @.str.11, i64 9, ptr %varargslots30, i64 1)
   %not_err34 = icmp eq i64 %24, 0
   %25 = call i1 @llvm.expect.i1(i1 %not_err34, i1 true)
   br i1 %25, label %after_check35, label %after_check35
diff --git a/test/test_suite/errors/optional_taddr_and_access.c3t b/test/test_suite/errors/optional_taddr_and_access.c3t
index 36742611c..c7c7c66db 100644
--- a/test/test_suite/errors/optional_taddr_and_access.c3t
+++ b/test/test_suite/errors/optional_taddr_and_access.c3t
@@ -27,9 +27,9 @@ fn void main()
 
 %Foo = type { i32, i32 }
 
-@"ct$test.Foo" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
-@"test.MyErr$FOO" = linkonce constant %.fault { i64 ptrtoint (ptr @"ct$test.MyErr" to i64), %"char[]" { ptr @.fault, i64 3 } }, align 8
-@"ct$test.MyErr" = linkonce constant %.introspect { i8 9, i64 8, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
+@"$ct.test.Foo" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"test.MyErr$FOO" = linkonce constant %.fault { i64 ptrtoint (ptr @"$ct.test.MyErr" to i64), %"char[]" { ptr @.fault, i64 3 } }, align 8
+@"$ct.test.MyErr" = linkonce constant %.introspect { i8 9, i64 8, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
 @.str = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
 @.str.1 = private unnamed_addr constant [17 x i8] c"Not visible: %d\0A\00", align 1
 
diff --git a/test/test_suite/errors/optional_with_optional.c3t b/test/test_suite/errors/optional_with_optional.c3t
index c7a75dd57..d9b752f65 100644
--- a/test/test_suite/errors/optional_with_optional.c3t
+++ b/test/test_suite/errors/optional_with_optional.c3t
@@ -96,10 +96,10 @@ phi_block6:                                       ; preds = %else_block5, %phi_b
   %val7 = phi i32 [ %val, %phi_block ], [ -1, %else_block5 ]
   store i32 %val7, ptr %taddr, align 4
   %6 = insertvalue %variant undef, ptr %taddr, 0
-  %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %8 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %7, ptr %8, align 16
-  %9 = call i64 @std_io.printfn(ptr %retparam, ptr @.str, i64 4, ptr %varargslots, i64 1)
+  %9 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 4, ptr %varargslots, i64 1)
   %10 = call i64 @test.get_a(ptr %retparam12, i32 2)
   %not_err13 = icmp eq i64 %10, 0
   %11 = call i1 @llvm.expect.i1(i1 %not_err13, i1 true)
@@ -130,10 +130,10 @@ phi_block22:                                      ; preds = %else_block21, %phi_
   %val23 = phi i32 [ %val20, %phi_block19 ], [ -1, %else_block21 ]
   store i32 %val23, ptr %taddr24, align 4
   %16 = insertvalue %variant undef, ptr %taddr24, 0
-  %17 = insertvalue %variant %16, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %17 = insertvalue %variant %16, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %18 = getelementptr inbounds [1 x %variant], ptr %varargslots11, i64 0, i64 0
   store %variant %17, ptr %18, align 16
-  %19 = call i64 @std_io.printfn(ptr %retparam10, ptr @.str.2, i64 4, ptr %varargslots11, i64 1)
+  %19 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.2, i64 4, ptr %varargslots11, i64 1)
   %20 = call i64 @test.get_a(ptr %retparam29, i32 1)
   %not_err30 = icmp eq i64 %20, 0
   %21 = call i1 @llvm.expect.i1(i1 %not_err30, i1 true)
@@ -164,28 +164,28 @@ phi_block39:                                      ; preds = %else_block38, %phi_
   %val40 = phi i32 [ %val37, %phi_block36 ], [ -1, %else_block38 ]
   store i32 %val40, ptr %taddr41, align 4
   %26 = insertvalue %variant undef, ptr %taddr41, 0
-  %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %28 = getelementptr inbounds [1 x %variant], ptr %varargslots28, i64 0, i64 0
   store %variant %27, ptr %28, align 16
-  %29 = call i64 @std_io.printfn(ptr %retparam27, ptr @.str.3, i64 4, ptr %varargslots28, i64 1)
+  %29 = call i64 @std.io.printfn(ptr %retparam27, ptr @.str.3, i64 4, ptr %varargslots28, i64 1)
   store i64 ptrtoint (ptr @"test.Foo$DEF" to i64), ptr %taddr46, align 8
   %30 = insertvalue %variant undef, ptr %taddr46, 0
-  %31 = insertvalue %variant %30, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
+  %31 = insertvalue %variant %30, i64 ptrtoint (ptr @"$ct.anyerr" to i64), 1
   %32 = getelementptr inbounds [1 x %variant], ptr %varargslots45, i64 0, i64 0
   store %variant %31, ptr %32, align 16
-  %33 = call i64 @std_io.printfn(ptr %retparam44, ptr @.str.4, i64 4, ptr %varargslots45, i64 1)
+  %33 = call i64 @std.io.printfn(ptr %retparam44, ptr @.str.4, i64 4, ptr %varargslots45, i64 1)
   store i32 3, ptr %taddr51, align 4
   %34 = insertvalue %variant undef, ptr %taddr51, 0
-  %35 = insertvalue %variant %34, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %35 = insertvalue %variant %34, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %36 = getelementptr inbounds [1 x %variant], ptr %varargslots50, i64 0, i64 0
   store %variant %35, ptr %36, align 16
-  %37 = call i64 @std_io.printfn(ptr %retparam49, ptr @.str.5, i64 4, ptr %varargslots50, i64 1)
+  %37 = call i64 @std.io.printfn(ptr %retparam49, ptr @.str.5, i64 4, ptr %varargslots50, i64 1)
   store i64 ptrtoint (ptr @"test.Foo$DEF" to i64), ptr %taddr56, align 8
   %38 = insertvalue %variant undef, ptr %taddr56, 0
-  %39 = insertvalue %variant %38, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
+  %39 = insertvalue %variant %38, i64 ptrtoint (ptr @"$ct.anyerr" to i64), 1
   %40 = getelementptr inbounds [1 x %variant], ptr %varargslots55, i64 0, i64 0
   store %variant %39, ptr %40, align 16
-  %41 = call i64 @std_io.printfn(ptr %retparam54, ptr @.str.6, i64 4, ptr %varargslots55, i64 1)
+  %41 = call i64 @std.io.printfn(ptr %retparam54, ptr @.str.6, i64 4, ptr %varargslots55, i64 1)
   store i64 0, ptr %error_var, align 8
   br label %phi_block62
 
@@ -194,16 +194,16 @@ phi_block62:                                      ; preds = %phi_block39
 
 noerr_block:                                      ; preds = %phi_block62
   %42 = insertvalue %variant undef, ptr %error_var, 0
-  %43 = insertvalue %variant %42, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
+  %43 = insertvalue %variant %42, i64 ptrtoint (ptr @"$ct.anyerr" to i64), 1
   %44 = getelementptr inbounds [1 x %variant], ptr %varargslots60, i64 0, i64 0
   store %variant %43, ptr %44, align 16
-  %45 = call i64 @std_io.printfn(ptr %retparam59, ptr @.str.7, i64 4, ptr %varargslots60, i64 1)
+  %45 = call i64 @std.io.printfn(ptr %retparam59, ptr @.str.7, i64 4, ptr %varargslots60, i64 1)
   store i64 3, ptr %x, align 8
   %46 = insertvalue %variant undef, ptr %x, 0
-  %47 = insertvalue %variant %46, i64 ptrtoint (ptr @"ct$long" to i64), 1
+  %47 = insertvalue %variant %46, i64 ptrtoint (ptr @"$ct.long" to i64), 1
   %48 = getelementptr inbounds [1 x %variant], ptr %varargslots66, i64 0, i64 0
   store %variant %47, ptr %48, align 16
-  %49 = call i64 @std_io.printfn(ptr %retparam65, ptr @.str.8, i64 4, ptr %varargslots66, i64 1)
+  %49 = call i64 @std.io.printfn(ptr %retparam65, ptr @.str.8, i64 4, ptr %varargslots66, i64 1)
   store i64 ptrtoint (ptr @"test.Foo$DEF" to i64), ptr %xy.f, align 8
   ret void
 }
diff --git a/test/test_suite/errors/or_and_rethrow.c3t b/test/test_suite/errors/or_and_rethrow.c3t
index 5b1a19dfc..339011243 100644
--- a/test/test_suite/errors/or_and_rethrow.c3t
+++ b/test/test_suite/errors/or_and_rethrow.c3t
@@ -63,10 +63,10 @@ entry:
   %reterr = alloca i64, align 8
   store i32 %0, ptr %taddr, align 4
   %1 = insertvalue %variant undef, ptr %taddr, 0
-  %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %2, ptr %3, align 16
-  %4 = call i64 @std_io.printfn(ptr %retparam, ptr @.str.1, i64 8, ptr %varargslots, i64 1)
+  %4 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.1, i64 8, ptr %varargslots, i64 1)
   %intbool = icmp ne i32 %0, 0
   br i1 %intbool, label %or.phi, label %or.rhs
 
@@ -87,18 +87,18 @@ or.phi:                                           ; preds = %entry
 
 if.then:                                          ; preds = %or.phi
   store ptr @.str.2, ptr %x, align 8
-  %6 = call ptr @std_io.stdout()
+  %6 = call ptr @std.io.stdout()
   store ptr %6, ptr %result, align 8
   %7 = load ptr, ptr %x, align 8
-  %8 = call i64 @std_io.File_printn(ptr %retparam1, ptr %result, ptr %7, i64 3)
+  %8 = call i64 @std.io.File.printn(ptr %retparam1, ptr %result, ptr %7, i64 3)
   br label %if.exit
 
 if.exit:                                          ; preds = %if.then
   store ptr @.str.3, ptr %x2, align 8
-  %9 = call ptr @std_io.stdout()
+  %9 = call ptr @std.io.stdout()
   store ptr %9, ptr %result4, align 8
   %10 = load ptr, ptr %x2, align 8
-  %11 = call i64 @std_io.File_printn(ptr %retparam3, ptr %result4, ptr %10, i64 9)
+  %11 = call i64 @std.io.File.printn(ptr %retparam3, ptr %result4, ptr %10, i64 9)
   store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var5, align 8
   br label %opt_block_cleanup7
 
@@ -112,10 +112,10 @@ guard_block8:                                     ; preds = %opt_block_cleanup7
 
 if.exit13:                                        ; No predecessors!
   store ptr @.str.5, ptr %x14, align 8
-  %13 = call ptr @std_io.stdout()
+  %13 = call ptr @std.io.stdout()
   store ptr %13, ptr %result16, align 8
   %14 = load ptr, ptr %x14, align 8
-  %15 = call i64 @std_io.File_printn(ptr %retparam15, ptr %result16, ptr %14, i64 7)
+  %15 = call i64 @std.io.File.printn(ptr %retparam15, ptr %result16, ptr %14, i64 7)
   ret i64 0
 }
 
@@ -138,10 +138,10 @@ entry:
   %reterr = alloca i64, align 8
   store i32 %0, ptr %taddr, align 4
   %1 = insertvalue %variant undef, ptr %taddr, 0
-  %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %2, ptr %3, align 16
-  %4 = call i64 @std_io.printfn(ptr %retparam, ptr @.str.6, i64 9, ptr %varargslots, i64 1)
+  %4 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.6, i64 9, ptr %varargslots, i64 1)
   %intbool = icmp ne i32 %0, 0
   br i1 %intbool, label %and.rhs, label %and.phi
 
@@ -162,10 +162,10 @@ and.phi:                                          ; preds = %entry
 
 if.exit:                                          ; preds = %and.phi
   store ptr @.str.7, ptr %x, align 8
-  %6 = call ptr @std_io.stdout()
+  %6 = call ptr @std.io.stdout()
   store ptr %6, ptr %result, align 8
   %7 = load ptr, ptr %x, align 8
-  %8 = call i64 @std_io.File_printn(ptr %retparam1, ptr %result, ptr %7, i64 9)
+  %8 = call i64 @std.io.File.printn(ptr %retparam1, ptr %result, ptr %7, i64 9)
   store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var2, align 8
   br label %opt_block_cleanup4
 
@@ -179,10 +179,10 @@ guard_block5:                                     ; preds = %opt_block_cleanup4
 
 if.exit6:                                         ; No predecessors!
   store ptr @.str.8, ptr %x7, align 8
-  %10 = call ptr @std_io.stdout()
+  %10 = call ptr @std.io.stdout()
   store ptr %10, ptr %result9, align 8
   %11 = load ptr, ptr %x7, align 8
-  %12 = call i64 @std_io.File_printn(ptr %retparam8, ptr %result9, ptr %11, i64 7)
+  %12 = call i64 @std.io.File.printn(ptr %retparam8, ptr %result9, ptr %11, i64 7)
   ret i64 0
 }
 
diff --git a/test/test_suite/errors/printing_errors.c3t b/test/test_suite/errors/printing_errors.c3t
index feaadb828..aa3b4cdc9 100644
--- a/test/test_suite/errors/printing_errors.c3t
+++ b/test/test_suite/errors/printing_errors.c3t
@@ -25,7 +25,7 @@ entry:
   store i64 ptrtoint (ptr @"test.Cde$WORLD" to i64), ptr %x, align 8
   store ptr @.str.2, ptr %taddr, align 8
   %0 = insertvalue %variant undef, ptr %taddr, 0
-  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
+  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1
   %2 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %1, ptr %2, align 16
   %3 = load i64, ptr %x, align 8
@@ -44,9 +44,9 @@ faultname_ok:                                     ; preds = %entry
 faultname_exit:                                   ; preds = %faultname_ok, %faultname_no
   %faultname = phi ptr [ %faultname_zero, %faultname_no ], [ %5, %faultname_ok ]
   %6 = insertvalue %variant undef, ptr %faultname, 0
-  %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$sa$char" to i64), 1
+  %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
   %8 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %7, ptr %8, align 16
-  %9 = call i64 @std_io.printf(ptr %retparam, ptr @.str, i64 6, ptr %varargslots, i64 2)
+  %9 = call i64 @std.io.printf(ptr %retparam, ptr @.str, i64 6, ptr %varargslots, i64 2)
   ret void
 }
diff --git a/test/test_suite/expressions/optional_ternary.c3t b/test/test_suite/expressions/optional_ternary.c3t
index 946a53770..904601a83 100644
--- a/test/test_suite/expressions/optional_ternary.c3t
+++ b/test/test_suite/expressions/optional_ternary.c3t
@@ -64,9 +64,9 @@ target triple = "x86_64-apple-darwin"
 %"char[]" = type { i8*, i64 }
 %.introspect = type { i8, i64, i64, i64, [0 x i64] }
 
-@"test.Foo$X" = linkonce constant %.fault { i64 ptrtoint (%.introspect* @"ct$test.Foo" to i64), %"char[]" { i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.fault, i64 0, i64 0), i64 1 } }, align 8
+@"test.Foo$X" = linkonce constant %.fault { i64 ptrtoint (%.introspect* @"$ct.test.Foo" to i64), %"char[]" { i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.fault, i64 0, i64 0), i64 1 } }, align 8
 @.fault = internal constant [2 x i8] c"X\00", align 1
-@"ct$test.Foo" = linkonce constant %.introspect { i8 9, i64 8, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
+@"$ct.test.Foo" = linkonce constant %.introspect { i8 9, i64 8, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
 @.zstr = internal constant [28 x i8] c"Runtime error force unwrap!\00", align 1
 @.zstr.1 = internal constant [20 x i8] c"optional_ternary.c3\00", align 1
 @.zstr.2 = internal constant [5 x i8] c"main\00", align 1
@@ -347,7 +347,7 @@ after_check:                                      ; preds = %entry
   br label %noerr_block
 
 panic_block:                                      ; preds = %assign_optional
-  call void @std_core_builtin.panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr, i64 0, i64 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.zstr.1, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.2, i64 0, i64 0), i32 51)
+  call void @std.core.builtin.panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr, i64 0, i64 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.zstr.1, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.2, i64 0, i64 0), i32 51)
   unreachable
 
 noerr_block:                                      ; preds = %after_check
@@ -364,7 +364,7 @@ after_check5:                                     ; preds = %noerr_block
   br label %noerr_block7
 
 panic_block6:                                     ; preds = %assign_optional4
-  call void @std_core_builtin.panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr.3, i64 0, i64 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.zstr.4, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.5, i64 0, i64 0), i32 52)
+  call void @std.core.builtin.panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr.3, i64 0, i64 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.zstr.4, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.5, i64 0, i64 0), i32 52)
   unreachable
 
 noerr_block7:                                     ; preds = %after_check5
@@ -381,7 +381,7 @@ after_check12:                                    ; preds = %noerr_block7
   br label %noerr_block14
 
 panic_block13:                                    ; preds = %assign_optional11
-  call void @std_core_builtin.panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr.6, i64 0, i64 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.zstr.7, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.8, i64 0, i64 0), i32 53)
+  call void @std.core.builtin.panic(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.zstr.6, i64 0, i64 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.zstr.7, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.zstr.8, i64 0, i64 0), i32 53)
   unreachable
 
 noerr_block14:                                    ; preds = %after_check12
@@ -410,6 +410,6 @@ entry:
   ret i32 0
 }
 
-declare void @std_core_builtin.panic(i8*, i8*, i8*, i32)
+declare void @std.core.builtin.panic(i8*, i8*, i8*, i32)
 
 attributes #0 = { nounwind }
\ No newline at end of file
diff --git a/test/test_suite/expressions/pointer_access.c3t b/test/test_suite/expressions/pointer_access.c3t
index a5c04bb16..8c96ac8b9 100644
--- a/test/test_suite/expressions/pointer_access.c3t
+++ b/test/test_suite/expressions/pointer_access.c3t
@@ -42,10 +42,10 @@ fn void testSimple()
 %.anon = type { i32, i32 }
 %.anon.0 = type { double }
 
-@"ct$pointer_access.c" = linkonce constant %.introspect { i8 10, i64 40, i64 0, i64 5, [0 x i64] zeroinitializer }, align 8
-@"ct$pointer_access.$anon" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
-@"ct$pointer_access.$anon.4" = linkonce constant %.introspect { i8 11, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
-@"ct$pointer_access.ExtraSimple" = linkonce constant %.introspect { i8 10, i64 72, i64 0, i64 6, [0 x i64] zeroinitializer }, align 8
+@"$ct.pointer_access.c" = linkonce constant %.introspect { i8 10, i64 40, i64 0, i64 5, [0 x i64] zeroinitializer }, align 8
+@"$ct.pointer_access.$anon" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.pointer_access.$anon.4" = linkonce constant %.introspect { i8 11, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.pointer_access.ExtraSimple" = linkonce constant %.introspect { i8 10, i64 72, i64 0, i64 6, [0 x i64] zeroinitializer }, align 8
 @.str = private unnamed_addr constant [71 x i8] c"a = %d, c.e = %f, c.f = %f, c.j = %f, g = %d, o0 = %f, r = %d, s = %d\0A\00", align 1
 
 define void @pointer_access.testSimple() #0 {
diff --git a/test/test_suite/from_docs/examples_defer.c3t b/test/test_suite/from_docs/examples_defer.c3t
index 95bb93e7c..11144d03a 100644
--- a/test/test_suite/from_docs/examples_defer.c3t
+++ b/test/test_suite/from_docs/examples_defer.c3t
@@ -30,14 +30,14 @@ entry:
 
 if.then:                                          ; preds = %entry
   store ptr @.str, ptr %x, align 8
-  %1 = call ptr @std_io.stdout()
+  %1 = call ptr @std.io.stdout()
   store ptr %1, ptr %result, align 8
   %2 = load ptr, ptr %x, align 8
-  %3 = call i64 @std_io.File_print(ptr %retparam, ptr %result, ptr %2, i64 1)
+  %3 = call i64 @std.io.File.print(ptr %retparam, ptr %result, ptr %2, i64 1)
   store ptr @.str.1, ptr %x1, align 8
-  %4 = call ptr @std_io.stdout()
+  %4 = call ptr @std.io.stdout()
   store ptr %4, ptr %result3, align 8
-  %5 = call i64 @std_io.File_printn(ptr %retparam2, ptr %result3, ptr null, i64 0)
+  %5 = call i64 @std.io.File.printn(ptr %retparam2, ptr %result3, ptr null, i64 0)
   ret void
 
 if.exit:                                          ; preds = %entry
@@ -46,41 +46,41 @@ if.exit:                                          ; preds = %entry
 
 if.then5:                                         ; preds = %if.exit
   store ptr @.str.2, ptr %x6, align 8
-  %6 = call ptr @std_io.stdout()
+  %6 = call ptr @std.io.stdout()
   store ptr %6, ptr %result8, align 8
   %7 = load ptr, ptr %x6, align 8
-  %8 = call i64 @std_io.File_print(ptr %retparam7, ptr %result8, ptr %7, i64 1)
+  %8 = call i64 @std.io.File.print(ptr %retparam7, ptr %result8, ptr %7, i64 1)
   store ptr @.str.3, ptr %x9, align 8
-  %9 = call ptr @std_io.stdout()
+  %9 = call ptr @std.io.stdout()
   store ptr %9, ptr %result11, align 8
   %10 = load ptr, ptr %x9, align 8
-  %11 = call i64 @std_io.File_print(ptr %retparam10, ptr %result11, ptr %10, i64 1)
+  %11 = call i64 @std.io.File.print(ptr %retparam10, ptr %result11, ptr %10, i64 1)
   store ptr @.str.4, ptr %x12, align 8
-  %12 = call ptr @std_io.stdout()
+  %12 = call ptr @std.io.stdout()
   store ptr %12, ptr %result14, align 8
-  %13 = call i64 @std_io.File_printn(ptr %retparam13, ptr %result14, ptr null, i64 0)
+  %13 = call i64 @std.io.File.printn(ptr %retparam13, ptr %result14, ptr null, i64 0)
   ret void
 
 if.exit15:                                        ; preds = %if.exit
   store ptr @.str.5, ptr %x16, align 8
-  %14 = call ptr @std_io.stdout()
+  %14 = call ptr @std.io.stdout()
   store ptr %14, ptr %result18, align 8
   %15 = load ptr, ptr %x16, align 8
-  %16 = call i64 @std_io.File_print(ptr %retparam17, ptr %result18, ptr %15, i64 1)
+  %16 = call i64 @std.io.File.print(ptr %retparam17, ptr %result18, ptr %15, i64 1)
   store ptr @.str.6, ptr %x19, align 8
-  %17 = call ptr @std_io.stdout()
+  %17 = call ptr @std.io.stdout()
   store ptr %17, ptr %result21, align 8
   %18 = load ptr, ptr %x19, align 8
-  %19 = call i64 @std_io.File_print(ptr %retparam20, ptr %result21, ptr %18, i64 1)
+  %19 = call i64 @std.io.File.print(ptr %retparam20, ptr %result21, ptr %18, i64 1)
   store ptr @.str.7, ptr %x22, align 8
-  %20 = call ptr @std_io.stdout()
+  %20 = call ptr @std.io.stdout()
   store ptr %20, ptr %result24, align 8
   %21 = load ptr, ptr %x22, align 8
-  %22 = call i64 @std_io.File_print(ptr %retparam23, ptr %result24, ptr %21, i64 1)
+  %22 = call i64 @std.io.File.print(ptr %retparam23, ptr %result24, ptr %21, i64 1)
   store ptr @.str.8, ptr %x25, align 8
-  %23 = call ptr @std_io.stdout()
+  %23 = call ptr @std.io.stdout()
   store ptr %23, ptr %result27, align 8
-  %24 = call i64 @std_io.File_printn(ptr %retparam26, ptr %result27, ptr null, i64 0)
+  %24 = call i64 @std.io.File.printn(ptr %retparam26, ptr %result27, ptr null, i64 0)
   ret void
 }
 
diff --git a/test/test_suite/from_docs/examples_forswitch.c3t b/test/test_suite/from_docs/examples_forswitch.c3t
index 722b898b4..b0d978066 100644
--- a/test/test_suite/from_docs/examples_forswitch.c3t
+++ b/test/test_suite/from_docs/examples_forswitch.c3t
@@ -109,7 +109,7 @@ loop.body:                                        ; preds = %loop.cond
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
-  %4 = load ptr, ptr @std_core_builtin.panic, align 8
+  %4 = load ptr, ptr @std.core.builtin.panic, align 8
   call void %4(ptr @.panic_msg, i64 19, ptr @.file, i64 21, ptr @.func, i64 11, i32 14)
   unreachable
 
@@ -164,18 +164,18 @@ switch.entry:                                     ; preds = %entry
 
 switch.case:                                      ; preds = %switch.entry, %switch.entry
   store ptr @.str.1, ptr %x, align 8
-  %2 = call ptr @std_io.stdout()
+  %2 = call ptr @std.io.stdout()
   store ptr %2, ptr %result, align 8
   %3 = load ptr, ptr %x, align 8
-  %4 = call i64 @std_io.File_printn(ptr %retparam, ptr %result, ptr %3, i64 8)
+  %4 = call i64 @std.io.File.printn(ptr %retparam, ptr %result, ptr %3, i64 8)
   br label %switch.exit
 
 switch.case1:                                     ; preds = %switch.entry
   store ptr @.str.2, ptr %x2, align 8
-  %5 = call ptr @std_io.stdout()
+  %5 = call ptr @std.io.stdout()
   store ptr %5, ptr %result4, align 8
   %6 = load ptr, ptr %x2, align 8
-  %7 = call i64 @std_io.File_printn(ptr %retparam3, ptr %result4, ptr %6, i64 4)
+  %7 = call i64 @std.io.File.printn(ptr %retparam3, ptr %result4, ptr %6, i64 4)
   br label %switch.exit
 
 switch.exit:                                      ; preds = %switch.case1, %switch.case, %switch.entry
@@ -192,18 +192,18 @@ switch.entry6:                                    ; preds = %switch.exit
 
 switch.case7:                                     ; preds = %switch.entry6, %switch.entry6
   store ptr @.str.3, ptr %x8, align 8
-  %9 = call ptr @std_io.stdout()
+  %9 = call ptr @std.io.stdout()
   store ptr %9, ptr %result10, align 8
   %10 = load ptr, ptr %x8, align 8
-  %11 = call i64 @std_io.File_printn(ptr %retparam9, ptr %result10, ptr %10, i64 8)
+  %11 = call i64 @std.io.File.printn(ptr %retparam9, ptr %result10, ptr %10, i64 8)
   br label %switch.exit15
 
 switch.case11:                                    ; preds = %switch.entry6
   store ptr @.str.4, ptr %x12, align 8
-  %12 = call ptr @std_io.stdout()
+  %12 = call ptr @std.io.stdout()
   store ptr %12, ptr %result14, align 8
   %13 = load ptr, ptr %x12, align 8
-  %14 = call i64 @std_io.File_printn(ptr %retparam13, ptr %result14, ptr %13, i64 4)
+  %14 = call i64 @std.io.File.printn(ptr %retparam13, ptr %result14, ptr %13, i64 4)
   br label %switch.exit15
 
 switch.exit15:                                    ; preds = %switch.case11, %switch.case7, %switch.entry6
@@ -223,10 +223,10 @@ switch.case18:                                    ; preds = %switch.entry17
 
 switch.case19:                                    ; preds = %switch.entry17
   store ptr @.str.5, ptr %x20, align 8
-  %16 = call ptr @std_io.stdout()
+  %16 = call ptr @std.io.stdout()
   store ptr %16, ptr %result22, align 8
   %17 = load ptr, ptr %x20, align 8
-  %18 = call i64 @std_io.File_printn(ptr %retparam21, ptr %result22, ptr %17, i64 6)
+  %18 = call i64 @std.io.File.printn(ptr %retparam21, ptr %result22, ptr %17, i64 6)
   br label %switch.exit24
 
 switch.case23:                                    ; preds = %switch.entry17
@@ -265,27 +265,27 @@ switch.entry30:                                   ; preds = %switch.exit28
 switch.case31:                                    ; preds = %switch.entry30
   store i32 1, ptr %a, align 4
   store ptr @.str.6, ptr %x32, align 8
-  %21 = call ptr @std_io.stdout()
+  %21 = call ptr @std.io.stdout()
   store ptr %21, ptr %result34, align 8
   %22 = load ptr, ptr %x32, align 8
-  %23 = call i64 @std_io.File_printn(ptr %retparam33, ptr %result34, ptr %22, i64 1)
+  %23 = call i64 @std.io.File.printn(ptr %retparam33, ptr %result34, ptr %22, i64 1)
   br label %switch.case35
 
 switch.case35:                                    ; preds = %switch.entry30, %switch.case31
   store i32 2, ptr %a36, align 4
   store ptr @.str.7, ptr %x37, align 8
-  %24 = call ptr @std_io.stdout()
+  %24 = call ptr @std.io.stdout()
   store ptr %24, ptr %result39, align 8
   %25 = load ptr, ptr %x37, align 8
-  %26 = call i64 @std_io.File_printn(ptr %retparam38, ptr %result39, ptr %25, i64 1)
+  %26 = call i64 @std.io.File.printn(ptr %retparam38, ptr %result39, ptr %25, i64 1)
   br label %switch.case40
 
 switch.case40:                                    ; preds = %switch.entry30, %switch.case35
   store ptr @.str.8, ptr %x41, align 8
-  %27 = call ptr @std_io.stdout()
+  %27 = call ptr @std.io.stdout()
   store ptr %27, ptr %result43, align 8
   %28 = load ptr, ptr %x41, align 8
-  %29 = call i64 @std_io.File_printn(ptr %retparam42, ptr %result43, ptr %28, i64 1)
+  %29 = call i64 @std.io.File.printn(ptr %retparam42, ptr %result43, ptr %28, i64 1)
   br label %switch.exit44
 
 switch.exit44:                                    ; preds = %switch.case40, %switch.entry30
diff --git a/test/test_suite/functions/func_ptr_conversions_and_names.c3t b/test/test_suite/functions/func_ptr_conversions_and_names.c3t
index e69b640a3..29851c094 100644
--- a/test/test_suite/functions/func_ptr_conversions_and_names.c3t
+++ b/test/test_suite/functions/func_ptr_conversions_and_names.c3t
@@ -32,28 +32,28 @@ fn void main()
 /* #expect: test.ll
 
 @.str = private unnamed_addr constant [3 x i8] c"%d\00", align 1
-@"ct$int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
 @.str.1 = private unnamed_addr constant [3 x i8] c"%d\00", align 1
 @.str.2 = private unnamed_addr constant [3 x i8] c"%d\00", align 1
 @.str.3 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
 @.str.4 = private unnamed_addr constant [13 x i8] c"fn int(int)*\00", align 1
-@"ct$char" = linkonce constant %.introspect { i8 3, i64 1, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$a12$char" = linkonce constant %.introspect { i8 15, i64 12, i64 ptrtoint (ptr @"ct$char" to i64), i64 12, [0 x i64] zeroinitializer }, align 8
-@"ct$p$a12$char" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"ct$a12$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.char" = linkonce constant %.introspect { i8 3, i64 1, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.a12$char" = linkonce constant %.introspect { i8 15, i64 12, i64 ptrtoint (ptr @"$ct.char" to i64), i64 12, [0 x i64] zeroinitializer }, align 8
+@"$ct.p$a12$char" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"$ct.a12$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
 @.str.5 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
 @.str.6 = private unnamed_addr constant [13 x i8] c"fn int(int)*\00", align 1
 @.str.7 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
 @.str.8 = private unnamed_addr constant [13 x i8] c"test::test2*\00", align 1
 @.str.9 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
 @.str.10 = private unnamed_addr constant [7 x i8] c"test2*\00", align 1
-@"ct$a6$char" = linkonce constant %.introspect { i8 15, i64 6, i64 ptrtoint (ptr @"ct$char" to i64), i64 6, [0 x i64] zeroinitializer }, align 8
-@"ct$p$a6$char" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"ct$a6$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.a6$char" = linkonce constant %.introspect { i8 15, i64 6, i64 ptrtoint (ptr @"$ct.char" to i64), i64 6, [0 x i64] zeroinitializer }, align 8
+@"$ct.p$a6$char" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"$ct.a6$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
 @.str.11 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
 @.str.12 = private unnamed_addr constant [14 x i8] c"fn int!(int)*\00", align 1
-@"ct$a13$char" = linkonce constant %.introspect { i8 15, i64 13, i64 ptrtoint (ptr @"ct$char" to i64), i64 13, [0 x i64] zeroinitializer }, align 8
-@"ct$p$a13$char" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"ct$a13$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$fn$int$int$" = linkonce constant %.introspect { i8 13, i64 8, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$p$fn$int$int$" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"ct$fn$int$int$" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.a13$char" = linkonce constant %.introspect { i8 15, i64 13, i64 ptrtoint (ptr @"$ct.char" to i64), i64 13, [0 x i64] zeroinitializer }, align 8
+@"$ct.p$a13$char" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"$ct.a13$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.fn$int$int$" = linkonce constant %.introspect { i8 13, i64 8, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.p$fn$int$int$" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"$ct.fn$int$int$" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
 
 define void @test.main() #0 {
 entry:
@@ -92,57 +92,57 @@ entry:
   %1 = call i32 %0(i32 123)
   store i32 %1, ptr %taddr, align 4
   %2 = insertvalue %variant undef, ptr %taddr, 0
-  %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %4 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %3, ptr %4, align 16
-  %5 = call i64 @std_io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
+  %5 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
   %6 = call i32 @test.test2(i32 3)
   store i32 %6, ptr %taddr3, align 4
   %7 = insertvalue %variant undef, ptr %taddr3, 0
-  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %9 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0
   store %variant %8, ptr %9, align 16
-  %10 = call i64 @std_io.printfn(ptr %retparam1, ptr @.str.1, i64 2, ptr %varargslots2, i64 1)
+  %10 = call i64 @std.io.printfn(ptr %retparam1, ptr @.str.1, i64 2, ptr %varargslots2, i64 1)
   store ptr @test.test2, ptr %z, align 8
   %11 = load ptr, ptr %z, align 8
   %12 = call i32 %11(i32 444)
   store i32 %12, ptr %taddr6, align 4
   %13 = insertvalue %variant undef, ptr %taddr6, 0
-  %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %15 = getelementptr inbounds [1 x %variant], ptr %varargslots5, i64 0, i64 0
   store %variant %14, ptr %15, align 16
-  %16 = call i64 @std_io.printfn(ptr %retparam4, ptr @.str.2, i64 2, ptr %varargslots5, i64 1)
+  %16 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.2, i64 2, ptr %varargslots5, i64 1)
   store ptr @.str.4, ptr %taddr9, align 8
   %17 = insertvalue %variant undef, ptr %taddr9, 0
-  %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"ct$p$a12$char" to i64), 1
+  %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"$ct.p$a12$char" to i64), 1
   %19 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
   store %variant %18, ptr %19, align 16
-  %20 = call i64 @std_io.printfn(ptr %retparam7, ptr @.str.3, i64 2, ptr %varargslots8, i64 1)
+  %20 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.3, i64 2, ptr %varargslots8, i64 1)
   store ptr @.str.6, ptr %taddr12, align 8
   %21 = insertvalue %variant undef, ptr %taddr12, 0
-  %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"ct$p$a12$char" to i64), 1
+  %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"$ct.p$a12$char" to i64), 1
   %23 = getelementptr inbounds [1 x %variant], ptr %varargslots11, i64 0, i64 0
   store %variant %22, ptr %23, align 16
-  %24 = call i64 @std_io.printfn(ptr %retparam10, ptr @.str.5, i64 2, ptr %varargslots11, i64 1)
+  %24 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.5, i64 2, ptr %varargslots11, i64 1)
   store ptr @.str.8, ptr %taddr15, align 8
   %25 = insertvalue %variant undef, ptr %taddr15, 0
-  %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$p$a12$char" to i64), 1
+  %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"$ct.p$a12$char" to i64), 1
   %27 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0
   store %variant %26, ptr %27, align 16
-  %28 = call i64 @std_io.printfn(ptr %retparam13, ptr @.str.7, i64 2, ptr %varargslots14, i64 1)
+  %28 = call i64 @std.io.printfn(ptr %retparam13, ptr @.str.7, i64 2, ptr %varargslots14, i64 1)
   store ptr @.str.10, ptr %taddr18, align 8
   %29 = insertvalue %variant undef, ptr %taddr18, 0
-  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1
+  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.p$a6$char" to i64), 1
   %31 = getelementptr inbounds [1 x %variant], ptr %varargslots17, i64 0, i64 0
   store %variant %30, ptr %31, align 16
-  %32 = call i64 @std_io.printfn(ptr %retparam16, ptr @.str.9, i64 2, ptr %varargslots17, i64 1)
+  %32 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.9, i64 2, ptr %varargslots17, i64 1)
   store ptr @.str.12, ptr %taddr21, align 8
   %33 = insertvalue %variant undef, ptr %taddr21, 0
-  %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$p$a13$char" to i64), 1
+  %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.p$a13$char" to i64), 1
   %35 = getelementptr inbounds [1 x %variant], ptr %varargslots20, i64 0, i64 0
   store %variant %34, ptr %35, align 16
-  %36 = call i64 @std_io.printfn(ptr %retparam19, ptr @.str.11, i64 2, ptr %varargslots20, i64 1)
+  %36 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.11, i64 2, ptr %varargslots20, i64 1)
   store ptr @test.test2, ptr %y, align 8
-  store i64 ptrtoint (ptr @"ct$p$fn$int$int$" to i64), ptr %zfoke, align 8
+  store i64 ptrtoint (ptr @"$ct.p$fn$int$int$" to i64), ptr %zfoke, align 8
   ret void
 }
diff --git a/test/test_suite/functions/test_regression.c3t b/test/test_suite/functions/test_regression.c3t
index d3b8f8c45..d8a1a423f 100644
--- a/test/test_suite/functions/test_regression.c3t
+++ b/test/test_suite/functions/test_regression.c3t
@@ -243,16 +243,16 @@ fn Type getValue(Blob blob)
 %List = type { i64, i64, ptr, ptr }
 %Foo = type { i32, i32 }
 
-@"ct$test.Bobo" = linkonce constant %.introspect { i8 10, i64 20, i64 0, i64 6, [0 x i64] zeroinitializer }, align 8
-@"ct$test.Blob" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
-@"ct$test.Foor" = linkonce constant %.introspect { i8 11, i64 16, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
-@"ct$test.Foo2" = linkonce constant %.introspect { i8 10, i64 4, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
+@"$ct.test.Bobo" = linkonce constant %.introspect { i8 10, i64 20, i64 0, i64 6, [0 x i64] zeroinitializer }, align 8
+@"$ct.test.Blob" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.test.Foor" = linkonce constant %.introspect { i8 11, i64 16, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.test.Foo2" = linkonce constant %.introspect { i8 10, i64 4, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
 
-@"ct$int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$test.MyEnum" = linkonce constant { i8, i64, i64, i64, [3 x %"char[]"] } { i8 8, i64 4, i64 ptrtoint (ptr @"ct$int" to i64), i64 3, [3 x %"char[]"] [%"char[]" { ptr @.enum.0, i64 4 }, %"char[]" { ptr @.enum.1, i64 5 }, %"char[]" { ptr @.enum.2, i64 3 }] }, align 8
+@"$ct.int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.test.MyEnum" = linkonce constant { i8, i64, i64, i64, [3 x %"char[]"] } { i8 8, i64 4, i64 ptrtoint (ptr @"$ct.int" to i64), i64 3, [3 x %"char[]"] [%"char[]" { ptr @.enum.0, i64 4 }, %"char[]" { ptr @.enum.1, i64 5 }, %"char[]" { ptr @.enum.2, i64 3 }] }, align 8
 @"test_static$x" = internal unnamed_addr global i32 1, align 4
 
-define void @test.Foo2_printme(ptr %0) #0 {
+define void @test.Foo2.printme(ptr %0) #0 {
 entry:
   %1 = getelementptr inbounds %Foo2, ptr %0, i32 0, i32 0
   %2 = load i32, ptr %1, align 4
@@ -261,7 +261,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define i32 @test.Foo2_mutate(ptr %0) #0 {
+define i32 @test.Foo2.mutate(ptr %0) #0 {
 entry:
   %1 = call i32 (ptr, ...) @printf(ptr @.str.22)
   %2 = getelementptr inbounds %Foo2, ptr %0, i32 0, i32 0
@@ -431,15 +431,15 @@ entry:
   %2 = call i32 @test.test_static()
   call void @hello_world.hello()
   call void @llvm.memset.p0.i64(ptr align 8 %list, i8 0, i64 32, i1 false)
-  call void @"std_collections_linkedlist$$int.LinkedList_push"(ptr %list, i32 10)
-  call void @"std_collections_linkedlist$$int.LinkedList_push"(ptr %list, i32 15)
-  call void @"std_collections_linkedlist$$int.LinkedList_push"(ptr %list, i32 30)
+  call void @"std.collections.linkedlist$int$.LinkedList.push"(ptr %list, i32 10)
+  call void @"std.collections.linkedlist$int$.LinkedList.push"(ptr %list, i32 15)
+  call void @"std.collections.linkedlist$int$.LinkedList.push"(ptr %list, i32 30)
   store i32 0, ptr %i, align 4
   br label %loop.cond
 
 loop.cond:                                        ; preds = %loop.body, %entry
   %3 = load i32, ptr %i, align 4
-  %4 = call i64 @"std_collections_linkedlist$$int.LinkedList_len"(ptr %list) #3
+  %4 = call i64 @"std.collections.linkedlist$int$.LinkedList.len"(ptr %list) #3
   %uisitrunc = trunc i64 %4 to i32
   %lt = icmp slt i32 %3, %uisitrunc
   br i1 %lt, label %loop.body, label %loop.exit
@@ -448,7 +448,7 @@ loop.body:                                        ; preds = %loop.cond
   %5 = load i32, ptr %i, align 4
   %6 = load i32, ptr %i, align 4
   %siuiext = sext i32 %6 to i64
-  %7 = call i32 @"std_collections_linkedlist$$int.LinkedList_get"(ptr %list, i64 %siuiext)
+  %7 = call i32 @"std.collections.linkedlist$int$.LinkedList.get"(ptr %list, i64 %siuiext)
   %8 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %5, i32 %7)
   %9 = load i32, ptr %i, align 4
   %add = add i32 %9, 1
@@ -456,22 +456,22 @@ loop.body:                                        ; preds = %loop.cond
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
-  call void @"std_collections_linkedlist$$int.LinkedList_free"(ptr %list)
+  call void @"std.collections.linkedlist$int$.LinkedList.free"(ptr %list)
   %10 = call i32 (ptr, ...) @printf(ptr @.str.3, i32 3)
   store i32 3, ptr %elements, align 4
   %11 = call i32 (ptr, ...) @printf(ptr @.str.4)
   call void @llvm.memset.p0.i64(ptr align 8 %array, i8 0, i64 32, i1 false)
-  call void @"std_collections_list$$int.List_append"(ptr %array, i32 100)
-  call void @"std_collections_list$$int.List_append"(ptr %array, i32 200)
-  call void @"std_collections_list$$int.List_append"(ptr %array, i32 400)
-  call void @"std_collections_list$$int.List_push"(ptr %array, i32 600) #3
-  call void @"std_collections_list$$int.List_insert_at"(ptr %array, i64 2, i32 300)
+  call void @"std.collections.list$int$.List.append"(ptr %array, i32 100)
+  call void @"std.collections.list$int$.List.append"(ptr %array, i32 200)
+  call void @"std.collections.list$int$.List.append"(ptr %array, i32 400)
+  call void @"std.collections.list$int$.List.push"(ptr %array, i32 600) #3
+  call void @"std.collections.list$int$.List.insert_at"(ptr %array, i64 2, i32 300)
   store i32 0, ptr %i1, align 4
   br label %loop.cond2
 
 loop.cond2:                                       ; preds = %loop.body5, %loop.exit
   %12 = load i32, ptr %i1, align 4
-  %13 = call i64 @"std_collections_list$$int.List_len"(ptr %array)
+  %13 = call i64 @"std.collections.list$int$.List.len"(ptr %array)
   %uisitrunc3 = trunc i64 %13 to i32
   %lt4 = icmp slt i32 %12, %uisitrunc3
   br i1 %lt4, label %loop.body5, label %loop.exit8
@@ -480,7 +480,7 @@ loop.body5:                                       ; preds = %loop.cond2
   %14 = load i32, ptr %i1, align 4
   %15 = load i32, ptr %i1, align 4
   %siuiext6 = sext i32 %15 to i64
-  %16 = call i32 @"std_collections_list$$int.List_get"(ptr %array, i64 %siuiext6)
+  %16 = call i32 @"std.collections.list$int$.List.get"(ptr %array, i64 %siuiext6)
   %17 = call i32 (ptr, ...) @printf(ptr @.str.5, i32 %14, i32 %16)
   %18 = load i32, ptr %i1, align 4
   %add7 = add i32 %18, 1
@@ -488,18 +488,18 @@ loop.body5:                                       ; preds = %loop.cond2
   br label %loop.cond2
 
 loop.exit8:                                       ; preds = %loop.cond2
-  call void @"std_collections_list$$int.List_free"(ptr %array)
+  call void @"std.collections.list$int$.List.free"(ptr %array)
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a, ptr align 4 @.__const.6, i32 4, i1 false)
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %b, ptr align 8 @.__const.7, i32 8, i1 false)
   %19 = load i32, ptr %a, align 4
-  %20 = call i32 @"test2$$int.getValue"(i32 %19)
+  %20 = call i32 @"test2$int$.getValue"(i32 %19)
   %21 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %20)
   %22 = load double, ptr %b, align 8
-  %23 = call double @"test2$$double.getValue"(double %22)
+  %23 = call double @"test2$double$.getValue"(double %22)
   %24 = call i32 (ptr, ...) @printf(ptr @.str.9, double %23)
-  %25 = call i32 @"test2$$int.getMult"(i32 25)
+  %25 = call i32 @"test2$int$.getMult"(i32 25)
   %26 = call i32 (ptr, ...) @printf(ptr @.str.10, i32 %25)
-  %27 = call double @"test2$$double.getMult"(double 3.300000e+00)
+  %27 = call double @"test2$double$.getMult"(double 3.300000e+00)
   %28 = call i32 (ptr, ...) @printf(ptr @.str.11, double %27)
   call void @test.helloWorld()
   %29 = getelementptr inbounds %Foo, ptr %ddx, i32 0, i32 0
@@ -552,13 +552,13 @@ loop.exit8:                                       ; preds = %loop.cond2
 define void @hello_world.hello()
 entry:
   %0 = call i32 (ptr, ...) @printf(ptr @.str)
-  %1 = call double @"foo$$double.check"(double 1.110000e+01)
+  %1 = call double @"foo$double$.check"(double 1.110000e+01)
   %2 = call i32 (ptr, ...) @printf(ptr @.str.1, double %1)
   ret void
 
 // #expect: foo.double.ll
 
-define double @"foo$$double.check"(double %0)
+define double @"foo$double$.check"(double %0)
 entry:
   %fmul = fmul double %0, %0
   ret double %fmul
@@ -567,20 +567,20 @@ entry:
 // #expect: test2.int.ll
 
 %Blob = type { i32 }
-@"test2$$int.argh" = local_unnamed_addr global i32 234, align 4
+@"test2$int$.argh" = local_unnamed_addr global i32 234, align 4
 
-define i32 @"test2$$int.getMult"(i32 %0) #0 {
+define i32 @"test2$int$.getMult"(i32 %0) #0 {
 entry:
   %mul = mul i32 %0, %0
   ret i32 %mul
 }
 
-define i32 @"test2$$int.hello"() #0 {
+define i32 @"test2$int$.hello"() #0 {
 entry:
   ret i32 1
 }
 
-define i32 @"test2$$int.getValue"(i32 %0) #0 {
+define i32 @"test2$int$.getValue"(i32 %0) #0 {
 entry:
   %blob = alloca %Blob, align 4
   store i32 %0, ptr %blob, align 4
@@ -592,18 +592,18 @@ entry:
 // #expect: test2.double.ll
 
 %Blob = type { double }
-@"test2$$double.argh" = local_unnamed_addr global double 2.340000e+02, align 8
+@"test2$double$.argh" = local_unnamed_addr global double 2.340000e+02, align 8
 
-define double @"test2$$double.getMult"(double %0)
+define double @"test2$double$.getMult"(double %0)
 entry:
   %fmul = fmul double %0, %0
   ret double %fmul
 
-define i32 @"test2$$double.hello"()
+define i32 @"test2$double$.hello"()
 entry:
   ret i32 1
 
-define double @"test2$$double.getValue"(double %0)
+define double @"test2$double$.getValue"(double %0)
 entry:
   %blob = alloca %Blob, align 8
   store double %0, ptr %blob, align 8
diff --git a/test/test_suite/functions/test_regression_mingw.c3t b/test/test_suite/functions/test_regression_mingw.c3t
index ea6989396..47818e0b8 100644
--- a/test/test_suite/functions/test_regression_mingw.c3t
+++ b/test/test_suite/functions/test_regression_mingw.c3t
@@ -245,27 +245,27 @@ fn Type getValue(Blob blob)
 %List = type { i64, i64, ptr, ptr }
 %Foo = type { i32, i32 }
 
-$"ct$test.Bobo" = comdat any
+$"$ct.test.Bobo" = comdat any
 
-$"ct$test.Blob" = comdat any
+$"$ct.test.Blob" = comdat any
 
-$"ct$test.Foor" = comdat any
+$"$ct.test.Foor" = comdat any
 
-$"ct$test.Foo2" = comdat any
+$"$ct.test.Foo2" = comdat any
 
-$"ct$test.Foo" = comdat any
+$"$ct.test.Foo" = comdat any
 
-$"ct$int" = comdat any
+$"$ct.int" = comdat any
 
-$"ct$test.MyEnum" = comdat any
+$"$ct.test.MyEnum" = comdat any
 
-@"ct$test.Bobo" = linkonce constant %.introspect { i8 10, i64 20, i64 0, i64 6, [0 x i64] zeroinitializer }, comdat, align 8
-@"ct$test.Blob" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, comdat, align 8
-@"ct$test.Foor" = linkonce constant %.introspect { i8 11, i64 16, i64 0, i64 2, [0 x i64] zeroinitializer }, comdat, align 8
-@"ct$test.Foo2" = linkonce constant %.introspect { i8 10, i64 4, i64 0, i64 1, [0 x i64] zeroinitializer }, comdat, align 8
-@"ct$test.Foo" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, comdat, align 8
-@"ct$int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, comdat, align 8
-@"ct$test.MyEnum" = linkonce constant { i8, i64, i64, i64, [3 x %"char[]"] } { i8 8, i64 4, i64 ptrtoint (ptr @"ct$int" to i64), i64 3, [3 x %"char[]"] [%"char[]" { ptr @.enum.0, i64 4 }, %"char[]" { ptr @.enum.1, i64 5 }, %"char[]" { ptr @.enum.2, i64 3 }] }, comdat, align 8
+@"$ct.test.Bobo" = linkonce constant %.introspect { i8 10, i64 20, i64 0, i64 6, [0 x i64] zeroinitializer }, comdat, align 8
+@"$ct.test.Blob" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, comdat, align 8
+@"$ct.test.Foor" = linkonce constant %.introspect { i8 11, i64 16, i64 0, i64 2, [0 x i64] zeroinitializer }, comdat, align 8
+@"$ct.test.Foo2" = linkonce constant %.introspect { i8 10, i64 4, i64 0, i64 1, [0 x i64] zeroinitializer }, comdat, align 8
+@"$ct.test.Foo" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, comdat, align 8
+@"$ct.int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, comdat, align 8
+@"$ct.test.MyEnum" = linkonce constant { i8, i64, i64, i64, [3 x %"char[]"] } { i8 8, i64 4, i64 ptrtoint (ptr @"$ct.int" to i64), i64 3, [3 x %"char[]"] [%"char[]" { ptr @.enum.0, i64 4 }, %"char[]" { ptr @.enum.1, i64 5 }, %"char[]" { ptr @.enum.2, i64 3 }] }, comdat, align 8
 @.str = private unnamed_addr constant [13 x i8] c"helloWorld!\0A\00", align 1
 @"test_static$x" = internal unnamed_addr global i32 1, align 4
 @.str.1 = private unnamed_addr constant [16 x i8] c"Test static %d\0A\00", align 1
@@ -293,7 +293,7 @@ $"ct$test.MyEnum" = comdat any
 @.str.22 = private unnamed_addr constant [9 x i8] c"Mutating\00", align 1
 
 ; Function Attrs: nounwind
-define void @test.Foo2_printme(ptr %0) #0 {
+define void @test.Foo2.printme(ptr %0) #0 {
 entry:
   %1 = getelementptr inbounds %Foo2, ptr %0, i32 0, i32 0
   %2 = load i32, ptr %1, align 4
@@ -302,7 +302,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define i32 @test.Foo2_mutate(ptr %0) #0 {
+define i32 @test.Foo2.mutate(ptr %0) #0 {
 entry:
   %1 = call i32 (ptr, ...) @printf(ptr @.str.22)
   %2 = getelementptr inbounds %Foo2, ptr %0, i32 0, i32 0
@@ -474,15 +474,15 @@ entry:
   %2 = call i32 @test.test_static()
   call void @hello_world.hello()
   call void @llvm.memset.p0.i64(ptr align 8 %list, i8 0, i64 32, i1 false)
-  call void @"std_collections_linkedlist$$int.LinkedList_push"(ptr %list, i32 10)
-  call void @"std_collections_linkedlist$$int.LinkedList_push"(ptr %list, i32 15)
-  call void @"std_collections_linkedlist$$int.LinkedList_push"(ptr %list, i32 30)
+  call void @"std.collections.linkedlist$int$.LinkedList.push"(ptr %list, i32 10)
+  call void @"std.collections.linkedlist$int$.LinkedList.push"(ptr %list, i32 15)
+  call void @"std.collections.linkedlist$int$.LinkedList.push"(ptr %list, i32 30)
   store i32 0, ptr %i, align 4
   br label %loop.cond
 
 loop.cond:                                        ; preds = %loop.body, %entry
   %3 = load i32, ptr %i, align 4
-  %4 = call i64 @"std_collections_linkedlist$$int.LinkedList_len"(ptr %list) #3
+  %4 = call i64 @"std.collections.linkedlist$int$.LinkedList.len"(ptr %list) #3
   %uisitrunc = trunc i64 %4 to i32
   %lt = icmp slt i32 %3, %uisitrunc
   br i1 %lt, label %loop.body, label %loop.exit
@@ -491,7 +491,7 @@ loop.body:                                        ; preds = %loop.cond
   %5 = load i32, ptr %i, align 4
   %6 = load i32, ptr %i, align 4
   %siuiext = sext i32 %6 to i64
-  %7 = call i32 @"std_collections_linkedlist$$int.LinkedList_get"(ptr %list, i64 %siuiext)
+  %7 = call i32 @"std.collections.linkedlist$int$.LinkedList.get"(ptr %list, i64 %siuiext)
   %8 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %5, i32 %7)
   %9 = load i32, ptr %i, align 4
   %add = add i32 %9, 1
@@ -499,22 +499,22 @@ loop.body:                                        ; preds = %loop.cond
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
-  call void @"std_collections_linkedlist$$int.LinkedList_free"(ptr %list)
+  call void @"std.collections.linkedlist$int$.LinkedList.free"(ptr %list)
   %10 = call i32 (ptr, ...) @printf(ptr @.str.3, i32 3)
   store i32 3, ptr %elements, align 4
   %11 = call i32 (ptr, ...) @printf(ptr @.str.4)
   call void @llvm.memset.p0.i64(ptr align 8 %array, i8 0, i64 32, i1 false)
-  call void @"std_collections_list$$int.List_append"(ptr %array, i32 100)
-  call void @"std_collections_list$$int.List_append"(ptr %array, i32 200)
-  call void @"std_collections_list$$int.List_append"(ptr %array, i32 400)
-  call void @"std_collections_list$$int.List_push"(ptr %array, i32 600) #3
-  call void @"std_collections_list$$int.List_insert_at"(ptr %array, i64 2, i32 300)
+  call void @"std.collections.list$int$.List.append"(ptr %array, i32 100)
+  call void @"std.collections.list$int$.List.append"(ptr %array, i32 200)
+  call void @"std.collections.list$int$.List.append"(ptr %array, i32 400)
+  call void @"std.collections.list$int$.List.push"(ptr %array, i32 600) #3
+  call void @"std.collections.list$int$.List.insert_at"(ptr %array, i64 2, i32 300)
   store i32 0, ptr %i1, align 4
   br label %loop.cond2
 
 loop.cond2:                                       ; preds = %loop.body5, %loop.exit
   %12 = load i32, ptr %i1, align 4
-  %13 = call i64 @"std_collections_list$$int.List_len"(ptr %array)
+  %13 = call i64 @"std.collections.list$int$.List.len"(ptr %array)
   %uisitrunc3 = trunc i64 %13 to i32
   %lt4 = icmp slt i32 %12, %uisitrunc3
   br i1 %lt4, label %loop.body5, label %loop.exit8
@@ -523,7 +523,7 @@ loop.body5:                                       ; preds = %loop.cond2
   %14 = load i32, ptr %i1, align 4
   %15 = load i32, ptr %i1, align 4
   %siuiext6 = sext i32 %15 to i64
-  %16 = call i32 @"std_collections_list$$int.List_get"(ptr %array, i64 %siuiext6)
+  %16 = call i32 @"std.collections.list$int$.List.get"(ptr %array, i64 %siuiext6)
   %17 = call i32 (ptr, ...) @printf(ptr @.str.5, i32 %14, i32 %16)
   %18 = load i32, ptr %i1, align 4
   %add7 = add i32 %18, 1
@@ -531,18 +531,18 @@ loop.body5:                                       ; preds = %loop.cond2
   br label %loop.cond2
 
 loop.exit8:                                       ; preds = %loop.cond2
-  call void @"std_collections_list$$int.List_free"(ptr %array)
+  call void @"std.collections.list$int$.List.free"(ptr %array)
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %a, ptr align 4 @.__const.6, i32 4, i1 false)
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %b, ptr align 8 @.__const.7, i32 8, i1 false)
   %19 = load i32, ptr %a, align 4
-  %20 = call i32 @"test2$$int.getValue"(i32 %19)
+  %20 = call i32 @"test2$int$.getValue"(i32 %19)
   %21 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %20)
   %22 = load i64, ptr %b, align 8
-  %23 = call double @"test2$$double.getValue"(i64 %22)
+  %23 = call double @"test2$double$.getValue"(i64 %22)
   %24 = call i32 (ptr, ...) @printf(ptr @.str.9, double %23)
-  %25 = call i32 @"test2$$int.getMult"(i32 25)
+  %25 = call i32 @"test2$int$.getMult"(i32 25)
   %26 = call i32 (ptr, ...) @printf(ptr @.str.10, i32 %25)
-  %27 = call double @"test2$$double.getMult"(double 3.300000e+00)
+  %27 = call double @"test2$double$.getMult"(double 3.300000e+00)
   %28 = call i32 (ptr, ...) @printf(ptr @.str.11, double %27)
   call void @test.helloWorld()
   %29 = getelementptr inbounds %Foo, ptr %ddx, i32 0, i32 0
@@ -607,39 +607,47 @@ declare void @hello_world.hello() #0
 
 declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #2
 
-declare void @"std_collections_linkedlist$$int.LinkedList_push"(ptr, i32) #0
+declare void @"std.collections.linkedlist$int$.LinkedList.push"(ptr, i32) #0
 
-declare i64 @"std_collections_linkedlist$$int.LinkedList_len"(ptr) #0
+declare i64 @"std.collections.linkedlist$int$.LinkedList.len"(ptr) #0
 
-declare i32 @"std_collections_linkedlist$$int.LinkedList_get"(ptr, i64) #0
+declare i32 @"std.collections.linkedlist$int$.LinkedList.get"(ptr, i64) #0
 
-declare void @"std_collections_linkedlist$$int.LinkedList_free"(ptr) #0
+declare void @"std.collections.linkedlist$int$.LinkedList.free"(ptr) #0
 
-declare void @"std_collections_list$$int.List_append"(ptr, i32) #0
+declare void @"std.collections.list$int$.List.append"(ptr, i32) #0
 
-declare void @"std_collections_list$$int.List_push"(ptr, i32) #0
+declare void @"std.collections.list$int$.List.push"(ptr, i32) #0
 
-declare void @"std_collections_list$$int.List_insert_at"(ptr, i64, i32) #0
+declare void @"std.collections.list$int$.List.insert_at"(ptr, i64, i32) #0
 
-declare i64 @"std_collections_list$$int.List_len"(ptr) #0
+declare i64 @"std.collections.list$int$.List.len"(ptr) #0
 
-declare i32 @"std_collections_list$$int.List_get"(ptr, i64) #0
+declare i32 @"std.collections.list$int$.List.get"(ptr, i64) #0
 
-declare void @"std_collections_list$$int.List_free"(ptr) #0
+declare void @"std.collections.list$int$.List.free"(ptr) #0
+
+declare i32 @"test2$int$.getValue"(i32) #0
+
+declare double @"test2$double$.getValue"(i64) #0
+
+declare i32 @"test2$int$.getMult"(i32) #0
+
+declare double @"test2$double$.getMult"(double) #0
 
 // #expect: hello_world.ll
 
 define void @hello_world.hello() #0 {
 entry:
   %0 = call i32 (ptr, ...) @printf(ptr @.str)
-  %1 = call double @"foo$$double.check"(double 1.110000e+01)
+  %1 = call double @"foo$double$.check"(double 1.110000e+01)
   %2 = call i32 (ptr, ...) @printf(ptr @.str.1, double %1)
   ret void
 }
 
 // #expect: foo.double.ll
 
-define double @"foo$$double.check"(double %0)
+define double @"foo$double$.check"(double %0)
 entry:
   %fmul = fmul double %0, %0
   ret double %fmul
@@ -648,19 +656,19 @@ entry:
 // #expect: test2.int.ll
 
 %Blob = type { i32 }
-@"test2$$int.argh" = local_unnamed_addr global i32 234, align 4
+@"test2$int$.argh" = local_unnamed_addr global i32 234, align 4
 
-define i32 @"test2$$int.getMult"(i32 %0)
+define i32 @"test2$int$.getMult"(i32 %0)
 entry:
   %mul = mul i32 %0, %0
   ret i32 %mul
 
-define i32 @"test2$$int.hello"()
+define i32 @"test2$int$.hello"()
 entry:
   ret i32 1
 }
 
-define i32 @"test2$$int.getValue"(i32 %0)
+define i32 @"test2$int$.getValue"(i32 %0)
 entry:
   %blob = alloca %Blob, align 4
   store i32 %0, ptr %blob, align 4
@@ -672,19 +680,19 @@ entry:
 // #expect: test2.double.ll
 
 %Blob = type { double }
-@"test2$$double.argh" = local_unnamed_addr global double 2.340000e+02, align 8
+@"test2$double$.argh" = local_unnamed_addr global double 2.340000e+02, align 8
 
-define double @"test2$$double.getMult"(double %0)
+define double @"test2$double$.getMult"(double %0)
 entry:
   %fmul = fmul double %0, %0
   ret double %fmul
 
 
-define i32 @"test2$$double.hello"()
+define i32 @"test2$double$.hello"()
 entry:
   ret i32 1
 
-define double @"test2$$double.getValue"(i64 %0)
+define double @"test2$double$.getValue"(i64 %0)
 entry:
   %blob = alloca %Blob, align 8
   store i64 %0, ptr %blob, align 8
diff --git a/test/test_suite/functions/typeless_varargs.c3t b/test/test_suite/functions/typeless_varargs.c3t
index e527f4a6c..b65875c2b 100644
--- a/test/test_suite/functions/typeless_varargs.c3t
+++ b/test/test_suite/functions/typeless_varargs.c3t
@@ -22,7 +22,7 @@ fn int main()
 
 /* #expect: test.ll
 
-@"ct$int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
 
 define void @test.retest(ptr %0, i64 %1) #0 {
 entry:
@@ -64,13 +64,13 @@ entry:
   store i32 1, ptr %i, align 4
   store i32 1, ptr %taddr, align 4
   %0 = insertvalue %variant undef, ptr %taddr, 0
-  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %2 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %1, ptr %2, align 16
   call void @test.test(ptr %varargslots, i64 1)
   store i32 1, ptr %taddr2, align 4
   %3 = insertvalue %variant undef, ptr %taddr2, 0
-  %4 = insertvalue %variant %3, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %4 = insertvalue %variant %3, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %5 = getelementptr inbounds [1 x %variant], ptr %varargslots1, i64 0, i64 0
   store %variant %4, ptr %5, align 16
   call void @test.retest(ptr %varargslots1, i64 1)
diff --git a/test/test_suite/functions/varargs_followed_by_named.c3t b/test/test_suite/functions/varargs_followed_by_named.c3t
index bb953769e..2516083b7 100644
--- a/test/test_suite/functions/varargs_followed_by_named.c3t
+++ b/test/test_suite/functions/varargs_followed_by_named.c3t
@@ -71,12 +71,12 @@ entry:
   call void @foo.test(i32 3, ptr %varargslots, i64 2, i32 123)
   store i32 4, ptr %taddr, align 4
   %2 = insertvalue %variant undef, ptr %taddr, 0
-  %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %4 = getelementptr inbounds [2 x %variant], ptr %varargslots1, i64 0, i64 0
   store %variant %3, ptr %4, align 16
   store i32 5, ptr %taddr2, align 4
   %5 = insertvalue %variant undef, ptr %taddr2, 0
-  %6 = insertvalue %variant %5, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %6 = insertvalue %variant %5, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %7 = getelementptr inbounds [2 x %variant], ptr %varargslots1, i64 0, i64 1
   store %variant %6, ptr %7, align 16
   call void @foo.test2(i32 3, ptr %varargslots1, i64 2, i32 123)
@@ -87,12 +87,12 @@ entry:
   call void @foo.test(i32 3, ptr %varargslots3, i64 2, i32 2)
   store i32 4, ptr %taddr5, align 4
   %10 = insertvalue %variant undef, ptr %taddr5, 0
-  %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %11 = insertvalue %variant %10, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %12 = getelementptr inbounds [2 x %variant], ptr %varargslots4, i64 0, i64 0
   store %variant %11, ptr %12, align 16
   store i32 5, ptr %taddr6, align 4
   %13 = insertvalue %variant undef, ptr %taddr6, 0
-  %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %15 = getelementptr inbounds [2 x %variant], ptr %varargslots4, i64 0, i64 1
   store %variant %14, ptr %15, align 16
   call void @foo.test2(i32 3, ptr %varargslots4, i64 2, i32 2)
diff --git a/test/test_suite/generic/enum_set_test.c3t b/test/test_suite/generic/enum_set_test.c3t
index 75fa8bad7..10e3ce0d0 100644
--- a/test/test_suite/generic/enum_set_test.c3t
+++ b/test/test_suite/generic/enum_set_test.c3t
@@ -47,47 +47,47 @@ entry:
   %varargslots11 = alloca [1 x %variant], align 16
   %taddr12 = alloca i8, align 1
   store i32 0, ptr %set, align 4
-  %0 = call i8 @"std_collections_enumset$$test.Abc.EnumSet_has"(ptr %set, i32 1)
+  %0 = call i8 @"std.collections.enumset$test.Abc$.EnumSet.has"(ptr %set, i32 1)
   store i8 %0, ptr %taddr, align 1
   %1 = insertvalue %variant undef, ptr %taddr, 0
-  %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %2, ptr %3, align 16
-  %4 = call i64 @std_io.printf(ptr %retparam, ptr @.str, i64 14, ptr %varargslots, i64 1)
-  call void @"std_collections_enumset$$test.Abc.EnumSet_add"(ptr %set, i32 0)
-  %5 = call i8 @"std_collections_enumset$$test.Abc.EnumSet_has"(ptr %set, i32 1)
+  %4 = call i64 @std.io.printf(ptr %retparam, ptr @.str, i64 14, ptr %varargslots, i64 1)
+  call void @"std.collections.enumset$test.Abc$.EnumSet.add"(ptr %set, i32 0)
+  %5 = call i8 @"std.collections.enumset$test.Abc$.EnumSet.has"(ptr %set, i32 1)
   store i8 %5, ptr %taddr3, align 1
   %6 = insertvalue %variant undef, ptr %taddr3, 0
-  %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %8 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0
   store %variant %7, ptr %8, align 16
-  %9 = call i64 @std_io.printf(ptr %retparam1, ptr @.str.1, i64 14, ptr %varargslots2, i64 1)
-  call void @"std_collections_enumset$$test.Abc.EnumSet_add"(ptr %set, i32 1)
-  %10 = call i8 @"std_collections_enumset$$test.Abc.EnumSet_has"(ptr %set, i32 1)
+  %9 = call i64 @std.io.printf(ptr %retparam1, ptr @.str.1, i64 14, ptr %varargslots2, i64 1)
+  call void @"std.collections.enumset$test.Abc$.EnumSet.add"(ptr %set, i32 1)
+  %10 = call i8 @"std.collections.enumset$test.Abc$.EnumSet.has"(ptr %set, i32 1)
   store i8 %10, ptr %taddr6, align 1
   %11 = insertvalue %variant undef, ptr %taddr6, 0
-  %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %13 = getelementptr inbounds [1 x %variant], ptr %varargslots5, i64 0, i64 0
   store %variant %12, ptr %13, align 16
-  %14 = call i64 @std_io.printf(ptr %retparam4, ptr @.str.2, i64 14, ptr %varargslots5, i64 1)
+  %14 = call i64 @std.io.printf(ptr %retparam4, ptr @.str.2, i64 14, ptr %varargslots5, i64 1)
   store i32 0, ptr %set2, align 4
   %15 = load i32, ptr %set, align 4
-  call void @"std_collections_enumset$$test.Abc.EnumSet_add_all"(ptr %set2, i32 %15)
-  %16 = call i8 @"std_collections_enumset$$test.Abc.EnumSet_has"(ptr %set2, i32 1)
+  call void @"std.collections.enumset$test.Abc$.EnumSet.add_all"(ptr %set2, i32 %15)
+  %16 = call i8 @"std.collections.enumset$test.Abc$.EnumSet.has"(ptr %set2, i32 1)
   store i8 %16, ptr %taddr9, align 1
   %17 = insertvalue %variant undef, ptr %taddr9, 0
-  %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %19 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
   store %variant %18, ptr %19, align 16
-  %20 = call i64 @std_io.printf(ptr %retparam7, ptr @.str.3, i64 14, ptr %varargslots8, i64 1)
+  %20 = call i64 @std.io.printf(ptr %retparam7, ptr @.str.3, i64 14, ptr %varargslots8, i64 1)
   %21 = load i32, ptr %set2, align 4
-  call void @"std_collections_enumset$$test.Abc.EnumSet_remove_all"(ptr %set, i32 %21)
-  %22 = call i8 @"std_collections_enumset$$test.Abc.EnumSet_has"(ptr %set, i32 1)
+  call void @"std.collections.enumset$test.Abc$.EnumSet.remove_all"(ptr %set, i32 %21)
+  %22 = call i8 @"std.collections.enumset$test.Abc$.EnumSet.has"(ptr %set, i32 1)
   store i8 %22, ptr %taddr12, align 1
   %23 = insertvalue %variant undef, ptr %taddr12, 0
-  %24 = insertvalue %variant %23, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %24 = insertvalue %variant %23, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %25 = getelementptr inbounds [1 x %variant], ptr %varargslots11, i64 0, i64 0
   store %variant %24, ptr %25, align 16
-  %26 = call i64 @std_io.printf(ptr %retparam10, ptr @.str.4, i64 14, ptr %varargslots11, i64 1)
+  %26 = call i64 @std.io.printf(ptr %retparam10, ptr @.str.4, i64 14, ptr %varargslots11, i64 1)
   ret void
 }
diff --git a/test/test_suite/generic/generic_idents.c3t b/test/test_suite/generic/generic_idents.c3t
index d3e56e51b..a9c152b81 100644
--- a/test/test_suite/generic/generic_idents.c3t
+++ b/test/test_suite/generic/generic_idents.c3t
@@ -28,13 +28,13 @@ fn double getIt2(double i)
 
 /* #expect: gen.int.ll
 
-define i32 @"gen$$int.mult"(i32 %0) #0 {
+define i32 @"gen$int$.mult"(i32 %0) #0 {
 entry:
   %mul = mul i32 %0, %0
   ret i32 %mul
 }
 
-define i32 @"gen$$int.addMult"(i32 %0, i32 %1, i32 %2) #0 {
+define i32 @"gen$int$.addMult"(i32 %0, i32 %1, i32 %2) #0 {
 entry:
   %mul = mul i32 %0, %1
   %add = add i32 %mul, %2
@@ -46,23 +46,23 @@ entry:
 
 define i32 @test.getIt(i32 %0) #0 {
 entry:
-  %1 = call i32 @"gen$$int.mult"(i32 %0)
+  %1 = call i32 @"gen$int$.mult"(i32 %0)
   %add = add i32 %1, 1
   ret i32 %add
 }
 
 define double @test.getIt2(double %0) #0 {
 entry:
-  %1 = call double @"gen$$double.addMult"(double %0, double 2.000000e+00, double 3.000000e+00)
+  %1 = call double @"gen$double$.addMult"(double %0, double 2.000000e+00, double 3.000000e+00)
   ret double %1
 }
 
-declare i32 @"gen$$int.mult"(i32)
+declare i32 @"gen$int$.mult"(i32)
 
-declare double @"gen$$double.addMult"(double, double, double)
+declare double @"gen$double$.addMult"(double, double, double)
 
 // #expect: gen.double.ll
 
-define double @"gen$$double.addMult"(double %0, double %1, double %2)
+define double @"gen$double$.addMult"(double %0, double %1, double %2)
   %3 = call double @llvm.fmuladd.f64(double %0, double %1, double %2)
   ret double %3
diff --git a/test/test_suite/generic/generic_num.c3t b/test/test_suite/generic/generic_num.c3t
index b0615670f..9d62ffe5c 100644
--- a/test/test_suite/generic/generic_num.c3t
+++ b/test/test_suite/generic/generic_num.c3t
@@ -24,13 +24,13 @@ entry:
   %retparam = alloca i64, align 8
   %varargslots = alloca [1 x %variant], align 16
   %taddr = alloca i32, align 4
-  %0 = call i32 @"hello$$int._123.x"(i32 4)
+  %0 = call i32 @"hello$int$_123$.x"(i32 4)
   store i32 %0, ptr %taddr, align 4
   %1 = insertvalue %variant undef, ptr %taddr, 0
-  %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %2, ptr %3, align 16
-  %4 = call i64 @std_io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
+  %4 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
   ret void
 }
 
diff --git a/test/test_suite/initializer_lists/general_tests.c3t b/test/test_suite/initializer_lists/general_tests.c3t
index c329b920b..e59434e44 100644
--- a/test/test_suite/initializer_lists/general_tests.c3t
+++ b/test/test_suite/initializer_lists/general_tests.c3t
@@ -37,8 +37,8 @@ fn int test()
 %"int[]" = type { ptr, i64 }
 %"Bar[]" = type { ptr, i64 }
 
-@"ct$general_tests.Baz" = linkonce constant %.introspect { i8 11, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
-@"ct$general_tests.Bar" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.general_tests.Baz" = linkonce constant %.introspect { i8 11, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.general_tests.Bar" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
 @.__const = private unnamed_addr constant { i32, [4 x i8] } { i32 1, [4 x i8] undef }, align 8
 @"test$foo1" = internal unnamed_addr global i32 22, align 4
 @.str = private unnamed_addr constant [7 x i8] c"Hello!\00", align 1
diff --git a/test/test_suite/initializer_lists/statics.c3t b/test/test_suite/initializer_lists/statics.c3t
index 73dbd49f7..c0710f590 100644
--- a/test/test_suite/initializer_lists/statics.c3t
+++ b/test/test_suite/initializer_lists/statics.c3t
@@ -35,8 +35,8 @@ fn int main()
 %Bar = type { i32, i32 }
 %"Bar[]" = type { ptr, i64 }
 
-@"ct$statics.Baz" = linkonce constant %.introspect { i8 11, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
-@"ct$statics.Bar" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.statics.Baz" = linkonce constant %.introspect { i8 11, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.statics.Bar" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
 @.taddr = private global [1 x %Bar] [%Bar { i32 1, i32 2 }], align 8
 @"test$c" = internal unnamed_addr global %"Bar[]" { ptr @.taddr, i64 1 }, align 8
 @.str = private unnamed_addr constant [7 x i8] c"%d %d\0A\00", align 1
diff --git a/test/test_suite/initializer_lists/subarrays.c3t b/test/test_suite/initializer_lists/subarrays.c3t
index 4be64b041..33a2aa340 100644
--- a/test/test_suite/initializer_lists/subarrays.c3t
+++ b/test/test_suite/initializer_lists/subarrays.c3t
@@ -49,8 +49,8 @@ fn int main()
 %"Bar[]" = type { ptr, i64 }
 %"int[]" = type { ptr, i64 }
 %Baz = type { double }
-@"ct$subarrays.Baz" = linkonce constant %.introspect { i8 11, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
-@"ct$subarrays.Bar" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.subarrays.Baz" = linkonce constant %.introspect { i8 11, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.subarrays.Bar" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
 @.taddr = private global [2 x %Bar] [%Bar { i32 3, i32 4 }, %Bar { i32 8, i32 9 }], align 8
 @subarrays.arrbar = local_unnamed_addr global %"Bar[]" { ptr @.taddr, i64 2 }, align 8
 @.taddr.3 = private global [2 x i32] [i32 1, i32 2], align 4
@@ -112,10 +112,10 @@ entry:
   store i32 567, ptr %12, align 4
   store ptr %literal2, ptr %y, align 8
   store ptr @.str.5, ptr %x3, align 8
-  %13 = call ptr @std_io.stdout()
+  %13 = call ptr @std.io.stdout()
   store ptr %13, ptr %result, align 8
   %14 = load ptr, ptr %x3, align 8
-  %15 = call i64 @std_io.File_printn(ptr %retparam, ptr %result, ptr %14, i64 6)
+  %15 = call i64 @std.io.File.printn(ptr %retparam, ptr %result, ptr %14, i64 6)
   %16 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1
   %17 = load i64, ptr %16, align 8
   %uisitrunc = trunc i64 %17 to i32
@@ -154,10 +154,10 @@ entry:
 
 if.then:                                          ; preds = %entry
   store ptr @.str.9, ptr %x9, align 8
-  %38 = call ptr @std_io.stdout()
+  %38 = call ptr @std.io.stdout()
   store ptr %38, ptr %result11, align 8
   %39 = load ptr, ptr %x9, align 8
-  %40 = call i64 @std_io.File_printn(ptr %retparam10, ptr %result11, ptr %39, i64 2)
+  %40 = call i64 @std.io.File.printn(ptr %retparam10, ptr %result11, ptr %39, i64 2)
   br label %if.exit
 
 if.exit:                                          ; preds = %if.then, %entry
diff --git a/test/test_suite/literals/bin_literal.c3t b/test/test_suite/literals/bin_literal.c3t
index bafd6b525..b8526654b 100644
--- a/test/test_suite/literals/bin_literal.c3t
+++ b/test/test_suite/literals/bin_literal.c3t
@@ -43,17 +43,17 @@ entry:
   %5 = call i32 @llvm.smax.i32(i32 %3, i32 %4)
   store i32 %5, ptr %d, align 4
   %6 = insertvalue %variant undef, ptr %c, 0
-  %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %8 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %7, ptr %8, align 16
   %9 = insertvalue %variant undef, ptr %d, 0
-  %10 = insertvalue %variant %9, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %10 = insertvalue %variant %9, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %11 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %10, ptr %11, align 16
-  %12 = call i64 @std_io.printfn(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2)
+  %12 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2)
   store i8 -35, ptr %z, align 1
   %13 = insertvalue %variant undef, ptr %z, 0
-  %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"ct$char" to i64), 1
+  %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"$ct.char" to i64), 1
   %15 = getelementptr inbounds [3 x %variant], ptr %varargslots2, i64 0, i64 0
   store %variant %14, ptr %15, align 16
   %16 = load i8, ptr %z, align 1
@@ -65,7 +65,7 @@ entry:
   %20 = call i8 @llvm.fshr.i8(i8 %17, i8 %18, i8 %19)
   store i8 %20, ptr %taddr, align 1
   %21 = insertvalue %variant undef, ptr %taddr, 0
-  %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"ct$char" to i64), 1
+  %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"$ct.char" to i64), 1
   %23 = getelementptr inbounds [3 x %variant], ptr %varargslots2, i64 0, i64 1
   store %variant %22, ptr %23, align 16
   %24 = load i8, ptr %z, align 1
@@ -77,9 +77,9 @@ entry:
   %28 = call i8 @llvm.fshl.i8(i8 %25, i8 %26, i8 %27)
   store i8 %28, ptr %taddr5, align 1
   %29 = insertvalue %variant undef, ptr %taddr5, 0
-  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$char" to i64), 1
+  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.char" to i64), 1
   %31 = getelementptr inbounds [3 x %variant], ptr %varargslots2, i64 0, i64 2
   store %variant %30, ptr %31, align 16
-  %32 = call i64 @std_io.printfn(ptr %retparam1, ptr @.str.1, i64 8, ptr %varargslots2, i64 3)
+  %32 = call i64 @std.io.printfn(ptr %retparam1, ptr @.str.1, i64 8, ptr %varargslots2, i64 3)
   ret void
 }
diff --git a/test/test_suite/macros/macro_typed_varargs.c3t b/test/test_suite/macros/macro_typed_varargs.c3t
index ad565a9a5..a218a934b 100644
--- a/test/test_suite/macros/macro_typed_varargs.c3t
+++ b/test/test_suite/macros/macro_typed_varargs.c3t
@@ -77,10 +77,10 @@ loop.body:                                        ; preds = %loop.cond
   %13 = load i32, ptr %ptroffset, align 4
   store i32 %13, ptr %i, align 4
   %14 = insertvalue %variant undef, ptr %i, 0
-  %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %16 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %15, ptr %16, align 16
-  %17 = call i64 @std_io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
+  %17 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
   %18 = load i64, ptr %.anon1, align 8
   %add = add i64 %18, 1
   store i64 %add, ptr %.anon1, align 8
@@ -89,22 +89,22 @@ loop.exit:                                        ; preds = %loop.cond
   %19 = getelementptr inbounds [4 x %variant], ptr %literal3, i64 0, i64 0
   store i32 1, ptr %taddr, align 4
   %20 = insertvalue %variant undef, ptr %taddr, 0
-  %21 = insertvalue %variant %20, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %21 = insertvalue %variant %20, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   store %variant %21, ptr %19, align 8
   %22 = getelementptr inbounds [4 x %variant], ptr %literal3, i64 0, i64 1
   store i32 -1, ptr %taddr4, align 4
   %23 = insertvalue %variant undef, ptr %taddr4, 0
-  %24 = insertvalue %variant %23, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %24 = insertvalue %variant %23, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   store %variant %24, ptr %22, align 8
   %25 = getelementptr inbounds [4 x %variant], ptr %literal3, i64 0, i64 2
   store i32 3141, ptr %taddr5, align 4
   %26 = insertvalue %variant undef, ptr %taddr5, 0
-  %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   store %variant %27, ptr %25, align 8
   %28 = getelementptr inbounds [4 x %variant], ptr %literal3, i64 0, i64 3
   store i32 1000, ptr %taddr6, align 4
   %29 = insertvalue %variant undef, ptr %taddr6, 0
-  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   store %variant %30, ptr %28, align 8
   %31 = insertvalue %"variant[]" undef, ptr %literal3, 0
   %32 = insertvalue %"variant[]" %31, i64 4, 1
@@ -128,10 +128,10 @@ loop.body11:                                      ; preds = %loop.cond9
   %40 = getelementptr inbounds %variant, ptr %i12, i32 0, i32 0
   %41 = load ptr, ptr %40, align 8
   %42 = insertvalue %variant undef, ptr %41, 0
-  %43 = insertvalue %variant %42, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %43 = insertvalue %variant %42, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %44 = getelementptr inbounds [1 x %variant], ptr %varargslots15, i64 0, i64 0
   store %variant %43, ptr %44, align 16
-  %45 = call i64 @std_io.printfn(ptr %retparam14, ptr @.str.1, i64 2, ptr %varargslots15, i64 1)
+  %45 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.1, i64 2, ptr %varargslots15, i64 1)
   %46 = load i64, ptr %.anon8, align 8
   %add16 = add i64 %46, 1
   store i64 %add16, ptr %.anon8, align 8
diff --git a/test/test_suite/macros/macro_untyped_varargs_2.c3t b/test/test_suite/macros/macro_untyped_varargs_2.c3t
index 8d8060ba8..f2de6215c 100644
--- a/test/test_suite/macros/macro_untyped_varargs_2.c3t
+++ b/test/test_suite/macros/macro_untyped_varargs_2.c3t
@@ -67,10 +67,10 @@ entry:
   %taddr = alloca i32, align 4
   store i32 %0, ptr %taddr, align 4
   %1 = insertvalue %variant undef, ptr %taddr, 0
-  %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %2 = insertvalue %variant %1, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %2, ptr %3, align 16
-  %4 = call i64 @std_io.printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 1)
+  %4 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 1)
   ret i32 %0
 }
 
@@ -126,45 +126,45 @@ entry:
   %add4 = add i32 %6, %7
   store i32 %add4, ptr %j, align 4
   %8 = insertvalue %variant undef, ptr %.anon1, 0
-  %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %10 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %9, ptr %10, align 16
-  %11 = call i64 @std_io.printfn(ptr %retparam, ptr @.str.1, i64 2, ptr %varargslots, i64 1)
+  %11 = call i64 @std.io.printfn(ptr %retparam, ptr @.str.1, i64 2, ptr %varargslots, i64 1)
   %12 = insertvalue %variant undef, ptr %.anon, 0
-  %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %14 = getelementptr inbounds [1 x %variant], ptr %varargslots6, i64 0, i64 0
   store %variant %13, ptr %14, align 16
-  %15 = call i64 @std_io.printfn(ptr %retparam5, ptr @.str.2, i64 2, ptr %varargslots6, i64 1)
+  %15 = call i64 @std.io.printfn(ptr %retparam5, ptr @.str.2, i64 2, ptr %varargslots6, i64 1)
   %16 = insertvalue %variant undef, ptr %.anon2, 0
-  %17 = insertvalue %variant %16, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %17 = insertvalue %variant %16, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %18 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
   store %variant %17, ptr %18, align 16
-  %19 = call i64 @std_io.printfn(ptr %retparam7, ptr @.str.3, i64 2, ptr %varargslots8, i64 1)
+  %19 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.3, i64 2, ptr %varargslots8, i64 1)
   %20 = insertvalue %variant undef, ptr %.anon3, 0
-  %21 = insertvalue %variant %20, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %21 = insertvalue %variant %20, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %22 = getelementptr inbounds [1 x %variant], ptr %varargslots10, i64 0, i64 0
   store %variant %21, ptr %22, align 16
-  %23 = call i64 @std_io.printfn(ptr %retparam9, ptr @.str.4, i64 2, ptr %varargslots10, i64 1)
+  %23 = call i64 @std.io.printfn(ptr %retparam9, ptr @.str.4, i64 2, ptr %varargslots10, i64 1)
   store i32 0, ptr %x, align 4
   store ptr @.str.6, ptr %taddr, align 8
   %24 = insertvalue %variant undef, ptr %taddr, 0
-  %25 = insertvalue %variant %24, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
+  %25 = insertvalue %variant %24, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1
   %26 = getelementptr inbounds [1 x %variant], ptr %varargslots12, i64 0, i64 0
   store %variant %25, ptr %26, align 16
-  %27 = call i64 @std_io.printfn(ptr %retparam11, ptr @.str.5, i64 2, ptr %varargslots12, i64 1)
+  %27 = call i64 @std.io.printfn(ptr %retparam11, ptr @.str.5, i64 2, ptr %varargslots12, i64 1)
   store double 0.000000e+00, ptr %x13, align 8
   store ptr @.str.8, ptr %taddr16, align 8
   %28 = insertvalue %variant undef, ptr %taddr16, 0
-  %29 = insertvalue %variant %28, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1
+  %29 = insertvalue %variant %28, i64 ptrtoint (ptr @"$ct.p$a6$char" to i64), 1
   %30 = getelementptr inbounds [1 x %variant], ptr %varargslots15, i64 0, i64 0
   store %variant %29, ptr %30, align 16
-  %31 = call i64 @std_io.printfn(ptr %retparam14, ptr @.str.7, i64 2, ptr %varargslots15, i64 1)
+  %31 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.7, i64 2, ptr %varargslots15, i64 1)
   store i32 105, ptr %taddr19, align 4
   %32 = insertvalue %variant undef, ptr %taddr19, 0
-  %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %34 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0
   store %variant %33, ptr %34, align 16
-  %35 = call i64 @std_io.printfn(ptr %retparam17, ptr @.str.9, i64 2, ptr %varargslots18, i64 1)
+  %35 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.9, i64 2, ptr %varargslots18, i64 1)
   store i32 123, ptr %x20, align 4
   store i32 33, ptr %y, align 4
   %36 = load i32, ptr %x20, align 4
@@ -174,14 +174,14 @@ entry:
   %38 = load i32, ptr %a, align 4
   store i32 %38, ptr %y, align 4
   %39 = insertvalue %variant undef, ptr %x20, 0
-  %40 = insertvalue %variant %39, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %40 = insertvalue %variant %39, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %41 = getelementptr inbounds [2 x %variant], ptr %varargslots22, i64 0, i64 0
   store %variant %40, ptr %41, align 16
   %42 = insertvalue %variant undef, ptr %y, 0
-  %43 = insertvalue %variant %42, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %43 = insertvalue %variant %42, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %44 = getelementptr inbounds [2 x %variant], ptr %varargslots22, i64 0, i64 1
   store %variant %43, ptr %44, align 16
-  %45 = call i64 @std_io.printfn(ptr %retparam21, ptr @.str.10, i64 6, ptr %varargslots22, i64 2)
+  %45 = call i64 @std.io.printfn(ptr %retparam21, ptr @.str.10, i64 6, ptr %varargslots22, i64 2)
   %46 = load i32, ptr %x20, align 4
   store i32 %46, ptr %a23, align 4
   %47 = load i32, ptr %y, align 4
@@ -189,13 +189,13 @@ entry:
   %48 = load i32, ptr %a23, align 4
   store i32 %48, ptr %y, align 4
   %49 = insertvalue %variant undef, ptr %x20, 0
-  %50 = insertvalue %variant %49, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %50 = insertvalue %variant %49, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %51 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 0
   store %variant %50, ptr %51, align 16
   %52 = insertvalue %variant undef, ptr %y, 0
-  %53 = insertvalue %variant %52, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %53 = insertvalue %variant %52, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %54 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 1
   store %variant %53, ptr %54, align 16
-  %55 = call i64 @std_io.printfn(ptr %retparam24, ptr @.str.11, i64 6, ptr %varargslots25, i64 2)
+  %55 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.11, i64 6, ptr %varargslots25, i64 2)
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/macros/macro_vasplat.c3t b/test/test_suite/macros/macro_vasplat.c3t
index 20edc755c..458e7292a 100644
--- a/test/test_suite/macros/macro_vasplat.c3t
+++ b/test/test_suite/macros/macro_vasplat.c3t
@@ -153,14 +153,14 @@ loop.body:                                        ; preds = %loop.cond
   %4 = load i32, ptr %3, align 4
   store i32 %4, ptr %x, align 4
   %5 = insertvalue %variant undef, ptr %i, 0
-  %6 = insertvalue %variant %5, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %6 = insertvalue %variant %5, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %7 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %6, ptr %7, align 16
   %8 = insertvalue %variant undef, ptr %x, 0
-  %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %10 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %9, ptr %10, align 16
-  %11 = call i64 @std_io.printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 2)
+  %11 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 2)
   %12 = load i64, ptr %.anon, align 8
   %add = add i64 %12, 1
   store i64 %add, ptr %.anon, align 8
@@ -184,14 +184,14 @@ loop.body5:                                       ; preds = %loop.cond3
   %17 = load i32, ptr %16, align 4
   store i32 %17, ptr %x7, align 4
   %18 = insertvalue %variant undef, ptr %i6, 0
-  %19 = insertvalue %variant %18, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %19 = insertvalue %variant %18, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %20 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 0
   store %variant %19, ptr %20, align 16
   %21 = insertvalue %variant undef, ptr %x7, 0
-  %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %23 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 1
   store %variant %22, ptr %23, align 16
-  %24 = call i64 @std_io.printfn(ptr %retparam8, ptr @.str.2, i64 8, ptr %varargslots9, i64 2)
+  %24 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.2, i64 8, ptr %varargslots9, i64 2)
   %25 = load i64, ptr %.anon2, align 8
   %add10 = add i64 %25, 1
   store i64 %add10, ptr %.anon2, align 8
@@ -215,14 +215,14 @@ loop.body16:                                      ; preds = %loop.cond14
   %30 = load i32, ptr %29, align 4
   store i32 %30, ptr %x18, align 4
   %31 = insertvalue %variant undef, ptr %i17, 0
-  %32 = insertvalue %variant %31, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %32 = insertvalue %variant %31, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %33 = getelementptr inbounds [2 x %variant], ptr %varargslots20, i64 0, i64 0
   store %variant %32, ptr %33, align 16
   %34 = insertvalue %variant undef, ptr %x18, 0
-  %35 = insertvalue %variant %34, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %35 = insertvalue %variant %34, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %36 = getelementptr inbounds [2 x %variant], ptr %varargslots20, i64 0, i64 1
   store %variant %35, ptr %36, align 16
-  %37 = call i64 @std_io.printfn(ptr %retparam19, ptr @.str.4, i64 6, ptr %varargslots20, i64 2)
+  %37 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.4, i64 6, ptr %varargslots20, i64 2)
   %38 = load i64, ptr %.anon13, align 8
   %add21 = add i64 %38, 1
   store i64 %add21, ptr %.anon13, align 8
@@ -246,14 +246,14 @@ loop.body27:                                      ; preds = %loop.cond25
   %43 = load i32, ptr %42, align 4
   store i32 %43, ptr %x29, align 4
   %44 = insertvalue %variant undef, ptr %i28, 0
-  %45 = insertvalue %variant %44, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %45 = insertvalue %variant %44, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %46 = getelementptr inbounds [2 x %variant], ptr %varargslots31, i64 0, i64 0
   store %variant %45, ptr %46, align 16
   %47 = insertvalue %variant undef, ptr %x29, 0
-  %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %49 = getelementptr inbounds [2 x %variant], ptr %varargslots31, i64 0, i64 1
   store %variant %48, ptr %49, align 16
-  %50 = call i64 @std_io.printfn(ptr %retparam30, ptr @.str.6, i64 6, ptr %varargslots31, i64 2)
+  %50 = call i64 @std.io.printfn(ptr %retparam30, ptr @.str.6, i64 6, ptr %varargslots31, i64 2)
   %51 = load i64, ptr %.anon24, align 8
   %add32 = add i64 %51, 1
   store i64 %add32, ptr %.anon24, align 8
@@ -277,14 +277,14 @@ loop.body38:                                      ; preds = %loop.cond36
   %56 = load i32, ptr %55, align 4
   store i32 %56, ptr %x40, align 4
   %57 = insertvalue %variant undef, ptr %i39, 0
-  %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %59 = getelementptr inbounds [2 x %variant], ptr %varargslots42, i64 0, i64 0
   store %variant %58, ptr %59, align 16
   %60 = insertvalue %variant undef, ptr %x40, 0
-  %61 = insertvalue %variant %60, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %61 = insertvalue %variant %60, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %62 = getelementptr inbounds [2 x %variant], ptr %varargslots42, i64 0, i64 1
   store %variant %61, ptr %62, align 16
-  %63 = call i64 @std_io.printfn(ptr %retparam41, ptr @.str.8, i64 8, ptr %varargslots42, i64 2)
+  %63 = call i64 @std.io.printfn(ptr %retparam41, ptr @.str.8, i64 8, ptr %varargslots42, i64 2)
   %64 = load i64, ptr %.anon35, align 8
   %add43 = add i64 %64, 1
   store i64 %add43, ptr %.anon35, align 8
@@ -308,14 +308,14 @@ loop.body49:                                      ; preds = %loop.cond47
   %69 = load i32, ptr %68, align 4
   store i32 %69, ptr %x51, align 4
   %70 = insertvalue %variant undef, ptr %i50, 0
-  %71 = insertvalue %variant %70, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %71 = insertvalue %variant %70, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %72 = getelementptr inbounds [2 x %variant], ptr %varargslots53, i64 0, i64 0
   store %variant %71, ptr %72, align 16
   %73 = insertvalue %variant undef, ptr %x51, 0
-  %74 = insertvalue %variant %73, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %74 = insertvalue %variant %73, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %75 = getelementptr inbounds [2 x %variant], ptr %varargslots53, i64 0, i64 1
   store %variant %74, ptr %75, align 16
-  %76 = call i64 @std_io.printfn(ptr %retparam52, ptr @.str.10, i64 8, ptr %varargslots53, i64 2)
+  %76 = call i64 @std.io.printfn(ptr %retparam52, ptr @.str.10, i64 8, ptr %varargslots53, i64 2)
   %77 = load i64, ptr %.anon46, align 8
   %add54 = add i64 %77, 1
   store i64 %add54, ptr %.anon46, align 8
@@ -339,14 +339,14 @@ loop.body60:                                      ; preds = %loop.cond58
   %82 = load i32, ptr %81, align 4
   store i32 %82, ptr %x62, align 4
   %83 = insertvalue %variant undef, ptr %i61, 0
-  %84 = insertvalue %variant %83, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %84 = insertvalue %variant %83, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %85 = getelementptr inbounds [2 x %variant], ptr %varargslots64, i64 0, i64 0
   store %variant %84, ptr %85, align 16
   %86 = insertvalue %variant undef, ptr %x62, 0
-  %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %88 = getelementptr inbounds [2 x %variant], ptr %varargslots64, i64 0, i64 1
   store %variant %87, ptr %88, align 16
-  %89 = call i64 @std_io.printfn(ptr %retparam63, ptr @.str.12, i64 8, ptr %varargslots64, i64 2)
+  %89 = call i64 @std.io.printfn(ptr %retparam63, ptr @.str.12, i64 8, ptr %varargslots64, i64 2)
   %90 = load i64, ptr %.anon57, align 8
   %add65 = add i64 %90, 1
   store i64 %add65, ptr %.anon57, align 8
@@ -370,14 +370,14 @@ loop.body71:                                      ; preds = %loop.cond69
   %95 = load i32, ptr %94, align 4
   store i32 %95, ptr %x73, align 4
   %96 = insertvalue %variant undef, ptr %i72, 0
-  %97 = insertvalue %variant %96, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %97 = insertvalue %variant %96, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %98 = getelementptr inbounds [2 x %variant], ptr %varargslots75, i64 0, i64 0
   store %variant %97, ptr %98, align 16
   %99 = insertvalue %variant undef, ptr %x73, 0
-  %100 = insertvalue %variant %99, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %100 = insertvalue %variant %99, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %101 = getelementptr inbounds [2 x %variant], ptr %varargslots75, i64 0, i64 1
   store %variant %100, ptr %101, align 16
-  %102 = call i64 @std_io.printfn(ptr %retparam74, ptr @.str.14, i64 8, ptr %varargslots75, i64 2)
+  %102 = call i64 @std.io.printfn(ptr %retparam74, ptr @.str.14, i64 8, ptr %varargslots75, i64 2)
   %103 = load i64, ptr %.anon68, align 8
   %add76 = add i64 %103, 1
   store i64 %add76, ptr %.anon68, align 8
@@ -401,14 +401,14 @@ loop.body82:                                      ; preds = %loop.cond80
   %108 = load i32, ptr %107, align 4
   store i32 %108, ptr %x84, align 4
   %109 = insertvalue %variant undef, ptr %i83, 0
-  %110 = insertvalue %variant %109, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %110 = insertvalue %variant %109, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %111 = getelementptr inbounds [2 x %variant], ptr %varargslots86, i64 0, i64 0
   store %variant %110, ptr %111, align 16
   %112 = insertvalue %variant undef, ptr %x84, 0
-  %113 = insertvalue %variant %112, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %113 = insertvalue %variant %112, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %114 = getelementptr inbounds [2 x %variant], ptr %varargslots86, i64 0, i64 1
   store %variant %113, ptr %114, align 16
-  %115 = call i64 @std_io.printfn(ptr %retparam85, ptr @.str.16, i64 8, ptr %varargslots86, i64 2)
+  %115 = call i64 @std.io.printfn(ptr %retparam85, ptr @.str.16, i64 8, ptr %varargslots86, i64 2)
   %116 = load i64, ptr %.anon79, align 8
   %add87 = add i64 %116, 1
   store i64 %add87, ptr %.anon79, align 8
@@ -432,14 +432,14 @@ loop.body92:                                      ; preds = %loop.cond90
   %121 = load i32, ptr %120, align 4
   store i32 %121, ptr %x94, align 4
   %122 = insertvalue %variant undef, ptr %i93, 0
-  %123 = insertvalue %variant %122, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %123 = insertvalue %variant %122, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %124 = getelementptr inbounds [2 x %variant], ptr %varargslots96, i64 0, i64 0
   store %variant %123, ptr %124, align 16
   %125 = insertvalue %variant undef, ptr %x94, 0
-  %126 = insertvalue %variant %125, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %126 = insertvalue %variant %125, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %127 = getelementptr inbounds [2 x %variant], ptr %varargslots96, i64 0, i64 1
   store %variant %126, ptr %127, align 16
-  %128 = call i64 @std_io.printfn(ptr %retparam95, ptr @.str.18, i64 8, ptr %varargslots96, i64 2)
+  %128 = call i64 @std.io.printfn(ptr %retparam95, ptr @.str.18, i64 8, ptr %varargslots96, i64 2)
   %129 = load i64, ptr %.anon89, align 8
   %add97 = add i64 %129, 1
   store i64 %add97, ptr %.anon89, align 8
@@ -463,14 +463,14 @@ loop.body102:                                     ; preds = %loop.cond100
   %134 = load i32, ptr %133, align 4
   store i32 %134, ptr %x104, align 4
   %135 = insertvalue %variant undef, ptr %i103, 0
-  %136 = insertvalue %variant %135, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %136 = insertvalue %variant %135, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %137 = getelementptr inbounds [2 x %variant], ptr %varargslots106, i64 0, i64 0
   store %variant %136, ptr %137, align 16
   %138 = insertvalue %variant undef, ptr %x104, 0
-  %139 = insertvalue %variant %138, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %139 = insertvalue %variant %138, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %140 = getelementptr inbounds [2 x %variant], ptr %varargslots106, i64 0, i64 1
   store %variant %139, ptr %140, align 16
-  %141 = call i64 @std_io.printfn(ptr %retparam105, ptr @.str.20, i64 9, ptr %varargslots106, i64 2)
+  %141 = call i64 @std.io.printfn(ptr %retparam105, ptr @.str.20, i64 9, ptr %varargslots106, i64 2)
   %142 = load i64, ptr %.anon99, align 8
   %add107 = add i64 %142, 1
   store i64 %add107, ptr %.anon99, align 8
@@ -494,14 +494,14 @@ loop.body113:                                     ; preds = %loop.cond111
   %147 = load i32, ptr %146, align 4
   store i32 %147, ptr %x115, align 4
   %148 = insertvalue %variant undef, ptr %i114, 0
-  %149 = insertvalue %variant %148, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
+  %149 = insertvalue %variant %148, i64 ptrtoint (ptr @"$ct.ulong" to i64), 1
   %150 = getelementptr inbounds [2 x %variant], ptr %varargslots117, i64 0, i64 0
   store %variant %149, ptr %150, align 16
   %151 = insertvalue %variant undef, ptr %x115, 0
-  %152 = insertvalue %variant %151, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %152 = insertvalue %variant %151, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %153 = getelementptr inbounds [2 x %variant], ptr %varargslots117, i64 0, i64 1
   store %variant %152, ptr %153, align 16
-  %154 = call i64 @std_io.printfn(ptr %retparam116, ptr @.str.22, i64 6, ptr %varargslots117, i64 2)
+  %154 = call i64 @std.io.printfn(ptr %retparam116, ptr @.str.22, i64 6, ptr %varargslots117, i64 2)
   %155 = load i64, ptr %.anon110, align 8
   %add118 = add i64 %155, 1
   store i64 %add118, ptr %.anon110, align 8
diff --git a/test/test_suite/macros/macro_with_body.c3t b/test/test_suite/macros/macro_with_body.c3t
index 19ef40a9b..88bfeb71e 100644
--- a/test/test_suite/macros/macro_with_body.c3t
+++ b/test/test_suite/macros/macro_with_body.c3t
@@ -45,7 +45,7 @@ fn void main()
 
 /* #expect: withbody.ll
 
-define i32 @withbody.Foo_mutate(ptr %0) #0 {
+define i32 @withbody.Foo.mutate(ptr %0) #0 {
 entry:
   %1 = call i32 (ptr, ...) @printf(ptr @.str.2)
   %2 = getelementptr inbounds %Foo, ptr %0, i32 0, i32 0
@@ -72,7 +72,7 @@ entry:
   %0 = getelementptr inbounds %Foo, ptr %foo, i32 0, i32 0
   %1 = load i32, ptr %0, align 4
   store i32 %1, ptr %y, align 4
-  %2 = call i32 @withbody.Foo_mutate(ptr %foo)
+  %2 = call i32 @withbody.Foo.mutate(ptr %foo)
   store i32 %2, ptr %x, align 4
   %3 = load i32, ptr %y, align 4
   store i32 %3, ptr %dy, align 4
diff --git a/test/test_suite/macros/userland_bitcast.c3t b/test/test_suite/macros/userland_bitcast.c3t
index 22a26b3c9..0be9495b2 100644
--- a/test/test_suite/macros/userland_bitcast.c3t
+++ b/test/test_suite/macros/userland_bitcast.c3t
@@ -78,7 +78,7 @@ fn void main()
 
 %Foo = type { i16, i8, i8, i16, i16 }
 
-@"ct$userland_bitcast.Foo" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 5, [0 x i64] zeroinitializer }, align 8
+@"$ct.userland_bitcast.Foo" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 5, [0 x i64] zeroinitializer }, align 8
 @.str = private unnamed_addr constant [16 x i8] c"%f => %d => %f\0A\00", align 1
 @.str.1 = private unnamed_addr constant [18 x i8] c"%e => %llu => %e\0A\00", align 1
 
diff --git a/test/test_suite/methods/enum_distinct_err_methods.c3t b/test/test_suite/methods/enum_distinct_err_methods.c3t
index 239b4977d..81b5db541 100644
--- a/test/test_suite/methods/enum_distinct_err_methods.c3t
+++ b/test/test_suite/methods/enum_distinct_err_methods.c3t
@@ -43,18 +43,18 @@ fn int main()
 
 /* #expect: foo.ll
 
-define void @foo.Foo_hello(ptr %0) #0 {
+define void @foo.Foo.hello(ptr %0) #0 {
 entry:
   store ptr @.str, ptr %x, align 8
   ret void
 }
 
-define void @foo.Bar_hello(ptr %0) #0 {
+define void @foo.Bar.hello(ptr %0) #0 {
 entry:
   store ptr @.str.1, ptr %x, align 8
 }
 
-define void @foo.MyEnum_hello(ptr %0) #0 {
+define void @foo.MyEnum.hello(ptr %0) #0 {
 entry:
   store ptr @.str.2, ptr %x, align 8
 }
@@ -67,8 +67,8 @@ entry:
   store i64 0, ptr %f, align 8
   store i32 0, ptr %b, align 4
   store i32 0, ptr %a, align 4
-  call void @foo.Foo_hello(ptr %f)
-  call void @foo.Bar_hello(ptr %b)
-  call void @foo.MyEnum_hello(ptr %a)
+  call void @foo.Foo.hello(ptr %f)
+  call void @foo.Bar.hello(ptr %b)
+  call void @foo.MyEnum.hello(ptr %a)
   ret i32 0
 }
\ No newline at end of file
diff --git a/test/test_suite/methods/extension_method.c3t b/test/test_suite/methods/extension_method.c3t
index 44841a046..34b38f07f 100644
--- a/test/test_suite/methods/extension_method.c3t
+++ b/test/test_suite/methods/extension_method.c3t
@@ -33,8 +33,8 @@ define i32 @main() #0 {
 entry:
   %bar = alloca %Bar, align 4
   store i32 0, ptr %bar, align 4
-  call void @foo.Bar_test(ptr %bar)
+  call void @foo.Bar.test(ptr %bar)
   ret i32 0
 }
 
-declare void @foo.Bar_test(ptr)
+declare void @foo.Bar.test(ptr)
diff --git a/test/test_suite/methods/extension_method_in_other_modules.c3t b/test/test_suite/methods/extension_method_in_other_modules.c3t
index ec0c90ed5..abe98c5c1 100644
--- a/test/test_suite/methods/extension_method_in_other_modules.c3t
+++ b/test/test_suite/methods/extension_method_in_other_modules.c3t
@@ -20,14 +20,14 @@ fn void main()
 
 /* #expect: foob.ll
 
-define void @foob.Foo_test(ptr %0) #0 {
+define void @foob.Foo.test(ptr %0) #0 {
 entry:
   ret void
 }
 
 // #expect: baz.ll
 
-define void @foob.Foo_test2(ptr %0, i32 %1) #0 {
+define void @foob.Foo.test2(ptr %0, i32 %1) #0 {
 entry:
   ret void
 }
@@ -36,7 +36,7 @@ define void @baz.main() #0 {
 entry:
   %f = alloca %Foo, align 4
   store i32 0, ptr %f, align 4
-  call void @foob.Foo_test(ptr %f)
-  call void @foob.Foo_test2(ptr %f, i32 123)
+  call void @foob.Foo.test(ptr %f)
+  call void @foob.Foo.test2(ptr %f, i32 123)
   ret void
 }
diff --git a/test/test_suite/overloading/set_overload.c3t b/test/test_suite/overloading/set_overload.c3t
index 402b9f5ae..044edd099 100644
--- a/test/test_suite/overloading/set_overload.c3t
+++ b/test/test_suite/overloading/set_overload.c3t
@@ -18,7 +18,7 @@ define void @test.main() #0 {
 entry:
   %map = alloca %HashMap, align 8
   call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 40, i1 false)
-  %0 = call i8 @"std_collections_map$$sa$char.int.HashMap_set"(ptr %map, ptr @.str, i64 5, i32 4)
-  %1 = call i8 @"std_collections_map$$sa$char.int.HashMap_set"(ptr %map, ptr @.str.1, i64 3, i32 5)
+  %0 = call i8 @"std.collections.map$sa$char$int$.HashMap.set"(ptr %map, ptr @.str, i64 5, i32 4)
+  %1 = call i8 @"std.collections.map$sa$char$int$.HashMap.set"(ptr %map, ptr @.str.1, i64 3, i32 5)
   ret void
 }
\ No newline at end of file
diff --git a/test/test_suite/pointers/subarray_variant_to_ptr.c3t b/test/test_suite/pointers/subarray_variant_to_ptr.c3t
index a7e0f7238..dfc909ae7 100644
--- a/test/test_suite/pointers/subarray_variant_to_ptr.c3t
+++ b/test/test_suite/pointers/subarray_variant_to_ptr.c3t
@@ -29,7 +29,7 @@ fn void main()
 %variant = type { ptr, i64 }
 %"int[]" = type { ptr, i64 }
 
-@"ct$int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
 
 define void @foo.test1(i64 %0, ptr %1) #0 {
 entry:
@@ -73,7 +73,7 @@ entry:
   store i32 293483, ptr %y, align 4
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %w, ptr align 4 @.__const, i32 8, i1 false)
   %0 = insertvalue %variant undef, ptr %x, 0
-  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   store %variant %1, ptr %taddr, align 8
   %2 = getelementptr inbounds { i64, ptr }, ptr %taddr, i32 0, i32 0
   %lo = load i64, ptr %2, align 8
diff --git a/test/test_suite/safe/deref.c3t b/test/test_suite/safe/deref.c3t
index 3f92c6fd8..0fc9e33a0 100644
--- a/test/test_suite/safe/deref.c3t
+++ b/test/test_suite/safe/deref.c3t
@@ -20,7 +20,7 @@ entry:
   br i1 %checknull, label %panic, label %checkok
 
 panic:                                            ; preds = %entry
-  %1 = load ptr, ptr @std_core_builtin.panic, align 8
+  %1 = load ptr, ptr @std.core.builtin.panic, align 8
   call void %1(ptr @.panic_msg, i64 27, ptr @.file, i64 8, ptr @.func, i64 4, i32 6)
   br label %checkok
 
diff --git a/test/test_suite/slices/slice_to_slice_assign.c3t b/test/test_suite/slices/slice_to_slice_assign.c3t
index d985dc886..e94219f32 100644
--- a/test/test_suite/slices/slice_to_slice_assign.c3t
+++ b/test/test_suite/slices/slice_to_slice_assign.c3t
@@ -59,14 +59,14 @@ entry:
   %10 = mul i64 %9, 4
   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %6, ptr align 4 %7, i64 %10, i1 false)
   %11 = insertvalue %variant undef, ptr %y, 0
-  %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$a6$int" to i64), 1
+  %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"$ct.a6$int" to i64), 1
   %13 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %12, ptr %13, align 16
   %14 = insertvalue %variant undef, ptr %z, 0
-  %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$a7$int" to i64), 1
+  %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"$ct.a7$int" to i64), 1
   %16 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %15, ptr %16, align 16
-  %17 = call i64 @std_io.printfn(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2)
+  %17 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2)
   %18 = getelementptr inbounds [7 x i32], ptr %z, i64 0, i64 5
   %19 = insertvalue %"int[]" undef, ptr %18, 0
   %20 = insertvalue %"int[]" %19, i64 2, 1
@@ -81,14 +81,14 @@ entry:
   %28 = mul i64 %27, 4
   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %24, ptr align 4 %25, i64 %28, i1 false)
   %29 = insertvalue %variant undef, ptr %y, 0
-  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$a6$int" to i64), 1
+  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.a6$int" to i64), 1
   %31 = getelementptr inbounds [2 x %variant], ptr %varargslots3, i64 0, i64 0
   store %variant %30, ptr %31, align 16
   %32 = insertvalue %variant undef, ptr %z, 0
-  %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"ct$a7$int" to i64), 1
+  %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"$ct.a7$int" to i64), 1
   %34 = getelementptr inbounds [2 x %variant], ptr %varargslots3, i64 0, i64 1
   store %variant %33, ptr %34, align 16
-  %35 = call i64 @std_io.printfn(ptr %retparam2, ptr @.str.1, i64 5, ptr %varargslots3, i64 2)
+  %35 = call i64 @std.io.printfn(ptr %retparam2, ptr @.str.1, i64 5, ptr %varargslots3, i64 2)
   %36 = getelementptr inbounds [1 x %"int[]"], ptr %literal, i64 0, i64 0
   %37 = getelementptr inbounds [1 x i32], ptr %literal4, i64 0, i64 0
   store i32 1, ptr %37, align 4
@@ -108,10 +108,10 @@ entry:
   %47 = insertvalue %"int[][]" %46, i64 1, 1
   store %"int[][]" %47, ptr %b, align 8
   %48 = insertvalue %variant undef, ptr %a, 0
-  %49 = insertvalue %variant %48, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1
+  %49 = insertvalue %variant %48, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1
   %50 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
   store %variant %49, ptr %50, align 16
-  %51 = call i64 @std_io.printfn(ptr %retparam7, ptr @.str.2, i64 2, ptr %varargslots8, i64 1)
+  %51 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.2, i64 2, ptr %varargslots8, i64 1)
   %52 = load %"int[][]", ptr %b, align 8
   %53 = extractvalue %"int[][]" %52, 0
   %ptroffset = getelementptr inbounds %"int[]", ptr %53, i64 0
@@ -130,10 +130,10 @@ entry:
   %64 = mul i64 %63, 16
   call void @llvm.memcpy.p0.p0.i64(ptr align 8 %60, ptr align 8 %61, i64 %64, i1 false)
   %65 = insertvalue %variant undef, ptr %a, 0
-  %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1
+  %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1
   %67 = getelementptr inbounds [1 x %variant], ptr %varargslots12, i64 0, i64 0
   store %variant %66, ptr %67, align 16
-  %68 = call i64 @std_io.printfn(ptr %retparam11, ptr @.str.3, i64 2, ptr %varargslots12, i64 1)
+  %68 = call i64 @std.io.printfn(ptr %retparam11, ptr @.str.3, i64 2, ptr %varargslots12, i64 1)
   %69 = getelementptr inbounds [6 x i32], ptr %y, i64 0, i64 2
   %70 = insertvalue %"int[]" undef, ptr %69, 0
   %71 = insertvalue %"int[]" %70, i64 3, 1
@@ -142,9 +142,9 @@ entry:
   %ptroffset13 = getelementptr inbounds %"int[]", ptr %73, i64 0
   store %"int[]" %71, ptr %ptroffset13, align 8
   %74 = insertvalue %variant undef, ptr %a, 0
-  %75 = insertvalue %variant %74, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1
+  %75 = insertvalue %variant %74, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1
   %76 = getelementptr inbounds [1 x %variant], ptr %varargslots15, i64 0, i64 0
   store %variant %75, ptr %76, align 16
-  %77 = call i64 @std_io.printfn(ptr %retparam14, ptr @.str.4, i64 2, ptr %varargslots15, i64 1)
+  %77 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.4, i64 2, ptr %varargslots15, i64 1)
   ret void
 }
diff --git a/test/test_suite/slices/slice_to_slice_vector_assign.c3t b/test/test_suite/slices/slice_to_slice_vector_assign.c3t
index 6b165068c..36aa5412e 100644
--- a/test/test_suite/slices/slice_to_slice_vector_assign.c3t
+++ b/test/test_suite/slices/slice_to_slice_vector_assign.c3t
@@ -60,14 +60,14 @@ entry:
   %10 = mul i64 %9, 4
   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %6, ptr align 4 %7, i64 %10, i1 false)
   %11 = insertvalue %variant undef, ptr %y, 0
-  %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$v6$int" to i64), 1
+  %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"$ct.v6$int" to i64), 1
   %13 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %12, ptr %13, align 16
   %14 = insertvalue %variant undef, ptr %z, 0
-  %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$v7$int" to i64), 1
+  %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"$ct.v7$int" to i64), 1
   %16 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %15, ptr %16, align 16
-  %17 = call i64 @std_io.printfn(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2)
+  %17 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2)
   %18 = getelementptr inbounds <7 x i32>, ptr %z, i64 0, i64 5
   %19 = insertvalue %"int[]" undef, ptr %18, 0
   %20 = insertvalue %"int[]" %19, i64 2, 1
@@ -82,14 +82,14 @@ entry:
   %28 = mul i64 %27, 4
   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %24, ptr align 4 %25, i64 %28, i1 false)
   %29 = insertvalue %variant undef, ptr %y, 0
-  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$v6$int" to i64), 1
+  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.v6$int" to i64), 1
   %31 = getelementptr inbounds [2 x %variant], ptr %varargslots3, i64 0, i64 0
   store %variant %30, ptr %31, align 16
   %32 = insertvalue %variant undef, ptr %z, 0
-  %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"ct$v7$int" to i64), 1
+  %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"$ct.v7$int" to i64), 1
   %34 = getelementptr inbounds [2 x %variant], ptr %varargslots3, i64 0, i64 1
   store %variant %33, ptr %34, align 16
-  %35 = call i64 @std_io.printfn(ptr %retparam2, ptr @.str.1, i64 5, ptr %varargslots3, i64 2)
+  %35 = call i64 @std.io.printfn(ptr %retparam2, ptr @.str.1, i64 5, ptr %varargslots3, i64 2)
   %36 = getelementptr inbounds [1 x %"int[]"], ptr %literal, i64 0, i64 0
   %37 = getelementptr inbounds [1 x i32], ptr %literal4, i64 0, i64 0
   store i32 1, ptr %37, align 4
@@ -109,10 +109,10 @@ entry:
   %47 = insertvalue %"int[][]" %46, i64 1, 1
   store %"int[][]" %47, ptr %b, align 8
   %48 = insertvalue %variant undef, ptr %a, 0
-  %49 = insertvalue %variant %48, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1
+  %49 = insertvalue %variant %48, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1
   %50 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
   store %variant %49, ptr %50, align 16
-  %51 = call i64 @std_io.printfn(ptr %retparam7, ptr @.str.2, i64 2, ptr %varargslots8, i64 1)
+  %51 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.2, i64 2, ptr %varargslots8, i64 1)
   %52 = load %"int[][]", ptr %b, align 8
   %53 = extractvalue %"int[][]" %52, 0
   %ptroffset = getelementptr inbounds %"int[]", ptr %53, i64 0
@@ -131,10 +131,10 @@ entry:
   %64 = mul i64 %63, 16
   call void @llvm.memcpy.p0.p0.i64(ptr align 8 %60, ptr align 8 %61, i64 %64, i1 false)
   %65 = insertvalue %variant undef, ptr %a, 0
-  %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1
+  %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1
   %67 = getelementptr inbounds [1 x %variant], ptr %varargslots12, i64 0, i64 0
   store %variant %66, ptr %67, align 16
-  %68 = call i64 @std_io.printfn(ptr %retparam11, ptr @.str.3, i64 2, ptr %varargslots12, i64 1)
+  %68 = call i64 @std.io.printfn(ptr %retparam11, ptr @.str.3, i64 2, ptr %varargslots12, i64 1)
   %69 = getelementptr inbounds <6 x i32>, ptr %y, i64 0, i64 2
   %70 = insertvalue %"int[]" undef, ptr %69, 0
   %71 = insertvalue %"int[]" %70, i64 3, 1
@@ -143,9 +143,9 @@ entry:
   %ptroffset13 = getelementptr inbounds %"int[]", ptr %73, i64 0
   store %"int[]" %71, ptr %ptroffset13, align 8
   %74 = insertvalue %variant undef, ptr %a, 0
-  %75 = insertvalue %variant %74, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1
+  %75 = insertvalue %variant %74, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1
   %76 = getelementptr inbounds [1 x %variant], ptr %varargslots15, i64 0, i64 0
   store %variant %75, ptr %76, align 16
-  %77 = call i64 @std_io.printfn(ptr %retparam14, ptr @.str.4, i64 2, ptr %varargslots15, i64 1)
+  %77 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.4, i64 2, ptr %varargslots15, i64 1)
   ret void
 }
diff --git a/test/test_suite/statements/custom_foreach_with_ref.c3t b/test/test_suite/statements/custom_foreach_with_ref.c3t
index f29445692..bd2a60f26 100644
--- a/test/test_suite/statements/custom_foreach_with_ref.c3t
+++ b/test/test_suite/statements/custom_foreach_with_ref.c3t
@@ -85,7 +85,7 @@ fn void main()
 
 %Foo = type { [3 x i32] }
 
-@"ct$foo.Foo" = linkonce constant %.introspect { i8 10, i64 12, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
+@"$ct.foo.Foo" = linkonce constant %.introspect { i8 10, i64 12, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
 @.str = private unnamed_addr constant [11 x i8] c"getFields\0A\00", align 1
 @.str.1 = private unnamed_addr constant [11 x i8] c"Call made\0A\00", align 1
 @.__const = private unnamed_addr constant %Foo { [3 x i32] [i32 1, i32 5, i32 7] }, align 4
diff --git a/test/test_suite/statements/foreach_custom_macro.c3t b/test/test_suite/statements/foreach_custom_macro.c3t
index 6a9a19b5d..fe57d3a2f 100644
--- a/test/test_suite/statements/foreach_custom_macro.c3t
+++ b/test/test_suite/statements/foreach_custom_macro.c3t
@@ -35,7 +35,7 @@ extern fn int printf(char *fmt, ...);
 %Foo = type { %"int[]" }
 %"int[]" = type { ptr, i64 }
 
-@"ct$foo.Foo" = linkonce constant %.introspect { i8 10, i64 16, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
+@"$ct.foo.Foo" = linkonce constant %.introspect { i8 10, i64 16, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
 @.__const = private unnamed_addr constant [3 x i32] [i32 1, i32 3, i32 10], align 4
 @.str = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
 
diff --git a/test/test_suite/statements/foreach_more_implementations.c3t b/test/test_suite/statements/foreach_more_implementations.c3t
index ad584d9c2..db03a546f 100644
--- a/test/test_suite/statements/foreach_more_implementations.c3t
+++ b/test/test_suite/statements/foreach_more_implementations.c3t
@@ -90,10 +90,10 @@ loop.body:                                        ; preds = %loop.cond
   store ptr %ptroffset, ptr %ref, align 8
   %11 = load ptr, ptr %ref, align 8
   %12 = insertvalue %variant undef, ptr %11, 0
-  %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %14 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %13, ptr %14, align 16
-  %15 = call i64 @std_io.printf(ptr %retparam, ptr @.str, i64 3, ptr %varargslots, i64 1)
+  %15 = call i64 @std.io.printf(ptr %retparam, ptr @.str, i64 3, ptr %varargslots, i64 1)
   %16 = load ptr, ptr %ref, align 8
   %17 = load i32, ptr %16, align 4
   %add = add i32 %17, 2
@@ -129,10 +129,10 @@ loop.body9:                                       ; preds = %loop.cond7
   %28 = load i32, ptr %ptroffset12, align 4
   store i32 %28, ptr %i, align 4
   %29 = insertvalue %variant undef, ptr %i, 0
-  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %31 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0
   store %variant %30, ptr %31, align 16
-  %32 = call i64 @std_io.printf(ptr %retparam13, ptr @.str.1, i64 3, ptr %varargslots14, i64 1)
+  %32 = call i64 @std.io.printf(ptr %retparam13, ptr @.str.1, i64 3, ptr %varargslots14, i64 1)
   %33 = load i64, ptr %.anon6, align 8
   %add15 = add i64 %33, 1
   store i64 %add15, ptr %.anon6, align 8
diff --git a/test/test_suite/statements/various_switching.c3t b/test/test_suite/statements/various_switching.c3t
index cfd510c9c..3bac521d4 100644
--- a/test/test_suite/statements/various_switching.c3t
+++ b/test/test_suite/statements/various_switching.c3t
@@ -82,7 +82,7 @@ entry:
   %switch17 = alloca i32, align 4
   %switch27 = alloca i8, align 1
   store i64 ptrtoint (ptr @"mymodule.ByeErr$BAR" to i64), ptr %x.f, align 8
-  store i64 ptrtoint (ptr @"ct$int" to i64), ptr %z, align 8
+  store i64 ptrtoint (ptr @"$ct.int" to i64), ptr %z, align 8
   br label %testblock
 
 testblock:                                        ; preds = %entry
@@ -142,7 +142,7 @@ if.exit:                                          ; preds = %switch.exit, %end_b
 
 switch.entry5:                                    ; preds = %if.exit
   %4 = load i64, ptr %switch4, align 8
-  %eq6 = icmp eq i64 ptrtoint (ptr @"ct$int" to i64), %4
+  %eq6 = icmp eq i64 ptrtoint (ptr @"$ct.int" to i64), %4
   br i1 %eq6, label %switch.case7, label %next_if8
 
 switch.case7:                                     ; preds = %switch.entry5
@@ -150,14 +150,14 @@ switch.case7:                                     ; preds = %switch.entry5
   br label %switch.exit16
 
 next_if8:                                         ; preds = %switch.entry5
-  %eq9 = icmp eq i64 ptrtoint (ptr @"ct$bool" to i64), %4
+  %eq9 = icmp eq i64 ptrtoint (ptr @"$ct.bool" to i64), %4
   br i1 %eq9, label %switch.case10, label %next_if11
 
 switch.case10:                                    ; preds = %next_if8
   br label %switch.case13
 
 next_if11:                                        ; preds = %next_if8
-  %eq12 = icmp eq i64 ptrtoint (ptr @"ct$double" to i64), %4
+  %eq12 = icmp eq i64 ptrtoint (ptr @"$ct.double" to i64), %4
   br i1 %eq12, label %switch.case13, label %next_if14
 
 switch.case13:                                    ; preds = %next_if11, %switch.case10
diff --git a/test/test_suite/stdlib/map.c3t b/test/test_suite/stdlib/map.c3t
index 068b76903..ec760636d 100644
--- a/test/test_suite/stdlib/map.c3t
+++ b/test/test_suite/stdlib/map.c3t
@@ -59,41 +59,41 @@ fn void main()
 
 define internal void @.static_initialize.0() {
 entry:
-  %0 = load i64, ptr getelementptr inbounds (%"Entry*[]", ptr @std_io.tostring_functions, i32 0, i32 1), align 8
+  %0 = load i64, ptr getelementptr inbounds (%"Entry*[]", ptr @std.io.tostring_functions, i32 0, i32 1), align 8
   %not = icmp eq i64 %0, 0
   br i1 %not, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %entry
-  %1 = load ptr, ptr @std_core_mem.thread_allocator, align 8
-  call void @"std_collections_map$$typeid.p$std_io$ToStringFunction.HashMap_init"(ptr @std_io.tostring_functions, i32 64, float 7.500000e-01, ptr %1)
+  %1 = load ptr, ptr @std.core.mem.thread_allocator, align 8
+  call void @"std.collections.map$typeid$p$std.io$ToStringFunction$.HashMap.init"(ptr @std.io.tostring_functions, i32 64, float 7.500000e-01, ptr %1)
   br label %if.exit
 
 if.exit:                                          ; preds = %if.then, %entry
-  %2 = call i8 @"std_collections_map$$typeid.p$std_io$ToStringFunction.HashMap_set"(ptr @std_io.tostring_functions, i64 ptrtoint (ptr @"ct$test.Foo" to i64), ptr @test.Foo_to_string)
+  %2 = call i8 @"std.collections.map$typeid$p$std.io$ToStringFunction$.HashMap.set"(ptr @std.io.tostring_functions, i64 ptrtoint (ptr @"$ct.test.Foo" to i64), ptr @test.Foo.to_string)
   ret void
 }
 
-define { ptr, i64 } @test.Foo_to_string(ptr %0, ptr %1) #0 {
+define { ptr, i64 } @test.Foo.to_string(ptr %0, ptr %1) #0 {
 entry:
   %s = alloca ptr, align 8
   %retparam = alloca i64, align 8
   %varargslots = alloca [2 x %variant], align 16
   %result = alloca %"char[]", align 8
-  %2 = call ptr @std_core_string.new_with_capacity(i64 128, ptr %1)
+  %2 = call ptr @std.core.string.new_with_capacity(i64 128, ptr %1)
   store ptr %2, ptr %s, align 8
   %3 = getelementptr inbounds %Foo, ptr %0, i32 0, i32 0
   %4 = insertvalue %variant undef, ptr %3, 0
-  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %6 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %5, ptr %6, align 16
   %7 = getelementptr inbounds %Foo, ptr %0, i32 0, i32 1
   %8 = insertvalue %variant undef, ptr %7, 0
-  %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$p$void" to i64), 1
+  %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"$ct.p$void" to i64), 1
   %10 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
   store %variant %9, ptr %10, align 16
-  %11 = call i64 @std_core_string.VarString_printf(ptr %retparam, ptr %s, ptr @.str.12, i64 8, ptr %varargslots, i64 2)
+  %11 = call i64 @std.core.string.VarString.printf(ptr %retparam, ptr %s, ptr @.str.12, i64 8, ptr %varargslots, i64 2)
   %12 = load ptr, ptr %s, align 8
-  %13 = call { ptr, i64 } @std_core_string.VarString_str(ptr %12)
+  %13 = call { ptr, i64 } @std.core.string.VarString.str(ptr %12)
   store { ptr, i64 } %13, ptr %result, align 8
   %14 = load { ptr, i64 }, ptr %result, align 8
   ret { ptr, i64 } %14
@@ -146,14 +146,14 @@ entry:
   %varargslots53 = alloca [1 x %variant], align 16
   %result54 = alloca %"int[]", align 8
   call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 40, i1 false)
-  %0 = load ptr, ptr @std_core_mem.thread_allocator, align 8
-  call void @"std_collections_map$$int.test.Foo.HashMap_init"(ptr %map, i32 16, float 7.500000e-01, ptr %0)
+  %0 = load ptr, ptr @std.core.mem.thread_allocator, align 8
+  call void @"std.collections.map$int$test.Foo$.HashMap.init"(ptr %map, i32 16, float 7.500000e-01, ptr %0)
   %1 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2
   %2 = insertvalue %variant undef, ptr %1, 0
-  %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   %4 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %3, ptr %4, align 16
-  %5 = call i64 @std_io.printfn(ptr %retparam, ptr @.str, i64 12, ptr %varargslots, i64 1)
+  %5 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 12, ptr %varargslots, i64 1)
   %6 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 0
   store i32 1, ptr %6, align 8
   %7 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 1
@@ -162,13 +162,13 @@ entry:
   %lo = load i64, ptr %8, align 8
   %9 = getelementptr inbounds { i64, ptr }, ptr %literal, i32 0, i32 1
   %hi = load ptr, ptr %9, align 8
-  %10 = call i8 @"std_collections_map$$int.test.Foo.HashMap_set"(ptr %map, i32 1, i64 %lo, ptr %hi)
+  %10 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i64 %lo, ptr %hi)
   %11 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2
   %12 = insertvalue %variant undef, ptr %11, 0
-  %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   %14 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0
   store %variant %13, ptr %14, align 16
-  %15 = call i64 @std_io.printfn(ptr %retparam1, ptr @.str.1, i64 12, ptr %varargslots2, i64 1)
+  %15 = call i64 @std.io.printfn(ptr %retparam1, ptr @.str.1, i64 12, ptr %varargslots2, i64 1)
   %16 = getelementptr inbounds %Foo, ptr %literal3, i32 0, i32 0
   store i32 2, ptr %16, align 8
   %17 = getelementptr inbounds %Foo, ptr %literal3, i32 0, i32 1
@@ -177,14 +177,14 @@ entry:
   %lo4 = load i64, ptr %18, align 8
   %19 = getelementptr inbounds { i64, ptr }, ptr %literal3, i32 0, i32 1
   %hi5 = load ptr, ptr %19, align 8
-  %20 = call i8 @"std_collections_map$$int.test.Foo.HashMap_set"(ptr %map, i32 1, i64 %lo4, ptr %hi5)
+  %20 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i64 %lo4, ptr %hi5)
   %21 = getelementptr inbounds %HashMap.0, ptr %map, i32 0, i32 2
   %22 = insertvalue %variant undef, ptr %21, 0
-  %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$uint" to i64), 1
+  %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
   %24 = getelementptr inbounds [1 x %variant], ptr %varargslots7, i64 0, i64 0
   store %variant %23, ptr %24, align 16
-  %25 = call i64 @std_io.printfn(ptr %retparam6, ptr @.str.2, i64 12, ptr %varargslots7, i64 1)
-  %26 = call i64 @"std_collections_map$$int.test.Foo.HashMap_get"(ptr %retparam10, ptr %map, i32 1)
+  %25 = call i64 @std.io.printfn(ptr %retparam6, ptr @.str.2, i64 12, ptr %varargslots7, i64 1)
+  %26 = call i64 @"std.collections.map$int$test.Foo$.HashMap.get"(ptr %retparam10, ptr %map, i32 1)
   %not_err = icmp eq i64 %26, 0
   %27 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
   br i1 %27, label %after_check, label %after_check12
@@ -192,29 +192,29 @@ entry:
 after_check:                                      ; preds = %entry
   %28 = getelementptr inbounds %Foo, ptr %retparam10, i32 0, i32 0
   %29 = insertvalue %variant undef, ptr %28, 0
-  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   %31 = getelementptr inbounds [1 x %variant], ptr %varargslots9, i64 0, i64 0
   store %variant %30, ptr %31, align 16
-  %32 = call i64 @std_io.printfn(ptr %retparam8, ptr @.str.3, i64 7, ptr %varargslots9, i64 1)
+  %32 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.3, i64 7, ptr %varargslots9, i64 1)
   %not_err11 = icmp eq i64 %32, 0
   %33 = call i1 @llvm.expect.i1(i1 %not_err11, i1 true)
   br i1 %33, label %after_check12, label %after_check12
 
 after_check12:                                    ; preds = %entry, %after_check, %after_check
-  %34 = call i8 @"std_collections_map$$int.test.Foo.HashMap_has_key"(ptr %map, i32 1)
+  %34 = call i8 @"std.collections.map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 1)
   store i8 %34, ptr %taddr, align 1
   %35 = insertvalue %variant undef, ptr %taddr, 0
-  %36 = insertvalue %variant %35, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %36 = insertvalue %variant %35, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %37 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0
   store %variant %36, ptr %37, align 16
-  %38 = call i64 @std_io.printfn(ptr %retparam13, ptr @.str.4, i64 9, ptr %varargslots14, i64 1)
-  %39 = call i8 @"std_collections_map$$int.test.Foo.HashMap_has_key"(ptr %map, i32 2)
+  %38 = call i64 @std.io.printfn(ptr %retparam13, ptr @.str.4, i64 9, ptr %varargslots14, i64 1)
+  %39 = call i8 @"std.collections.map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 2)
   store i8 %39, ptr %taddr19, align 1
   %40 = insertvalue %variant undef, ptr %taddr19, 0
-  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %42 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0
   store %variant %41, ptr %42, align 16
-  %43 = call i64 @std_io.printfn(ptr %retparam17, ptr @.str.5, i64 9, ptr %varargslots18, i64 1)
+  %43 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.5, i64 9, ptr %varargslots18, i64 1)
   %44 = getelementptr inbounds %Foo, ptr %literal22, i32 0, i32 0
   store i32 4, ptr %44, align 8
   %45 = getelementptr inbounds %Foo, ptr %literal22, i32 0, i32 1
@@ -223,57 +223,57 @@ after_check12:                                    ; preds = %entry, %after_check
   %lo23 = load i64, ptr %46, align 8
   %47 = getelementptr inbounds { i64, ptr }, ptr %literal22, i32 0, i32 1
   %hi24 = load ptr, ptr %47, align 8
-  %48 = call i8 @"std_collections_map$$int.test.Foo.HashMap_set"(ptr %map, i32 7, i64 %lo23, ptr %hi24)
-  %49 = load ptr, ptr @std_core_mem.thread_allocator, align 8
-  %50 = call { ptr, i64 } @"std_collections_map$$int.test.Foo.HashMap_value_list"(ptr %map, ptr %49)
+  %48 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i64 %lo23, ptr %hi24)
+  %49 = load ptr, ptr @std.core.mem.thread_allocator, align 8
+  %50 = call { ptr, i64 } @"std.collections.map$int$test.Foo$.HashMap.value_list"(ptr %map, ptr %49)
   store { ptr, i64 } %50, ptr %result, align 8
   %51 = insertvalue %variant undef, ptr %result, 0
-  %52 = insertvalue %variant %51, i64 ptrtoint (ptr @"ct$sa$test.Foo" to i64), 1
+  %52 = insertvalue %variant %51, i64 ptrtoint (ptr @"$ct.sa$test.Foo" to i64), 1
   %53 = getelementptr inbounds [1 x %variant], ptr %varargslots26, i64 0, i64 0
   store %variant %52, ptr %53, align 16
-  %54 = call i64 @std_io.printfn(ptr %retparam25, ptr @.str.6, i64 10, ptr %varargslots26, i64 1)
+  %54 = call i64 @std.io.printfn(ptr %retparam25, ptr @.str.6, i64 10, ptr %varargslots26, i64 1)
   call void @llvm.memset.p0.i64(ptr align 8 %map2, i8 0, i64 40, i1 false)
-  %55 = load ptr, ptr @std_core_mem.thread_allocator, align 8
-  call void @"std_collections_map$$int.double.HashMap_init"(ptr %map2, i32 16, float 7.500000e-01, ptr %55)
-  %56 = call i8 @"std_collections_map$$int.double.HashMap_set"(ptr %map2, i32 4, double 1.300000e+00)
-  %57 = call i8 @"std_collections_map$$int.double.HashMap_has_value"(ptr %map2, double 1.300000e+00)
+  %55 = load ptr, ptr @std.core.mem.thread_allocator, align 8
+  call void @"std.collections.map$int$double$.HashMap.init"(ptr %map2, i32 16, float 7.500000e-01, ptr %55)
+  %56 = call i8 @"std.collections.map$int$double$.HashMap.set"(ptr %map2, i32 4, double 1.300000e+00)
+  %57 = call i8 @"std.collections.map$int$double$.HashMap.has_value"(ptr %map2, double 1.300000e+00)
   store i8 %57, ptr %taddr31, align 1
   %58 = insertvalue %variant undef, ptr %taddr31, 0
-  %59 = insertvalue %variant %58, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %59 = insertvalue %variant %58, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %60 = getelementptr inbounds [1 x %variant], ptr %varargslots30, i64 0, i64 0
   store %variant %59, ptr %60, align 16
-  %61 = call i64 @std_io.printfn(ptr %retparam29, ptr @.str.7, i64 12, ptr %varargslots30, i64 1)
-  %62 = call i8 @"std_collections_map$$int.double.HashMap_has_value"(ptr %map2, double 1.200000e+00)
+  %61 = call i64 @std.io.printfn(ptr %retparam29, ptr @.str.7, i64 12, ptr %varargslots30, i64 1)
+  %62 = call i8 @"std.collections.map$int$double$.HashMap.has_value"(ptr %map2, double 1.200000e+00)
   store i8 %62, ptr %taddr36, align 1
   %63 = insertvalue %variant undef, ptr %taddr36, 0
-  %64 = insertvalue %variant %63, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %64 = insertvalue %variant %63, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   %65 = getelementptr inbounds [1 x %variant], ptr %varargslots35, i64 0, i64 0
   store %variant %64, ptr %65, align 16
-  %66 = call i64 @std_io.printfn(ptr %retparam34, ptr @.str.8, i64 12, ptr %varargslots35, i64 1)
-  %67 = call i8 @"std_collections_map$$int.double.HashMap_set"(ptr %map2, i32 100, double 3.400000e+00)
-  %68 = load ptr, ptr @std_core_mem.thread_allocator, align 8
-  %69 = call { ptr, i64 } @"std_collections_map$$int.double.HashMap_key_list"(ptr %map2, ptr %68)
+  %66 = call i64 @std.io.printfn(ptr %retparam34, ptr @.str.8, i64 12, ptr %varargslots35, i64 1)
+  %67 = call i8 @"std.collections.map$int$double$.HashMap.set"(ptr %map2, i32 100, double 3.400000e+00)
+  %68 = load ptr, ptr @std.core.mem.thread_allocator, align 8
+  %69 = call { ptr, i64 } @"std.collections.map$int$double$.HashMap.key_list"(ptr %map2, ptr %68)
   store { ptr, i64 } %69, ptr %result41, align 8
   %70 = insertvalue %variant undef, ptr %result41, 0
-  %71 = insertvalue %variant %70, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1
+  %71 = insertvalue %variant %70, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
   %72 = getelementptr inbounds [1 x %variant], ptr %varargslots40, i64 0, i64 0
   store %variant %71, ptr %72, align 16
-  %73 = call i64 @std_io.printfn(ptr %retparam39, ptr @.str.9, i64 2, ptr %varargslots40, i64 1)
-  %74 = load ptr, ptr @std_core_mem.thread_allocator, align 8
-  %75 = call { ptr, i64 } @"std_collections_map$$int.double.HashMap_value_list"(ptr %map2, ptr %74)
+  %73 = call i64 @std.io.printfn(ptr %retparam39, ptr @.str.9, i64 2, ptr %varargslots40, i64 1)
+  %74 = load ptr, ptr @std.core.mem.thread_allocator, align 8
+  %75 = call { ptr, i64 } @"std.collections.map$int$double$.HashMap.value_list"(ptr %map2, ptr %74)
   store { ptr, i64 } %75, ptr %result46, align 8
   %76 = insertvalue %variant undef, ptr %result46, 0
-  %77 = insertvalue %variant %76, i64 ptrtoint (ptr @"ct$sa$double" to i64), 1
+  %77 = insertvalue %variant %76, i64 ptrtoint (ptr @"$ct.sa$double" to i64), 1
   %78 = getelementptr inbounds [1 x %variant], ptr %varargslots45, i64 0, i64 0
   store %variant %77, ptr %78, align 16
-  %79 = call i64 @std_io.printfn(ptr %retparam44, ptr @.str.10, i64 2, ptr %varargslots45, i64 1)
-  %80 = load ptr, ptr @std_core_mem.thread_temp_allocator, align 8
+  %79 = call i64 @std.io.printfn(ptr %retparam44, ptr @.str.10, i64 2, ptr %varargslots45, i64 1)
+  %80 = load ptr, ptr @std.core.mem.thread_temp_allocator, align 8
   %not = icmp eq ptr %80, null
   br i1 %not, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %after_check12
-  %81 = load ptr, ptr @std_core_mem.thread_allocator, align 8
-  %82 = call i64 @std_core_mem_allocator.new_temp(ptr %retparam49, i64 262144, ptr %81)
+  %81 = load ptr, ptr @std.core.mem.thread_allocator, align 8
+  %82 = call i64 @std.core.mem.allocator.new_temp(ptr %retparam49, i64 262144, ptr %81)
   %not_err50 = icmp eq i64 %82, 0
   %83 = call i1 @llvm.expect.i1(i1 %not_err50, i1 true)
   br i1 %83, label %after_check51, label %assign_optional
@@ -287,37 +287,37 @@ after_check51:                                    ; preds = %if.then
   br label %noerr_block
 
 panic_block:                                      ; preds = %assign_optional
-  %85 = load ptr, ptr @std_core_builtin.panic, align 8
+  %85 = load ptr, ptr @std.core.builtin.panic, align 8
   call void %85(ptr @.panic_msg, i64 27, ptr @.file, i64 6, ptr @.func
   unreachable
 
 noerr_block:                                      ; preds = %after_check51
-  store ptr %84, ptr @std_core_mem.thread_temp_allocator, align 8
+  store ptr %84, ptr @std.core.mem.thread_temp_allocator, align 8
   br label %if.exit
 
 if.exit:                                          ; preds = %noerr_block, %after_check12
-  %86 = load ptr, ptr @std_core_mem.thread_temp_allocator, align 8
+  %86 = load ptr, ptr @std.core.mem.thread_temp_allocator, align 8
   store ptr %86, ptr %temp, align 8
   %87 = load ptr, ptr %temp, align 8
   %88 = getelementptr inbounds %TempAllocator, ptr %87, i32 0, i32 3
   %89 = load i64, ptr %88, align 8
   store i64 %89, ptr %mark, align 8
   call void @llvm.memset.p0.i64(ptr align 8 %map3, i8 0, i64 40, i1 false)
-  %90 = load ptr, ptr @std_core_mem.thread_allocator, align 8
-  call void @"std_collections_map$$int.double.HashMap_init"(ptr %map3, i32 16, float 7.500000e-01, ptr %90)
-  %91 = call i8 @"std_collections_map$$int.double.HashMap_set"(ptr %map3, i32 5, double 3.200000e+00)
-  %92 = call i8 @"std_collections_map$$int.double.HashMap_set"(ptr %map3, i32 7, double 5.200000e+00)
-  %93 = load ptr, ptr @std_core_mem.thread_allocator, align 8
-  %94 = call { ptr, i64 } @"std_collections_map$$int.double.HashMap_key_list"(ptr %map3, ptr %93)
+  %90 = load ptr, ptr @std.core.mem.thread_allocator, align 8
+  call void @"std.collections.map$int$double$.HashMap.init"(ptr %map3, i32 16, float 7.500000e-01, ptr %90)
+  %91 = call i8 @"std.collections.map$int$double$.HashMap.set"(ptr %map3, i32 5, double 3.200000e+00)
+  %92 = call i8 @"std.collections.map$int$double$.HashMap.set"(ptr %map3, i32 7, double 5.200000e+00)
+  %93 = load ptr, ptr @std.core.mem.thread_allocator, align 8
+  %94 = call { ptr, i64 } @"std.collections.map$int$double$.HashMap.key_list"(ptr %map3, ptr %93)
   store { ptr, i64 } %94, ptr %result54, align 8
   %95 = insertvalue %variant undef, ptr %result54, 0
-  %96 = insertvalue %variant %95, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1
+  %96 = insertvalue %variant %95, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
   %97 = getelementptr inbounds [1 x %variant], ptr %varargslots53, i64 0, i64 0
   store %variant %96, ptr %97, align 16
-  %98 = call i64 @std_io.printfn(ptr %retparam52, ptr @.str.11, i64 2, ptr %varargslots53, i64 1)
+  %98 = call i64 @std.io.printfn(ptr %retparam52, ptr @.str.11, i64 2, ptr %varargslots53, i64 1)
   %99 = load ptr, ptr %temp, align 8
   %100 = getelementptr inbounds %TempAllocator, ptr %99, i32 0, i32 0
   %101 = load i64, ptr %mark, align 8
-  call void @std_core_mem_allocator.Allocator_reset(ptr %100, i64 %101)
+  call void @std.core.mem.allocator.Allocator.reset(ptr %100, i64 %101)
   ret void
 }
diff --git a/test/test_suite/struct/nested_struct_init.c3t b/test/test_suite/struct/nested_struct_init.c3t
index 10e7b697b..c0cad3dee 100644
--- a/test/test_suite/struct/nested_struct_init.c3t
+++ b/test/test_suite/struct/nested_struct_init.c3t
@@ -38,12 +38,12 @@ fn void main()
 %Matrix2x2_b = type { %.anon.1 }
 %.anon.1 = type { [4 x float] }
 
-@"ct$foo.$anon" = linkonce constant %.introspect { i8 10, i64 16, i64 0, i64 4, [0 x i64] zeroinitializer }, align 8
-@"ct$foo.$anon.3" = linkonce constant %.introspect { i8 11, i64 16, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
-@"ct$foo.Matrix2x2" = linkonce constant %.introspect { i8 10, i64 16, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
-@"ct$foo.$anon.6" = linkonce constant %.introspect { i8 10, i64 16, i64 0, i64 4, [0 x i64] zeroinitializer }, align 8
-@"ct$foo.$anon.7" = linkonce constant %.introspect { i8 11, i64 16, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
-@"ct$foo.Matrix2x2_b" = linkonce constant %.introspect { i8 10, i64 16, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
+@"$ct.foo.$anon" = linkonce constant %.introspect { i8 10, i64 16, i64 0, i64 4, [0 x i64] zeroinitializer }, align 8
+@"$ct.foo.$anon.3" = linkonce constant %.introspect { i8 11, i64 16, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.foo.Matrix2x2" = linkonce constant %.introspect { i8 10, i64 16, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
+@"$ct.foo.$anon.6" = linkonce constant %.introspect { i8 10, i64 16, i64 0, i64 4, [0 x i64] zeroinitializer }, align 8
+@"$ct.foo.$anon.7" = linkonce constant %.introspect { i8 11, i64 16, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.foo.Matrix2x2_b" = linkonce constant %.introspect { i8 10, i64 16, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
 @.__const = private unnamed_addr constant %Matrix2x2 { %.anon { %.anon.0 { float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00 } } }, align 4
 @.__const.8 = private unnamed_addr constant %Matrix2x2_b { %.anon.1 { [4 x float] [float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00] } }, align 4
 @.str = private unnamed_addr constant [13 x i8] c"%f %f %f %f\0A\00", align 1
diff --git a/test/test_suite/struct/struct_as_value.c3t b/test/test_suite/struct/struct_as_value.c3t
index 2cfa1c197..f5685bcd7 100644
--- a/test/test_suite/struct/struct_as_value.c3t
+++ b/test/test_suite/struct/struct_as_value.c3t
@@ -16,7 +16,7 @@ fn Event test(int x)
 /* #expect: test.ll
 %Event = type { i32 }
 
-@"ct$test.Event" = linkonce constant %.introspect { i8 10, i64 4, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
+@"$ct.test.Event" = linkonce constant %.introspect { i8 10, i64 4, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
 @.__const = private unnamed_addr constant %Event { i32 1 }, align 4
 @.__const.1 = private unnamed_addr constant %Event { i32 2 }, align 4
 
diff --git a/test/test_suite/struct/struct_codegen.c3t b/test/test_suite/struct/struct_codegen.c3t
index bf95b2159..c5aa72401 100644
--- a/test/test_suite/struct/struct_codegen.c3t
+++ b/test/test_suite/struct/struct_codegen.c3t
@@ -16,7 +16,7 @@ fn void test1()
 
 %Point = type { i32, i32 }
 
-@"ct$test.Point" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.test.Point" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
 @.__const = private unnamed_addr constant %Point { i32 5, i32 6 }, align 4
 
 define void @test.test1() #0 {
diff --git a/test/test_suite/struct/struct_const_construct_simple.c3t b/test/test_suite/struct/struct_const_construct_simple.c3t
index ccd12b2eb..30ee77aeb 100644
--- a/test/test_suite/struct/struct_const_construct_simple.c3t
+++ b/test/test_suite/struct/struct_const_construct_simple.c3t
@@ -20,7 +20,7 @@ Foo foo8 @private = FOO7;
 
 /* #expect: structo.ll
 
-@"ct$structo.Foo" = linkonce constant %.introspect { i8 10, i64 16, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
+@"$ct.structo.Foo" = linkonce constant %.introspect { i8 10, i64 16, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
 @structo.x = protected unnamed_addr global i64 16, align 8
 @structo.foo1 = protected unnamed_addr global %Foo { i32 1, i64 2 }, align 8
 @structo.foo2 = protected unnamed_addr global %Foo { i32 2, i64 0 }, align 8
diff --git a/test/test_suite/variant/variant_assign.c3t b/test/test_suite/variant/variant_assign.c3t
index 587336968..bb5406f83 100644
--- a/test/test_suite/variant/variant_assign.c3t
+++ b/test/test_suite/variant/variant_assign.c3t
@@ -58,9 +58,9 @@ fn int main()
 
 /* #expect: foo.ll
 
-@"ct$int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$double" = linkonce constant %.introspect { i8 4, i64 8, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$bool" = linkonce constant %.introspect { i8 1, i64 1, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.double" = linkonce constant %.introspect { i8 4, i64 8, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.bool" = linkonce constant %.introspect { i8 1, i64 1, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
 
 define void @foo.test(i64 %0, ptr %1) #0 {
 entry:
@@ -78,7 +78,7 @@ entry:
 
 switch.entry:                                     ; preds = %entry
   %4 = load i64, ptr %switch, align 8
-  %eq = icmp eq i64 ptrtoint (ptr @"ct$int" to i64), %4
+  %eq = icmp eq i64 ptrtoint (ptr @"$ct.int" to i64), %4
   br i1 %eq, label %switch.case, label %next_if
 
 switch.case:                                      ; preds = %switch.entry
@@ -91,7 +91,7 @@ switch.case:                                      ; preds = %switch.entry
   br label %switch.exit
 
 next_if:                                          ; preds = %switch.entry
-  %eq2 = icmp eq i64 ptrtoint (ptr @"ct$double" to i64), %4
+  %eq2 = icmp eq i64 ptrtoint (ptr @"$ct.double" to i64), %4
   br i1 %eq2, label %switch.case3, label %next_if5
 
 switch.case3:                                     ; preds = %next_if
@@ -133,7 +133,7 @@ entry:
 
 switch.entry:                                     ; preds = %entry
   %4 = load i64, ptr %switch, align 8
-  %eq = icmp eq i64 ptrtoint (ptr @"ct$int" to i64), %4
+  %eq = icmp eq i64 ptrtoint (ptr @"$ct.int" to i64), %4
   br i1 %eq, label %switch.case, label %next_if
 
 switch.case:                                      ; preds = %switch.entry
@@ -142,7 +142,7 @@ switch.case:                                      ; preds = %switch.entry
   store ptr %6, ptr %z, align 8
   store i32 12, ptr %taddr, align 4
   %7 = insertvalue %variant undef, ptr %taddr, 0
-  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   store %variant %8, ptr %y, align 8
   %9 = load ptr, ptr %z, align 8
   %10 = load i32, ptr %9, align 4
@@ -150,7 +150,7 @@ switch.case:                                      ; preds = %switch.entry
   br label %switch.exit
 
 next_if:                                          ; preds = %switch.entry
-  %eq1 = icmp eq i64 ptrtoint (ptr @"ct$double" to i64), %4
+  %eq1 = icmp eq i64 ptrtoint (ptr @"$ct.double" to i64), %4
   br i1 %eq1, label %switch.case2, label %next_if4
 
 switch.case2:                                     ; preds = %next_if
@@ -191,7 +191,7 @@ entry:
 
 switch.entry:                                     ; preds = %entry
   %4 = load i64, ptr %switch, align 8
-  %eq = icmp eq i64 ptrtoint (ptr @"ct$int" to i64), %4
+  %eq = icmp eq i64 ptrtoint (ptr @"$ct.int" to i64), %4
   br i1 %eq, label %switch.case, label %next_if
 
 switch.case:                                      ; preds = %switch.entry
@@ -204,7 +204,7 @@ switch.case:                                      ; preds = %switch.entry
   br label %switch.exit
 
 next_if:                                          ; preds = %switch.entry
-  %eq1 = icmp eq i64 ptrtoint (ptr @"ct$double" to i64), %4
+  %eq1 = icmp eq i64 ptrtoint (ptr @"$ct.double" to i64), %4
   br i1 %eq1, label %switch.case2, label %next_if4
 
 switch.case2:                                     ; preds = %next_if
@@ -249,7 +249,7 @@ entry:
   %taddr31 = alloca %variant, align 8
   store double 1.230000e+02, ptr %taddr, align 8
   %0 = insertvalue %variant undef, ptr %taddr, 0
-  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"ct$double" to i64), 1
+  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"$ct.double" to i64), 1
   store %variant %1, ptr %taddr1, align 8
   %2 = getelementptr inbounds { i64, ptr }, ptr %taddr1, i32 0, i32 0
   %lo = load i64, ptr %2, align 8
@@ -258,7 +258,7 @@ entry:
   call void @foo.test(i64 %lo, ptr %hi)
   store i32 1, ptr %taddr2, align 4
   %4 = insertvalue %variant undef, ptr %taddr2, 0
-  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   store %variant %5, ptr %taddr3, align 8
   %6 = getelementptr inbounds { i64, ptr }, ptr %taddr3, i32 0, i32 0
   %lo4 = load i64, ptr %6, align 8
@@ -267,7 +267,7 @@ entry:
   call void @foo.test(i64 %lo4, ptr %hi5)
   store i8 1, ptr %taddr6, align 1
   %8 = insertvalue %variant undef, ptr %taddr6, 0
-  %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   store %variant %9, ptr %taddr7, align 8
   %10 = getelementptr inbounds { i64, ptr }, ptr %taddr7, i32 0, i32 0
   %lo8 = load i64, ptr %10, align 8
@@ -276,7 +276,7 @@ entry:
   call void @foo.test(i64 %lo8, ptr %hi9)
   store double 1.235000e+02, ptr %taddr10, align 8
   %12 = insertvalue %variant undef, ptr %taddr10, 0
-  %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$double" to i64), 1
+  %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"$ct.double" to i64), 1
   store %variant %13, ptr %taddr11, align 8
   %14 = getelementptr inbounds { i64, ptr }, ptr %taddr11, i32 0, i32 0
   %lo12 = load i64, ptr %14, align 8
@@ -285,7 +285,7 @@ entry:
   call void @foo.test2(i64 %lo12, ptr %hi13)
   store i32 1, ptr %taddr14, align 4
   %16 = insertvalue %variant undef, ptr %taddr14, 0
-  %17 = insertvalue %variant %16, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %17 = insertvalue %variant %16, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   store %variant %17, ptr %taddr15, align 8
   %18 = getelementptr inbounds { i64, ptr }, ptr %taddr15, i32 0, i32 0
   %lo16 = load i64, ptr %18, align 8
@@ -294,7 +294,7 @@ entry:
   call void @foo.test2(i64 %lo16, ptr %hi17)
   store i8 1, ptr %taddr18, align 1
   %20 = insertvalue %variant undef, ptr %taddr18, 0
-  %21 = insertvalue %variant %20, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %21 = insertvalue %variant %20, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   store %variant %21, ptr %taddr19, align 8
   %22 = getelementptr inbounds { i64, ptr }, ptr %taddr19, i32 0, i32 0
   %lo20 = load i64, ptr %22, align 8
@@ -303,7 +303,7 @@ entry:
   call void @foo.test2(i64 %lo20, ptr %hi21)
   store double 1.240000e+02, ptr %taddr22, align 8
   %24 = insertvalue %variant undef, ptr %taddr22, 0
-  %25 = insertvalue %variant %24, i64 ptrtoint (ptr @"ct$double" to i64), 1
+  %25 = insertvalue %variant %24, i64 ptrtoint (ptr @"$ct.double" to i64), 1
   store %variant %25, ptr %taddr23, align 8
   %26 = getelementptr inbounds { i64, ptr }, ptr %taddr23, i32 0, i32 0
   %lo24 = load i64, ptr %26, align 8
@@ -312,7 +312,7 @@ entry:
   call void @foo.test3(i64 %lo24, ptr %hi25)
   store i32 2, ptr %taddr26, align 4
   %28 = insertvalue %variant undef, ptr %taddr26, 0
-  %29 = insertvalue %variant %28, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %29 = insertvalue %variant %28, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   store %variant %29, ptr %taddr27, align 8
   %30 = getelementptr inbounds { i64, ptr }, ptr %taddr27, i32 0, i32 0
   %lo28 = load i64, ptr %30, align 8
@@ -321,7 +321,7 @@ entry:
   call void @foo.test3(i64 %lo28, ptr %hi29)
   store i8 1, ptr %taddr30, align 1
   %32 = insertvalue %variant undef, ptr %taddr30, 0
-  %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %33 = insertvalue %variant %32, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   store %variant %33, ptr %taddr31, align 8
   %34 = getelementptr inbounds { i64, ptr }, ptr %taddr31, i32 0, i32 0
   %lo32 = load i64, ptr %34, align 8
diff --git a/test/test_suite/variant/variant_switch.c3t b/test/test_suite/variant/variant_switch.c3t
index 88e45bf41..8c0f86c78 100644
--- a/test/test_suite/variant/variant_switch.c3t
+++ b/test/test_suite/variant/variant_switch.c3t
@@ -30,9 +30,9 @@ fn int main()
 
 /* #expect: foo.ll
 
-@"ct$int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$double" = linkonce constant %.introspect { i8 4, i64 8, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$bool" = linkonce constant %.introspect { i8 1, i64 1, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.double" = linkonce constant %.introspect { i8 4, i64 8, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.bool" = linkonce constant %.introspect { i8 1, i64 1, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
 
 define void @foo.test(i64 %0, ptr %1) #0 {
 entry:
@@ -50,7 +50,7 @@ entry:
 
 switch.entry:                                     ; preds = %entry
   %4 = load i64, ptr %switch, align 8
-  %eq = icmp eq i64 ptrtoint (ptr @"ct$int" to i64), %4
+  %eq = icmp eq i64 ptrtoint (ptr @"$ct.int" to i64), %4
   br i1 %eq, label %switch.case, label %next_if
 
 switch.case:                                      ; preds = %switch.entry
@@ -65,7 +65,7 @@ switch.case:                                      ; preds = %switch.entry
   br label %switch.exit
 
 next_if:                                          ; preds = %switch.entry
-  %eq2 = icmp eq i64 ptrtoint (ptr @"ct$double" to i64), %4
+  %eq2 = icmp eq i64 ptrtoint (ptr @"$ct.double" to i64), %4
   br i1 %eq2, label %switch.case3, label %next_if5
 
 switch.case3:                                     ; preds = %next_if
@@ -87,7 +87,7 @@ switch.default:                                   ; preds = %next_if5
 switch.exit:                                      ; preds = %switch.default, %switch.case3, %switch.case
   %14 = getelementptr inbounds %variant, ptr %z, i32 0, i32 1
   %15 = load i64, ptr %14, align 8
-  %eq6 = icmp eq i64 %15, ptrtoint (ptr @"ct$int" to i64)
+  %eq6 = icmp eq i64 %15, ptrtoint (ptr @"$ct.int" to i64)
   br i1 %eq6, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %switch.exit
@@ -112,7 +112,7 @@ entry:
   %taddr7 = alloca %variant, align 8
   store double 1.230000e+02, ptr %taddr, align 8
   %0 = insertvalue %variant undef, ptr %taddr, 0
-  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"ct$double" to i64), 1
+  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"$ct.double" to i64), 1
   store %variant %1, ptr %taddr1, align 8
   %2 = getelementptr inbounds { i64, ptr }, ptr %taddr1, i32 0, i32 0
   %lo = load i64, ptr %2, align 8
@@ -121,7 +121,7 @@ entry:
   call void @foo.test(i64 %lo, ptr %hi)
   store i32 1, ptr %taddr2, align 4
   %4 = insertvalue %variant undef, ptr %taddr2, 0
-  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   store %variant %5, ptr %taddr3, align 8
   %6 = getelementptr inbounds { i64, ptr }, ptr %taddr3, i32 0, i32 0
   %lo4 = load i64, ptr %6, align 8
@@ -130,7 +130,7 @@ entry:
   call void @foo.test(i64 %lo4, ptr %hi5)
   store i8 1, ptr %taddr6, align 1
   %8 = insertvalue %variant undef, ptr %taddr6, 0
-  %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %9 = insertvalue %variant %8, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   store %variant %9, ptr %taddr7, align 8
   %10 = getelementptr inbounds { i64, ptr }, ptr %taddr7, i32 0, i32 0
   %lo8 = load i64, ptr %10, align 8
diff --git a/test/test_suite/variant/variant_test.c3t b/test/test_suite/variant/variant_test.c3t
index 2a733ff88..dcd9a8da2 100644
--- a/test/test_suite/variant/variant_test.c3t
+++ b/test/test_suite/variant/variant_test.c3t
@@ -66,11 +66,11 @@ fn void main()
 %variant = type { ptr, i64 }
 %"variant[]" = type { ptr, i64 }
 
-@"ct$int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$double" = linkonce constant %.introspect { i8 4, i64 8, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$variant" = linkonce constant %.introspect { i8 7, i64 16, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$p$int" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"ct$int" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
-@"ct$bool" = linkonce constant %.introspect { i8 1, i64 1, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.double" = linkonce constant %.introspect { i8 4, i64 8, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.variant" = linkonce constant %.introspect { i8 7, i64 16, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.p$int" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (ptr @"$ct.int" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.bool" = linkonce constant %.introspect { i8 1, i64 1, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
 
 define void @foo.test(i64 %0, ptr %1) #0 {
 entry:
@@ -86,7 +86,7 @@ entry:
 
 switch.entry:                                     ; preds = %entry
   %4 = load i64, ptr %switch, align 8
-  %eq = icmp eq i64 ptrtoint (ptr @"ct$int" to i64), %4
+  %eq = icmp eq i64 ptrtoint (ptr @"$ct.int" to i64), %4
   br i1 %eq, label %switch.case, label %next_if
 
 switch.case:                                      ; preds = %switch.entry
@@ -94,7 +94,7 @@ switch.case:                                      ; preds = %switch.entry
   br label %switch.exit
 
 next_if:                                          ; preds = %switch.entry
-  %eq1 = icmp eq i64 ptrtoint (ptr @"ct$double" to i64), %4
+  %eq1 = icmp eq i64 ptrtoint (ptr @"$ct.double" to i64), %4
   br i1 %eq1, label %switch.case2, label %next_if3
 
 switch.case2:                                     ; preds = %next_if
@@ -102,7 +102,7 @@ switch.case2:                                     ; preds = %next_if
   br label %switch.exit
 
 next_if3:                                         ; preds = %next_if
-  %eq4 = icmp eq i64 ptrtoint (ptr @"ct$variant" to i64), %4
+  %eq4 = icmp eq i64 ptrtoint (ptr @"$ct.variant" to i64), %4
   br i1 %eq4, label %switch.case5, label %next_if6
 
 switch.case5:                                     ; preds = %next_if3
@@ -110,7 +110,7 @@ switch.case5:                                     ; preds = %next_if3
   br label %switch.exit
 
 next_if6:                                         ; preds = %next_if3
-  %eq7 = icmp eq i64 ptrtoint (ptr @"ct$p$int" to i64), %4
+  %eq7 = icmp eq i64 ptrtoint (ptr @"$ct.p$int" to i64), %4
   br i1 %eq7, label %switch.case8, label %next_if9
 
 switch.case8:                                     ; preds = %next_if6
@@ -191,11 +191,11 @@ entry:
   %taddr23 = alloca double, align 8
   store i32 1, ptr %taddr, align 4
   %0 = insertvalue %variant undef, ptr %taddr, 0
-  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   store %variant %1, ptr %x, align 8
   store i32 0, ptr %z, align 4
   %2 = insertvalue %variant undef, ptr %z, 0
-  %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %3 = insertvalue %variant %2, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   store %variant %3, ptr %y, align 8
   %4 = getelementptr inbounds %variant, ptr %y, i32 0, i32 1
   %5 = load i64, ptr %4, align 8
@@ -205,7 +205,7 @@ entry:
   store i64 %7, ptr %h, align 8
   %8 = getelementptr inbounds %variant, ptr %y, i32 0, i32 1
   %9 = load i64, ptr %8, align 8
-  %eq = icmp eq i64 %9, ptrtoint (ptr @"ct$int" to i64)
+  %eq = icmp eq i64 %9, ptrtoint (ptr @"$ct.int" to i64)
   br i1 %eq, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %entry
@@ -215,7 +215,7 @@ if.then:                                          ; preds = %entry
 if.exit:                                          ; preds = %if.then, %entry
   %10 = getelementptr inbounds %variant, ptr %x, i32 0, i32 1
   %11 = load i64, ptr %10, align 8
-  %eq1 = icmp eq i64 %11, ptrtoint (ptr @"ct$int" to i64)
+  %eq1 = icmp eq i64 %11, ptrtoint (ptr @"$ct.int" to i64)
   br i1 %eq1, label %if.then2, label %if.exit3
 
 if.then2:                                         ; preds = %if.exit
@@ -225,14 +225,14 @@ if.then2:                                         ; preds = %if.exit
 if.exit3:                                         ; preds = %if.then2, %if.exit
   store double 1.000000e+00, ptr %taddr4, align 8
   %12 = insertvalue %variant undef, ptr %taddr4, 0
-  %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$double" to i64), 1
+  %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"$ct.double" to i64), 1
   store %variant %13, ptr %y, align 8
   %14 = insertvalue %variant undef, ptr %x, 0
-  %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$variant" to i64), 1
+  %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"$ct.variant" to i64), 1
   store %variant %15, ptr %x, align 8
   %16 = getelementptr inbounds %variant, ptr %y, i32 0, i32 1
   %17 = load i64, ptr %16, align 8
-  %eq5 = icmp eq i64 %17, ptrtoint (ptr @"ct$int" to i64)
+  %eq5 = icmp eq i64 %17, ptrtoint (ptr @"$ct.int" to i64)
   br i1 %eq5, label %if.then6, label %if.exit7
 
 if.then6:                                         ; preds = %if.exit3
@@ -242,7 +242,7 @@ if.then6:                                         ; preds = %if.exit3
 if.exit7:                                         ; preds = %if.then6, %if.exit3
   %18 = getelementptr inbounds %variant, ptr %x, i32 0, i32 1
   %19 = load i64, ptr %18, align 8
-  %eq8 = icmp eq i64 %19, ptrtoint (ptr @"ct$int" to i64)
+  %eq8 = icmp eq i64 %19, ptrtoint (ptr @"$ct.int" to i64)
   br i1 %eq8, label %if.then9, label %if.exit10
 
 if.then9:                                         ; preds = %if.exit7
@@ -257,7 +257,7 @@ if.exit10:                                        ; preds = %if.then9, %if.exit7
   call void @foo.test(i64 %lo, ptr %hi)
   store double 1.000000e+00, ptr %taddr11, align 8
   %22 = insertvalue %variant undef, ptr %taddr11, 0
-  %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$double" to i64), 1
+  %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"$ct.double" to i64), 1
   store %variant %23, ptr %taddr12, align 8
   %24 = getelementptr inbounds { i64, ptr }, ptr %taddr12, i32 0, i32 0
   %lo13 = load i64, ptr %24, align 8
@@ -266,7 +266,7 @@ if.exit10:                                        ; preds = %if.then9, %if.exit7
   call void @foo.test(i64 %lo13, ptr %hi14)
   store i32 1, ptr %taddr15, align 4
   %26 = insertvalue %variant undef, ptr %taddr15, 0
-  %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"$ct.int" to i64), 1
   store %variant %27, ptr %taddr16, align 8
   %28 = getelementptr inbounds { i64, ptr }, ptr %taddr16, i32 0, i32 0
   %lo17 = load i64, ptr %28, align 8
@@ -275,7 +275,7 @@ if.exit10:                                        ; preds = %if.then9, %if.exit7
   call void @foo.test(i64 %lo17, ptr %hi18)
   store i8 1, ptr %taddr19, align 1
   %30 = insertvalue %variant undef, ptr %taddr19, 0
-  %31 = insertvalue %variant %30, i64 ptrtoint (ptr @"ct$bool" to i64), 1
+  %31 = insertvalue %variant %30, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
   store %variant %31, ptr %taddr20, align 8
   %32 = getelementptr inbounds { i64, ptr }, ptr %taddr20, i32 0, i32 0
   %lo21 = load i64, ptr %32, align 8
@@ -290,15 +290,15 @@ if.exit10:                                        ; preds = %if.then9, %if.exit7
   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %35, ptr align 8 %x, i32 16, i1 false)
   store double 1.000000e+00, ptr %taddr23, align 8
   %36 = insertvalue %variant undef, ptr %taddr23, 0
-  %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$double" to i64), 1
+  %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"$ct.double" to i64), 1
   %38 = getelementptr inbounds [5 x %variant], ptr %varargslots, i64 0, i64 2
   store %variant %37, ptr %38, align 16
   %39 = insertvalue %variant undef, ptr %x, 0
-  %40 = insertvalue %variant %39, i64 ptrtoint (ptr @"ct$variant" to i64), 1
+  %40 = insertvalue %variant %39, i64 ptrtoint (ptr @"$ct.variant" to i64), 1
   %41 = getelementptr inbounds [5 x %variant], ptr %varargslots, i64 0, i64 3
   store %variant %40, ptr %41, align 16
   %42 = insertvalue %variant undef, ptr %df, 0
-  %43 = insertvalue %variant %42, i64 ptrtoint (ptr @"ct$p$int" to i64), 1
+  %43 = insertvalue %variant %42, i64 ptrtoint (ptr @"$ct.p$int" to i64), 1
   %44 = getelementptr inbounds [5 x %variant], ptr %varargslots, i64 0, i64 4
   store %variant %43, ptr %44, align 16
   call void @foo.test_all(ptr %varargslots, i64 5)
diff --git a/test/test_suite/vector/vector_ops2.c3t b/test/test_suite/vector/vector_ops2.c3t
index f18bb3d3b..bf6648dea 100644
--- a/test/test_suite/vector/vector_ops2.c3t
+++ b/test/test_suite/vector/vector_ops2.c3t
@@ -43,7 +43,7 @@ entry:
   br i1 %zero, label %panic, label %checkok
 
 panic:                                            ; preds = %entry
-  %6 = load ptr, ptr @std_core_builtin.panic, align 8
+  %6 = load ptr, ptr @std.core.builtin.panic, align 8
   call void %6(ptr @.panic_msg, i64 17, ptr @.file, i64 14, ptr @.func, i64 5, i32 9)
   br label %checkok