diff --git a/lib/std/core/builtin.c3 b/lib/std/core/builtin.c3
index 79b82a19b..098f62831 100644
--- a/lib/std/core/builtin.c3
+++ b/lib/std/core/builtin.c3
@@ -205,4 +205,5 @@ macro uint long.hash(long i) => (uint)((i >> 32) ^ i);
 macro uint ulong.hash(ulong i) => (uint)((i >> 32) ^ i);
 macro uint bool.hash(bool b) => (uint)b;
 macro uint typeid.hash(typeid t) => (uint)(((uptr)t >> 32) ^ (uptr)t);
-macro uint String.hash(String c) => (uint)fnv32a::encode(c);
\ No newline at end of file
+macro uint String.hash(String c) => (uint)fnv32a::encode(c);
+macro uint char[].hash(char[] c) => (uint)fnv32a::encode(c);
\ No newline at end of file
diff --git a/lib/std/core/dstring.c3 b/lib/std/core/dstring.c3
index d21f4d9da..9325afae7 100644
--- a/lib/std/core/dstring.c3
+++ b/lib/std/core/dstring.c3
@@ -96,7 +96,7 @@ fn void DString.chop(DString this, usz new_size)
 fn String DString.str(DString str)
 {
 	StringData* data = (StringData*)str;
-	if (!data) return String {};
+	if (!data) return "";
 	return (String)data.chars[:data.len];
 }
 
diff --git a/lib/std/core/private/main_stub.c3 b/lib/std/core/private/main_stub.c3
index 2359e6358..8ba24dabe 100644
--- a/lib/std/core/private/main_stub.c3
+++ b/lib/std/core/private/main_stub.c3
@@ -22,7 +22,7 @@ macro String[] args_to_strings(int argc, char** argv) @private
 	{
 		char* arg = argv[i];
 		usz len = 0;
-		list[i] = arg[:_strlen(arg)];
+		list[i] = (String)arg[:_strlen(arg)];
 	}
 	return list[:argc];
 }
diff --git a/lib/std/core/str.c3 b/lib/std/core/str.c3
index dbaf0407e..f2d4050f6 100644
--- a/lib/std/core/str.c3
+++ b/lib/std/core/str.c3
@@ -1,7 +1,6 @@
 module std::core::string;
 
-typedef ZString = distinct char*;
-typedef String = char[];
+typedef ZString = distinct inline char*;
 typedef Char32 = uint;
 typedef Char16 = ushort;
 
@@ -220,7 +219,7 @@ fn String String.copy(String s, Allocator* using = mem::heap())
     char* str = malloc(len + 1, .using = using);
     mem::copy(str, s.ptr, len);
     str[len] = 0;
-    return str[:len];
+    return (String)str[:len];
 }
 
 fn String String.tcopy(String s) => s.copy(mem::temp()) @inline;
@@ -405,7 +404,7 @@ fn String utf32to8(Char32[] utf32, Allocator* using = mem::heap())
 	char* data = malloc_checked(len + 1, .using = using)!!;
 	conv::utf32to8_unsafe(utf32, data);
 	data[len] = 0;
-	return data[:len];
+	return (String)data[:len];
 }
 
 fn Char16[]! utf8to16(String utf8, Allocator* using = mem::heap())
@@ -424,21 +423,21 @@ fn String! utf16to8(Char16[] utf16, Allocator* using = mem::heap())
 	char* data = malloc_checked(len + 1, .using = using)?;
 	conv::utf16to8_unsafe(utf16, data)?;
 	data[len] = 0;
-	return data[:len];
+	return (String)data[:len];
 }
 
 fn String copy(String s, Allocator* using = mem::heap()) @deprecated
 {
     usz len = s.len;
     ZString str_copy = s.zstr_copy(using) @inline;
-    return str_copy[:len];
+    return (String)str_copy[:len];
 }
 
 fn String tcopy(String s) @deprecated
 {
     usz len = s.len;
     ZString str_copy = s.zstr_tcopy() @inline;
-    return str_copy[:len];
+    return (String)str_copy[:len];
 }
 
 fn String tconcat(String s1, String s2)
@@ -449,7 +448,7 @@ fn String tconcat(String s1, String s2)
     mem::copy(str, s1.ptr, s1_len);
     mem::copy(str + s1_len, s2.ptr, s2.len);
     str[full_len] = 0;
-    return str[:full_len];
+    return (String)str[:full_len];
 }
 
 fn String concat(String s1, String s2)
@@ -460,12 +459,12 @@ fn String concat(String s1, String s2)
     mem::copy(str, s1.ptr, s1_len);
     mem::copy(str + s1_len, s2.ptr, s2.len);
     str[full_len] = 0;
-    return str[:full_len];
+    return (String)str[:full_len];
 }
 
 fn String ZString.as_str(ZString str)
 {
-	return ((char*)str)[:str.len()];
+	return (String)((char*)str)[:str.len()];
 }
 
 fn usz ZString.char_len(ZString str)
diff --git a/lib/std/core/string.c3 b/lib/std/core/string.c3
index d12c5a2ad..946f469b8 100644
--- a/lib/std/core/string.c3
+++ b/lib/std/core/string.c3
@@ -72,7 +72,7 @@ fn void VarString.chop(VarString this, usz new_size)
 fn String VarString.str(VarString str)
 {
 	StringData* data = (StringData*)str;
-	if (!data) return String {};
+	if (!data) return "";
 	return (String)data.chars[:data.len];
 }
 
diff --git a/lib/std/io/io_formatter_private.c3 b/lib/std/io/io_formatter_private.c3
index caee12b5c..64cc167d7 100644
--- a/lib/std/io/io_formatter_private.c3
+++ b/lib/std/io/io_formatter_private.c3
@@ -403,7 +403,7 @@ fn void! Formatter.ntoa(Formatter* this, uint128 value, bool negative, uint base
 		}
 		while (value);
 	}
-	return this.ntoa_format(buf[:PRINTF_NTOA_BUFFER_SIZE], len, negative, base);
+	return this.ntoa_format((String)buf[:PRINTF_NTOA_BUFFER_SIZE], len, negative, base);
 }
 
 fn void! Formatter.ntoa_format(Formatter* this, String buf, usz len, bool negative, uint base) @private
@@ -502,7 +502,7 @@ fn void! Formatter.out_char(Formatter* this, variant arg) @private
 }
 
 
-fn void! Formatter.out_reverse(Formatter* this, String buf) @private
+fn void! Formatter.out_reverse(Formatter* this, char[] buf) @private
 {
 	usz buffer_start_idx = this.idx;
 	usz len = buf.len;
diff --git a/lib/std/io/io_printf.c3 b/lib/std/io/io_printf.c3
index 3225880eb..ffbf9dc98 100644
--- a/lib/std/io/io_printf.c3
+++ b/lib/std/io/io_printf.c3
@@ -243,12 +243,6 @@ fn void! Formatter.out_str(Formatter* this, variant arg) @private
         	return this.out_str(variant { arg.ptr, arg.type.inner });
 		case POINTER:
 			if (this.print_with_function(arg)?) return;
-			typeid inner = arg.type.inner;
-			if (inner.kindof == TypeKind.ARRAY && inner.inner == char.typeid)
-			{
-				char *ptr = *(char**)arg.ptr;
-				return this.out_substr(ptr[:inner.len]);
-			}
 			return this.ntoa_variant(arg, 16);
 		case SIGNED_INT:
 		case UNSIGNED_INT:
diff --git a/lib/std/io/stream/bytewriter.c3 b/lib/std/io/stream/bytewriter.c3
index 2f90fc363..9273385a7 100644
--- a/lib/std/io/stream/bytewriter.c3
+++ b/lib/std/io/stream/bytewriter.c3
@@ -41,7 +41,7 @@ fn void ByteWriter.destroy(ByteWriter* writer)
 
 fn String ByteWriter.as_str(ByteWriter* writer)
 {
-	return writer.bytes[:writer.index];
+	return (String)writer.bytes[:writer.index];
 }
 
 fn void! ByteWriter.ensure_capacity(ByteWriter* writer, usz len) @inline
diff --git a/src/compiler/llvm_codegen_stmt.c b/src/compiler/llvm_codegen_stmt.c
index 39d318354..bec3708f3 100644
--- a/src/compiler/llvm_codegen_stmt.c
+++ b/src/compiler/llvm_codegen_stmt.c
@@ -1377,7 +1377,7 @@ void llvm_emit_panic(GenContext *c, const char *message, SourceSpan loc)
 	Type **types = prototype->param_types;
 	for (unsigned i = 0; i < 4; i++)
 	{
-		Type *type = types[i]->canonical;
+		Type *type = type_lowering(types[i]);
 		BEValue value = { .value = args[i], .type = type };
 		llvm_emit_parameter(c, actual_args, &count, abi_args[i], &value, type);
 	}
diff --git a/src/compiler/parse_global.c b/src/compiler/parse_global.c
index b5e86dc1c..f45309f7d 100644
--- a/src/compiler/parse_global.c
+++ b/src/compiler/parse_global.c
@@ -1885,10 +1885,24 @@ static inline Decl *parse_define_type(ParseContext *c)
 
 	CONSUME_OR_RET(TOKEN_EQ, poisoned_decl);
 	bool distinct = false;
-	if (tok_is(c, TOKEN_IDENT) && symstr(c) == kw_distinct)
+	bool is_inline = false;
+	if (tok_is(c, TOKEN_IDENT))
 	{
-		distinct = true;
-		advance(c);
+		if (symstr(c) == kw_inline)
+		{
+			SEMA_ERROR_HERE("'inline' must always follow 'distinct'.");
+			return poisoned_decl;
+		}
+		if (symstr(c) == kw_distinct)
+		{
+			distinct = true;
+			advance(c);
+			if (tok_is(c, TOKEN_IDENT) && symstr(c) == kw_inline)
+			{
+				is_inline = true;
+				advance(c);
+			}
+		}
 	}
 
 	// 1. Did we have `fn`? In that case it's a function pointer.
@@ -1898,6 +1912,7 @@ static inline Decl *parse_define_type(ParseContext *c)
 		decl_add_type(decl, TYPE_TYPEDEF);
 		decl->typedef_decl.is_func = true;
 		decl->typedef_decl.is_distinct = distinct;
+		decl->is_substruct = is_inline;
 		ASSIGN_TYPE_OR_RET(TypeInfo *type_info, parse_optional_type(c), poisoned_decl);
 		decl->typedef_decl.function_signature.rtype = type_infoid(type_info);
 		if (!parse_fn_parameter_list(c, &(decl->typedef_decl.function_signature), true))
@@ -1933,6 +1948,7 @@ static inline Decl *parse_define_type(ParseContext *c)
 	{
 		decl->decl_kind = DECL_DISTINCT;
 		decl_add_type(decl, TYPE_DISTINCT);
+		decl->is_substruct = is_inline;
 		TypedefDecl typedef_decl = decl->typedef_decl; // Ensure value semantics.
 		decl->distinct_decl.typedef_decl = typedef_decl;
 		decl->type->type_kind = TYPE_DISTINCT;
diff --git a/src/compiler/sema_casts.c b/src/compiler/sema_casts.c
index 68d0e302e..2865a7fad 100644
--- a/src/compiler/sema_casts.c
+++ b/src/compiler/sema_casts.c
@@ -1575,6 +1575,12 @@ static bool cast_expr_inner(SemaContext *context, Expr *expr, Type *to_type, boo
 	// Grab the underlying expression type.
 	Type *from = is_explicit ? type_flatten(from_type) : from_type->canonical;
 
+	// Auto-converting distinct type.
+	if (from->type_kind == TYPE_DISTINCT && from->decl->is_substruct && from != to)
+	{
+		from = type_flatten(from);
+	}
+
 	// We may already be done.
 	if (from == to)
 	{
diff --git a/src/compiler/sema_decls.c b/src/compiler/sema_decls.c
index 0ee54efe7..4030d0616 100644
--- a/src/compiler/sema_decls.c
+++ b/src/compiler/sema_decls.c
@@ -1987,7 +1987,7 @@ static inline MainType sema_find_main_type(SemaContext *context, Signature *sig,
 			break;
 		case 1:
 			arg_type = type_flatten(params[0]->type);
-			if (arg_type == type_get_subarray(type_get_subarray(type_char))) return MAIN_TYPE_ARGS;
+			if (arg_type == type_get_subarray(type_string)) return MAIN_TYPE_ARGS;
 			SEMA_ERROR(params[0], "Expected a parameter of type 'String[]'.");
 			return MAIN_TYPE_ERROR;
 		case 2:
@@ -2020,7 +2020,7 @@ static inline MainType sema_find_main_type(SemaContext *context, Signature *sig,
 				SEMA_ERROR(params[0], "Expected a parameter of type 'void*' (HINSTANCE)");
 				return MAIN_TYPE_ERROR;
 			}
-			if (arg_type2 != type_get_subarray(type_get_subarray(type_char)))
+			if (arg_type2 != type_get_subarray(type_string))
 			{
 				SEMA_ERROR(params[1], "Expected a parameter of type 'String[]'.");
 				return MAIN_TYPE_ERROR;
diff --git a/src/compiler/sema_expr.c b/src/compiler/sema_expr.c
index 12aca6e1d..332d3d4c9 100644
--- a/src/compiler/sema_expr.c
+++ b/src/compiler/sema_expr.c
@@ -2772,7 +2772,7 @@ static inline void sema_expr_replace_with_enum_name_array(Expr *enum_array_expr,
 	initializer->initializer_list = element_values;
 	enum_array_expr->expr_kind = EXPR_COMPOUND_LITERAL;
 	enum_array_expr->expr_compound_literal.initializer = initializer;
-	enum_array_expr->expr_compound_literal.type_info = type_info_new_base(type_get_subarray(global_context_string_type()), span);
+	enum_array_expr->expr_compound_literal.type_info = type_info_new_base(type_get_subarray(type_string), span);
 	enum_array_expr->resolve_status = RESOLVE_NOT_DONE;
 }
 
@@ -3282,7 +3282,7 @@ static bool sema_expr_rewrite_to_typeid_property(SemaContext *context, Expr *exp
 			sema_expr_rewrite_typeid_kind(expr, typeid);
 			return true;
 		case TYPE_PROPERTY_NAMES:
-			return sema_expr_rewrite_typeid_call(expr, typeid, TYPEID_INFO_NAMES, type_get_subarray(global_context_string_type()));
+			return sema_expr_rewrite_typeid_call(expr, typeid, TYPEID_INFO_NAMES, type_get_subarray(type_string));
 		case TYPE_PROPERTY_ALIGNOF:
 		case TYPE_PROPERTY_INF:
 		case TYPE_PROPERTY_MIN:
@@ -3646,7 +3646,7 @@ CHECK_DEEPER:
 			}
 			else
 			{
-				expr_rewrite_to_builtin_access(expr, current_parent, ACCESS_ENUMNAME, global_context_string_type());
+				expr_rewrite_to_builtin_access(expr, current_parent, ACCESS_ENUMNAME, type_string);
 				return true;
 			}
 		}
@@ -3657,7 +3657,7 @@ CHECK_DEEPER:
 				expr_rewrite_to_string(expr, current_parent->const_expr.enum_err_val->name);
 				return true;
 			}
-			expr_rewrite_to_builtin_access(expr, current_parent, ACCESS_FAULTNAME, global_context_string_type());
+			expr_rewrite_to_builtin_access(expr, current_parent, ACCESS_FAULTNAME, type_string);
 			return true;
 		}
 	}
@@ -6245,10 +6245,10 @@ static inline bool sema_expr_analyse_compiler_const(SemaContext *context, Expr *
 				expr->expr_kind = EXPR_CONST;
 				ConstInitializer *init = expr->const_expr.initializer = CALLOCS(ConstInitializer);
 				init->kind = CONST_INIT_ZERO;
-				init->type = expr->type = type_get_subarray(global_context_string_type());
+				init->type = expr->type = type_get_subarray(type_string);
 				return true;
 			}
-			expr->type = type_get_subarray(global_context_string_type());
+			expr->type = type_get_subarray(type_string);
 			expr->test_hook_expr = BUILTIN_DEF_TEST_NAMES;
 			expr->expr_kind = EXPR_TEST_HOOK;
 			return true;
diff --git a/src/compiler/sema_initializers.c b/src/compiler/sema_initializers.c
index 621151bf1..672842837 100644
--- a/src/compiler/sema_initializers.c
+++ b/src/compiler/sema_initializers.c
@@ -546,7 +546,7 @@ bool sema_expr_analyse_initializer_list(SemaContext *context, Type *to, Expr *ex
 				expr->expr_kind = EXPR_CONST;
 				expr->const_expr.const_kind = CONST_POINTER;
 				expr->const_expr.ptr = 0;
-				expr->type = flattened;
+				expr->type = to;
 				return true;
 			}
 			// Resolve this as an inferred array.
diff --git a/src/compiler/sema_internal.h b/src/compiler/sema_internal.h
index c4c233122..c6795904c 100644
--- a/src/compiler/sema_internal.h
+++ b/src/compiler/sema_internal.h
@@ -31,7 +31,6 @@ extern const char *ct_eval_error;
 
 Decl **global_context_acquire_locals_list(void);
 void generic_context_release_locals_list(Decl **);
-Type *global_context_string_type(void);
 
 AstId context_get_defers(SemaContext *context, AstId defer_top, AstId defer_bottom, bool is_success);
 void context_pop_defers(SemaContext *context, AstId *next);
diff --git a/src/compiler/sema_types.c b/src/compiler/sema_types.c
index c6fafbb8c..141f57821 100644
--- a/src/compiler/sema_types.c
+++ b/src/compiler/sema_types.c
@@ -168,6 +168,12 @@ static inline bool sema_resolve_array_type(SemaContext *context, TypeInfo *type,
 
 static bool sema_resolve_type_identifier(SemaContext *context, TypeInfo *type_info)
 {
+	if (type_info->unresolved.name == type_string->name && !type_info->unresolved.path)
+	{
+		type_info->type = type_string;
+		type_info->resolve_status = RESOLVE_DONE;
+		return true;
+	}
 	Decl *decl = sema_resolve_symbol(context, type_info->unresolved.name, type_info->unresolved.path, type_info->span);
 
 	assert(decl);
diff --git a/src/compiler/semantic_analyser.c b/src/compiler/semantic_analyser.c
index 128c9eac0..33cf03543 100644
--- a/src/compiler/semantic_analyser.c
+++ b/src/compiler/semantic_analyser.c
@@ -230,20 +230,6 @@ static void sema_analyze_to_stage(AnalysisStage stage)
 	halt_on_error();
 }
 
-Type *global_context_string_type(void)
-{
-	if (global_context.string_type) return global_context.string_type;
-	DeclId type = decltable_get(&global_context.symbols, symtab_preset("String", TOKEN_TYPE_IDENT));
-	if (!type) error_exit("Missing definition of 'String' type.");
-	Decl *decl = declptr(type);
-	if (decl->decl_kind == DECL_TYPEDEF || decl->decl_kind == DECL_DISTINCT)
-	{
-		if (type_flatten(decl->type) == type_chars) return global_context.string_type = decl->type;
-
-	}
-	error_exit("Invalid definition of String, expected a type with an underlying char[]");
-}
-
 /**
  * Perform the entire semantic analysis.
  */
@@ -350,8 +336,7 @@ RESOLVE_LAMBDA:;
 		{
 			error_exit("'%s::%s' is not a function pointer.", path->module, ident);
 		}
-		Type *string = global_context_string_type();
-		if (!type_func_match(panic_fn_type, type_void, 4, string, string, string, type_uint))
+		if (!type_func_match(panic_fn_type, type_void, 4, type_string, type_string, type_string, type_uint))
 		{
 			error_exit("Expected panic function to have the signature fn void(String, String, String, uint).");
 		}
diff --git a/src/compiler/types.c b/src/compiler/types.c
index 18f4fec1f..176d6b7eb 100644
--- a/src/compiler/types.c
+++ b/src/compiler/types.c
@@ -12,6 +12,7 @@ static struct
 	Type u8, u16, u32, u64, u128;
 	Type f16, f32, f64, f128;
 	Type usz, isz, uptr, iptr;
+	Type string;
 	Type voidstar, typeid, anyerr, member, typeinfo, untyped_list;
 	Type any, anyfail;
 } t;
@@ -45,7 +46,7 @@ Type *type_untypedlist = &t.untyped_list;
 Type *type_anyfail = &t.anyfail;
 Type *type_member = &t.member;
 Type *type_chars = NULL;
-Type *type_string = NULL;
+Type *type_string = &t.string;
 
 static unsigned size_subarray;
 static AlignSize alignment_subarray;
@@ -1506,7 +1507,14 @@ void type_setup(PlatformTarget *target)
 	size_subarray = (unsigned)(alignment_subarray * 2);
 	type_init("anyerr", &t.anyerr, TYPE_ANYERR, target->width_pointer, target->align_pointer);
 	type_chars = type_get_subarray(type_char);
-	type_string = type_chars;
+	Decl *string_decl = decl_new_with_type(symtab_preset("String", TOKEN_TYPE_IDENT), INVALID_SPAN, DECL_DISTINCT);
+	string_decl->extname = string_decl->name;
+	string_decl->is_substruct = true;
+	string_decl->distinct_decl.base_type = type_chars;
+	string_decl->resolve_status = RESOLVE_DONE;
+	type_string = string_decl->type;
+	global_context_add_type(string_decl->type);
+	global_context_add_decl(string_decl);
 }
 
 int type_kind_bitsize(TypeKind kind)
@@ -1954,6 +1962,13 @@ Type *type_find_max_type(Type *type, Type *other)
 
 	if (type == other) return type;
 
+	// Lower inlined distinct types.
+	while (type->type_kind == TYPE_DISTINCT && type->decl->is_substruct) type = type->decl->distinct_decl.base_type;
+	while (other->type_kind == TYPE_DISTINCT && other->decl->is_substruct) other = other->decl->distinct_decl.base_type;
+
+	// We may now have a match.
+	if (type == other) return type;
+
 	// Sort types
 	if (type->type_kind > other->type_kind)
 	{
diff --git a/test/test_suite/arrays/global_init.c3t b/test/test_suite/arrays/global_init.c3t
index 5d4c26713..cab5a2640 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 %"char[]" { ptr @.str, i64 3 }, 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.sa$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.String" to i64) }], align 16
 
 define void @test.main() #0 {
 entry:
@@ -56,7 +56,7 @@ entry:
   %6 = getelementptr inbounds [3 x %variant], ptr %y, i64 0, i64 2
   store %"char[]" { ptr @.str.12, i64 3 }, ptr %taddr2, align 8
   %7 = insertvalue %variant undef, ptr %taddr2, 0
-  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %8 = insertvalue %variant %7, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   store %variant %8, ptr %6, align 16
   ret void
 }
diff --git a/test/test_suite/asm/asm_ops_x64_1.c3t b/test/test_suite/asm/asm_ops_x64_1.c3t
index c399bc821..bdb444022 100644
--- a/test/test_suite/asm/asm_ops_x64_1.c3t
+++ b/test/test_suite/asm/asm_ops_x64_1.c3t
@@ -1,7 +1,7 @@
 // #target: macos-x64
 module test;
 
-fn void main(char[][] args)
+fn void main(String[] args)
 {
 	int x;
 	if (args.len < 10) return;
diff --git a/test/test_suite/asm/asm_ops_x64_2.c3t b/test/test_suite/asm/asm_ops_x64_2.c3t
index a9c3db917..4090068d8 100644
--- a/test/test_suite/asm/asm_ops_x64_2.c3t
+++ b/test/test_suite/asm/asm_ops_x64_2.c3t
@@ -1,7 +1,7 @@
 // #target: macos-x64
 module test;
 
-fn void main(char[][] args)
+fn void main(String[] args)
 {
 	int foo;
 	asm
diff --git a/test/test_suite/compile_time/ct_memberof.c3t b/test/test_suite/compile_time/ct_memberof.c3t
index 93eb03d87..f9d4d5694 100644
--- a/test/test_suite/compile_time/ct_memberof.c3t
+++ b/test/test_suite/compile_time/ct_memberof.c3t
@@ -252,129 +252,129 @@ entry:
   %35 = call i64 @std.io.File.printn(ptr %retparam27, ptr %32, ptr %lo29, i64 %hi30)
   store %"char[]" { ptr @.str.17, i64 3 }, ptr %taddr, align 8
   %36 = insertvalue %variant undef, ptr %taddr, 0
-  %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %38 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
   store %variant %37, ptr %38, align 16
   %39 = call i64 @std.io.printfn(ptr %retparam31, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
   store %"char[]" { ptr @.str.19, i64 1 }, ptr %taddr34, align 8
   %40 = insertvalue %variant undef, ptr %taddr34, 0
-  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %42 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 0
   store %variant %41, ptr %42, align 16
   store %"char[]" { ptr @.str.20, i64 3 }, ptr %taddr35, align 8
   %43 = insertvalue %variant undef, ptr %taddr35, 0
-  %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %45 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 1
   store %variant %44, ptr %45, align 16
   %46 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.18, i64 6, ptr %varargslots33, i64 2)
   store %"char[]" { ptr @.str.22, i64 4 }, ptr %taddr38, align 8
   %47 = insertvalue %variant undef, ptr %taddr38, 0
-  %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %49 = getelementptr inbounds [2 x %variant], ptr %varargslots37, i64 0, i64 0
   store %variant %48, ptr %49, align 16
   store %"char[]" { ptr @.str.23, i64 4 }, ptr %taddr39, align 8
   %50 = insertvalue %variant undef, ptr %taddr39, 0
-  %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %52 = getelementptr inbounds [2 x %variant], ptr %varargslots37, i64 0, i64 1
   store %variant %51, ptr %52, align 16
   %53 = call i64 @std.io.printfn(ptr %retparam36, ptr @.str.21, i64 6, ptr %varargslots37, i64 2)
   store %"char[]" zeroinitializer, ptr %taddr42, align 8
   %54 = insertvalue %variant undef, ptr %taddr42, 0
-  %55 = insertvalue %variant %54, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %55 = insertvalue %variant %54, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %56 = getelementptr inbounds [2 x %variant], ptr %varargslots41, i64 0, i64 0
   store %variant %55, ptr %56, align 16
   store %"char[]" { ptr @.str.25, i64 5 }, ptr %taddr43, align 8
   %57 = insertvalue %variant undef, ptr %taddr43, 0
-  %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %59 = getelementptr inbounds [2 x %variant], ptr %varargslots41, i64 0, i64 1
   store %variant %58, ptr %59, align 16
   %60 = call i64 @std.io.printfn(ptr %retparam40, ptr @.str.24, i64 6, ptr %varargslots41, i64 2)
   store %"char[]" { ptr @.str.27, i64 1 }, ptr %taddr46, align 8
   %61 = insertvalue %variant undef, ptr %taddr46, 0
-  %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %63 = getelementptr inbounds [2 x %variant], ptr %varargslots45, i64 0, i64 0
   store %variant %62, ptr %63, align 16
   store %"char[]" { ptr @.str.28, i64 6 }, ptr %taddr47, align 8
   %64 = insertvalue %variant undef, ptr %taddr47, 0
-  %65 = insertvalue %variant %64, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %65 = insertvalue %variant %64, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %66 = getelementptr inbounds [2 x %variant], ptr %varargslots45, i64 0, i64 1
   store %variant %65, ptr %66, align 16
   %67 = call i64 @std.io.printfn(ptr %retparam44, ptr @.str.26, i64 6, ptr %varargslots45, i64 2)
   store %"char[]" { ptr @.str.30, i64 3 }, ptr %taddr50, align 8
   %68 = insertvalue %variant undef, ptr %taddr50, 0
-  %69 = insertvalue %variant %68, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %69 = insertvalue %variant %68, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %70 = getelementptr inbounds [1 x %variant], ptr %varargslots49, i64 0, i64 0
   store %variant %69, ptr %70, align 16
   %71 = call i64 @std.io.printfn(ptr %retparam48, ptr @.str.29, i64 8, ptr %varargslots49, i64 1)
   store %"char[]" { ptr @.str.32, i64 1 }, ptr %taddr53, align 8
   %72 = insertvalue %variant undef, ptr %taddr53, 0
-  %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %74 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 0
   store %variant %73, ptr %74, align 16
   store %"char[]" { ptr @.str.33, i64 4 }, ptr %taddr54, align 8
   %75 = insertvalue %variant undef, ptr %taddr54, 0
-  %76 = insertvalue %variant %75, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %76 = insertvalue %variant %75, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %77 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 1
   store %variant %76, ptr %77, align 16
   %78 = call i64 @std.io.printfn(ptr %retparam51, ptr @.str.31, i64 6, ptr %varargslots52, i64 2)
   store %"char[]" { ptr @.str.35, i64 1 }, ptr %taddr57, align 8
   %79 = insertvalue %variant undef, ptr %taddr57, 0
-  %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %81 = getelementptr inbounds [2 x %variant], ptr %varargslots56, i64 0, i64 0
   store %variant %80, ptr %81, align 16
   store %"char[]" { ptr @.str.36, i64 5 }, ptr %taddr58, align 8
   %82 = insertvalue %variant undef, ptr %taddr58, 0
-  %83 = insertvalue %variant %82, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %83 = insertvalue %variant %82, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %84 = getelementptr inbounds [2 x %variant], ptr %varargslots56, i64 0, i64 1
   store %variant %83, ptr %84, align 16
   %85 = call i64 @std.io.printfn(ptr %retparam55, ptr @.str.34, i64 6, ptr %varargslots56, i64 2)
   store %"char[]" zeroinitializer, ptr %taddr61, align 8
   %86 = insertvalue %variant undef, ptr %taddr61, 0
-  %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %88 = getelementptr inbounds [2 x %variant], ptr %varargslots60, i64 0, i64 0
   store %variant %87, ptr %88, align 16
   store %"char[]" { ptr @.str.38, i64 5 }, ptr %taddr62, align 8
   %89 = insertvalue %variant undef, ptr %taddr62, 0
-  %90 = insertvalue %variant %89, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %90 = insertvalue %variant %89, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %91 = getelementptr inbounds [2 x %variant], ptr %varargslots60, i64 0, i64 1
   store %variant %90, ptr %91, align 16
   %92 = call i64 @std.io.printfn(ptr %retparam59, ptr @.str.37, i64 6, ptr %varargslots60, i64 2)
   store %"char[]" { ptr @.str.40, i64 3 }, ptr %taddr65, align 8
   %93 = insertvalue %variant undef, ptr %taddr65, 0
-  %94 = insertvalue %variant %93, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %94 = insertvalue %variant %93, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %95 = getelementptr inbounds [2 x %variant], ptr %varargslots64, i64 0, i64 0
   store %variant %94, ptr %95, align 16
   store %"char[]" { ptr @.str.41, i64 3 }, ptr %taddr66, align 8
   %96 = insertvalue %variant undef, ptr %taddr66, 0
-  %97 = insertvalue %variant %96, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %97 = insertvalue %variant %96, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %98 = getelementptr inbounds [2 x %variant], ptr %varargslots64, i64 0, i64 1
   store %variant %97, ptr %98, align 16
   %99 = call i64 @std.io.printfn(ptr %retparam63, ptr @.str.39, i64 6, ptr %varargslots64, i64 2)
   store %"char[]" { ptr @.str.43, i64 4 }, ptr %taddr69, align 8
   %100 = insertvalue %variant undef, ptr %taddr69, 0
-  %101 = insertvalue %variant %100, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %101 = insertvalue %variant %100, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %102 = getelementptr inbounds [1 x %variant], ptr %varargslots68, i64 0, i64 0
   store %variant %101, ptr %102, align 16
   %103 = call i64 @std.io.printfn(ptr %retparam67, ptr @.str.42, i64 8, ptr %varargslots68, i64 1)
   store %"char[]" { ptr @.str.45, i64 1 }, ptr %taddr72, align 8
   %104 = insertvalue %variant undef, ptr %taddr72, 0
-  %105 = insertvalue %variant %104, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %105 = insertvalue %variant %104, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %106 = getelementptr inbounds [2 x %variant], ptr %varargslots71, i64 0, i64 0
   store %variant %105, ptr %106, align 16
   store %"char[]" { ptr @.str.46, i64 3 }, ptr %taddr73, align 8
   %107 = insertvalue %variant undef, ptr %taddr73, 0
-  %108 = insertvalue %variant %107, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %108 = insertvalue %variant %107, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %109 = getelementptr inbounds [2 x %variant], ptr %varargslots71, i64 0, i64 1
   store %variant %108, ptr %109, align 16
   %110 = call i64 @std.io.printfn(ptr %retparam70, ptr @.str.44, i64 6, ptr %varargslots71, i64 2)
   store %"char[]" { ptr @.str.48, i64 1 }, ptr %taddr76, align 8
   %111 = insertvalue %variant undef, ptr %taddr76, 0
-  %112 = insertvalue %variant %111, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %112 = insertvalue %variant %111, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %113 = getelementptr inbounds [2 x %variant], ptr %varargslots75, i64 0, i64 0
   store %variant %112, ptr %113, align 16
   store %"char[]" { ptr @.str.49, i64 5 }, ptr %taddr77, align 8
   %114 = insertvalue %variant undef, ptr %taddr77, 0
-  %115 = insertvalue %variant %114, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %115 = insertvalue %variant %114, i64 ptrtoint (ptr @"$ct.String" to i64), 1
   %116 = getelementptr inbounds [2 x %variant], ptr %varargslots75, i64 0, i64 1
   store %variant %115, ptr %116, align 16
   %117 = call i64 @std.io.printfn(ptr %retparam74, ptr @.str.47, i64 6, ptr %varargslots75, i64 2)
diff --git a/test/test_suite/enumerations/enum_associated_values_other.c3t b/test/test_suite/enumerations/enum_associated_values_other.c3t
index 7d8c5517b..935624da0 100644
--- a/test/test_suite/enumerations/enum_associated_values_other.c3t
+++ b/test/test_suite/enumerations/enum_associated_values_other.c3t
@@ -52,7 +52,7 @@ enum Foo : int(String val)
 
 define void @test.main(ptr %0, i64 %1) #0 {
 entry:
-  %args = alloca %"char[][]", align 8
+  %args = alloca %"String[]", align 8
   %y = alloca i64, align 8
   %x = alloca ptr, align 8
   %a = alloca i32, align 4
@@ -69,7 +69,7 @@ entry:
   %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.String" 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)
diff --git a/test/test_suite/errors/error_introspect.c3t b/test/test_suite/errors/error_introspect.c3t
index 56a9c1151..62633f792 100644
--- a/test/test_suite/errors/error_introspect.c3t
+++ b/test/test_suite/errors/error_introspect.c3t
@@ -10,7 +10,7 @@ fault Foo
 
 fn void main()
 {
-  char[][] x = Foo.names;
+  String[] x = Foo.names;
   io::printfn("Foo.names: %s", x);
   io::printfn("Foo.values: %s", Foo.values);
   io::printfn("Foo.elements: %s", Foo.elements);
@@ -28,14 +28,16 @@ fn void main()
 @.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.String" = linkonce constant %.introspect { i8 18, i64 16, i64 ptrtoint (ptr @"$ct.sa$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
+@"$ct.sa$String" = linkonce constant %.introspect { i8 16, i64 16, i64 ptrtoint (ptr @"$ct.String" 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
 @.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
 
+
 entry:
-  %x = alloca %"char[][]", align 8
+  %x = alloca %"String[]", align 8
   %literal = alloca [2 x %"char[]"], align 16
   %retparam = alloca i64, align 8
   %varargslots = alloca [1 x %variant], align 16
@@ -49,11 +51,11 @@ entry:
   store %"char[]" { ptr @.str, i64 3 }, ptr %0, align 8
   %1 = getelementptr inbounds [2 x %"char[]"], ptr %literal, i64 0, i64 1
   store %"char[]" { ptr @.str.2, i64 3 }, ptr %1, align 8
-  %2 = insertvalue %"char[][]" undef, ptr %literal, 0
-  %3 = insertvalue %"char[][]" %2, i64 2, 1
-  store %"char[][]" %3, ptr %x, align 8
+  %2 = insertvalue %"String[]" undef, ptr %literal, 0
+  %3 = insertvalue %"String[]" %2, i64 2, 1
+  store %"String[]" %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$String" 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)
diff --git a/test/test_suite/errors/printing_errors.c3t b/test/test_suite/errors/printing_errors.c3t
index 86da78b8a..744e6dc4e 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 %"char[]" { ptr @.str.2, i64 5 }, ptr %taddr, align 8
   %0 = insertvalue %variant undef, ptr %taddr, 0
-  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %1 = insertvalue %variant %0, i64 ptrtoint (ptr @"$ct.String" 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,7 +44,7 @@ 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.String" 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)
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 7f6b0d33d..997fdee5d 100644
--- a/test/test_suite/functions/func_ptr_conversions_and_names.c3t
+++ b/test/test_suite/functions/func_ptr_conversions_and_names.c3t
@@ -39,6 +39,7 @@ fn void main()
 @.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.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.String" = linkonce constant %.introspect { i8 18, i64 16, i64 ptrtoint (ptr @"$ct.sa$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
@@ -109,31 +110,31 @@ entry:
   %16 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.2, i64 2, ptr %varargslots5, i64 1)
   store %"char[]" { ptr @.str.4, i64 12 }, ptr %taddr9, align 8
   %17 = insertvalue %variant undef, ptr %taddr9, 0
-  %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"$ct.String" 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)
   store %"char[]" { ptr @.str.6, i64 12 }, ptr %taddr12, align 8
   %21 = insertvalue %variant undef, ptr %taddr12, 0
-  %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %22 = insertvalue %variant %21, i64 ptrtoint (ptr @"$ct.String" 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)
   store %"char[]" { ptr @.str.8, i64 12 }, ptr %taddr15, align 8
   %25 = insertvalue %variant undef, ptr %taddr15, 0
-  %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"$ct.String" 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)
   store %"char[]" { ptr @.str.10, i64 6 }, ptr %taddr18, align 8
   %29 = insertvalue %variant undef, ptr %taddr18, 0
-  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.String" 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)
   store %"char[]" { ptr @.str.12, i64 13 }, ptr %taddr21, align 8
   %33 = insertvalue %variant undef, ptr %taddr21, 0
-  %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.String" 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)
diff --git a/test/test_suite/macros/macro_untyped_varargs_2.c3t b/test/test_suite/macros/macro_untyped_varargs_2.c3t
index 613bf5476..c742fd9da 100644
--- a/test/test_suite/macros/macro_untyped_varargs_2.c3t
+++ b/test/test_suite/macros/macro_untyped_varargs_2.c3t
@@ -148,14 +148,14 @@ entry:
   store i32 0, ptr %x, align 4
   store %"char[]" { ptr @.str.6, i64 3 }, ptr %taddr, align 8
   %24 = insertvalue %variant undef, ptr %taddr, 0
-  %25 = insertvalue %variant %24, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %25 = insertvalue %variant %24, i64 ptrtoint (ptr @"$ct.String" 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)
   store double 0.000000e+00, ptr %x13, align 8
   store %"char[]" { ptr @.str.8, i64 6 }, ptr %taddr16, align 8
   %28 = insertvalue %variant undef, ptr %taddr16, 0
-  %29 = insertvalue %variant %28, i64 ptrtoint (ptr @"$ct.sa$char" to i64), 1
+  %29 = insertvalue %variant %28, i64 ptrtoint (ptr @"$ct.String" 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)
diff --git a/test/test_suite/symbols/various.c3 b/test/test_suite/symbols/various.c3
index 0432a215a..56b16c193 100644
--- a/test/test_suite/symbols/various.c3
+++ b/test/test_suite/symbols/various.c3
@@ -125,7 +125,7 @@ fn void test16()
 
 fn void test17()
 {
-    int a = "test";             // #error: 'char[]' to 'int'
+    int a = "test";             // #error: 'String' to 'int'
 }
 
 fn void test18()
diff --git a/test/unit/stdlib/core/string.c3 b/test/unit/stdlib/core/string.c3
index cee899f71..37768fb39 100644
--- a/test/unit/stdlib/core/string.c3
+++ b/test/unit/stdlib/core/string.c3
@@ -16,9 +16,9 @@ fn void test_trim()
 {
 	String s = " \t\nabc ";
 	assert(s.trim() == "abc");
-	assert(((String)"\n\t").trim() == "");
-	assert(((String)"  \n\tok").trim() == "ok");
-	assert(((String)"!! \n\t ").trim() == "!!");
+	assert("\n\t".trim() == "");
+	assert("  \n\tok".trim() == "ok");
+	assert("!! \n\t ".trim() == "!!");
 	assert(s.trim("c \t") == "\nab");
 }
 
diff --git a/test/unit/stdlib/io/bytestream.c3 b/test/unit/stdlib/io/bytestream.c3
index a1c70e198..f62302681 100644
--- a/test/unit/stdlib/io/bytestream.c3
+++ b/test/unit/stdlib/io/bytestream.c3
@@ -10,7 +10,7 @@ fn void! bytestream()
 	assert('a' == s.read_byte()?);
 	s.pushback_byte()?;
 	usz len = s.read(&buffer)?;
-	assert(buffer[:len] == "abc");
+	assert((String)buffer[:len] == "abc");
 	ByteWriter w;
 	w.init();
 	Stream ws = w.as_stream();