diff --git a/src/compiler/ast.c b/src/compiler/ast.c
index 364c02b7d..856aa6cc0 100644
--- a/src/compiler/ast.c
+++ b/src/compiler/ast.c
@@ -89,7 +89,7 @@ Decl *decl_new_with_type(const char *name, SourceSpan loc, DeclKind decl_type, V
 		case DECL_BODYPARAM:
 			UNREACHABLE
 	}
-	Type *type = type_new(kind, name ? name : "anon");
+	Type *type = type_new(kind, name ? name : "$anon");
 	type->canonical = type;
 	type->decl = decl;
 	decl->type = type;
@@ -202,7 +202,7 @@ void decl_set_external_name(Decl *decl)
 	if (decl->has_extname) return;
 
 	const char *name = decl->name;
-	if (!name) name = "anon";
+	if (!name) name = "$anon";
 
 	// "extern" or the module has no prefix?
 	if (decl->visibility == VISIBLE_EXTERN || decl->unit->module->no_extprefix)
diff --git a/src/compiler/compiler_internal.h b/src/compiler/compiler_internal.h
index 587cd558d..2979322ac 100644
--- a/src/compiler/compiler_internal.h
+++ b/src/compiler/compiler_internal.h
@@ -1114,6 +1114,7 @@ typedef struct
 	bool index_by_ref : 1;
 	bool value_by_ref : 1;
 	bool iterator : 1;
+	bool is_reverse : 1;
 	CastKind cast : 8;
 	ExprId enumeration;
 	AstId body;
diff --git a/src/compiler/enums.h b/src/compiler/enums.h
index 214389c9f..01b95d61b 100644
--- a/src/compiler/enums.h
+++ b/src/compiler/enums.h
@@ -481,6 +481,7 @@ typedef enum
 	TOKEN_FAULT,
 	TOKEN_FOR,
 	TOKEN_FOREACH,
+	TOKEN_FOREACH_R,
 	TOKEN_FN,
 	TOKEN_GENERIC,
 	TOKEN_TLOCAL,
diff --git a/src/compiler/llvm_codegen.c b/src/compiler/llvm_codegen.c
index 588d16eeb..c5c00566f 100644
--- a/src/compiler/llvm_codegen.c
+++ b/src/compiler/llvm_codegen.c
@@ -523,7 +523,7 @@ void llvm_emit_and_set_decl_alloca(GenContext *c, Decl *decl)
 {
 	Type *type = type_lowering(decl->type);
 	if (type == type_void) return;
-	decl->backend_ref = llvm_emit_alloca(c, llvm_get_type(c, type), decl->alignment, decl->name ? decl->name : "anon");
+	decl->backend_ref = llvm_emit_alloca(c, llvm_get_type(c, type), decl->alignment, decl->name ? decl->name : ".anon");
 }
 
 void llvm_emit_local_var_alloca(GenContext *c, Decl *decl)
diff --git a/src/compiler/llvm_codegen_debug_info.c b/src/compiler/llvm_codegen_debug_info.c
index 8bd2771c4..20da5c511 100644
--- a/src/compiler/llvm_codegen_debug_info.c
+++ b/src/compiler/llvm_codegen_debug_info.c
@@ -152,7 +152,7 @@ void llvm_emit_debug_local_var(GenContext *c, Decl *decl)
 	if (!row) row = 1;
 	if (!col) col = 1;
 	const char *name = decl->name;
-	if (!name) name = "anon";
+	if (!name) name = ".temp";
 	LLVMMetadataRef var = LLVMDIBuilderCreateAutoVariable(
 			c->debug.builder,
 			c->debug.function,
@@ -184,7 +184,7 @@ void llvm_emit_debug_local_var(GenContext *c, Decl *decl)
 void llvm_emit_debug_parameter(GenContext *c, Decl *parameter, unsigned index)
 {
 	assert(!llvm_is_global_eval(c));
-	const char *name = parameter->name ? parameter->name : "anon";
+	const char *name = parameter->name ? parameter->name : ".anon";
 	bool always_preserve = false;
 
 	unsigned row = parameter->span.row;
diff --git a/src/compiler/llvm_codegen_function.c b/src/compiler/llvm_codegen_function.c
index b7dcf1a1a..d7a5de9e2 100644
--- a/src/compiler/llvm_codegen_function.c
+++ b/src/compiler/llvm_codegen_function.c
@@ -155,7 +155,7 @@ static inline void llvm_process_parameter_value(GenContext *c, Decl *decl, ABIAr
 				AlignSize struct_alignment = llvm_abi_alignment(c, struct_type);
 				if (decl_alignment < struct_alignment) decl->alignment = decl_alignment = struct_alignment;
 				coerce = llvm_emit_alloca(c, struct_type, decl_alignment, "");
-				decl->backend_ref = LLVMBuildBitCast(c->builder, coerce, llvm_get_ptr_type(c, decl->type), decl->name ? decl->name : "anon");
+				decl->backend_ref = LLVMBuildBitCast(c->builder, coerce, llvm_get_ptr_type(c, decl->type), decl->name ? decl->name : ".anon");
 			}
 			else
 			{
@@ -425,7 +425,7 @@ void llvm_emit_function_body(GenContext *c, Decl *decl)
 			scratch_buffer_clear();
 			scratch_buffer_append(decl->unit->module->name->module);
 			scratch_buffer_append("::");
-			scratch_buffer_append(decl->name ? decl->name : "anon");
+			scratch_buffer_append(decl->name ? decl->name : "$anon");
 			c->debug.func_name = llvm_emit_zstring(c, scratch_buffer_to_string());
 
 			File *file = source_file_by_id(decl->span.file_id);
diff --git a/src/compiler/llvm_codegen_type.c b/src/compiler/llvm_codegen_type.c
index 28d00f570..64d664877 100644
--- a/src/compiler/llvm_codegen_type.c
+++ b/src/compiler/llvm_codegen_type.c
@@ -32,7 +32,7 @@ static inline LLVMTypeRef llvm_type_from_decl(GenContext *c, Decl *decl)
 		case DECL_STRUCT:
 		{
 			LLVMTypeRef *types = NULL;
-			LLVMTypeRef type = LLVMStructCreateNamed(c->context, decl->name ? decl->name : "anon");
+			LLVMTypeRef type = LLVMStructCreateNamed(c->context, decl->name ? decl->name : ".anon");
 			// Avoid recursive issues.
 			decl->type->backend_type = type;
 			Decl **members = decl->strukt.members;
@@ -54,7 +54,7 @@ static inline LLVMTypeRef llvm_type_from_decl(GenContext *c, Decl *decl)
 		}
 		case DECL_UNION:
 		{
-			LLVMTypeRef type = LLVMStructCreateNamed(c->context, decl->name ? decl->name : "anon");
+			LLVMTypeRef type = LLVMStructCreateNamed(c->context, decl->name ? decl->name : ".anon");
 			// Avoid recursive issues.
 			decl->type->backend_type = type;
 			Decl **members = decl->strukt.members;
diff --git a/src/compiler/parse_stmt.c b/src/compiler/parse_stmt.c
index 70c2c1a14..2a92f8a37 100644
--- a/src/compiler/parse_stmt.c
+++ b/src/compiler/parse_stmt.c
@@ -406,7 +406,12 @@ static inline bool parse_foreach_var(ParseContext *c, Ast *foreach)
 static inline Ast* parse_foreach_stmt(ParseContext *c)
 {
 	Ast *ast = new_ast(AST_FOREACH_STMT, c->span);
-	advance_and_verify(c, TOKEN_FOREACH);
+
+	if (!(ast->foreach_stmt.is_reverse = try_consume(c, TOKEN_FOREACH_R)))
+	{
+		advance_and_verify(c, TOKEN_FOREACH);
+	}
+
 	ASSIGN_DECL_OR_RET(ast->foreach_stmt.flow.label, parse_optional_label(c, ast), poisoned_ast);
 	CONSUME_OR_RET(TOKEN_LPAREN, poisoned_ast);
 
@@ -889,6 +894,7 @@ Ast *parse_stmt(ParseContext *c)
 		case TOKEN_FOR:
 			return parse_for_stmt(c);
 		case TOKEN_FOREACH:
+		case TOKEN_FOREACH_R:
 			return parse_foreach_stmt(c);
 		case TOKEN_CONTINUE:
 		{
diff --git a/src/compiler/sema_decls.c b/src/compiler/sema_decls.c
index df5d7263a..4cc7d2046 100644
--- a/src/compiler/sema_decls.c
+++ b/src/compiler/sema_decls.c
@@ -381,7 +381,7 @@ static bool sema_analyse_struct_union(SemaContext *context, Decl *decl)
 
 	if (!sema_analyse_attributes(context, decl, decl->attributes, domain)) return decl_poison(decl);
 
-	DEBUG_LOG("Beginning analysis of %s.", decl->name ? decl->name : "anon");
+	DEBUG_LOG("Beginning analysis of %s.", decl->name ? decl->name : ".anon");
 	bool success;
 	Decl **members = decl->strukt.members;
 	if (!vec_size(members))
@@ -554,7 +554,7 @@ static bool sema_analyse_bitstruct(SemaContext *context, Decl *decl)
 {
 	if (!sema_analyse_attributes(context, decl, decl->attributes, ATTR_BITSTRUCT)) return decl_poison(decl);
 
-	DEBUG_LOG("Beginning analysis of %s.", decl->name ? decl->name : "anon");
+	DEBUG_LOG("Beginning analysis of %s.", decl->name ? decl->name : ".anon");
 	if (!sema_resolve_type_info(context, decl->bitstruct.base_type)) return false;
 	Type *type = decl->bitstruct.base_type->type->canonical;
 	Type *base_type = type->type_kind == TYPE_ARRAY ? type->array.base : type;
@@ -2489,10 +2489,10 @@ bool sema_analyse_decl(SemaContext *context, Decl *decl)
 
 	SemaContext temp_context;
 	context = transform_context_for_eval(context, &temp_context, decl->unit);
-	DEBUG_LOG(">>> Analysing %s.", decl->name ? decl->name : "anon");
+	DEBUG_LOG(">>> Analysing %s.", decl->name ? decl->name : ".anon");
 	if (decl->resolve_status == RESOLVE_RUNNING)
 	{
-		SEMA_ERROR(decl, "Recursive definition of '%s'.", decl->name ? decl->name : "anon");
+		SEMA_ERROR(decl, "Recursive definition of '%s'.", decl->name ? decl->name : ".anon");
 		goto FAILED;
 	}
 	decl->resolve_status = RESOLVE_RUNNING;
diff --git a/src/compiler/sema_stmts.c b/src/compiler/sema_stmts.c
index 0e02f8e89..d3fa566cb 100644
--- a/src/compiler/sema_stmts.c
+++ b/src/compiler/sema_stmts.c
@@ -933,7 +933,7 @@ static inline bool sema_analyse_foreach_stmt(SemaContext *context, Ast *statemen
 	AstId first_stmt = 0;
 	AstId *succ = &first_stmt;
 	Expr **expressions = NULL;
-
+	bool is_reverse = statement->foreach_stmt.is_reverse;
 	bool value_by_ref = statement->foreach_stmt.value_by_ref;
 	bool success = true;
 
@@ -1089,11 +1089,6 @@ static inline bool sema_analyse_foreach_stmt(SemaContext *context, Ast *statemen
 		}
 	}
 
-	// IndexType __idx$ = 0
-	Decl *idx_decl = decl_new_generated_var(index_type, VARDECL_LOCAL, index ? index->span : enumerator->span);
-	Expr *idx_init = expr_new(EXPR_CONST, idx_decl->span);
-	expr_rewrite_to_int_const(idx_init, index_type, 0, true);
-	vec_add(expressions, expr_generate_decl(idx_decl, idx_init));
 
 	// We either have "foreach (x : some_var)" or "foreach (x : some_call())"
 	// So we grab the former by address (implicit &) and the latter as the value.
@@ -1150,42 +1145,84 @@ static inline bool sema_analyse_foreach_stmt(SemaContext *context, Ast *statemen
 			len_call->type = type_isize;
 		}
 	}
+	Decl *idx_decl = decl_new_generated_var(index_type, VARDECL_LOCAL, index ? index->span : enumerator->span);
 
 	// IndexType __len$ = (IndexType)(@__enum$.len())
 	Decl *len_decl = NULL;
-	if (len_call)
-	{
-		len_decl = decl_new_generated_var(idx_init->type, VARDECL_LOCAL, enumerator->span);
-		if (!cast_implicit(len_call, idx_init->type)) return false;
-		vec_add(expressions, expr_generate_decl(len_decl, len_call));
-	}
 
+	if (is_reverse)
+	{
+		if (!len_call)
+		{
+			// Create const len if missing.
+			len_call = expr_new(EXPR_CONST, enumerator->span);
+			expr_rewrite_to_int_const(len_call, type_isize, array_len, true);
+		}
+		if (!cast_implicit(len_call, index_type)) return false;
+		// __idx$ = (IndexType)(@__enum$.len()) (or const)
+		vec_add(expressions, expr_generate_decl(idx_decl, len_call));
+	}
+	else
+	{
+		if (len_call)
+		{
+			len_decl = decl_new_generated_var(index_type, VARDECL_LOCAL, enumerator->span);
+			if (!cast_implicit(len_call, index_type)) return false;
+			vec_add(expressions, expr_generate_decl(len_decl, len_call));
+		}
+		Expr *idx_init = expr_new(EXPR_CONST, idx_decl->span);
+		expr_rewrite_to_int_const(idx_init, index_type, 0, true);
+		vec_add(expressions, expr_generate_decl(idx_decl, idx_init));
+	}
 
 	// Add all declarations to the init
 	Expr *init_expr = expr_new(EXPR_EXPRESSION_LIST, var->span);
 	init_expr->expression_list = expressions;
 
-	// Create __idx$ < __len$
-	Expr *binary = expr_new(EXPR_BINARY, idx_decl->span);
-	binary->binary_expr.operator = BINARYOP_LT;
-	binary->binary_expr.left = exprid(expr_variable(idx_decl));
-	if (len_decl)
+	Expr *update = NULL;
+	Expr *cond;
+	if (is_reverse)
 	{
-		binary->binary_expr.right = exprid(expr_variable(len_decl));
+		// Create __idx$ > 0
+		cond = expr_new(EXPR_BINARY, idx_decl->span);
+		cond->binary_expr.operator = BINARYOP_GT;
+		cond->binary_expr.left = exprid(expr_variable(idx_decl));
+		Expr *rhs = expr_new(EXPR_CONST, enumerator->span);
+		expr_rewrite_to_int_const(rhs, index_type, 0, true);
+		cond->binary_expr.right = exprid(rhs);
+
+		// Create --__idx$
+		Expr *dec = expr_new(EXPR_UNARY, idx_decl->span);
+		dec->unary_expr.expr = expr_variable(idx_decl);
+		dec->unary_expr.operator = UNARYOP_DEC;
+		Ast *update_stmt = new_ast(AST_EXPR_STMT, idx_decl->span);
+		update_stmt->expr_stmt = dec;
+		ast_append(&succ, update_stmt);
 	}
 	else
 	{
-		Expr *rhs = expr_new(EXPR_CONST, enumerator->span);
-		expr_rewrite_to_int_const(rhs, type_isize, array_len, true);
-		binary->binary_expr.right = exprid(rhs);
+		// Create __idx$ < __len$
+		cond = expr_new(EXPR_BINARY, idx_decl->span);
+		cond->binary_expr.operator = BINARYOP_LT;
+		cond->binary_expr.left = exprid(expr_variable(idx_decl));
+		if (len_decl)
+		{
+			cond->binary_expr.right = exprid(expr_variable(len_decl));
+		}
+		else
+		{
+			Expr *rhs = expr_new(EXPR_CONST, enumerator->span);
+			expr_rewrite_to_int_const(rhs, type_isize, array_len, true);
+			cond->binary_expr.right = exprid(rhs);
+		}
+
+		// Create ++__idx$
+		update = expr_new(EXPR_UNARY, idx_decl->span);
+		update->unary_expr.expr = expr_variable(idx_decl);
+		update->unary_expr.operator = UNARYOP_INC;
 	}
 
-	// Create __idx$++
-	Expr *inc = expr_new(EXPR_UNARY, idx_decl->span);
-	inc->unary_expr.expr = expr_variable(idx_decl);
-	inc->unary_expr.operator = UNARYOP_INC;
-
-	// Create IndexType index = __idx$++
+	// Create IndexType index = __idx$
 	if (index)
 	{
 		Ast *declare_ast = new_ast(AST_DECLARE_STMT, var->span);
@@ -1220,8 +1257,8 @@ static inline bool sema_analyse_foreach_stmt(SemaContext *context, Ast *statemen
 	compound_stmt->compound_stmt.first_stmt = first_stmt;
 	FlowCommon flow = statement->foreach_stmt.flow;
 	statement->for_stmt = (AstForStmt){ .init = exprid(init_expr),
-										.cond = exprid(binary),
-										.incr = exprid(inc),
+										.cond = exprid(cond),
+										.incr = update ? exprid(update) : 0,
 										.flow = flow,
 										.body = astid(compound_stmt)
 	};
diff --git a/src/compiler/tilde_codegen.c b/src/compiler/tilde_codegen.c
index ee3c28c3b..367513de9 100644
--- a/src/compiler/tilde_codegen.c
+++ b/src/compiler/tilde_codegen.c
@@ -494,7 +494,7 @@ void llvm_emit_and_set_decl_alloca(GenContext *c, Decl *decl)
 {
 	Type *type = type_lowering(decl->type);
 	if (type == type_void) return;
-	decl->backend_ref = llvm_emit_alloca(c, llvm_get_type(c, type), decl->alignment, decl->name ? decl->name : "anon");
+	decl->backend_ref = llvm_emit_alloca(c, llvm_get_type(c, type), decl->alignment, decl->name ? decl->name : ".anon");
 }
 
 void llvm_emit_local_var_alloca(GenContext *c, Decl *decl)
@@ -688,7 +688,7 @@ void llvm_emit_introspection_type_from_decl(GenContext *c, Decl *decl)
 			decl->enums.values[i]->backend_ref = llvm_emit_array_gep_raw(c, enum_elements, elements_type, i, alignment, &store_align);
 		}
 	}
-	LLVMValueRef global_name = LLVMAddGlobal(c->module, llvm_get_type(c, type_char), decl->name ? decl->name : "anon");
+	LLVMValueRef global_name = LLVMAddGlobal(c->module, llvm_get_type(c, type_char), decl->name ? decl->name : ".anon");
 	LLVMSetGlobalConstant(global_name, 1);
 	LLVMSetInitializer(global_name, LLVMConstInt(llvm_get_type(c, type_char), 1, false));
 	decl->type->backend_typeid = LLVMConstPointerCast(global_name, llvm_get_type(c, type_typeid));
diff --git a/src/compiler/tokens.c b/src/compiler/tokens.c
index dd97e2c66..405430408 100644
--- a/src/compiler/tokens.c
+++ b/src/compiler/tokens.c
@@ -231,6 +231,8 @@ const char *token_type_to_string(TokenType type)
 			return "for";
 		case TOKEN_FOREACH:
 			return "foreach";
+		case TOKEN_FOREACH_R:
+			return "foreach_r";
 		case TOKEN_FN:
 			return "fn";
 		case TOKEN_GENERIC:
diff --git a/src/version.h b/src/version.h
index 8256bc222..e30b94597 100644
--- a/src/version.h
+++ b/src/version.h
@@ -1 +1 @@
-#define COMPILER_VERSION "0.3.14"
\ No newline at end of file
+#define COMPILER_VERSION "0.3.15"
\ No newline at end of file
diff --git a/test/test_suite/bitstruct/embedded_bitstruct.c3t b/test/test_suite/bitstruct/embedded_bitstruct.c3t
index a91acad64..9614c47d8 100644
--- a/test/test_suite/bitstruct/embedded_bitstruct.c3t
+++ b/test/test_suite/bitstruct/embedded_bitstruct.c3t
@@ -53,8 +53,8 @@ entry:
   %0 = bitcast %Bar* %b to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %0, i8* align 4 bitcast (%Bar* @.__const to i8*), i32 12, i1 false)
   %1 = getelementptr inbounds %Bar, %Bar* %b, i32 0, i32 1
-  %2 = getelementptr inbounds %anon, %anon* %1, i32 0, i32 0
-  %3 = getelementptr inbounds %anon.0, %anon.0* %2, i32 0, i32 0
+  %2 = getelementptr inbounds %.anon, %.anon* %1, i32 0, i32 0
+  %3 = getelementptr inbounds %.anon.0, %.anon.0* %2, i32 0, i32 0
   %4 = load i32, i32* %3, align 4
   %5 = getelementptr inbounds %Bar, %Bar* %b, i32 0, i32 2
   %6 = load i32, i32* %5, align 4
@@ -64,15 +64,15 @@ entry:
   %7 = bitcast %Foo* %f to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %7, i8* align 4 bitcast (%Foo* @.__const.10 to i8*), i32 16, i1 false)
   %8 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0
-  %9 = getelementptr inbounds %anon.1, %anon.1* %8, i32 0, i32 0
-  %10 = getelementptr inbounds %anon.2, %anon.2* %9, i32 0, i32 0
+  %9 = getelementptr inbounds %.anon.1, %.anon.1* %8, i32 0, i32 0
+  %10 = getelementptr inbounds %.anon.2, %.anon.2* %9, i32 0, i32 0
   %11 = load i32, i32* %10, align 4
   %12 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0
-  %13 = getelementptr inbounds %anon.1, %anon.1* %12, i32 0, i32 1
-  %14 = getelementptr inbounds %anon.3, %anon.3* %13, i32 0, i32 0
+  %13 = getelementptr inbounds %.anon.1, %.anon.1* %12, i32 0, i32 1
+  %14 = getelementptr inbounds %.anon.3, %.anon.3* %13, i32 0, i32 0
   %15 = load i32, i32* %14, align 4
   %16 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0
-  %17 = getelementptr inbounds %anon.1, %anon.1* %16, i32 0, i32 2
+  %17 = getelementptr inbounds %.anon.1, %.anon.1* %16, i32 0, i32 2
   %18 = load i32, i32* %17, align 4
   %19 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 1
   %20 = load i32, i32* %19, align 4
diff --git a/test/test_suite/errors/error_regression_2.c3t b/test/test_suite/errors/error_regression_2.c3t
index 5a777863f..98f1e5afb 100644
--- a/test/test_suite/errors/error_regression_2.c3t
+++ b/test/test_suite/errors/error_regression_2.c3t
@@ -810,8 +810,8 @@ define void @test_main() #0 {
 entry:
   %URLS = alloca %"char[][]", align 8
   %literal = alloca [5 x %"char[]"], align 16
-  %anon = alloca i64, align 8
-  %anon1 = alloca i64, align 8
+  %.anon = alloca i64, align 8
+  %.anon1 = alloca i64, align 8
   %url = alloca %"char[]", align 8
   %summary = alloca %Summary, align 8
   %result = alloca %Summary, align 8
@@ -833,22 +833,22 @@ entry:
   %6 = insertvalue %"char[][]" undef, %"char[]"* %5, 0
   %7 = insertvalue %"char[][]" %6, i64 5, 1
   store %"char[][]" %7, %"char[][]"* %URLS, align 8
-  store i64 0, i64* %anon, align 8
   %8 = getelementptr inbounds %"char[][]", %"char[][]"* %URLS, i32 0, i32 1
   %9 = load i64, i64* %8, align 8
-  store i64 %9, i64* %anon1, align 8
+  store i64 %9, i64* %.anon, align 8
+  store i64 0, i64* %.anon1, align 8
   br label %loop.cond
 
 loop.cond:                                        ; preds = %phi_block12, %entry
-  %10 = load i64, i64* %anon, align 8
-  %11 = load i64, i64* %anon1, align 8
+  %10 = load i64, i64* %.anon1, align 8
+  %11 = load i64, i64* %.anon, align 8
   %lt = icmp ult i64 %10, %11
   br i1 %lt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
   %12 = getelementptr inbounds %"char[][]", %"char[][]"* %URLS, i32 0, i32 0
   %13 = load %"char[]"*, %"char[]"** %12, align 8
-  %14 = load i64, i64* %anon, align 8
+  %14 = load i64, i64* %.anon1, align 8
   %ptroffset = getelementptr inbounds %"char[]", %"char[]"* %13, i64 %14
   %15 = bitcast %"char[]"* %url to i8*
   %16 = bitcast %"char[]"* %ptroffset to i8*
@@ -949,9 +949,9 @@ phi_block12:                                      ; preds = %else_block11, %afte
   %val13 = phi i1 [ %52, %after_check10 ], [ false, %else_block11 ]
   %ternary = select i1 %val13, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.26, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.27, i32 0, i32 0)
   %53 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.25, i32 0, i32 0), i8* %val7, i8* %ternary)
-  %54 = load i64, i64* %anon, align 8
+  %54 = load i64, i64* %.anon1, align 8
   %add = add i64 %54, 1
-  store i64 %add, i64* %anon, align 8
+  store i64 %add, i64* %.anon1, align 8
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
diff --git a/test/test_suite/expressions/pointer_access.c3t b/test/test_suite/expressions/pointer_access.c3t
index a3aa585fe..77cf39af5 100644
--- a/test/test_suite/expressions/pointer_access.c3t
+++ b/test/test_suite/expressions/pointer_access.c3t
@@ -37,14 +37,14 @@ fn void testSimple()
 // TODO these may be wrong.
 /* #expect: pointer_access.ll
 
-%ExtraSimple = type { i32, i32, %c, %anon, %anon.0, i32 }
+%ExtraSimple = type { i32, i32, %c, %.anon, %.anon.0, i32 }
 %c = type { double, double, double, double, double }
-%anon = type { i32, i32 }
-%anon.0 = type { double }
+%.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_$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
 
@@ -67,12 +67,12 @@ entry:
   %7 = getelementptr inbounds %c, %c* %2, i32 0, i32 4
   store double 3.300000e+00, double* %7, align 8
   %8 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 3
-  %9 = getelementptr inbounds %anon, %anon* %8, i32 0, i32 0
+  %9 = getelementptr inbounds %.anon, %.anon* %8, i32 0, i32 0
   store i32 0, i32* %9, align 8
-  %10 = getelementptr inbounds %anon, %anon* %8, i32 0, i32 1
+  %10 = getelementptr inbounds %.anon, %.anon* %8, i32 0, i32 1
   store i32 0, i32* %10, align 4
   %11 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 4
-  %12 = bitcast %anon.0* %11 to i8*
+  %12 = bitcast %.anon.0* %11 to i8*
   call void @llvm.memset.p0i8.i64(i8* align 8 %12, i8 0, i64 8, i1 false)
   %13 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 5
   store i32 0, i32* %13, align 8
@@ -93,13 +93,13 @@ entry:
   %27 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 5
   %28 = load i32, i32* %27, align 8
   %29 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 4
-  %30 = bitcast %anon.0* %29 to double*
+  %30 = bitcast %.anon.0* %29 to double*
   %31 = load double, double* %30, align 8
   %32 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 3
-  %33 = getelementptr inbounds %anon, %anon* %32, i32 0, i32 0
+  %33 = getelementptr inbounds %.anon, %.anon* %32, i32 0, i32 0
   %34 = load i32, i32* %33, align 8
   %35 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 3
-  %36 = getelementptr inbounds %anon, %anon* %35, i32 0, i32 1
+  %36 = getelementptr inbounds %.anon, %.anon* %35, i32 0, i32 1
   %37 = load i32, i32* %36, align 4
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str, i32 0, i32 0), i32 %17, double %20, double %23, double %26, i32 %28, double %31, i32 %34, i32 %37)
   ret void
diff --git a/test/test_suite/initializer_lists/ranges_to_dynamic.c3t b/test/test_suite/initializer_lists/ranges_to_dynamic.c3t
index 0d2c6d41a..8d64221af 100644
--- a/test/test_suite/initializer_lists/ranges_to_dynamic.c3t
+++ b/test/test_suite/initializer_lists/ranges_to_dynamic.c3t
@@ -22,7 +22,7 @@ fn void main()
 define void @test_test(i32 %0) #0 {
 entry:
   %y = alloca [10 x i32], align 16
-  %anon = alloca i64, align 8
+  %.anon = alloca i64, align 8
   %v = alloca i32, align 4
   %1 = bitcast [10 x i32]* %y to i8*
   call void @llvm.memset.p0i8.i64(i8* align 16 %1, i8 0, i64 40, i1 false)
@@ -40,24 +40,24 @@ entry:
   store i32 %0, i32* %7, align 4
   %8 = getelementptr inbounds [10 x i32], [10 x i32]* %y, i64 0, i64 8
   store i32 %0, i32* %8, align 4
-  store i64 0, i64* %anon, align 8
+  store i64 0, i64* %.anon, align 8
   br label %loop.cond
 
 loop.cond:                                        ; preds = %loop.body, %entry
-  %9 = load i64, i64* %anon, align 8
+  %9 = load i64, i64* %.anon, align 8
   %gt = icmp ugt i64 10, %9
   br i1 %gt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
-  %10 = load i64, i64* %anon, align 8
+  %10 = load i64, i64* %.anon, align 8
   %11 = getelementptr inbounds [10 x i32], [10 x i32]* %y, i64 0, i64 %10
   %12 = load i32, i32* %11, align 4
   store i32 %12, i32* %v, align 4
   %13 = load i32, i32* %v, align 4
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %13)
-  %14 = load i64, i64* %anon, align 8
+  %14 = load i64, i64* %.anon, align 8
   %add = add i64 %14, 1
-  store i64 %add, i64* %anon, align 8
+  store i64 %add, i64* %.anon, align 8
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
diff --git a/test/test_suite/slices/slice_assign.c3t b/test/test_suite/slices/slice_assign.c3t
index 014caa2e7..f89d4f9a4 100644
--- a/test/test_suite/slices/slice_assign.c3t
+++ b/test/test_suite/slices/slice_assign.c3t
@@ -21,7 +21,7 @@ fn void main()
 define void @test_main() #0 {
 entry:
   %x = alloca [8 x i32], align 16
-  %anon = alloca i64, align 8
+  %.anon = alloca i64, align 8
   %i = alloca i32, align 4
   %0 = bitcast [8 x i32]* %x to i8*
   call void @llvm.memset.p0i8.i64(i8* align 16 %0, i8 0, i64 32, i1 false)
@@ -39,34 +39,40 @@ entry:
   store i32 52, i32* %6, align 4
   %7 = getelementptr inbounds [8 x i32], [8 x i32]* %x, i64 0, i64 7
   store i32 52, i32* %7, align 4
-  store i64 0, i64* %anon, align 8
+  store i64 0, i64* %.anon, align 8
   br label %loop.cond
+
 loop.cond:                                        ; preds = %loop.body, %entry
-  %8 = load i64, i64* %anon, align 8
+  %8 = load i64, i64* %.anon, align 8
   %gt = icmp ugt i64 8, %8
   br i1 %gt, label %loop.body, label %loop.exit
+
 loop.body:                                        ; preds = %loop.cond
-  %9 = load i64, i64* %anon, align 8
+  %9 = load i64, i64* %.anon, align 8
   %10 = getelementptr inbounds [8 x i32], [8 x i32]* %x, i64 0, i64 %9
   %11 = load i32, i32* %10, align 4
   store i32 %11, i32* %i, align 4
   %12 = load i32, i32* %i, align 4
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %12)
-  %13 = load i64, i64* %anon, align 8
+  %13 = load i64, i64* %.anon, align 8
   %add = add i64 %13, 1
-  store i64 %add, i64* %anon, align 8
+  store i64 %add, i64* %.anon, align 8
   br label %loop.cond
+
 loop.exit:                                        ; preds = %loop.cond
   br label %cond
+
 cond:                                             ; preds = %assign, %loop.exit
   %14 = phi i64 [ 0, %loop.exit ], [ %add1, %assign ]
   %lt = icmp slt i64 %14, 8
   br i1 %lt, label %assign, label %exit
+
 assign:                                           ; preds = %cond
   %15 = getelementptr inbounds [8 x i32], [8 x i32]* %x, i64 0, i64 %14
   store i32 123, i32* %15, align 4
   %add1 = add i64 %14, 1
   br label %cond
+
 exit:                                             ; preds = %cond
   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 93df7c612..9bd1ddb6c 100644
--- a/test/test_suite/statements/custom_foreach_with_ref.c3t
+++ b/test/test_suite/statements/custom_foreach_with_ref.c3t
@@ -121,6 +121,8 @@ entry:
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %6, i8* align 4 %7, i32 20, i1 false)
   ret void
 }
+
+; Function Attrs: nounwind
 define %Foo* @foo_call(%Foo* %0) #0 {
 entry:
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i32 0, i32 0))
@@ -132,44 +134,44 @@ entry:
   %a = alloca i32, align 4
   %a1 = alloca i32, align 4
   %a3 = alloca i32, align 4
-  %anon = alloca i32, align 4
-  %anon5 = alloca %Foo*, align 8
-  %anon6 = alloca i32, align 4
+  %.anon = alloca %Foo*, align 8
+  %.anon5 = alloca i32, align 4
+  %.anon6 = alloca i32, align 4
   %i = alloca i32, align 4
   %y = alloca i32, align 4
   %a7 = alloca i32, align 4
-  %anon9 = alloca i32, align 4
-  %anon10 = alloca i32, align 4
+  %.anon9 = alloca i32, align 4
+  %.anon10 = alloca i32, align 4
   %i14 = alloca i32, align 4
   %y15 = alloca i32*, align 8
   %a16 = alloca i32, align 4
-  %anon21 = alloca i32, align 4
-  %anon22 = alloca i32, align 4
+  %.anon21 = alloca i32, align 4
+  %.anon22 = alloca i32, align 4
   %i26 = alloca i32, align 4
   %y27 = alloca i32, align 4
   %a28 = alloca i32, align 4
-  %anon32 = alloca i32, align 4
-  %anon33 = alloca i32, align 4
+  %.anon32 = alloca i32, align 4
+  %.anon33 = alloca i32, align 4
   %i37 = alloca i32, align 4
   %y38 = alloca i32, align 4
   %a39 = alloca i32, align 4
-  %anon43 = alloca i32, align 4
-  %anon44 = alloca i32, align 4
+  %.anon43 = alloca i32, align 4
+  %.anon44 = alloca i32, align 4
   %i48 = alloca i32, align 4
   %y49 = alloca i32, align 4
   %a50 = alloca i32, align 4
-  %anon55 = alloca i64, align 8
-  %anon56 = alloca [5 x i32], align 16
+  %.anon55 = alloca [5 x i32], align 16
+  %.anon56 = alloca i64, align 8
   %i59 = alloca i64, align 8
   %y60 = alloca i32, align 4
-  %anon64 = alloca i64, align 8
-  %anon65 = alloca [5 x i32], align 16
+  %.anon64 = alloca [5 x i32], align 16
   %sretparam = alloca [5 x i32], align 4
+  %.anon65 = alloca i64, align 8
   %i69 = alloca i64, align 8
   %y70 = alloca i32, align 4
-  %anon73 = alloca i64, align 8
-  %anon74 = alloca [5 x i32]*, align 8
-  %sretparam75 = alloca [5 x i32], align 4
+  %.anon73 = alloca [5 x i32]*, align 8
+  %sretparam74 = alloca [5 x i32], align 4
+  %.anon75 = alloca i64, align 8
   %i79 = alloca i64, align 8
   %y80 = alloca i32, align 4
   %a83 = alloca i32, align 4
@@ -199,23 +201,23 @@ entry:
   %11 = getelementptr inbounds [3 x i32], [3 x i32]* %9, i64 0, i64 %sisiext4
   %12 = load i32, i32* %11, align 4
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i32 0, i32 0), i32 %4, i32 %8, i32 %12)
-  store i32 0, i32* %anon, align 4
   %13 = call %Foo* @foo_call(%Foo* %x)
-  store %Foo* %13, %Foo** %anon5, align 8
-  store i32 3, i32* %anon6, align 4
+  store %Foo* %13, %Foo** %.anon, align 8
+  store i32 3, i32* %.anon5, align 4
+  store i32 0, i32* %.anon6, align 4
   br label %loop.cond
 
 loop.cond:                                        ; preds = %loop.body, %entry
-  %14 = load i32, i32* %anon, align 4
-  %15 = load i32, i32* %anon6, align 4
+  %14 = load i32, i32* %.anon6, align 4
+  %15 = load i32, i32* %.anon5, align 4
   %lt = icmp slt i32 %14, %15
   br i1 %lt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
-  %16 = load i32, i32* %anon, align 4
+  %16 = load i32, i32* %.anon6, align 4
   store i32 %16, i32* %i, align 4
-  %17 = load %Foo*, %Foo** %anon5, align 8
-  %18 = load i32, i32* %anon, align 4
+  %17 = load %Foo*, %Foo** %.anon, align 8
+  %18 = load i32, i32* %.anon6, align 4
   store i32 %18, i32* %a7, align 4
   %19 = getelementptr inbounds %Foo, %Foo* %17, i32 0, i32 0
   %20 = load i32, i32* %a7, align 4
@@ -226,26 +228,26 @@ loop.body:                                        ; preds = %loop.cond
   %23 = load i32, i32* %i, align 4
   %24 = load i32, i32* %y, align 4
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.3, i32 0, i32 0), i32 %23, i32 %24)
-  %25 = load i32, i32* %anon, align 4
+  %25 = load i32, i32* %.anon6, align 4
   %add = add i32 %25, 1
-  store i32 %add, i32* %anon, align 4
+  store i32 %add, i32* %.anon6, align 4
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
-  store i32 0, i32* %anon9, align 4
-  store i32 3, i32* %anon10, align 4
+  store i32 3, i32* %.anon9, align 4
+  store i32 0, i32* %.anon10, align 4
   br label %loop.cond11
 
 loop.cond11:                                      ; preds = %loop.body13, %loop.exit
-  %26 = load i32, i32* %anon9, align 4
-  %27 = load i32, i32* %anon10, align 4
+  %26 = load i32, i32* %.anon10, align 4
+  %27 = load i32, i32* %.anon9, align 4
   %lt12 = icmp slt i32 %26, %27
   br i1 %lt12, label %loop.body13, label %loop.exit20
 
 loop.body13:                                      ; preds = %loop.cond11
-  %28 = load i32, i32* %anon9, align 4
+  %28 = load i32, i32* %.anon10, align 4
   store i32 %28, i32* %i14, align 4
-  %29 = load i32, i32* %anon9, align 4
+  %29 = load i32, i32* %.anon10, align 4
   store i32 %29, i32* %a16, align 4
   %30 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
   %31 = load i32, i32* %a16, align 4
@@ -260,26 +262,26 @@ loop.body13:                                      ; preds = %loop.cond11
   %36 = load i32*, i32** %y15, align 8
   %37 = load i32, i32* %36, align 8
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.4, i32 0, i32 0), i32 %35, i32 %37)
-  %38 = load i32, i32* %anon9, align 4
+  %38 = load i32, i32* %.anon10, align 4
   %add19 = add i32 %38, 1
-  store i32 %add19, i32* %anon9, align 4
+  store i32 %add19, i32* %.anon10, align 4
   br label %loop.cond11
 
 loop.exit20:                                      ; preds = %loop.cond11
-  store i32 0, i32* %anon21, align 4
-  store i32 3, i32* %anon22, align 4
+  store i32 3, i32* %.anon21, align 4
+  store i32 0, i32* %.anon22, align 4
   br label %loop.cond23
 
 loop.cond23:                                      ; preds = %loop.body25, %loop.exit20
-  %39 = load i32, i32* %anon21, align 4
-  %40 = load i32, i32* %anon22, align 4
+  %39 = load i32, i32* %.anon22, align 4
+  %40 = load i32, i32* %.anon21, align 4
   %lt24 = icmp slt i32 %39, %40
   br i1 %lt24, label %loop.body25, label %loop.exit31
 
 loop.body25:                                      ; preds = %loop.cond23
-  %41 = load i32, i32* %anon21, align 4
+  %41 = load i32, i32* %.anon22, align 4
   store i32 %41, i32* %i26, align 4
-  %42 = load i32, i32* %anon21, align 4
+  %42 = load i32, i32* %.anon22, align 4
   store i32 %42, i32* %a28, align 4
   %43 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
   %44 = load i32, i32* %a28, align 4
@@ -290,26 +292,26 @@ loop.body25:                                      ; preds = %loop.cond23
   %47 = load i32, i32* %i26, align 4
   %48 = load i32, i32* %y27, align 4
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i32 0, i32 0), i32 %47, i32 %48)
-  %49 = load i32, i32* %anon21, align 4
+  %49 = load i32, i32* %.anon22, align 4
   %add30 = add i32 %49, 1
-  store i32 %add30, i32* %anon21, align 4
+  store i32 %add30, i32* %.anon22, align 4
   br label %loop.cond23
 
 loop.exit31:                                      ; preds = %loop.cond23
-  store i32 0, i32* %anon32, align 4
-  store i32 3, i32* %anon33, align 4
+  store i32 3, i32* %.anon32, align 4
+  store i32 0, i32* %.anon33, align 4
   br label %loop.cond34
 
 loop.cond34:                                      ; preds = %loop.body36, %loop.exit31
-  %50 = load i32, i32* %anon32, align 4
-  %51 = load i32, i32* %anon33, align 4
+  %50 = load i32, i32* %.anon33, align 4
+  %51 = load i32, i32* %.anon32, align 4
   %lt35 = icmp slt i32 %50, %51
   br i1 %lt35, label %loop.body36, label %loop.exit42
 
 loop.body36:                                      ; preds = %loop.cond34
-  %52 = load i32, i32* %anon32, align 4
+  %52 = load i32, i32* %.anon33, align 4
   store i32 %52, i32* %i37, align 4
-  %53 = load i32, i32* %anon32, align 4
+  %53 = load i32, i32* %.anon33, align 4
   store i32 %53, i32* %a39, align 4
   %54 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
   %55 = load i32, i32* %a39, align 4
@@ -320,26 +322,26 @@ loop.body36:                                      ; preds = %loop.cond34
   %58 = load i32, i32* %i37, align 4
   %59 = load i32, i32* %y38, align 4
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.6, i32 0, i32 0), i32 %58, i32 %59)
-  %60 = load i32, i32* %anon32, align 4
+  %60 = load i32, i32* %.anon33, align 4
   %add41 = add i32 %60, 1
-  store i32 %add41, i32* %anon32, align 4
+  store i32 %add41, i32* %.anon33, align 4
   br label %loop.cond34
 
 loop.exit42:                                      ; preds = %loop.cond34
-  store i32 0, i32* %anon43, align 4
-  store i32 3, i32* %anon44, align 4
+  store i32 3, i32* %.anon43, align 4
+  store i32 0, i32* %.anon44, align 4
   br label %loop.cond45
 
 loop.cond45:                                      ; preds = %loop.body47, %loop.exit42
-  %61 = load i32, i32* %anon43, align 4
-  %62 = load i32, i32* %anon44, align 4
+  %61 = load i32, i32* %.anon44, align 4
+  %62 = load i32, i32* %.anon43, align 4
   %lt46 = icmp slt i32 %61, %62
   br i1 %lt46, label %loop.body47, label %loop.exit54
 
 loop.body47:                                      ; preds = %loop.cond45
-  %63 = load i32, i32* %anon43, align 4
+  %63 = load i32, i32* %.anon44, align 4
   store i32 %63, i32* %i48, align 4
-  %64 = load i32, i32* %anon43, align 4
+  %64 = load i32, i32* %.anon44, align 4
   store i32 %64, i32* %a50, align 4
   %65 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
   %66 = load i32, i32* %a50, align 4
@@ -353,27 +355,27 @@ loop.body47:                                      ; preds = %loop.cond45
   %71 = load i32, i32* %i48, align 4
   %add52 = add i32 %71, 1
   store i32 %add52, i32* %i48, align 4
-  %72 = load i32, i32* %anon43, align 4
+  %72 = load i32, i32* %.anon44, align 4
   %add53 = add i32 %72, 1
-  store i32 %add53, i32* %anon43, align 4
+  store i32 %add53, i32* %.anon44, align 4
   br label %loop.cond45
 
 loop.exit54:                                      ; preds = %loop.cond45
-  store i64 0, i64* %anon55, align 8
-  %73 = bitcast [5 x i32]* %anon56 to i8*
+  %73 = bitcast [5 x i32]* %.anon55 to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %73, i8* align 16 bitcast ([5 x i32]* @.__const.8 to i8*), i32 20, i1 false)
+  store i64 0, i64* %.anon56, align 8
   br label %loop.cond57
 
 loop.cond57:                                      ; preds = %loop.body58, %loop.exit54
-  %74 = load i64, i64* %anon55, align 8
+  %74 = load i64, i64* %.anon56, align 8
   %gt = icmp ugt i64 5, %74
   br i1 %gt, label %loop.body58, label %loop.exit63
 
 loop.body58:                                      ; preds = %loop.cond57
-  %75 = load i64, i64* %anon55, align 8
+  %75 = load i64, i64* %.anon56, align 8
   store i64 %75, i64* %i59, align 8
-  %76 = load i64, i64* %anon55, align 8
-  %77 = getelementptr inbounds [5 x i32], [5 x i32]* %anon56, i64 0, i64 %76
+  %76 = load i64, i64* %.anon56, align 8
+  %77 = getelementptr inbounds [5 x i32], [5 x i32]* %.anon55, i64 0, i64 %76
   %78 = load i32, i32* %77, align 4
   store i32 %78, i32* %y60, align 4
   %79 = load i64, i64* %i59, align 8
@@ -382,64 +384,64 @@ loop.body58:                                      ; preds = %loop.cond57
   %81 = load i64, i64* %i59, align 8
   %add61 = add i64 %81, 1
   store i64 %add61, i64* %i59, align 8
-  %82 = load i64, i64* %anon55, align 8
+  %82 = load i64, i64* %.anon56, align 8
   %add62 = add i64 %82, 1
-  store i64 %add62, i64* %anon55, align 8
+  store i64 %add62, i64* %.anon56, align 8
   br label %loop.cond57
 
 loop.exit63:                                      ; preds = %loop.cond57
-  store i64 0, i64* %anon64, align 8
   call void @foo_getFields([5 x i32]* sret([5 x i32]) align 4 %sretparam)
-  %83 = bitcast [5 x i32]* %anon65 to i8*
+  %83 = bitcast [5 x i32]* %.anon64 to i8*
   %84 = bitcast [5 x i32]* %sretparam to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %83, i8* align 4 %84, i32 20, i1 false)
+  store i64 0, i64* %.anon65, align 8
   br label %loop.cond66
 
 loop.cond66:                                      ; preds = %loop.body68, %loop.exit63
-  %85 = load i64, i64* %anon64, align 8
+  %85 = load i64, i64* %.anon65, align 8
   %gt67 = icmp ugt i64 5, %85
   br i1 %gt67, label %loop.body68, label %loop.exit72
 
 loop.body68:                                      ; preds = %loop.cond66
-  %86 = load i64, i64* %anon64, align 8
+  %86 = load i64, i64* %.anon65, align 8
   store i64 %86, i64* %i69, align 8
-  %87 = load i64, i64* %anon64, align 8
-  %88 = getelementptr inbounds [5 x i32], [5 x i32]* %anon65, i64 0, i64 %87
+  %87 = load i64, i64* %.anon65, align 8
+  %88 = getelementptr inbounds [5 x i32], [5 x i32]* %.anon64, i64 0, i64 %87
   %89 = load i32, i32* %88, align 4
   store i32 %89, i32* %y70, align 4
   %90 = load i64, i64* %i69, align 8
   %91 = load i32, i32* %y70, align 4
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.10, i32 0, i32 0), i64 %90, i32 %91)
-  %92 = load i64, i64* %anon64, align 8
+  %92 = load i64, i64* %.anon65, align 8
   %add71 = add i64 %92, 1
-  store i64 %add71, i64* %anon64, align 8
+  store i64 %add71, i64* %.anon65, align 8
   br label %loop.cond66
 
 loop.exit72:                                      ; preds = %loop.cond66
-  store i64 0, i64* %anon73, align 8
-  call void @foo_getFields([5 x i32]* sret([5 x i32]) align 4 %sretparam75)
-  store [5 x i32]* %sretparam75, [5 x i32]** %anon74, align 8
+  call void @foo_getFields([5 x i32]* sret([5 x i32]) align 4 %sretparam74)
+  store [5 x i32]* %sretparam74, [5 x i32]** %.anon73, align 8
+  store i64 0, i64* %.anon75, align 8
   br label %loop.cond76
 
 loop.cond76:                                      ; preds = %loop.body78, %loop.exit72
-  %93 = load i64, i64* %anon73, align 8
+  %93 = load i64, i64* %.anon75, align 8
   %gt77 = icmp ugt i64 5, %93
   br i1 %gt77, label %loop.body78, label %loop.exit82
 
 loop.body78:                                      ; preds = %loop.cond76
-  %94 = load i64, i64* %anon73, align 8
+  %94 = load i64, i64* %.anon75, align 8
   store i64 %94, i64* %i79, align 8
-  %95 = load [5 x i32]*, [5 x i32]** %anon74, align 8
-  %96 = load i64, i64* %anon73, align 8
+  %95 = load [5 x i32]*, [5 x i32]** %.anon73, align 8
+  %96 = load i64, i64* %.anon75, align 8
   %97 = getelementptr inbounds [5 x i32], [5 x i32]* %95, i64 0, i64 %96
   %98 = load i32, i32* %97, align 4
   store i32 %98, i32* %y80, align 4
   %99 = load i64, i64* %i79, align 8
   %100 = load i32, i32* %y80, align 4
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.11, i32 0, i32 0), i64 %99, i32 %100)
-  %101 = load i64, i64* %anon73, align 8
+  %101 = load i64, i64* %.anon75, align 8
   %add81 = add i64 %101, 1
-  store i64 %add81, i64* %anon73, align 8
+  store i64 %add81, i64* %.anon75, align 8
   br label %loop.cond76
 
 loop.exit82:                                      ; preds = %loop.cond76
diff --git a/test/test_suite/statements/foreach_break.c3t b/test/test_suite/statements/foreach_break.c3t
index f44d4153c..c735dbc40 100644
--- a/test/test_suite/statements/foreach_break.c3t
+++ b/test/test_suite/statements/foreach_break.c3t
@@ -19,7 +19,7 @@ define void @test_test() #0 {
 entry:
   %x = alloca [3 x i32], align 4
   %g = alloca i32, align 4
-  %anon = alloca i64, align 8
+  %.anon = alloca i64, align 8
   %z = alloca i32, align 4
   %0 = getelementptr inbounds [3 x i32], [3 x i32]* %x, i64 0, i64 0
   store i32 0, i32* %0, align 4
@@ -28,16 +28,16 @@ entry:
   %2 = getelementptr inbounds [3 x i32], [3 x i32]* %x, i64 0, i64 2
   store i32 0, i32* %2, align 4
   store i32 0, i32* %g, align 4
-  store i64 0, i64* %anon, align 8
+  store i64 0, i64* %.anon, align 8
   br label %loop.cond
 
 loop.cond:                                        ; preds = %loop.inc, %entry
-  %3 = load i64, i64* %anon, align 8
+  %3 = load i64, i64* %.anon, align 8
   %gt = icmp ugt i64 3, %3
   br i1 %gt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
-  %4 = load i64, i64* %anon, align 8
+  %4 = load i64, i64* %.anon, align 8
   %5 = getelementptr inbounds [3 x i32], [3 x i32]* %x, i64 0, i64 %4
   %6 = load i32, i32* %5, align 4
   store i32 %6, i32* %z, align 4
@@ -64,9 +64,9 @@ if.exit3:                                         ; preds = %if.exit
   br label %loop.inc
 
 loop.inc:                                         ; preds = %if.exit3, %if.then2
-  %11 = load i64, i64* %anon, align 8
+  %11 = load i64, i64* %.anon, align 8
   %add4 = add i64 %11, 1
-  store i64 %add4, i64* %anon, align 8
+  store i64 %add4, i64* %.anon, align 8
   br label %loop.cond
 
 loop.exit:                                        ; preds = %if.then, %loop.cond
diff --git a/test/test_suite/statements/foreach_common.c3t b/test/test_suite/statements/foreach_common.c3t
index 096f1e886..7de45892c 100644
--- a/test/test_suite/statements/foreach_common.c3t
+++ b/test/test_suite/statements/foreach_common.c3t
@@ -56,69 +56,69 @@ fn void main()
 entry:
   %foo = alloca [3 x float], align 4
   %foo2 = alloca <3 x float>, align 16
-  %anon = alloca i64, align 8
+  %.anon = alloca i64, align 8
   %a = alloca float, align 4
-  %anon1 = alloca i64, align 8
+  %.anon1 = alloca i64, align 8
   %a5 = alloca float*, align 8
-  %anon9 = alloca i64, align 8
+  %.anon9 = alloca i64, align 8
   %a13 = alloca i8*, align 8
-  %anon18 = alloca i64, align 8
+  %.anon18 = alloca i64, align 8
   %i = alloca i64, align 8
   %a22 = alloca float, align 4
-  %anon26 = alloca i64, align 8
+  %.anon26 = alloca i64, align 8
   %i30 = alloca i8, align 1
   %a31 = alloca double, align 8
-  %anon35 = alloca i64, align 8
+  %.anon35 = alloca i64, align 8
   %a39 = alloca double, align 8
-  %anon43 = alloca i64, align 8
-  %anon44 = alloca i64, align 8
+  %.anon43 = alloca i64, align 8
+  %.anon44 = alloca i64, align 8
   %a47 = alloca float, align 4
-  %anon51 = alloca i64, align 8
-  %anon52 = alloca i64, align 8
+  %.anon51 = alloca i64, align 8
+  %.anon52 = alloca i64, align 8
   %i56 = alloca i64, align 8
   %a57 = alloca float, align 4
-  %anon61 = alloca i64, align 8
-  %anon62 = alloca i64, align 8
+  %.anon61 = alloca i64, align 8
+  %.anon62 = alloca i64, align 8
   %i66 = alloca i8, align 1
   %a68 = alloca double, align 8
-  %anon73 = alloca i64, align 8
-  %anon74 = alloca i64, align 8
+  %.anon73 = alloca i64, align 8
+  %.anon74 = alloca i64, align 8
   %a78 = alloca double, align 8
   %0 = bitcast [3 x float]* %foo to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %0, i8* align 4 bitcast ([3 x float]* @.__const to i8*), i32 12, i1 false)
   store <3 x float> <float 2.000000e+00, float 4.500000e+00, float 8.000000e+00>, <3 x float>* %foo2, align 16
-  store i64 0, i64* %anon, align 8
+  store i64 0, i64* %.anon, align 8
   br label %loop.cond
 
 loop.cond:                                        ; preds = %loop.body, %entry
-  %1 = load i64, i64* %anon, align 8
+  %1 = load i64, i64* %.anon, align 8
   %gt = icmp ugt i64 3, %1
   br i1 %gt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
-  %2 = load i64, i64* %anon, align 8
+  %2 = load i64, i64* %.anon, align 8
   %3 = getelementptr inbounds [3 x float], [3 x float]* %foo, i64 0, i64 %2
   %4 = load float, float* %3, align 4
   store float %4, float* %a, align 4
   %5 = load float, float* %a, align 4
   %fpfpext = fpext float %5 to double
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i32 0, i32 0), double %fpfpext)
-  %6 = load i64, i64* %anon, align 8
+  %6 = load i64, i64* %.anon, align 8
   %add = add i64 %6, 1
-  store i64 %add, i64* %anon, align 8
+  store i64 %add, i64* %.anon, align 8
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
-  store i64 0, i64* %anon1, align 8
+  store i64 0, i64* %.anon1, align 8
   br label %loop.cond2
 
 loop.cond2:                                       ; preds = %loop.body4, %loop.exit
-  %7 = load i64, i64* %anon1, align 8
+  %7 = load i64, i64* %.anon1, align 8
   %gt3 = icmp ugt i64 3, %7
   br i1 %gt3, label %loop.body4, label %loop.exit8
 
 loop.body4:                                       ; preds = %loop.cond2
-  %8 = load i64, i64* %anon1, align 8
+  %8 = load i64, i64* %.anon1, align 8
   %9 = getelementptr inbounds [3 x float], [3 x float]* %foo, i64 0, i64 %8
   store float* %9, float** %a5, align 8
   %10 = load float*, float** %a5, align 8
@@ -129,22 +129,22 @@ loop.body4:                                       ; preds = %loop.cond2
   %13 = load float, float* %12, align 8
   %fpfpext6 = fpext float %13 to double
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i32 0, i32 0), double %fpfpext6)
-  %14 = load i64, i64* %anon1, align 8
+  %14 = load i64, i64* %.anon1, align 8
   %add7 = add i64 %14, 1
-  store i64 %add7, i64* %anon1, align 8
+  store i64 %add7, i64* %.anon1, align 8
   br label %loop.cond2
 
 loop.exit8:                                       ; preds = %loop.cond2
-  store i64 0, i64* %anon9, align 8
+  store i64 0, i64* %.anon9, align 8
   br label %loop.cond10
 
 loop.cond10:                                      ; preds = %loop.body12, %loop.exit8
-  %15 = load i64, i64* %anon9, align 8
+  %15 = load i64, i64* %.anon9, align 8
   %gt11 = icmp ugt i64 3, %15
   br i1 %gt11, label %loop.body12, label %loop.exit17
 
 loop.body12:                                      ; preds = %loop.cond10
-  %16 = load i64, i64* %anon9, align 8
+  %16 = load i64, i64* %.anon9, align 8
   %17 = getelementptr inbounds [3 x float], [3 x float]* %foo, i64 0, i64 %16
   %ptrptr = bitcast float* %17 to i8*
   store i8* %ptrptr, i8** %a13, align 8
@@ -153,24 +153,24 @@ loop.body12:                                      ; preds = %loop.cond10
   %19 = load float, float* %ptrptr14, align 8
   %fpfpext15 = fpext float %19 to double
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i32 0, i32 0), double %fpfpext15)
-  %20 = load i64, i64* %anon9, align 8
+  %20 = load i64, i64* %.anon9, align 8
   %add16 = add i64 %20, 1
-  store i64 %add16, i64* %anon9, align 8
+  store i64 %add16, i64* %.anon9, align 8
   br label %loop.cond10
 
 loop.exit17:                                      ; preds = %loop.cond10
-  store i64 0, i64* %anon18, align 8
+  store i64 0, i64* %.anon18, align 8
   br label %loop.cond19
 
 loop.cond19:                                      ; preds = %loop.body21, %loop.exit17
-  %21 = load i64, i64* %anon18, align 8
+  %21 = load i64, i64* %.anon18, align 8
   %gt20 = icmp ugt i64 3, %21
   br i1 %gt20, label %loop.body21, label %loop.exit25
 
 loop.body21:                                      ; preds = %loop.cond19
-  %22 = load i64, i64* %anon18, align 8
+  %22 = load i64, i64* %.anon18, align 8
   store i64 %22, i64* %i, align 8
-  %23 = load i64, i64* %anon18, align 8
+  %23 = load i64, i64* %.anon18, align 8
   %24 = getelementptr inbounds [3 x float], [3 x float]* %foo, i64 0, i64 %23
   %25 = load float, float* %24, align 4
   store float %25, float* %a22, align 4
@@ -178,25 +178,25 @@ loop.body21:                                      ; preds = %loop.cond19
   %27 = load float, float* %a22, align 4
   %fpfpext23 = fpext float %27 to double
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.3, i32 0, i32 0), i64 %26, double %fpfpext23)
-  %28 = load i64, i64* %anon18, align 8
+  %28 = load i64, i64* %.anon18, align 8
   %add24 = add i64 %28, 1
-  store i64 %add24, i64* %anon18, align 8
+  store i64 %add24, i64* %.anon18, align 8
   br label %loop.cond19
 
 loop.exit25:                                      ; preds = %loop.cond19
-  store i64 0, i64* %anon26, align 8
+  store i64 0, i64* %.anon26, align 8
   br label %loop.cond27
 
 loop.cond27:                                      ; preds = %loop.body29, %loop.exit25
-  %29 = load i64, i64* %anon26, align 8
+  %29 = load i64, i64* %.anon26, align 8
   %gt28 = icmp ugt i64 3, %29
   br i1 %gt28, label %loop.body29, label %loop.exit34
 
 loop.body29:                                      ; preds = %loop.cond27
-  %30 = load i64, i64* %anon26, align 8
+  %30 = load i64, i64* %.anon26, align 8
   %ztrunc = trunc i64 %30 to i8
   store i8 %ztrunc, i8* %i30, align 1
-  %31 = load i64, i64* %anon26, align 8
+  %31 = load i64, i64* %.anon26, align 8
   %32 = getelementptr inbounds [3 x float], [3 x float]* %foo, i64 0, i64 %31
   %33 = load float, float* %32, align 4
   %fpfpext32 = fpext float %33 to double
@@ -205,101 +205,101 @@ loop.body29:                                      ; preds = %loop.cond27
   %uisiext = zext i8 %34 to i32
   %35 = load double, double* %a31, align 8
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i32 0, i32 0), i32 %uisiext, double %35)
-  %36 = load i64, i64* %anon26, align 8
+  %36 = load i64, i64* %.anon26, align 8
   %add33 = add i64 %36, 1
-  store i64 %add33, i64* %anon26, align 8
+  store i64 %add33, i64* %.anon26, align 8
   br label %loop.cond27
 
 loop.exit34:                                      ; preds = %loop.cond27
-  store i64 0, i64* %anon35, align 8
+  store i64 0, i64* %.anon35, align 8
   br label %loop.cond36
 
 loop.cond36:                                      ; preds = %loop.body38, %loop.exit34
-  %37 = load i64, i64* %anon35, align 8
+  %37 = load i64, i64* %.anon35, align 8
   %gt37 = icmp ugt i64 3, %37
   br i1 %gt37, label %loop.body38, label %loop.exit42
 
 loop.body38:                                      ; preds = %loop.cond36
-  %38 = load i64, i64* %anon35, align 8
+  %38 = load i64, i64* %.anon35, align 8
   %39 = getelementptr inbounds [3 x float], [3 x float]* %foo, i64 0, i64 %38
   %40 = load float, float* %39, align 4
   %fpfpext40 = fpext float %40 to double
   store double %fpfpext40, double* %a39, align 8
   %41 = load double, double* %a39, align 8
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.5, i32 0, i32 0), double %41)
-  %42 = load i64, i64* %anon35, align 8
+  %42 = load i64, i64* %.anon35, align 8
   %add41 = add i64 %42, 1
-  store i64 %add41, i64* %anon35, align 8
+  store i64 %add41, i64* %.anon35, align 8
   br label %loop.cond36
 
 loop.exit42:                                      ; preds = %loop.cond36
-  store i64 0, i64* %anon43, align 8
-  store i64 3, i64* %anon44, align 8
+  store i64 3, i64* %.anon43, align 8
+  store i64 0, i64* %.anon44, align 8
   br label %loop.cond45
 
 loop.cond45:                                      ; preds = %loop.body46, %loop.exit42
-  %43 = load i64, i64* %anon43, align 8
-  %44 = load i64, i64* %anon44, align 8
+  %43 = load i64, i64* %.anon44, align 8
+  %44 = load i64, i64* %.anon43, align 8
   %lt = icmp ult i64 %43, %44
   br i1 %lt, label %loop.body46, label %loop.exit50
 
 loop.body46:                                      ; preds = %loop.cond45
   %45 = load <3 x float>, <3 x float>* %foo2, align 16
-  %46 = load i64, i64* %anon43, align 8
+  %46 = load i64, i64* %.anon44, align 8
   %47 = extractelement <3 x float> %45, i64 %46
   store float %47, float* %a47, align 4
   %48 = load float, float* %a47, align 4
   %fpfpext48 = fpext float %48 to double
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.6, i32 0, i32 0), double %fpfpext48)
-  %49 = load i64, i64* %anon43, align 8
+  %49 = load i64, i64* %.anon44, align 8
   %add49 = add i64 %49, 1
-  store i64 %add49, i64* %anon43, align 8
+  store i64 %add49, i64* %.anon44, align 8
   br label %loop.cond45
 
 loop.exit50:                                      ; preds = %loop.cond45
-  store i64 0, i64* %anon51, align 8
-  store i64 3, i64* %anon52, align 8
+  store i64 3, i64* %.anon51, align 8
+  store i64 0, i64* %.anon52, align 8
   br label %loop.cond53
 
 loop.cond53:                                      ; preds = %loop.body55, %loop.exit50
-  %50 = load i64, i64* %anon51, align 8
-  %51 = load i64, i64* %anon52, align 8
+  %50 = load i64, i64* %.anon52, align 8
+  %51 = load i64, i64* %.anon51, align 8
   %lt54 = icmp ult i64 %50, %51
   br i1 %lt54, label %loop.body55, label %loop.exit60
 
 loop.body55:                                      ; preds = %loop.cond53
-  %52 = load i64, i64* %anon51, align 8
+  %52 = load i64, i64* %.anon52, align 8
   store i64 %52, i64* %i56, align 8
   %53 = load <3 x float>, <3 x float>* %foo2, align 16
-  %54 = load i64, i64* %anon51, align 8
+  %54 = load i64, i64* %.anon52, align 8
   %55 = extractelement <3 x float> %53, i64 %54
   store float %55, float* %a57, align 4
   %56 = load i64, i64* %i56, align 8
   %57 = load float, float* %a57, align 4
   %fpfpext58 = fpext float %57 to double
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.7, i32 0, i32 0), i64 %56, double %fpfpext58)
-  %58 = load i64, i64* %anon51, align 8
+  %58 = load i64, i64* %.anon52, align 8
   %add59 = add i64 %58, 1
-  store i64 %add59, i64* %anon51, align 8
+  store i64 %add59, i64* %.anon52, align 8
   br label %loop.cond53
 
 loop.exit60:                                      ; preds = %loop.cond53
-  store i64 0, i64* %anon61, align 8
-  store i64 3, i64* %anon62, align 8
+  store i64 3, i64* %.anon61, align 8
+  store i64 0, i64* %.anon62, align 8
   br label %loop.cond63
 
 loop.cond63:                                      ; preds = %loop.body65, %loop.exit60
-  %59 = load i64, i64* %anon61, align 8
-  %60 = load i64, i64* %anon62, align 8
+  %59 = load i64, i64* %.anon62, align 8
+  %60 = load i64, i64* %.anon61, align 8
   %lt64 = icmp ult i64 %59, %60
   br i1 %lt64, label %loop.body65, label %loop.exit72
 
 loop.body65:                                      ; preds = %loop.cond63
-  %61 = load i64, i64* %anon61, align 8
+  %61 = load i64, i64* %.anon62, align 8
   %ztrunc67 = trunc i64 %61 to i8
   store i8 %ztrunc67, i8* %i66, align 1
   %62 = load <3 x float>, <3 x float>* %foo2, align 16
-  %63 = load i64, i64* %anon61, align 8
+  %63 = load i64, i64* %.anon62, align 8
   %64 = extractelement <3 x float> %62, i64 %63
   %fpfpext69 = fpext float %64 to double
   store double %fpfpext69, double* %a68, align 8
@@ -307,33 +307,33 @@ loop.body65:                                      ; preds = %loop.cond63
   %uisiext70 = zext i8 %65 to i32
   %66 = load double, double* %a68, align 8
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.8, i32 0, i32 0), i32 %uisiext70, double %66)
-  %67 = load i64, i64* %anon61, align 8
+  %67 = load i64, i64* %.anon62, align 8
   %add71 = add i64 %67, 1
-  store i64 %add71, i64* %anon61, align 8
+  store i64 %add71, i64* %.anon62, align 8
   br label %loop.cond63
 
 loop.exit72:                                      ; preds = %loop.cond63
-  store i64 0, i64* %anon73, align 8
-  store i64 3, i64* %anon74, align 8
+  store i64 3, i64* %.anon73, align 8
+  store i64 0, i64* %.anon74, align 8
   br label %loop.cond75
 
 loop.cond75:                                      ; preds = %loop.body77, %loop.exit72
-  %68 = load i64, i64* %anon73, align 8
-  %69 = load i64, i64* %anon74, align 8
+  %68 = load i64, i64* %.anon74, align 8
+  %69 = load i64, i64* %.anon73, align 8
   %lt76 = icmp ult i64 %68, %69
   br i1 %lt76, label %loop.body77, label %loop.exit81
 
 loop.body77:                                      ; preds = %loop.cond75
   %70 = load <3 x float>, <3 x float>* %foo2, align 16
-  %71 = load i64, i64* %anon73, align 8
+  %71 = load i64, i64* %.anon74, align 8
   %72 = extractelement <3 x float> %70, i64 %71
   %fpfpext79 = fpext float %72 to double
   store double %fpfpext79, double* %a78, align 8
   %73 = load double, double* %a78, align 8
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.9, i32 0, i32 0), double %73)
-  %74 = load i64, i64* %anon73, align 8
+  %74 = load i64, i64* %.anon74, align 8
   %add80 = add i64 %74, 1
-  store i64 %add80, i64* %anon73, align 8
+  store i64 %add80, i64* %.anon74, align 8
   br label %loop.cond75
 
 loop.exit81:                                      ; preds = %loop.cond75
diff --git a/test/test_suite/statements/foreach_custom.c3t b/test/test_suite/statements/foreach_custom.c3t
index b730374ef..752920d2f 100644
--- a/test/test_suite/statements/foreach_custom.c3t
+++ b/test/test_suite/statements/foreach_custom.c3t
@@ -38,8 +38,8 @@ define void @foo_main() #0 {
 entry:
   %i = alloca [3 x i32], align 4
   %x = alloca %Foo, align 8
-  %anon = alloca i64, align 8
-  %anon1 = alloca i64, align 8
+  %.anon = alloca i64, align 8
+  %.anon1 = alloca i64, align 8
   %f = alloca i32, align 4
   %index = alloca i64, align 8
   %0 = bitcast [3 x i32]* %i to i8*
@@ -49,21 +49,21 @@ entry:
   %3 = insertvalue %"int[]" undef, i32* %2, 0
   %4 = insertvalue %"int[]" %3, i64 3, 1
   store %"int[]" %4, %"int[]"* %1, align 8
-  store i64 0, i64* %anon, align 8
   %5 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
   %6 = getelementptr inbounds %"int[]", %"int[]"* %5, i32 0, i32 1
   %7 = load i64, i64* %6, align 8
-  store i64 %7, i64* %anon1, align 8
+  store i64 %7, i64* %.anon, align 8
+  store i64 0, i64* %.anon1, align 8
   br label %loop.cond
 
 loop.cond:                                        ; preds = %entry
-  %8 = load i64, i64* %anon, align 8
-  %9 = load i64, i64* %anon1, align 8
+  %8 = load i64, i64* %.anon1, align 8
+  %9 = load i64, i64* %.anon, align 8
   %lt = icmp ult i64 %8, %9
   br i1 %lt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
-  %10 = load i64, i64* %anon, align 8
+  %10 = load i64, i64* %.anon1, align 8
   store i64 %10, i64* %index, align 8
   %11 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
   %12 = getelementptr inbounds %"int[]", %"int[]"* %11, i32 0, i32 0
diff --git a/test/test_suite/statements/foreach_custom_macro.c3t b/test/test_suite/statements/foreach_custom_macro.c3t
index 3d6a6b006..201651718 100644
--- a/test/test_suite/statements/foreach_custom_macro.c3t
+++ b/test/test_suite/statements/foreach_custom_macro.c3t
@@ -36,8 +36,8 @@ define void @foo_main() #0 {
 entry:
   %i = alloca [3 x i32], align 4
   %x = alloca %Foo, align 8
-  %anon = alloca i64, align 8
-  %anon1 = alloca i64, align 8
+  %.anon = alloca i64, align 8
+  %.anon1 = alloca i64, align 8
   %f = alloca i32, align 4
   %index = alloca i64, align 8
   %0 = bitcast [3 x i32]* %i to i8*
@@ -47,21 +47,21 @@ entry:
   %3 = insertvalue %"int[]" undef, i32* %2, 0
   %4 = insertvalue %"int[]" %3, i64 3, 1
   store %"int[]" %4, %"int[]"* %1, align 8
-  store i64 0, i64* %anon, align 8
   %5 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
   %6 = getelementptr inbounds %"int[]", %"int[]"* %5, i32 0, i32 1
   %7 = load i64, i64* %6, align 8
-  store i64 %7, i64* %anon1, align 8
+  store i64 %7, i64* %.anon, align 8
+  store i64 0, i64* %.anon1, align 8
   br label %loop.cond
 
 loop.cond:                                        ; preds = %entry
-  %8 = load i64, i64* %anon, align 8
-  %9 = load i64, i64* %anon1, align 8
+  %8 = load i64, i64* %.anon1, align 8
+  %9 = load i64, i64* %.anon, align 8
   %lt = icmp ult i64 %8, %9
   br i1 %lt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
-  %10 = load i64, i64* %anon, align 8
+  %10 = load i64, i64* %.anon1, align 8
   store i64 %10, i64* %index, align 8
   %11 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
   %12 = getelementptr inbounds %"int[]", %"int[]"* %11, i32 0, i32 0
diff --git a/test/test_suite/statements/foreach_r_test.c3t b/test/test_suite/statements/foreach_r_test.c3t
new file mode 100644
index 000000000..75d2db673
--- /dev/null
+++ b/test/test_suite/statements/foreach_r_test.c3t
@@ -0,0 +1,94 @@
+// #target: macos-x64
+module test;
+import std::io;
+
+fn void main()
+{
+	int[*] x = { 1, 5, 10 };
+	int[] y = &x;
+	foreach_r (int i, val : y)
+	{
+		io::printfln("%d: %d", i, val);
+	}
+}
+
+/* #expect: test.ll
+
+entry:
+  %x = alloca [3 x i32], align 4
+  %y = alloca %"int[]", align 8
+  %.anon = alloca i64, align 8
+  %i = alloca i32, align 4
+  %val = alloca i32, align 4
+  %retparam = alloca i64, align 8
+  %taddr = alloca %"char[]", align 8
+  %vararg = alloca %"variant[]", align 8
+  %varargslots = alloca [2 x %variant], align 16
+  %0 = bitcast [3 x i32]* %x to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %0, i8* align 4 bitcast ([3 x i32]* @.__const to i8*), i32 12, i1 false)
+  %1 = bitcast [3 x i32]* %x to i32*
+  %2 = insertvalue %"int[]" undef, i32* %1, 0
+  %3 = insertvalue %"int[]" %2, i64 3, 1
+  store %"int[]" %3, %"int[]"* %y, align 8
+  %4 = getelementptr inbounds %"int[]", %"int[]"* %y, i32 0, i32 1
+  %5 = load i64, i64* %4, align 8
+  store i64 %5, i64* %.anon, align 8
+  br label %loop.cond
+
+loop.cond:                                        ; preds = %voiderr, %entry
+  %6 = load i64, i64* %.anon, align 8
+  %gt = icmp ugt i64 %6, 0
+  br i1 %gt, label %loop.body, label %loop.exit
+
+loop.body:                                        ; preds = %loop.cond
+  %7 = load i64, i64* %.anon, align 8
+  %sub = sub i64 %7, 1
+  store i64 %sub, i64* %.anon, align 8
+  %8 = load i64, i64* %.anon, align 8
+  %uisitrunc = trunc i64 %8 to i32
+  store i32 %uisitrunc, i32* %i, align 4
+  %9 = getelementptr inbounds %"int[]", %"int[]"* %y, i32 0, i32 0
+  %10 = load i32*, i32** %9, align 8
+  %11 = load i64, i64* %.anon, align 8
+  %ptroffset = getelementptr inbounds i32, i32* %10, i64 %11
+  %12 = load i32, i32* %ptroffset, align 4
+  store i32 %12, i32* %val, align 4
+  store %"char[]" { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i32 0, i32 0), i64 6 }, %"char[]"* %taddr, align 8
+  %13 = bitcast %"char[]"* %taddr to { i8*, i64 }*
+  %14 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %13, i32 0, i32 0
+  %lo = load i8*, i8** %14, align 8
+  %15 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %13, i32 0, i32 1
+  %hi = load i64, i64* %15, align 8
+  %16 = bitcast i32* %i to i8*
+  %17 = insertvalue %variant undef, i8* %16, 0
+  %18 = insertvalue %variant %17, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
+  %19 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0
+  store %variant %18, %variant* %19, align 16
+  %20 = bitcast i32* %val to i8*
+  %21 = insertvalue %variant undef, i8* %20, 0
+  %22 = insertvalue %variant %21, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
+  %23 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1
+  store %variant %22, %variant* %23, align 16
+  %24 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1
+  store i64 2, i64* %24, align 8
+  %25 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0
+  %26 = bitcast [2 x %variant]* %varargslots to %variant*
+  store %variant* %26, %variant** %25, align 8
+  %27 = bitcast %"variant[]"* %vararg to { i8*, i64 }*
+  %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 0
+  %lo1 = load i8*, i8** %28, align 8
+  %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 1
+  %hi2 = load i64, i64* %29, align 8
+  %30 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo1, i64 %hi2)
+  %not_err = icmp eq i64 %30, 0
+  br i1 %not_err, label %after_check, label %voiderr
+
+after_check:                                      ; preds = %loop.body
+  br label %voiderr
+
+voiderr:                                          ; preds = %after_check, %loop.body
+  br label %loop.cond
+
+loop.exit:                                        ; preds = %loop.cond
+  ret void
+}
diff --git a/test/test_suite/struct/nested_struct_init.c3t b/test/test_suite/struct/nested_struct_init.c3t
index 4486f2bcd..fff61d8fc 100644
--- a/test/test_suite/struct/nested_struct_init.c3t
+++ b/test/test_suite/struct/nested_struct_init.c3t
@@ -32,20 +32,20 @@ fn void main()
 }
 /* #expect: foo.ll
 
-%Matrix2x2 = type { %anon }
-%anon = type { %anon.0 }
-%anon.0 = type { float, float, float, float }
-%Matrix2x2_b = type { %anon.1 }
-%anon.1 = type { [4 x float] }
+%Matrix2x2 = type { %.anon }
+%.anon = type { %.anon.0 }
+%.anon.0 = type { float, float, float, float }
+%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_$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_$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
+@.__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
 
 ; Function Attrs: nounwind
@@ -58,22 +58,22 @@ entry:
   %1 = bitcast %Matrix2x2_b* %m2 to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %1, i8* align 4 bitcast (%Matrix2x2_b* @.__const.8 to i8*), i32 16, i1 false)
   %2 = getelementptr inbounds %Matrix2x2, %Matrix2x2* %m, i32 0, i32 0
-  %3 = bitcast %anon* %2 to %anon.0*
-  %4 = getelementptr inbounds %anon.0, %anon.0* %3, i32 0, i32 0
+  %3 = bitcast %.anon* %2 to %.anon.0*
+  %4 = getelementptr inbounds %.anon.0, %.anon.0* %3, i32 0, i32 0
   %5 = load float, float* %4, align 4
   %fpfpext = fpext float %5 to double
   %6 = getelementptr inbounds %Matrix2x2, %Matrix2x2* %m, i32 0, i32 0
-  %7 = bitcast %anon* %6 to [4 x float]*
+  %7 = bitcast %.anon* %6 to [4 x float]*
   %8 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
   %9 = load float, float* %8, align 4
   %fpfpext1 = fpext float %9 to double
   %10 = getelementptr inbounds %Matrix2x2, %Matrix2x2* %m, i32 0, i32 0
-  %11 = bitcast %anon* %10 to %anon.0*
-  %12 = getelementptr inbounds %anon.0, %anon.0* %11, i32 0, i32 2
+  %11 = bitcast %.anon* %10 to %.anon.0*
+  %12 = getelementptr inbounds %.anon.0, %.anon.0* %11, i32 0, i32 2
   %13 = load float, float* %12, align 4
   %fpfpext2 = fpext float %13 to double
   %14 = getelementptr inbounds %Matrix2x2, %Matrix2x2* %m, i32 0, i32 0
-  %15 = bitcast %anon* %14 to [4 x float]*
+  %15 = bitcast %.anon* %14 to [4 x float]*
   %16 = getelementptr inbounds [4 x float], [4 x float]* %15, i64 0, i64 3
   %17 = load float, float* %16, align 4
   %fpfpext3 = fpext float %17 to double
diff --git a/test/test_suite/struct/nested_struct_union_init.c3t b/test/test_suite/struct/nested_struct_union_init.c3t
index e6a484821..3b78a2e60 100644
--- a/test/test_suite/struct/nested_struct_union_init.c3t
+++ b/test/test_suite/struct/nested_struct_union_init.c3t
@@ -53,14 +53,14 @@ fn void main()
 
 /* #expect: foob.ll
 
-%Matrix2x2 = type { %anon.1 }
-%anon.1 = type { [4 x float] }
-%Matrix2x2_b = type { %anon.2 }
-%anon.2 = type { %anon.3 }
-%anon.3 = type { float, float, float, float }
-%Matrix3x3 = type { %anon }
-%anon = type { %anon.0 }
-%anon.0 = type { float, float, float, float, float, float, float, float, float }
+%Matrix2x2 = type { %.anon.1 }
+%.anon.1 = type { [4 x float] }
+%Matrix2x2_b = type { %.anon.2 }
+%.anon.2 = type { %.anon.3 }
+%.anon.3 = type { float, float, float, float }
+%Matrix3x3 = type { %.anon }
+%.anon = type { %.anon.0 }
+%.anon.0 = type { float, float, float, float, float, float, float, float, float }
 
 define void @foob_main() #0 {
 entry:
@@ -68,46 +68,46 @@ entry:
   %m = alloca %Matrix2x2, align 4
   %m2 = alloca %Matrix2x2_b, align 4
   %0 = getelementptr inbounds %Matrix3x3, %Matrix3x3* %x, i32 0, i32 0
-  %1 = bitcast %anon* %0 to %anon.0*
-  %2 = getelementptr inbounds %anon.0, %anon.0* %1, i32 0, i32 0
+  %1 = bitcast %.anon* %0 to %.anon.0*
+  %2 = getelementptr inbounds %.anon.0, %.anon.0* %1, i32 0, i32 0
   store float 1.000000e+00, float* %2, align 4
-  %3 = getelementptr inbounds %anon.0, %anon.0* %1, i32 0, i32 1
+  %3 = getelementptr inbounds %.anon.0, %.anon.0* %1, i32 0, i32 1
   store float 2.000000e+00, float* %3, align 4
-  %4 = getelementptr inbounds %anon.0, %anon.0* %1, i32 0, i32 2
+  %4 = getelementptr inbounds %.anon.0, %.anon.0* %1, i32 0, i32 2
   store float 3.000000e+00, float* %4, align 4
-  %5 = getelementptr inbounds %anon.0, %anon.0* %1, i32 0, i32 3
+  %5 = getelementptr inbounds %.anon.0, %.anon.0* %1, i32 0, i32 3
   store float 4.000000e+00, float* %5, align 4
-  %6 = getelementptr inbounds %anon.0, %anon.0* %1, i32 0, i32 4
+  %6 = getelementptr inbounds %.anon.0, %.anon.0* %1, i32 0, i32 4
   store float 5.000000e+00, float* %6, align 4
-  %7 = getelementptr inbounds %anon.0, %anon.0* %1, i32 0, i32 5
+  %7 = getelementptr inbounds %.anon.0, %.anon.0* %1, i32 0, i32 5
   store float 6.000000e+00, float* %7, align 4
-  %8 = getelementptr inbounds %anon.0, %anon.0* %1, i32 0, i32 6
+  %8 = getelementptr inbounds %.anon.0, %.anon.0* %1, i32 0, i32 6
   store float 7.000000e+00, float* %8, align 4
-  %9 = getelementptr inbounds %anon.0, %anon.0* %1, i32 0, i32 7
+  %9 = getelementptr inbounds %.anon.0, %.anon.0* %1, i32 0, i32 7
   store float 8.000000e+00, float* %9, align 4
-  %10 = getelementptr inbounds %anon.0, %anon.0* %1, i32 0, i32 8
+  %10 = getelementptr inbounds %.anon.0, %.anon.0* %1, i32 0, i32 8
   store float 9.000000e+00, float* %10, align 4
   %11 = bitcast %Matrix2x2* %m to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %11, i8* align 4 bitcast (%Matrix2x2* @.__const to i8*), i32 16, i1 false)
   %12 = bitcast %Matrix2x2_b* %m2 to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %12, i8* align 4 bitcast (%Matrix2x2_b* @.__const.16 to i8*), i32 16, i1 false)
   %13 = getelementptr inbounds %Matrix3x3, %Matrix3x3* %x, i32 0, i32 0
-  %14 = bitcast %anon* %13 to %anon.0*
-  %15 = getelementptr inbounds %anon.0, %anon.0* %14, i32 0, i32 0
+  %14 = bitcast %.anon* %13 to %.anon.0*
+  %15 = getelementptr inbounds %.anon.0, %.anon.0* %14, i32 0, i32 0
   %16 = load float, float* %15, align 4
   %fpfpext = fpext float %16 to double
   %17 = getelementptr inbounds %Matrix3x3, %Matrix3x3* %x, i32 0, i32 0
-  %18 = bitcast %anon* %17 to [9 x float]*
+  %18 = bitcast %.anon* %17 to [9 x float]*
   %19 = getelementptr inbounds [9 x float], [9 x float]* %18, i64 0, i64 1
   %20 = load float, float* %19, align 4
   %fpfpext1 = fpext float %20 to double
   %21 = getelementptr inbounds %Matrix3x3, %Matrix3x3* %x, i32 0, i32 0
-  %22 = bitcast %anon* %21 to %anon.0*
-  %23 = getelementptr inbounds %anon.0, %anon.0* %22, i32 0, i32 3
+  %22 = bitcast %.anon* %21 to %.anon.0*
+  %23 = getelementptr inbounds %.anon.0, %.anon.0* %22, i32 0, i32 3
   %24 = load float, float* %23, align 4
   %fpfpext2 = fpext float %24 to double
   %25 = getelementptr inbounds %Matrix3x3, %Matrix3x3* %x, i32 0, i32 0
-  %26 = bitcast %anon* %25 to [9 x float]*
+  %26 = bitcast %.anon* %25 to [9 x float]*
   %27 = getelementptr inbounds [9 x float], [9 x float]* %26, i64 0, i64 3
   %28 = load float, float* %27, align 4
   %fpfpext3 = fpext float %28 to double
diff --git a/test/test_suite/struct/struct_codegen_fam.c3t b/test/test_suite/struct/struct_codegen_fam.c3t
index 1cb97e9be..ab6228118 100644
--- a/test/test_suite/struct/struct_codegen_fam.c3t
+++ b/test/test_suite/struct/struct_codegen_fam.c3t
@@ -19,8 +19,8 @@ fn void test(Bar b)
 
 /* #expect: foo.ll
 
-%Bar = type { %anon, i32, [0 x i32] }
-%anon = type { i32 }
+%Bar = type { %.anon, i32, [0 x i32] }
+%.anon = type { i32 }
 
 define void @foo_test(%Bar* byval(%Bar) align 8 %0) #0 {
 entry:
diff --git a/test/test_suite/union/union_in_struct.c3t b/test/test_suite/union/union_in_struct.c3t
index 5fb0cd4c5..6dee64784 100644
--- a/test/test_suite/union/union_in_struct.c3t
+++ b/test/test_suite/union/union_in_struct.c3t
@@ -38,7 +38,7 @@ fn void test(Blend_Map_Entry* foo)
 %vals = type { [2 x double], [8 x i8] }
 
 @test_foo1 = local_unnamed_addr global { i8, [4 x i8], { i32, [4 x i8] }, i32 } { i8 0, [4 x i8] undef, { i32, [4 x i8] } { i32 3, [4 x i8] undef }, i32 4 }, align 8
-@test_foo2 = local_unnamed_addr global %Foo { i8 0, %anon { double 3.000000e+00 }, i32 4 }, align 8
+@test_foo2 = local_unnamed_addr global %Foo { i8 0, %.anon { double 3.000000e+00 }, i32 4 }, align 8
 @test_a = local_unnamed_addr global { { [5 x float], [4 x i8] } } { { [5 x float], [4 x i8] } { [5 x float] [float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00, float 5.000000e+00], [4 x i8] undef } }, align 8
 @test_b = local_unnamed_addr global %Blend_Map_Entry { %vals { [2 x double] [double 6.000000e+00, double 7.000000e+00], [8 x i8] undef } }, align 8
 @test_c = local_unnamed_addr global { { { [2 x float], float, [2 x float] }, [4 x i8] } } { { { [2 x float], float, [2 x float] }, [4 x i8] } { { [2 x float], float, [2 x float] } { [2 x float] zeroinitializer, float 1.000000e+00, [2 x float] zeroinitializer }, [4 x i8] undef } }, align 8
diff --git a/test/test_suite/variant/variant_assign.c3t b/test/test_suite/variant/variant_assign.c3t
index ca1189764..0077353ed 100644
--- a/test/test_suite/variant/variant_assign.c3t
+++ b/test/test_suite/variant/variant_assign.c3t
@@ -121,7 +121,7 @@ switch.exit:                                      ; preds = %switch.default, %sw
 define void @foo_test2(i64 %0, i8* %1) #0 {
 entry:
   %y = alloca %variant, align 8
-  %anon = alloca %variant, align 8
+  %.anon = alloca %variant, align 8
   %switch = alloca i64, align 8
   %z = alloca i32*, align 8
   %taddr = alloca i32, align 4
@@ -131,7 +131,7 @@ entry:
   store i64 %0, i64* %2, align 8
   %3 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %pair, i32 0, i32 1
   store i8* %1, i8** %3, align 8
-  %4 = bitcast %variant* %anon to i8*
+  %4 = bitcast %variant* %.anon to i8*
   %5 = bitcast %variant* %y to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %4, i8* align 8 %5, i32 16, i1 false)
   %6 = getelementptr inbounds %variant, %variant* %y, i32 0, i32 1
@@ -145,7 +145,7 @@ switch.entry:                                     ; preds = %entry
   br i1 %eq, label %switch.case, label %next_if
 
 switch.case:                                      ; preds = %switch.entry
-  %9 = getelementptr inbounds %variant, %variant* %anon, i32 0, i32 0
+  %9 = getelementptr inbounds %variant, %variant* %.anon, i32 0, i32 0
   %10 = bitcast i8** %9 to i32**
   %11 = load i32*, i32** %10, align 8
   store i32* %11, i32** %z, align 8
@@ -164,7 +164,7 @@ next_if:                                          ; preds = %switch.entry
   br i1 %eq1, label %switch.case2, label %next_if4
 
 switch.case2:                                     ; preds = %next_if
-  %17 = getelementptr inbounds %variant, %variant* %anon, i32 0, i32 0
+  %17 = getelementptr inbounds %variant, %variant* %.anon, i32 0, i32 0
   %18 = bitcast i8** %17 to double**
   %19 = load double*, double** %18, align 8
   store double* %19, double** %z3, align 8
@@ -188,7 +188,7 @@ switch.exit:                                      ; preds = %switch.default, %sw
 define void @foo_test3(i64 %0, i8* %1) #0 {
 entry:
   %y = alloca %variant, align 8
-  %anon = alloca %variant, align 8
+  %.anon = alloca %variant, align 8
   %switch = alloca i64, align 8
   %z = alloca i32, align 4
   %z3 = alloca double, align 8
@@ -197,7 +197,7 @@ entry:
   store i64 %0, i64* %2, align 8
   %3 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %pair, i32 0, i32 1
   store i8* %1, i8** %3, align 8
-  %4 = bitcast %variant* %anon to i8*
+  %4 = bitcast %variant* %.anon to i8*
   %5 = bitcast %variant* %y to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %4, i8* align 8 %5, i32 16, i1 false)
   %6 = getelementptr inbounds %variant, %variant* %y, i32 0, i32 1
@@ -211,7 +211,7 @@ switch.entry:                                     ; preds = %entry
   br i1 %eq, label %switch.case, label %next_if
 
 switch.case:                                      ; preds = %switch.entry
-  %9 = getelementptr inbounds %variant, %variant* %anon, i32 0, i32 0
+  %9 = getelementptr inbounds %variant, %variant* %.anon, i32 0, i32 0
   %10 = bitcast i8** %9 to i32**
   %11 = load i32*, i32** %10, align 8
   %12 = load i32, i32* %11, align 8
@@ -225,7 +225,7 @@ next_if:                                          ; preds = %switch.entry
   br i1 %eq1, label %switch.case2, label %next_if4
 
 switch.case2:                                     ; preds = %next_if
-  %14 = getelementptr inbounds %variant, %variant* %anon, i32 0, i32 0
+  %14 = getelementptr inbounds %variant, %variant* %.anon, i32 0, i32 0
   %15 = bitcast i8** %14 to double**
   %16 = load double*, double** %15, align 8
   %17 = load double, double* %16, align 8
diff --git a/test/test_suite/variant/variant_test.c3t b/test/test_suite/variant/variant_test.c3t
index e8d8a7952..574111cea 100644
--- a/test/test_suite/variant/variant_test.c3t
+++ b/test/test_suite/variant/variant_test.c3t
@@ -134,30 +134,30 @@ switch.exit:                                      ; preds = %switch.default, %sw
 define void @foo_test_all(i8* %0, i64 %1) #0 {
 entry:
   %y = alloca %"variant[]", align 8
-  %anon = alloca i64, align 8
-  %anon1 = alloca i64, align 8
+  %.anon = alloca i64, align 8
+  %.anon1 = alloca i64, align 8
   %element = alloca %variant, align 8
   %pair = bitcast %"variant[]"* %y to { i8*, i64 }*
   %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %pair, i32 0, i32 0
   store i8* %0, i8** %2, align 8
   %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %pair, i32 0, i32 1
   store i64 %1, i64* %3, align 8
-  store i64 0, i64* %anon, align 8
   %4 = getelementptr inbounds %"variant[]", %"variant[]"* %y, i32 0, i32 1
   %5 = load i64, i64* %4, align 8
-  store i64 %5, i64* %anon1, align 8
+  store i64 %5, i64* %.anon, align 8
+  store i64 0, i64* %.anon1, align 8
   br label %loop.cond
 
 loop.cond:                                        ; preds = %loop.body, %entry
-  %6 = load i64, i64* %anon, align 8
-  %7 = load i64, i64* %anon1, align 8
+  %6 = load i64, i64* %.anon1, align 8
+  %7 = load i64, i64* %.anon, align 8
   %lt = icmp ult i64 %6, %7
   br i1 %lt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
   %8 = getelementptr inbounds %"variant[]", %"variant[]"* %y, i32 0, i32 0
   %9 = load %variant*, %variant** %8, align 8
-  %10 = load i64, i64* %anon, align 8
+  %10 = load i64, i64* %.anon1, align 8
   %ptroffset = getelementptr inbounds %variant, %variant* %9, i64 %10
   %11 = bitcast %variant* %element to i8*
   %12 = bitcast %variant* %ptroffset to i8*
@@ -168,9 +168,9 @@ loop.body:                                        ; preds = %loop.cond
   %15 = getelementptr inbounds { i64, i8* }, { i64, i8* }* %13, i32 0, i32 1
   %hi = load i8*, i8** %15, align 8
   call void @foo_test(i64 %lo, i8* %hi)
-  %16 = load i64, i64* %anon, align 8
+  %16 = load i64, i64* %.anon1, align 8
   %add = add i64 %16, 1
-  store i64 %add, i64* %anon, align 8
+  store i64 %add, i64* %.anon1, align 8
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
diff --git a/test/test_suite2/bitstruct/embedded_bitstruct.c3t b/test/test_suite2/bitstruct/embedded_bitstruct.c3t
index 7d1d49e6b..580cf5a57 100644
--- a/test/test_suite2/bitstruct/embedded_bitstruct.c3t
+++ b/test/test_suite2/bitstruct/embedded_bitstruct.c3t
@@ -52,8 +52,8 @@ entry:
   %f = alloca %Foo, align 4
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %b, ptr align 4 @.__const, i32 12, i1 false)
   %0 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1
-  %1 = getelementptr inbounds %anon, ptr %0, i32 0, i32 0
-  %2 = getelementptr inbounds %anon.0, ptr %1, i32 0, i32 0
+  %1 = getelementptr inbounds %.anon, ptr %0, i32 0, i32 0
+  %2 = getelementptr inbounds %.anon.0, ptr %1, i32 0, i32 0
   %3 = load i32, ptr %2, align 4
   %4 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 2
   %5 = load i32, ptr %4, align 4
@@ -62,15 +62,15 @@ entry:
   call void (ptr, ...) @printf(ptr @.str, i32 %3, i32 %ashr)
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %f, ptr align 4 @.__const.10, i32 16, i1 false)
   %6 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0
-  %7 = getelementptr inbounds %anon.1, ptr %6, i32 0, i32 0
-  %8 = getelementptr inbounds %anon.2, ptr %7, i32 0, i32 0
+  %7 = getelementptr inbounds %.anon.1, ptr %6, i32 0, i32 0
+  %8 = getelementptr inbounds %.anon.2, ptr %7, i32 0, i32 0
   %9 = load i32, ptr %8, align 4
   %10 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0
-  %11 = getelementptr inbounds %anon.1, ptr %10, i32 0, i32 1
-  %12 = getelementptr inbounds %anon.3, ptr %11, i32 0, i32 0
+  %11 = getelementptr inbounds %.anon.1, ptr %10, i32 0, i32 1
+  %12 = getelementptr inbounds %.anon.3, ptr %11, i32 0, i32 0
   %13 = load i32, ptr %12, align 4
   %14 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0
-  %15 = getelementptr inbounds %anon.1, ptr %14, i32 0, i32 2
+  %15 = getelementptr inbounds %.anon.1, ptr %14, i32 0, i32 2
   %16 = load i32, ptr %15, align 4
   %17 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 1
   %18 = load i32, ptr %17, align 4
diff --git a/test/test_suite2/errors/error_regression_2.c3t b/test/test_suite2/errors/error_regression_2.c3t
index 991d0e315..0a6f9c380 100644
--- a/test/test_suite2/errors/error_regression_2.c3t
+++ b/test/test_suite2/errors/error_regression_2.c3t
@@ -150,7 +150,6 @@ fn void main()
 
 /* #expect: test.ll
 
-; Function Attrs: nounwind
 define void @test_Summary_print(ptr %0, ptr %1) #0 {
 entry:
   %title = alloca %"char[]", align 8
@@ -758,8 +757,8 @@ define void @test_main() #0 {
 entry:
   %URLS = alloca %"char[][]", align 8
   %literal = alloca [5 x %"char[]"], align 16
-  %anon = alloca i64, align 8
-  %anon1 = alloca i64, align 8
+  %.anon = alloca i64, align 8
+  %.anon1 = alloca i64, align 8
   %url = alloca %"char[]", align 8
   %summary = alloca %Summary, align 8
   %result = alloca %Summary, align 8
@@ -780,22 +779,22 @@ entry:
   %5 = insertvalue %"char[][]" undef, ptr %literal, 0
   %6 = insertvalue %"char[][]" %5, i64 5, 1
   store %"char[][]" %6, ptr %URLS, align 8
-  store i64 0, ptr %anon, align 8
   %7 = getelementptr inbounds %"char[][]", ptr %URLS, i32 0, i32 1
   %8 = load i64, ptr %7, align 8
-  store i64 %8, ptr %anon1, align 8
+  store i64 %8, ptr %.anon, align 8
+  store i64 0, ptr %.anon1, align 8
   br label %loop.cond
 
 loop.cond:                                        ; preds = %phi_block12, %entry
-  %9 = load i64, ptr %anon, align 8
-  %10 = load i64, ptr %anon1, align 8
+  %9 = load i64, ptr %.anon1, align 8
+  %10 = load i64, ptr %.anon, align 8
   %lt = icmp ult i64 %9, %10
   br i1 %lt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
   %11 = getelementptr inbounds %"char[][]", ptr %URLS, i32 0, i32 0
   %12 = load ptr, ptr %11, align 8
-  %13 = load i64, ptr %anon, align 8
+  %13 = load i64, ptr %.anon1, align 8
   %ptroffset = getelementptr inbounds %"char[]", ptr %12, i64 %13
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %url, ptr align 8 %ptroffset, i32 16, i1 false)
   %14 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1
@@ -889,9 +888,9 @@ phi_block12:                                      ; preds = %else_block11, %afte
   %val13 = phi i1 [ %44, %after_check10 ], [ false, %else_block11 ]
   %ternary = select i1 %val13, ptr @.str.26, ptr @.str.27
   %45 = call i32 (ptr, ...) @printf(ptr @.str.25, ptr %val7, ptr %ternary)
-  %46 = load i64, ptr %anon, align 8
+  %46 = load i64, ptr %.anon1, align 8
   %add = add i64 %46, 1
-  store i64 %add, ptr %anon, align 8
+  store i64 %add, ptr %.anon1, align 8
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
diff --git a/test/test_suite2/expressions/pointer_access.c3t b/test/test_suite2/expressions/pointer_access.c3t
index ad7d61917..66aba105f 100644
--- a/test/test_suite2/expressions/pointer_access.c3t
+++ b/test/test_suite2/expressions/pointer_access.c3t
@@ -37,14 +37,14 @@ fn void testSimple()
 // TODO these may be wrong.
 /* #expect: pointer_access.ll
 
-%ExtraSimple = type { i32, i32, %c, %anon, %anon.0, i32 }
+%ExtraSimple = type { i32, i32, %c, %.anon, %.anon.0, i32 }
 %c = type { double, double, double, double, double }
-%anon = type { i32, i32 }
-%anon.0 = type { double }
+%.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_$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
 
@@ -67,9 +67,9 @@ entry:
   %7 = getelementptr inbounds %c, ptr %2, i32 0, i32 4
   store double 3.300000e+00, ptr %7, align 8
   %8 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 3
-  %9 = getelementptr inbounds %anon, ptr %8, i32 0, i32 0
+  %9 = getelementptr inbounds %.anon, ptr %8, i32 0, i32 0
   store i32 0, ptr %9, align 8
-  %10 = getelementptr inbounds %anon, ptr %8, i32 0, i32 1
+  %10 = getelementptr inbounds %.anon, ptr %8, i32 0, i32 1
   store i32 0, ptr %10, align 4
   %11 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 4
   call void @llvm.memset.p0.i64(ptr align 8 %11, i8 0, i64 8, i1 false)
@@ -94,10 +94,10 @@ entry:
   %28 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 4
   %29 = load double, ptr %28, align 8
   %30 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 3
-  %31 = getelementptr inbounds %anon, ptr %30, i32 0, i32 0
+  %31 = getelementptr inbounds %.anon, ptr %30, i32 0, i32 0
   %32 = load i32, ptr %31, align 8
   %33 = getelementptr inbounds %ExtraSimple, ptr %a, i32 0, i32 3
-  %34 = getelementptr inbounds %anon, ptr %33, i32 0, i32 1
+  %34 = getelementptr inbounds %.anon, ptr %33, i32 0, i32 1
   %35 = load i32, ptr %34, align 4
   call void (ptr, ...) @printf(ptr @.str, i32 %16, double %19, double %22, double %25, i32 %27, double %29, i32 %32, i32 %35)
   ret void
diff --git a/test/test_suite2/initializer_lists/ranges_to_dynamic.c3t b/test/test_suite2/initializer_lists/ranges_to_dynamic.c3t
index 8942723f4..e5a62f0af 100644
--- a/test/test_suite2/initializer_lists/ranges_to_dynamic.c3t
+++ b/test/test_suite2/initializer_lists/ranges_to_dynamic.c3t
@@ -22,7 +22,7 @@ fn void main()
 define void @test_test(i32 %0) #0 {
 entry:
   %y = alloca [10 x i32], align 16
-  %anon = alloca i64, align 8
+  %.anon = alloca i64, align 8
   %v = alloca i32, align 4
   call void @llvm.memset.p0.i64(ptr align 16 %y, i8 0, i64 40, i1 false)
   %1 = getelementptr inbounds [10 x i32], ptr %y, i64 0, i64 0
@@ -39,24 +39,24 @@ entry:
   store i32 %0, ptr %6, align 4
   %7 = getelementptr inbounds [10 x i32], ptr %y, i64 0, i64 8
   store i32 %0, ptr %7, align 4
-  store i64 0, ptr %anon, align 8
+  store i64 0, ptr %.anon, align 8
   br label %loop.cond
 
 loop.cond:                                        ; preds = %loop.body, %entry
-  %8 = load i64, ptr %anon, align 8
+  %8 = load i64, ptr %.anon, align 8
   %gt = icmp ugt i64 10, %8
   br i1 %gt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
-  %9 = load i64, ptr %anon, align 8
+  %9 = load i64, ptr %.anon, align 8
   %10 = getelementptr inbounds [10 x i32], ptr %y, i64 0, i64 %9
   %11 = load i32, ptr %10, align 4
   store i32 %11, ptr %v, align 4
   %12 = load i32, ptr %v, align 4
   call void (ptr, ...) @printf(ptr @.str, i32 %12)
-  %13 = load i64, ptr %anon, align 8
+  %13 = load i64, ptr %.anon, align 8
   %add = add i64 %13, 1
-  store i64 %add, ptr %anon, align 8
+  store i64 %add, ptr %.anon, align 8
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
diff --git a/test/test_suite2/slices/slice_assign.c3t b/test/test_suite2/slices/slice_assign.c3t
index 1a202efa3..13df9b6f6 100644
--- a/test/test_suite2/slices/slice_assign.c3t
+++ b/test/test_suite2/slices/slice_assign.c3t
@@ -26,7 +26,7 @@ declare void @printf(ptr, ...) #0
 define void @test_main() #0 {
 entry:
   %x = alloca [8 x i32], align 16
-  %anon = alloca i64, align 8
+  %.anon = alloca i64, align 8
   %i = alloca i32, align 4
   call void @llvm.memset.p0.i64(ptr align 16 %x, i8 0, i64 32, i1 false)
   %0 = getelementptr inbounds [8 x i32], ptr %x, i64 0, i64 0
@@ -43,24 +43,24 @@ entry:
   store i32 52, ptr %5, align 4
   %6 = getelementptr inbounds [8 x i32], ptr %x, i64 0, i64 7
   store i32 52, ptr %6, align 4
-  store i64 0, ptr %anon, align 8
+  store i64 0, ptr %.anon, align 8
   br label %loop.cond
 
 loop.cond:                                        ; preds = %loop.body, %entry
-  %7 = load i64, ptr %anon, align 8
+  %7 = load i64, ptr %.anon, align 8
   %gt = icmp ugt i64 8, %7
   br i1 %gt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
-  %8 = load i64, ptr %anon, align 8
+  %8 = load i64, ptr %.anon, align 8
   %9 = getelementptr inbounds [8 x i32], ptr %x, i64 0, i64 %8
   %10 = load i32, ptr %9, align 4
   store i32 %10, ptr %i, align 4
   %11 = load i32, ptr %i, align 4
   call void (ptr, ...) @printf(ptr @.str, i32 %11)
-  %12 = load i64, ptr %anon, align 8
+  %12 = load i64, ptr %.anon, align 8
   %add = add i64 %12, 1
-  store i64 %add, ptr %anon, align 8
+  store i64 %add, ptr %.anon, align 8
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
diff --git a/test/test_suite2/statements/custom_foreach_with_ref.c3t b/test/test_suite2/statements/custom_foreach_with_ref.c3t
index ae0fef70e..16be4dc1d 100644
--- a/test/test_suite2/statements/custom_foreach_with_ref.c3t
+++ b/test/test_suite2/statements/custom_foreach_with_ref.c3t
@@ -132,44 +132,44 @@ entry:
   %a = alloca i32, align 4
   %a1 = alloca i32, align 4
   %a3 = alloca i32, align 4
-  %anon = alloca i32, align 4
-  %anon5 = alloca ptr, align 8
-  %anon6 = alloca i32, align 4
+  %.anon = alloca ptr, align 8
+  %.anon5 = alloca i32, align 4
+  %.anon6 = alloca i32, align 4
   %i = alloca i32, align 4
   %y = alloca i32, align 4
   %a7 = alloca i32, align 4
-  %anon9 = alloca i32, align 4
-  %anon10 = alloca i32, align 4
+  %.anon9 = alloca i32, align 4
+  %.anon10 = alloca i32, align 4
   %i14 = alloca i32, align 4
   %y15 = alloca ptr, align 8
   %a16 = alloca i32, align 4
-  %anon21 = alloca i32, align 4
-  %anon22 = alloca i32, align 4
+  %.anon21 = alloca i32, align 4
+  %.anon22 = alloca i32, align 4
   %i26 = alloca i32, align 4
   %y27 = alloca i32, align 4
   %a28 = alloca i32, align 4
-  %anon32 = alloca i32, align 4
-  %anon33 = alloca i32, align 4
+  %.anon32 = alloca i32, align 4
+  %.anon33 = alloca i32, align 4
   %i37 = alloca i32, align 4
   %y38 = alloca i32, align 4
   %a39 = alloca i32, align 4
-  %anon43 = alloca i32, align 4
-  %anon44 = alloca i32, align 4
+  %.anon43 = alloca i32, align 4
+  %.anon44 = alloca i32, align 4
   %i48 = alloca i32, align 4
   %y49 = alloca i32, align 4
   %a50 = alloca i32, align 4
-  %anon55 = alloca i64, align 8
-  %anon56 = alloca [5 x i32], align 16
+  %.anon55 = alloca [5 x i32], align 16
+  %.anon56 = alloca i64, align 8
   %i59 = alloca i64, align 8
   %y60 = alloca i32, align 4
-  %anon64 = alloca i64, align 8
-  %anon65 = alloca [5 x i32], align 16
+  %.anon64 = alloca [5 x i32], align 16
   %sretparam = alloca [5 x i32], align 4
+  %.anon65 = alloca i64, align 8
   %i69 = alloca i64, align 8
   %y70 = alloca i32, align 4
-  %anon73 = alloca i64, align 8
-  %anon74 = alloca ptr, align 8
-  %sretparam75 = alloca [5 x i32], align 4
+  %.anon73 = alloca ptr, align 8
+  %sretparam74 = alloca [5 x i32], align 4
+  %.anon75 = alloca i64, align 8
   %i79 = alloca i64, align 8
   %y80 = alloca i32, align 4
   %a83 = alloca i32, align 4
@@ -198,23 +198,23 @@ entry:
   %10 = getelementptr inbounds [3 x i32], ptr %8, i64 0, i64 %sisiext4
   %11 = load i32, ptr %10, align 4
   call void (ptr, ...) @printf(ptr @.str.2, i32 %3, i32 %7, i32 %11)
-  store i32 0, ptr %anon, align 4
   %12 = call ptr @foo_call(ptr %x)
-  store ptr %12, ptr %anon5, align 8
-  store i32 3, ptr %anon6, align 4
+  store ptr %12, ptr %.anon, align 8
+  store i32 3, ptr %.anon5, align 4
+  store i32 0, ptr %.anon6, align 4
   br label %loop.cond
 
 loop.cond:                                        ; preds = %loop.body, %entry
-  %13 = load i32, ptr %anon, align 4
-  %14 = load i32, ptr %anon6, align 4
+  %13 = load i32, ptr %.anon6, align 4
+  %14 = load i32, ptr %.anon5, align 4
   %lt = icmp slt i32 %13, %14
   br i1 %lt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
-  %15 = load i32, ptr %anon, align 4
+  %15 = load i32, ptr %.anon6, align 4
   store i32 %15, ptr %i, align 4
-  %16 = load ptr, ptr %anon5, align 8
-  %17 = load i32, ptr %anon, align 4
+  %16 = load ptr, ptr %.anon, align 8
+  %17 = load i32, ptr %.anon6, align 4
   store i32 %17, ptr %a7, align 4
   %18 = getelementptr inbounds %Foo, ptr %16, i32 0, i32 0
   %19 = load i32, ptr %a7, align 4
@@ -225,26 +225,26 @@ loop.body:                                        ; preds = %loop.cond
   %22 = load i32, ptr %i, align 4
   %23 = load i32, ptr %y, align 4
   call void (ptr, ...) @printf(ptr @.str.3, i32 %22, i32 %23)
-  %24 = load i32, ptr %anon, align 4
+  %24 = load i32, ptr %.anon6, align 4
   %add = add i32 %24, 1
-  store i32 %add, ptr %anon, align 4
+  store i32 %add, ptr %.anon6, align 4
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
-  store i32 0, ptr %anon9, align 4
-  store i32 3, ptr %anon10, align 4
+  store i32 3, ptr %.anon9, align 4
+  store i32 0, ptr %.anon10, align 4
   br label %loop.cond11
 
 loop.cond11:                                      ; preds = %loop.body13, %loop.exit
-  %25 = load i32, ptr %anon9, align 4
-  %26 = load i32, ptr %anon10, align 4
+  %25 = load i32, ptr %.anon10, align 4
+  %26 = load i32, ptr %.anon9, align 4
   %lt12 = icmp slt i32 %25, %26
   br i1 %lt12, label %loop.body13, label %loop.exit20
 
 loop.body13:                                      ; preds = %loop.cond11
-  %27 = load i32, ptr %anon9, align 4
+  %27 = load i32, ptr %.anon10, align 4
   store i32 %27, ptr %i14, align 4
-  %28 = load i32, ptr %anon9, align 4
+  %28 = load i32, ptr %.anon10, align 4
   store i32 %28, ptr %a16, align 4
   %29 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0
   %30 = load i32, ptr %a16, align 4
@@ -259,26 +259,26 @@ loop.body13:                                      ; preds = %loop.cond11
   %35 = load ptr, ptr %y15, align 8
   %36 = load i32, ptr %35, align 8
   call void (ptr, ...) @printf(ptr @.str.4, i32 %34, i32 %36)
-  %37 = load i32, ptr %anon9, align 4
+  %37 = load i32, ptr %.anon10, align 4
   %add19 = add i32 %37, 1
-  store i32 %add19, ptr %anon9, align 4
+  store i32 %add19, ptr %.anon10, align 4
   br label %loop.cond11
 
 loop.exit20:                                      ; preds = %loop.cond11
-  store i32 0, ptr %anon21, align 4
-  store i32 3, ptr %anon22, align 4
+  store i32 3, ptr %.anon21, align 4
+  store i32 0, ptr %.anon22, align 4
   br label %loop.cond23
 
 loop.cond23:                                      ; preds = %loop.body25, %loop.exit20
-  %38 = load i32, ptr %anon21, align 4
-  %39 = load i32, ptr %anon22, align 4
+  %38 = load i32, ptr %.anon22, align 4
+  %39 = load i32, ptr %.anon21, align 4
   %lt24 = icmp slt i32 %38, %39
   br i1 %lt24, label %loop.body25, label %loop.exit31
 
 loop.body25:                                      ; preds = %loop.cond23
-  %40 = load i32, ptr %anon21, align 4
+  %40 = load i32, ptr %.anon22, align 4
   store i32 %40, ptr %i26, align 4
-  %41 = load i32, ptr %anon21, align 4
+  %41 = load i32, ptr %.anon22, align 4
   store i32 %41, ptr %a28, align 4
   %42 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0
   %43 = load i32, ptr %a28, align 4
@@ -289,26 +289,26 @@ loop.body25:                                      ; preds = %loop.cond23
   %46 = load i32, ptr %i26, align 4
   %47 = load i32, ptr %y27, align 4
   call void (ptr, ...) @printf(ptr @.str.5, i32 %46, i32 %47)
-  %48 = load i32, ptr %anon21, align 4
+  %48 = load i32, ptr %.anon22, align 4
   %add30 = add i32 %48, 1
-  store i32 %add30, ptr %anon21, align 4
+  store i32 %add30, ptr %.anon22, align 4
   br label %loop.cond23
 
 loop.exit31:                                      ; preds = %loop.cond23
-  store i32 0, ptr %anon32, align 4
-  store i32 3, ptr %anon33, align 4
+  store i32 3, ptr %.anon32, align 4
+  store i32 0, ptr %.anon33, align 4
   br label %loop.cond34
 
 loop.cond34:                                      ; preds = %loop.body36, %loop.exit31
-  %49 = load i32, ptr %anon32, align 4
-  %50 = load i32, ptr %anon33, align 4
+  %49 = load i32, ptr %.anon33, align 4
+  %50 = load i32, ptr %.anon32, align 4
   %lt35 = icmp slt i32 %49, %50
   br i1 %lt35, label %loop.body36, label %loop.exit42
 
 loop.body36:                                      ; preds = %loop.cond34
-  %51 = load i32, ptr %anon32, align 4
+  %51 = load i32, ptr %.anon33, align 4
   store i32 %51, ptr %i37, align 4
-  %52 = load i32, ptr %anon32, align 4
+  %52 = load i32, ptr %.anon33, align 4
   store i32 %52, ptr %a39, align 4
   %53 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0
   %54 = load i32, ptr %a39, align 4
@@ -319,26 +319,26 @@ loop.body36:                                      ; preds = %loop.cond34
   %57 = load i32, ptr %i37, align 4
   %58 = load i32, ptr %y38, align 4
   call void (ptr, ...) @printf(ptr @.str.6, i32 %57, i32 %58)
-  %59 = load i32, ptr %anon32, align 4
+  %59 = load i32, ptr %.anon33, align 4
   %add41 = add i32 %59, 1
-  store i32 %add41, ptr %anon32, align 4
+  store i32 %add41, ptr %.anon33, align 4
   br label %loop.cond34
 
 loop.exit42:                                      ; preds = %loop.cond34
-  store i32 0, ptr %anon43, align 4
-  store i32 3, ptr %anon44, align 4
+  store i32 3, ptr %.anon43, align 4
+  store i32 0, ptr %.anon44, align 4
   br label %loop.cond45
 
 loop.cond45:                                      ; preds = %loop.body47, %loop.exit42
-  %60 = load i32, ptr %anon43, align 4
-  %61 = load i32, ptr %anon44, align 4
+  %60 = load i32, ptr %.anon44, align 4
+  %61 = load i32, ptr %.anon43, align 4
   %lt46 = icmp slt i32 %60, %61
   br i1 %lt46, label %loop.body47, label %loop.exit54
 
 loop.body47:                                      ; preds = %loop.cond45
-  %62 = load i32, ptr %anon43, align 4
+  %62 = load i32, ptr %.anon44, align 4
   store i32 %62, ptr %i48, align 4
-  %63 = load i32, ptr %anon43, align 4
+  %63 = load i32, ptr %.anon44, align 4
   store i32 %63, ptr %a50, align 4
   %64 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0
   %65 = load i32, ptr %a50, align 4
@@ -352,26 +352,26 @@ loop.body47:                                      ; preds = %loop.cond45
   %70 = load i32, ptr %i48, align 4
   %add52 = add i32 %70, 1
   store i32 %add52, ptr %i48, align 4
-  %71 = load i32, ptr %anon43, align 4
+  %71 = load i32, ptr %.anon44, align 4
   %add53 = add i32 %71, 1
-  store i32 %add53, ptr %anon43, align 4
+  store i32 %add53, ptr %.anon44, align 4
   br label %loop.cond45
 
 loop.exit54:                                      ; preds = %loop.cond45
-  store i64 0, ptr %anon55, align 8
-  call void @llvm.memcpy.p0.p0.i32(ptr align 16 %anon56, ptr align 16 @.__const.8, i32 20, i1 false)
+  call void @llvm.memcpy.p0.p0.i32(ptr align 16 %.anon55, ptr align 16 @.__const.8, i32 20, i1 false)
+  store i64 0, ptr %.anon56, align 8
   br label %loop.cond57
 
 loop.cond57:                                      ; preds = %loop.body58, %loop.exit54
-  %72 = load i64, ptr %anon55, align 8
+  %72 = load i64, ptr %.anon56, align 8
   %gt = icmp ugt i64 5, %72
   br i1 %gt, label %loop.body58, label %loop.exit63
 
 loop.body58:                                      ; preds = %loop.cond57
-  %73 = load i64, ptr %anon55, align 8
+  %73 = load i64, ptr %.anon56, align 8
   store i64 %73, ptr %i59, align 8
-  %74 = load i64, ptr %anon55, align 8
-  %75 = getelementptr inbounds [5 x i32], ptr %anon56, i64 0, i64 %74
+  %74 = load i64, ptr %.anon56, align 8
+  %75 = getelementptr inbounds [5 x i32], ptr %.anon55, i64 0, i64 %74
   %76 = load i32, ptr %75, align 4
   store i32 %76, ptr %y60, align 4
   %77 = load i64, ptr %i59, align 8
@@ -380,62 +380,62 @@ loop.body58:                                      ; preds = %loop.cond57
   %79 = load i64, ptr %i59, align 8
   %add61 = add i64 %79, 1
   store i64 %add61, ptr %i59, align 8
-  %80 = load i64, ptr %anon55, align 8
+  %80 = load i64, ptr %.anon56, align 8
   %add62 = add i64 %80, 1
-  store i64 %add62, ptr %anon55, align 8
+  store i64 %add62, ptr %.anon56, align 8
   br label %loop.cond57
 
 loop.exit63:                                      ; preds = %loop.cond57
-  store i64 0, ptr %anon64, align 8
   call void @foo_getFields(ptr sret([5 x i32]) align 4 %sretparam)
-  call void @llvm.memcpy.p0.p0.i32(ptr align 16 %anon65, ptr align 4 %sretparam, i32 20, i1 false)
+  call void @llvm.memcpy.p0.p0.i32(ptr align 16 %.anon64, ptr align 4 %sretparam, i32 20, i1 false)
+  store i64 0, ptr %.anon65, align 8
   br label %loop.cond66
 
 loop.cond66:                                      ; preds = %loop.body68, %loop.exit63
-  %81 = load i64, ptr %anon64, align 8
+  %81 = load i64, ptr %.anon65, align 8
   %gt67 = icmp ugt i64 5, %81
   br i1 %gt67, label %loop.body68, label %loop.exit72
 
 loop.body68:                                      ; preds = %loop.cond66
-  %82 = load i64, ptr %anon64, align 8
+  %82 = load i64, ptr %.anon65, align 8
   store i64 %82, ptr %i69, align 8
-  %83 = load i64, ptr %anon64, align 8
-  %84 = getelementptr inbounds [5 x i32], ptr %anon65, i64 0, i64 %83
+  %83 = load i64, ptr %.anon65, align 8
+  %84 = getelementptr inbounds [5 x i32], ptr %.anon64, i64 0, i64 %83
   %85 = load i32, ptr %84, align 4
   store i32 %85, ptr %y70, align 4
   %86 = load i64, ptr %i69, align 8
   %87 = load i32, ptr %y70, align 4
   call void (ptr, ...) @printf(ptr @.str.10, i64 %86, i32 %87)
-  %88 = load i64, ptr %anon64, align 8
+  %88 = load i64, ptr %.anon65, align 8
   %add71 = add i64 %88, 1
-  store i64 %add71, ptr %anon64, align 8
+  store i64 %add71, ptr %.anon65, align 8
   br label %loop.cond66
 
 loop.exit72:                                      ; preds = %loop.cond66
-  store i64 0, ptr %anon73, align 8
-  call void @foo_getFields(ptr sret([5 x i32]) align 4 %sretparam75)
-  store ptr %sretparam75, ptr %anon74, align 8
+  call void @foo_getFields(ptr sret([5 x i32]) align 4 %sretparam74)
+  store ptr %sretparam74, ptr %.anon73, align 8
+  store i64 0, ptr %.anon75, align 8
   br label %loop.cond76
 
 loop.cond76:                                      ; preds = %loop.body78, %loop.exit72
-  %89 = load i64, ptr %anon73, align 8
+  %89 = load i64, ptr %.anon75, align 8
   %gt77 = icmp ugt i64 5, %89
   br i1 %gt77, label %loop.body78, label %loop.exit82
 
 loop.body78:                                      ; preds = %loop.cond76
-  %90 = load i64, ptr %anon73, align 8
+  %90 = load i64, ptr %.anon75, align 8
   store i64 %90, ptr %i79, align 8
-  %91 = load ptr, ptr %anon74, align 8
-  %92 = load i64, ptr %anon73, align 8
+  %91 = load ptr, ptr %.anon73, align 8
+  %92 = load i64, ptr %.anon75, align 8
   %93 = getelementptr inbounds [5 x i32], ptr %91, i64 0, i64 %92
   %94 = load i32, ptr %93, align 4
   store i32 %94, ptr %y80, align 4
   %95 = load i64, ptr %i79, align 8
   %96 = load i32, ptr %y80, align 4
   call void (ptr, ...) @printf(ptr @.str.11, i64 %95, i32 %96)
-  %97 = load i64, ptr %anon73, align 8
+  %97 = load i64, ptr %.anon75, align 8
   %add81 = add i64 %97, 1
-  store i64 %add81, ptr %anon73, align 8
+  store i64 %add81, ptr %.anon75, align 8
   br label %loop.cond76
 
 loop.exit82:                                      ; preds = %loop.cond76
diff --git a/test/test_suite2/statements/foreach_break.c3t b/test/test_suite2/statements/foreach_break.c3t
index ab7695033..000e6b1a5 100644
--- a/test/test_suite2/statements/foreach_break.c3t
+++ b/test/test_suite2/statements/foreach_break.c3t
@@ -19,7 +19,7 @@ define void @test_test() #0 {
 entry:
   %x = alloca [3 x i32], align 4
   %g = alloca i32, align 4
-  %anon = alloca i64, align 8
+  %.anon = alloca i64, align 8
   %z = alloca i32, align 4
   %0 = getelementptr inbounds [3 x i32], ptr %x, i64 0, i64 0
   store i32 0, ptr %0, align 4
@@ -28,16 +28,16 @@ entry:
   %2 = getelementptr inbounds [3 x i32], ptr %x, i64 0, i64 2
   store i32 0, ptr %2, align 4
   store i32 0, ptr %g, align 4
-  store i64 0, ptr %anon, align 8
+  store i64 0, ptr %.anon, align 8
   br label %loop.cond
 
 loop.cond:                                        ; preds = %loop.inc, %entry
-  %3 = load i64, ptr %anon, align 8
+  %3 = load i64, ptr %.anon, align 8
   %gt = icmp ugt i64 3, %3
   br i1 %gt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
-  %4 = load i64, ptr %anon, align 8
+  %4 = load i64, ptr %.anon, align 8
   %5 = getelementptr inbounds [3 x i32], ptr %x, i64 0, i64 %4
   %6 = load i32, ptr %5, align 4
   store i32 %6, ptr %z, align 4
@@ -64,9 +64,9 @@ if.exit3:                                         ; preds = %if.exit
   br label %loop.inc
 
 loop.inc:                                         ; preds = %if.exit3, %if.then2
-  %11 = load i64, ptr %anon, align 8
+  %11 = load i64, ptr %.anon, align 8
   %add4 = add i64 %11, 1
-  store i64 %add4, ptr %anon, align 8
+  store i64 %add4, ptr %.anon, align 8
   br label %loop.cond
 
 loop.exit:                                        ; preds = %if.then, %loop.cond
diff --git a/test/test_suite2/statements/foreach_common.c3t b/test/test_suite2/statements/foreach_common.c3t
index 8674f1846..190504e0b 100644
--- a/test/test_suite2/statements/foreach_common.c3t
+++ b/test/test_suite2/statements/foreach_common.c3t
@@ -53,10 +53,6 @@ fn void main()
 
 /* #expect: test.ll
 
-source_filename = "test"
-target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-apple-darwin"
-
 @.__const = private unnamed_addr constant [3 x float] [float 2.000000e+00, float 4.500000e+00, float 8.000000e+00], align 4
 @.str = private unnamed_addr constant [11 x i8] c"Value: %f\0A\00", align 1
 @.str.1 = private unnamed_addr constant [11 x i8] c"Value: %f\0A\00", align 1
@@ -77,68 +73,68 @@ define void @test_main() #0 {
 entry:
   %foo = alloca [3 x float], align 4
   %foo2 = alloca <3 x float>, align 16
-  %anon = alloca i64, align 8
+  %.anon = alloca i64, align 8
   %a = alloca float, align 4
-  %anon1 = alloca i64, align 8
+  %.anon1 = alloca i64, align 8
   %a5 = alloca ptr, align 8
-  %anon9 = alloca i64, align 8
+  %.anon9 = alloca i64, align 8
   %a13 = alloca ptr, align 8
-  %anon17 = alloca i64, align 8
+  %.anon17 = alloca i64, align 8
   %i = alloca i64, align 8
   %a21 = alloca float, align 4
-  %anon25 = alloca i64, align 8
+  %.anon25 = alloca i64, align 8
   %i29 = alloca i8, align 1
   %a30 = alloca double, align 8
-  %anon34 = alloca i64, align 8
+  %.anon34 = alloca i64, align 8
   %a38 = alloca double, align 8
-  %anon42 = alloca i64, align 8
-  %anon43 = alloca i64, align 8
+  %.anon42 = alloca i64, align 8
+  %.anon43 = alloca i64, align 8
   %a46 = alloca float, align 4
-  %anon50 = alloca i64, align 8
-  %anon51 = alloca i64, align 8
+  %.anon50 = alloca i64, align 8
+  %.anon51 = alloca i64, align 8
   %i55 = alloca i64, align 8
   %a56 = alloca float, align 4
-  %anon60 = alloca i64, align 8
-  %anon61 = alloca i64, align 8
+  %.anon60 = alloca i64, align 8
+  %.anon61 = alloca i64, align 8
   %i65 = alloca i8, align 1
   %a67 = alloca double, align 8
-  %anon72 = alloca i64, align 8
-  %anon73 = alloca i64, align 8
+  %.anon72 = alloca i64, align 8
+  %.anon73 = alloca i64, align 8
   %a77 = alloca double, align 8
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %foo, ptr align 4 @.__const, i32 12, i1 false)
   store <3 x float> <float 2.000000e+00, float 4.500000e+00, float 8.000000e+00>, ptr %foo2, align 16
-  store i64 0, ptr %anon, align 8
+  store i64 0, ptr %.anon, align 8
   br label %loop.cond
 
 loop.cond:                                        ; preds = %loop.body, %entry
-  %0 = load i64, ptr %anon, align 8
+  %0 = load i64, ptr %.anon, align 8
   %gt = icmp ugt i64 3, %0
   br i1 %gt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
-  %1 = load i64, ptr %anon, align 8
+  %1 = load i64, ptr %.anon, align 8
   %2 = getelementptr inbounds [3 x float], ptr %foo, i64 0, i64 %1
   %3 = load float, ptr %2, align 4
   store float %3, ptr %a, align 4
   %4 = load float, ptr %a, align 4
   %fpfpext = fpext float %4 to double
   call void (ptr, ...) @printf(ptr @.str, double %fpfpext)
-  %5 = load i64, ptr %anon, align 8
+  %5 = load i64, ptr %.anon, align 8
   %add = add i64 %5, 1
-  store i64 %add, ptr %anon, align 8
+  store i64 %add, ptr %.anon, align 8
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
-  store i64 0, ptr %anon1, align 8
+  store i64 0, ptr %.anon1, align 8
   br label %loop.cond2
 
 loop.cond2:                                       ; preds = %loop.body4, %loop.exit
-  %6 = load i64, ptr %anon1, align 8
+  %6 = load i64, ptr %.anon1, align 8
   %gt3 = icmp ugt i64 3, %6
   br i1 %gt3, label %loop.body4, label %loop.exit8
 
 loop.body4:                                       ; preds = %loop.cond2
-  %7 = load i64, ptr %anon1, align 8
+  %7 = load i64, ptr %.anon1, align 8
   %8 = getelementptr inbounds [3 x float], ptr %foo, i64 0, i64 %7
   store ptr %8, ptr %a5, align 8
   %9 = load ptr, ptr %a5, align 8
@@ -149,46 +145,46 @@ loop.body4:                                       ; preds = %loop.cond2
   %12 = load float, ptr %11, align 8
   %fpfpext6 = fpext float %12 to double
   call void (ptr, ...) @printf(ptr @.str.1, double %fpfpext6)
-  %13 = load i64, ptr %anon1, align 8
+  %13 = load i64, ptr %.anon1, align 8
   %add7 = add i64 %13, 1
-  store i64 %add7, ptr %anon1, align 8
+  store i64 %add7, ptr %.anon1, align 8
   br label %loop.cond2
 
 loop.exit8:                                       ; preds = %loop.cond2
-  store i64 0, ptr %anon9, align 8
+  store i64 0, ptr %.anon9, align 8
   br label %loop.cond10
 
 loop.cond10:                                      ; preds = %loop.body12, %loop.exit8
-  %14 = load i64, ptr %anon9, align 8
+  %14 = load i64, ptr %.anon9, align 8
   %gt11 = icmp ugt i64 3, %14
   br i1 %gt11, label %loop.body12, label %loop.exit16
 
 loop.body12:                                      ; preds = %loop.cond10
-  %15 = load i64, ptr %anon9, align 8
+  %15 = load i64, ptr %.anon9, align 8
   %16 = getelementptr inbounds [3 x float], ptr %foo, i64 0, i64 %15
   store ptr %16, ptr %a13, align 8
   %17 = load ptr, ptr %a13, align 8
   %18 = load float, ptr %17, align 8
   %fpfpext14 = fpext float %18 to double
   call void (ptr, ...) @printf(ptr @.str.2, double %fpfpext14)
-  %19 = load i64, ptr %anon9, align 8
+  %19 = load i64, ptr %.anon9, align 8
   %add15 = add i64 %19, 1
-  store i64 %add15, ptr %anon9, align 8
+  store i64 %add15, ptr %.anon9, align 8
   br label %loop.cond10
 
 loop.exit16:                                      ; preds = %loop.cond10
-  store i64 0, ptr %anon17, align 8
+  store i64 0, ptr %.anon17, align 8
   br label %loop.cond18
 
 loop.cond18:                                      ; preds = %loop.body20, %loop.exit16
-  %20 = load i64, ptr %anon17, align 8
+  %20 = load i64, ptr %.anon17, align 8
   %gt19 = icmp ugt i64 3, %20
   br i1 %gt19, label %loop.body20, label %loop.exit24
 
 loop.body20:                                      ; preds = %loop.cond18
-  %21 = load i64, ptr %anon17, align 8
+  %21 = load i64, ptr %.anon17, align 8
   store i64 %21, ptr %i, align 8
-  %22 = load i64, ptr %anon17, align 8
+  %22 = load i64, ptr %.anon17, align 8
   %23 = getelementptr inbounds [3 x float], ptr %foo, i64 0, i64 %22
   %24 = load float, ptr %23, align 4
   store float %24, ptr %a21, align 4
@@ -196,25 +192,25 @@ loop.body20:                                      ; preds = %loop.cond18
   %26 = load float, ptr %a21, align 4
   %fpfpext22 = fpext float %26 to double
   call void (ptr, ...) @printf(ptr @.str.3, i64 %25, double %fpfpext22)
-  %27 = load i64, ptr %anon17, align 8
+  %27 = load i64, ptr %.anon17, align 8
   %add23 = add i64 %27, 1
-  store i64 %add23, ptr %anon17, align 8
+  store i64 %add23, ptr %.anon17, align 8
   br label %loop.cond18
 
 loop.exit24:                                      ; preds = %loop.cond18
-  store i64 0, ptr %anon25, align 8
+  store i64 0, ptr %.anon25, align 8
   br label %loop.cond26
 
 loop.cond26:                                      ; preds = %loop.body28, %loop.exit24
-  %28 = load i64, ptr %anon25, align 8
+  %28 = load i64, ptr %.anon25, align 8
   %gt27 = icmp ugt i64 3, %28
   br i1 %gt27, label %loop.body28, label %loop.exit33
 
 loop.body28:                                      ; preds = %loop.cond26
-  %29 = load i64, ptr %anon25, align 8
+  %29 = load i64, ptr %.anon25, align 8
   %ztrunc = trunc i64 %29 to i8
   store i8 %ztrunc, ptr %i29, align 1
-  %30 = load i64, ptr %anon25, align 8
+  %30 = load i64, ptr %.anon25, align 8
   %31 = getelementptr inbounds [3 x float], ptr %foo, i64 0, i64 %30
   %32 = load float, ptr %31, align 4
   %fpfpext31 = fpext float %32 to double
@@ -223,101 +219,101 @@ loop.body28:                                      ; preds = %loop.cond26
   %uisiext = zext i8 %33 to i32
   %34 = load double, ptr %a30, align 8
   call void (ptr, ...) @printf(ptr @.str.4, i32 %uisiext, double %34)
-  %35 = load i64, ptr %anon25, align 8
+  %35 = load i64, ptr %.anon25, align 8
   %add32 = add i64 %35, 1
-  store i64 %add32, ptr %anon25, align 8
+  store i64 %add32, ptr %.anon25, align 8
   br label %loop.cond26
 
 loop.exit33:                                      ; preds = %loop.cond26
-  store i64 0, ptr %anon34, align 8
+  store i64 0, ptr %.anon34, align 8
   br label %loop.cond35
 
 loop.cond35:                                      ; preds = %loop.body37, %loop.exit33
-  %36 = load i64, ptr %anon34, align 8
+  %36 = load i64, ptr %.anon34, align 8
   %gt36 = icmp ugt i64 3, %36
   br i1 %gt36, label %loop.body37, label %loop.exit41
 
 loop.body37:                                      ; preds = %loop.cond35
-  %37 = load i64, ptr %anon34, align 8
+  %37 = load i64, ptr %.anon34, align 8
   %38 = getelementptr inbounds [3 x float], ptr %foo, i64 0, i64 %37
   %39 = load float, ptr %38, align 4
   %fpfpext39 = fpext float %39 to double
   store double %fpfpext39, ptr %a38, align 8
   %40 = load double, ptr %a38, align 8
   call void (ptr, ...) @printf(ptr @.str.5, double %40)
-  %41 = load i64, ptr %anon34, align 8
+  %41 = load i64, ptr %.anon34, align 8
   %add40 = add i64 %41, 1
-  store i64 %add40, ptr %anon34, align 8
+  store i64 %add40, ptr %.anon34, align 8
   br label %loop.cond35
 
 loop.exit41:                                      ; preds = %loop.cond35
-  store i64 0, ptr %anon42, align 8
-  store i64 3, ptr %anon43, align 8
+  store i64 3, ptr %.anon42, align 8
+  store i64 0, ptr %.anon43, align 8
   br label %loop.cond44
 
 loop.cond44:                                      ; preds = %loop.body45, %loop.exit41
-  %42 = load i64, ptr %anon42, align 8
-  %43 = load i64, ptr %anon43, align 8
+  %42 = load i64, ptr %.anon43, align 8
+  %43 = load i64, ptr %.anon42, align 8
   %lt = icmp ult i64 %42, %43
   br i1 %lt, label %loop.body45, label %loop.exit49
 
 loop.body45:                                      ; preds = %loop.cond44
   %44 = load <3 x float>, ptr %foo2, align 16
-  %45 = load i64, ptr %anon42, align 8
+  %45 = load i64, ptr %.anon43, align 8
   %46 = extractelement <3 x float> %44, i64 %45
   store float %46, ptr %a46, align 4
   %47 = load float, ptr %a46, align 4
   %fpfpext47 = fpext float %47 to double
   call void (ptr, ...) @printf(ptr @.str.6, double %fpfpext47)
-  %48 = load i64, ptr %anon42, align 8
+  %48 = load i64, ptr %.anon43, align 8
   %add48 = add i64 %48, 1
-  store i64 %add48, ptr %anon42, align 8
+  store i64 %add48, ptr %.anon43, align 8
   br label %loop.cond44
 
 loop.exit49:                                      ; preds = %loop.cond44
-  store i64 0, ptr %anon50, align 8
-  store i64 3, ptr %anon51, align 8
+  store i64 3, ptr %.anon50, align 8
+  store i64 0, ptr %.anon51, align 8
   br label %loop.cond52
 
 loop.cond52:                                      ; preds = %loop.body54, %loop.exit49
-  %49 = load i64, ptr %anon50, align 8
-  %50 = load i64, ptr %anon51, align 8
+  %49 = load i64, ptr %.anon51, align 8
+  %50 = load i64, ptr %.anon50, align 8
   %lt53 = icmp ult i64 %49, %50
   br i1 %lt53, label %loop.body54, label %loop.exit59
 
 loop.body54:                                      ; preds = %loop.cond52
-  %51 = load i64, ptr %anon50, align 8
+  %51 = load i64, ptr %.anon51, align 8
   store i64 %51, ptr %i55, align 8
   %52 = load <3 x float>, ptr %foo2, align 16
-  %53 = load i64, ptr %anon50, align 8
+  %53 = load i64, ptr %.anon51, align 8
   %54 = extractelement <3 x float> %52, i64 %53
   store float %54, ptr %a56, align 4
   %55 = load i64, ptr %i55, align 8
   %56 = load float, ptr %a56, align 4
   %fpfpext57 = fpext float %56 to double
   call void (ptr, ...) @printf(ptr @.str.7, i64 %55, double %fpfpext57)
-  %57 = load i64, ptr %anon50, align 8
+  %57 = load i64, ptr %.anon51, align 8
   %add58 = add i64 %57, 1
-  store i64 %add58, ptr %anon50, align 8
+  store i64 %add58, ptr %.anon51, align 8
   br label %loop.cond52
 
 loop.exit59:                                      ; preds = %loop.cond52
-  store i64 0, ptr %anon60, align 8
-  store i64 3, ptr %anon61, align 8
+  store i64 3, ptr %.anon60, align 8
+  store i64 0, ptr %.anon61, align 8
   br label %loop.cond62
 
 loop.cond62:                                      ; preds = %loop.body64, %loop.exit59
-  %58 = load i64, ptr %anon60, align 8
-  %59 = load i64, ptr %anon61, align 8
+  %58 = load i64, ptr %.anon61, align 8
+  %59 = load i64, ptr %.anon60, align 8
   %lt63 = icmp ult i64 %58, %59
   br i1 %lt63, label %loop.body64, label %loop.exit71
 
 loop.body64:                                      ; preds = %loop.cond62
-  %60 = load i64, ptr %anon60, align 8
+  %60 = load i64, ptr %.anon61, align 8
   %ztrunc66 = trunc i64 %60 to i8
   store i8 %ztrunc66, ptr %i65, align 1
   %61 = load <3 x float>, ptr %foo2, align 16
-  %62 = load i64, ptr %anon60, align 8
+  %62 = load i64, ptr %.anon61, align 8
   %63 = extractelement <3 x float> %61, i64 %62
   %fpfpext68 = fpext float %63 to double
   store double %fpfpext68, ptr %a67, align 8
@@ -325,33 +321,33 @@ loop.body64:                                      ; preds = %loop.cond62
   %uisiext69 = zext i8 %64 to i32
   %65 = load double, ptr %a67, align 8
   call void (ptr, ...) @printf(ptr @.str.8, i32 %uisiext69, double %65)
-  %66 = load i64, ptr %anon60, align 8
+  %66 = load i64, ptr %.anon61, align 8
   %add70 = add i64 %66, 1
-  store i64 %add70, ptr %anon60, align 8
+  store i64 %add70, ptr %.anon61, align 8
   br label %loop.cond62
 
 loop.exit71:                                      ; preds = %loop.cond62
-  store i64 0, ptr %anon72, align 8
-  store i64 3, ptr %anon73, align 8
+  store i64 3, ptr %.anon72, align 8
+  store i64 0, ptr %.anon73, align 8
   br label %loop.cond74
 
 loop.cond74:                                      ; preds = %loop.body76, %loop.exit71
-  %67 = load i64, ptr %anon72, align 8
-  %68 = load i64, ptr %anon73, align 8
+  %67 = load i64, ptr %.anon73, align 8
+  %68 = load i64, ptr %.anon72, align 8
   %lt75 = icmp ult i64 %67, %68
   br i1 %lt75, label %loop.body76, label %loop.exit80
 
 loop.body76:                                      ; preds = %loop.cond74
   %69 = load <3 x float>, ptr %foo2, align 16
-  %70 = load i64, ptr %anon72, align 8
+  %70 = load i64, ptr %.anon73, align 8
   %71 = extractelement <3 x float> %69, i64 %70
   %fpfpext78 = fpext float %71 to double
   store double %fpfpext78, ptr %a77, align 8
   %72 = load double, ptr %a77, align 8
   call void (ptr, ...) @printf(ptr @.str.9, double %72)
-  %73 = load i64, ptr %anon72, align 8
+  %73 = load i64, ptr %.anon73, align 8
   %add79 = add i64 %73, 1
-  store i64 %add79, ptr %anon72, align 8
+  store i64 %add79, ptr %.anon73, align 8
   br label %loop.cond74
 
 loop.exit80:                                      ; preds = %loop.cond74
diff --git a/test/test_suite2/statements/foreach_custom.c3t b/test/test_suite2/statements/foreach_custom.c3t
index 30842d9c2..aa3997c4a 100644
--- a/test/test_suite2/statements/foreach_custom.c3t
+++ b/test/test_suite2/statements/foreach_custom.c3t
@@ -38,8 +38,8 @@ define void @foo_main() #0 {
 entry:
   %i = alloca [3 x i32], align 4
   %x = alloca %Foo, align 8
-  %anon = alloca i64, align 8
-  %anon1 = alloca i64, align 8
+  %.anon = alloca i64, align 8
+  %.anon1 = alloca i64, align 8
   %f = alloca i32, align 4
   %index = alloca i64, align 8
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %i, ptr align 4 @.__const, i32 12, i1 false)
@@ -47,21 +47,21 @@ entry:
   %1 = insertvalue %"int[]" undef, ptr %i, 0
   %2 = insertvalue %"int[]" %1, i64 3, 1
   store %"int[]" %2, ptr %0, align 8
-  store i64 0, ptr %anon, align 8
   %3 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0
   %4 = getelementptr inbounds %"int[]", ptr %3, i32 0, i32 1
   %5 = load i64, ptr %4, align 8
-  store i64 %5, ptr %anon1, align 8
+  store i64 %5, ptr %.anon, align 8
+  store i64 0, ptr %.anon1, align 8
   br label %loop.cond
 
 loop.cond:                                        ; preds = %entry
-  %6 = load i64, ptr %anon, align 8
-  %7 = load i64, ptr %anon1, align 8
+  %6 = load i64, ptr %.anon1, align 8
+  %7 = load i64, ptr %.anon, align 8
   %lt = icmp ult i64 %6, %7
   br i1 %lt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
-  %8 = load i64, ptr %anon, align 8
+  %8 = load i64, ptr %.anon1, align 8
   store i64 %8, ptr %index, align 8
   %9 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0
   %10 = getelementptr inbounds %"int[]", ptr %9, i32 0, i32 0
diff --git a/test/test_suite2/statements/foreach_custom_macro.c3t b/test/test_suite2/statements/foreach_custom_macro.c3t
index 6faf10cd3..0561d8a2f 100644
--- a/test/test_suite2/statements/foreach_custom_macro.c3t
+++ b/test/test_suite2/statements/foreach_custom_macro.c3t
@@ -44,8 +44,8 @@ define void @foo_main() #0 {
 entry:
   %i = alloca [3 x i32], align 4
   %x = alloca %Foo, align 8
-  %anon = alloca i64, align 8
-  %anon1 = alloca i64, align 8
+  %.anon = alloca i64, align 8
+  %.anon1 = alloca i64, align 8
   %f = alloca i32, align 4
   %index = alloca i64, align 8
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %i, ptr align 4 @.__const, i32 12, i1 false)
@@ -53,21 +53,21 @@ entry:
   %1 = insertvalue %"int[]" undef, ptr %i, 0
   %2 = insertvalue %"int[]" %1, i64 3, 1
   store %"int[]" %2, ptr %0, align 8
-  store i64 0, ptr %anon, align 8
   %3 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0
   %4 = getelementptr inbounds %"int[]", ptr %3, i32 0, i32 1
   %5 = load i64, ptr %4, align 8
-  store i64 %5, ptr %anon1, align 8
+  store i64 %5, ptr %.anon, align 8
+  store i64 0, ptr %.anon1, align 8
   br label %loop.cond
 
 loop.cond:                                        ; preds = %entry
-  %6 = load i64, ptr %anon, align 8
-  %7 = load i64, ptr %anon1, align 8
+  %6 = load i64, ptr %.anon1, align 8
+  %7 = load i64, ptr %.anon, align 8
   %lt = icmp ult i64 %6, %7
   br i1 %lt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
-  %8 = load i64, ptr %anon, align 8
+  %8 = load i64, ptr %.anon1, align 8
   store i64 %8, ptr %index, align 8
   %9 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0
   %10 = getelementptr inbounds %"int[]", ptr %9, i32 0, i32 0
diff --git a/test/test_suite2/statements/foreach_r_test.c3t b/test/test_suite2/statements/foreach_r_test.c3t
new file mode 100644
index 000000000..d89809112
--- /dev/null
+++ b/test/test_suite2/statements/foreach_r_test.c3t
@@ -0,0 +1,87 @@
+// #target: macos-x64
+module test;
+import std::io;
+
+fn void main()
+{
+	int[*] x = { 1, 5, 10 };
+	int[] y = &x;
+	foreach_r (int i, val : y)
+	{
+		io::printfln("%d: %d", i, val);
+	}
+}
+
+/* #expect: test.ll
+
+entry:
+  %x = alloca [3 x i32], align 4
+  %y = alloca %"int[]", align 8
+  %.anon = alloca i64, align 8
+  %i = alloca i32, align 4
+  %val = alloca i32, align 4
+  %retparam = alloca i64, align 8
+  %taddr = alloca %"char[]", align 8
+  %vararg = alloca %"variant[]", align 8
+  %varargslots = alloca [2 x %variant], align 16
+  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %x, ptr align 4 @.__const, i32 12, i1 false)
+  %0 = insertvalue %"int[]" undef, ptr %x, 0
+  %1 = insertvalue %"int[]" %0, i64 3, 1
+  store %"int[]" %1, ptr %y, align 8
+  %2 = getelementptr inbounds %"int[]", ptr %y, i32 0, i32 1
+  %3 = load i64, ptr %2, align 8
+  store i64 %3, ptr %.anon, align 8
+  br label %loop.cond
+
+loop.cond:                                        ; preds = %voiderr, %entry
+  %4 = load i64, ptr %.anon, align 8
+  %gt = icmp ugt i64 %4, 0
+  br i1 %gt, label %loop.body, label %loop.exit
+
+loop.body:                                        ; preds = %loop.cond
+  %5 = load i64, ptr %.anon, align 8
+  %sub = sub i64 %5, 1
+  store i64 %sub, ptr %.anon, align 8
+  %6 = load i64, ptr %.anon, align 8
+  %uisitrunc = trunc i64 %6 to i32
+  store i32 %uisitrunc, ptr %i, align 4
+  %7 = getelementptr inbounds %"int[]", ptr %y, i32 0, i32 0
+  %8 = load ptr, ptr %7, align 8
+  %9 = load i64, ptr %.anon, align 8
+  %ptroffset = getelementptr inbounds i32, ptr %8, i64 %9
+  %10 = load i32, ptr %ptroffset, align 4
+  store i32 %10, ptr %val, align 4
+  store %"char[]" { ptr @.str, i64 6 }, ptr %taddr, align 8
+  %11 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0
+  %lo = load ptr, ptr %11, align 8
+  %12 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1
+  %hi = load i64, ptr %12, align 8
+  %13 = insertvalue %variant undef, ptr %i, 0
+  %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %15 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
+  store %variant %14, ptr %15, align 16
+  %16 = insertvalue %variant undef, ptr %val, 0
+  %17 = insertvalue %variant %16, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %18 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
+  store %variant %17, ptr %18, align 16
+  %19 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1
+  store i64 2, ptr %19, align 8
+  %20 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0
+  store ptr %varargslots, ptr %20, align 8
+  %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0
+  %lo1 = load ptr, ptr %21, align 8
+  %22 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1
+  %hi2 = load i64, ptr %22, align 8
+  %23 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo1, i64 %hi2)
+  %not_err = icmp eq i64 %23, 0
+  br i1 %not_err, label %after_check, label %voiderr
+
+after_check:                                      ; preds = %loop.body
+  br label %voiderr
+
+voiderr:                                          ; preds = %after_check, %loop.body
+  br label %loop.cond
+
+loop.exit:                                        ; preds = %loop.cond
+  ret void
+}
diff --git a/test/test_suite2/struct/nested_struct_init.c3t b/test/test_suite2/struct/nested_struct_init.c3t
index ce348cb83..fcb8e549c 100644
--- a/test/test_suite2/struct/nested_struct_init.c3t
+++ b/test/test_suite2/struct/nested_struct_init.c3t
@@ -32,20 +32,20 @@ fn void main()
 }
 /* #expect: foo.ll
 
-%Matrix2x2 = type { %anon }
-%anon = type { %anon.0 }
-%anon.0 = type { float, float, float, float }
-%Matrix2x2_b = type { %anon.1 }
-%anon.1 = type { [4 x float] }
+%Matrix2x2 = type { %.anon }
+%.anon = type { %.anon.0 }
+%.anon.0 = type { float, float, float, float }
+%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_$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_$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
+@.__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
 
 ; Function Attrs: nounwind
@@ -56,7 +56,7 @@ entry:
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %m, ptr align 4 @.__const, i32 16, i1 false)
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %m2, ptr align 4 @.__const.8, i32 16, i1 false)
   %0 = getelementptr inbounds %Matrix2x2, ptr %m, i32 0, i32 0
-  %1 = getelementptr inbounds %anon.0, ptr %0, i32 0, i32 0
+  %1 = getelementptr inbounds %.anon.0, ptr %0, i32 0, i32 0
   %2 = load float, ptr %1, align 4
   %fpfpext = fpext float %2 to double
   %3 = getelementptr inbounds %Matrix2x2, ptr %m, i32 0, i32 0
@@ -64,7 +64,7 @@ entry:
   %5 = load float, ptr %4, align 4
   %fpfpext1 = fpext float %5 to double
   %6 = getelementptr inbounds %Matrix2x2, ptr %m, i32 0, i32 0
-  %7 = getelementptr inbounds %anon.0, ptr %6, i32 0, i32 2
+  %7 = getelementptr inbounds %.anon.0, ptr %6, i32 0, i32 2
   %8 = load float, ptr %7, align 4
   %fpfpext2 = fpext float %8 to double
   %9 = getelementptr inbounds %Matrix2x2, ptr %m, i32 0, i32 0
diff --git a/test/test_suite2/struct/nested_struct_union_init.c3t b/test/test_suite2/struct/nested_struct_union_init.c3t
index 07c4333e0..74da5fe7c 100644
--- a/test/test_suite2/struct/nested_struct_union_init.c3t
+++ b/test/test_suite2/struct/nested_struct_union_init.c3t
@@ -53,14 +53,14 @@ fn void main()
 
 /* #expect: foob.ll
 
-%Matrix2x2 = type { %anon.1 }
-%anon.1 = type { [4 x float] }
-%Matrix2x2_b = type { %anon.2 }
-%anon.2 = type { %anon.3 }
-%anon.3 = type { float, float, float, float }
-%Matrix3x3 = type { %anon }
-%anon = type { %anon.0 }
-%anon.0 = type { float, float, float, float, float, float, float, float, float }
+%Matrix2x2 = type { %.anon.1 }
+%.anon.1 = type { [4 x float] }
+%Matrix2x2_b = type { %.anon.2 }
+%.anon.2 = type { %.anon.3 }
+%.anon.3 = type { float, float, float, float }
+%Matrix3x3 = type { %.anon }
+%.anon = type { %.anon.0 }
+%.anon.0 = type { float, float, float, float, float, float, float, float, float }
 
 define void @foob_main() #0 {
 entry:
@@ -68,28 +68,28 @@ entry:
   %m = alloca %Matrix2x2, align 4
   %m2 = alloca %Matrix2x2_b, align 4
   %0 = getelementptr inbounds %Matrix3x3, ptr %x, i32 0, i32 0
-  %1 = getelementptr inbounds %anon.0, ptr %0, i32 0, i32 0
+  %1 = getelementptr inbounds %.anon.0, ptr %0, i32 0, i32 0
   store float 1.000000e+00, ptr %1, align 4
-  %2 = getelementptr inbounds %anon.0, ptr %0, i32 0, i32 1
+  %2 = getelementptr inbounds %.anon.0, ptr %0, i32 0, i32 1
   store float 2.000000e+00, ptr %2, align 4
-  %3 = getelementptr inbounds %anon.0, ptr %0, i32 0, i32 2
+  %3 = getelementptr inbounds %.anon.0, ptr %0, i32 0, i32 2
   store float 3.000000e+00, ptr %3, align 4
-  %4 = getelementptr inbounds %anon.0, ptr %0, i32 0, i32 3
+  %4 = getelementptr inbounds %.anon.0, ptr %0, i32 0, i32 3
   store float 4.000000e+00, ptr %4, align 4
-  %5 = getelementptr inbounds %anon.0, ptr %0, i32 0, i32 4
+  %5 = getelementptr inbounds %.anon.0, ptr %0, i32 0, i32 4
   store float 5.000000e+00, ptr %5, align 4
-  %6 = getelementptr inbounds %anon.0, ptr %0, i32 0, i32 5
+  %6 = getelementptr inbounds %.anon.0, ptr %0, i32 0, i32 5
   store float 6.000000e+00, ptr %6, align 4
-  %7 = getelementptr inbounds %anon.0, ptr %0, i32 0, i32 6
+  %7 = getelementptr inbounds %.anon.0, ptr %0, i32 0, i32 6
   store float 7.000000e+00, ptr %7, align 4
-  %8 = getelementptr inbounds %anon.0, ptr %0, i32 0, i32 7
+  %8 = getelementptr inbounds %.anon.0, ptr %0, i32 0, i32 7
   store float 8.000000e+00, ptr %8, align 4
-  %9 = getelementptr inbounds %anon.0, ptr %0, i32 0, i32 8
+  %9 = getelementptr inbounds %.anon.0, ptr %0, i32 0, i32 8
   store float 9.000000e+00, ptr %9, align 4
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %m, ptr align 4 @.__const, i32 16, i1 false)
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %m2, ptr align 4 @.__const.16, i32 16, i1 false)
   %10 = getelementptr inbounds %Matrix3x3, ptr %x, i32 0, i32 0
-  %11 = getelementptr inbounds %anon.0, ptr %10, i32 0, i32 0
+  %11 = getelementptr inbounds %.anon.0, ptr %10, i32 0, i32 0
   %12 = load float, ptr %11, align 4
   %fpfpext = fpext float %12 to double
   %13 = getelementptr inbounds %Matrix3x3, ptr %x, i32 0, i32 0
@@ -97,7 +97,7 @@ entry:
   %15 = load float, ptr %14, align 4
   %fpfpext1 = fpext float %15 to double
   %16 = getelementptr inbounds %Matrix3x3, ptr %x, i32 0, i32 0
-  %17 = getelementptr inbounds %anon.0, ptr %16, i32 0, i32 3
+  %17 = getelementptr inbounds %.anon.0, ptr %16, i32 0, i32 3
   %18 = load float, ptr %17, align 4
   %fpfpext2 = fpext float %18 to double
   %19 = getelementptr inbounds %Matrix3x3, ptr %x, i32 0, i32 0
diff --git a/test/test_suite2/struct/struct_codegen_fam.c3t b/test/test_suite2/struct/struct_codegen_fam.c3t
index bbb9893db..27b47ebbe 100644
--- a/test/test_suite2/struct/struct_codegen_fam.c3t
+++ b/test/test_suite2/struct/struct_codegen_fam.c3t
@@ -19,8 +19,8 @@ fn void test(Bar b)
 
 /* #expect: foo.ll
 
-%Bar = type { %anon, i32, [0 x i32] }
-%anon = type { i32 }
+%Bar = type { %.anon, i32, [0 x i32] }
+%.anon = type { i32 }
 
 define void @foo_test(ptr byval(%Bar) align 8 %0) #0 {
 entry:
diff --git a/test/test_suite2/union/union_in_struct.c3t b/test/test_suite2/union/union_in_struct.c3t
index 5fb0cd4c5..6dee64784 100644
--- a/test/test_suite2/union/union_in_struct.c3t
+++ b/test/test_suite2/union/union_in_struct.c3t
@@ -38,7 +38,7 @@ fn void test(Blend_Map_Entry* foo)
 %vals = type { [2 x double], [8 x i8] }
 
 @test_foo1 = local_unnamed_addr global { i8, [4 x i8], { i32, [4 x i8] }, i32 } { i8 0, [4 x i8] undef, { i32, [4 x i8] } { i32 3, [4 x i8] undef }, i32 4 }, align 8
-@test_foo2 = local_unnamed_addr global %Foo { i8 0, %anon { double 3.000000e+00 }, i32 4 }, align 8
+@test_foo2 = local_unnamed_addr global %Foo { i8 0, %.anon { double 3.000000e+00 }, i32 4 }, align 8
 @test_a = local_unnamed_addr global { { [5 x float], [4 x i8] } } { { [5 x float], [4 x i8] } { [5 x float] [float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00, float 5.000000e+00], [4 x i8] undef } }, align 8
 @test_b = local_unnamed_addr global %Blend_Map_Entry { %vals { [2 x double] [double 6.000000e+00, double 7.000000e+00], [8 x i8] undef } }, align 8
 @test_c = local_unnamed_addr global { { { [2 x float], float, [2 x float] }, [4 x i8] } } { { { [2 x float], float, [2 x float] }, [4 x i8] } { { [2 x float], float, [2 x float] } { [2 x float] zeroinitializer, float 1.000000e+00, [2 x float] zeroinitializer }, [4 x i8] undef } }, align 8
diff --git a/test/test_suite2/variant/variant_assign.c3t b/test/test_suite2/variant/variant_assign.c3t
index 109064770..9c494ac70 100644
--- a/test/test_suite2/variant/variant_assign.c3t
+++ b/test/test_suite2/variant/variant_assign.c3t
@@ -118,7 +118,7 @@ switch.exit:                                      ; preds = %switch.default, %sw
 define void @foo_test2(i64 %0, ptr %1) #0 {
 entry:
   %y = alloca %variant, align 8
-  %anon = alloca %variant, align 8
+  %.anon = alloca %variant, align 8
   %switch = alloca i64, align 8
   %z = alloca ptr, align 8
   %taddr = alloca i32, align 4
@@ -127,7 +127,7 @@ entry:
   store i64 %0, ptr %2, align 8
   %3 = getelementptr inbounds { i64, ptr }, ptr %y, i32 0, i32 1
   store ptr %1, ptr %3, align 8
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %anon, ptr align 8 %y, i32 16, i1 false)
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %.anon, ptr align 8 %y, i32 16, i1 false)
   %4 = getelementptr inbounds %variant, ptr %y, i32 0, i32 1
   %5 = load i64, ptr %4, align 8
   store i64 %5, ptr %switch, align 8
@@ -139,7 +139,7 @@ switch.entry:                                     ; preds = %entry
   br i1 %eq, label %switch.case, label %next_if
 
 switch.case:                                      ; preds = %switch.entry
-  %7 = getelementptr inbounds %variant, ptr %anon, i32 0, i32 0
+  %7 = getelementptr inbounds %variant, ptr %.anon, i32 0, i32 0
   %8 = load ptr, ptr %7, align 8
   store ptr %8, ptr %z, align 8
   store i32 12, ptr %taddr, align 4
@@ -156,7 +156,7 @@ next_if:                                          ; preds = %switch.entry
   br i1 %eq1, label %switch.case2, label %next_if4
 
 switch.case2:                                     ; preds = %next_if
-  %13 = getelementptr inbounds %variant, ptr %anon, i32 0, i32 0
+  %13 = getelementptr inbounds %variant, ptr %.anon, i32 0, i32 0
   %14 = load ptr, ptr %13, align 8
   store ptr %14, ptr %z3, align 8
   %15 = load ptr, ptr %z3, align 8
@@ -178,7 +178,7 @@ switch.exit:                                      ; preds = %switch.default, %sw
 define void @foo_test3(i64 %0, ptr %1) #0 {
 entry:
   %y = alloca %variant, align 8
-  %anon = alloca %variant, align 8
+  %.anon = alloca %variant, align 8
   %switch = alloca i64, align 8
   %z = alloca i32, align 4
   %z3 = alloca double, align 8
@@ -186,7 +186,7 @@ entry:
   store i64 %0, ptr %2, align 8
   %3 = getelementptr inbounds { i64, ptr }, ptr %y, i32 0, i32 1
   store ptr %1, ptr %3, align 8
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %anon, ptr align 8 %y, i32 16, i1 false)
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %.anon, ptr align 8 %y, i32 16, i1 false)
   %4 = getelementptr inbounds %variant, ptr %y, i32 0, i32 1
   %5 = load i64, ptr %4, align 8
   store i64 %5, ptr %switch, align 8
@@ -198,7 +198,7 @@ switch.entry:                                     ; preds = %entry
   br i1 %eq, label %switch.case, label %next_if
 
 switch.case:                                      ; preds = %switch.entry
-  %7 = getelementptr inbounds %variant, ptr %anon, i32 0, i32 0
+  %7 = getelementptr inbounds %variant, ptr %.anon, i32 0, i32 0
   %8 = load ptr, ptr %7, align 8
   %9 = load i32, ptr %8, align 8
   store i32 %9, ptr %z, align 4
@@ -211,7 +211,7 @@ next_if:                                          ; preds = %switch.entry
   br i1 %eq1, label %switch.case2, label %next_if4
 
 switch.case2:                                     ; preds = %next_if
-  %11 = getelementptr inbounds %variant, ptr %anon, i32 0, i32 0
+  %11 = getelementptr inbounds %variant, ptr %.anon, i32 0, i32 0
   %12 = load ptr, ptr %11, align 8
   %13 = load double, ptr %12, align 8
   store double %13, ptr %z3, align 8
diff --git a/test/test_suite2/variant/variant_test.c3t b/test/test_suite2/variant/variant_test.c3t
index 14348368f..9c806fa55 100644
--- a/test/test_suite2/variant/variant_test.c3t
+++ b/test/test_suite2/variant/variant_test.c3t
@@ -133,29 +133,29 @@ switch.exit:                                      ; preds = %switch.default, %sw
 define void @foo_test_all(ptr %0, i64 %1) #0 {
 entry:
   %y = alloca %"variant[]", align 8
-  %anon = alloca i64, align 8
-  %anon1 = alloca i64, align 8
+  %.anon = alloca i64, align 8
+  %.anon1 = alloca i64, align 8
   %element = alloca %variant, align 8
   %2 = getelementptr inbounds { ptr, i64 }, ptr %y, i32 0, i32 0
   store ptr %0, ptr %2, align 8
   %3 = getelementptr inbounds { ptr, i64 }, ptr %y, i32 0, i32 1
   store i64 %1, ptr %3, align 8
-  store i64 0, ptr %anon, align 8
   %4 = getelementptr inbounds %"variant[]", ptr %y, i32 0, i32 1
   %5 = load i64, ptr %4, align 8
-  store i64 %5, ptr %anon1, align 8
+  store i64 %5, ptr %.anon, align 8
+  store i64 0, ptr %.anon1, align 8
   br label %loop.cond
 
 loop.cond:                                        ; preds = %loop.body, %entry
-  %6 = load i64, ptr %anon, align 8
-  %7 = load i64, ptr %anon1, align 8
+  %6 = load i64, ptr %.anon1, align 8
+  %7 = load i64, ptr %.anon, align 8
   %lt = icmp ult i64 %6, %7
   br i1 %lt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
   %8 = getelementptr inbounds %"variant[]", ptr %y, i32 0, i32 0
   %9 = load ptr, ptr %8, align 8
-  %10 = load i64, ptr %anon, align 8
+  %10 = load i64, ptr %.anon1, align 8
   %ptroffset = getelementptr inbounds %variant, ptr %9, i64 %10
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %element, ptr align 8 %ptroffset, i32 16, i1 false)
   %11 = getelementptr inbounds { i64, ptr }, ptr %element, i32 0, i32 0
@@ -163,9 +163,9 @@ loop.body:                                        ; preds = %loop.cond
   %12 = getelementptr inbounds { i64, ptr }, ptr %element, i32 0, i32 1
   %hi = load ptr, ptr %12, align 8
   call void @foo_test(i64 %lo, ptr %hi)
-  %13 = load i64, ptr %anon, align 8
+  %13 = load i64, ptr %.anon1, align 8
   %add = add i64 %13, 1
-  store i64 %add, ptr %anon, align 8
+  store i64 %add, ptr %.anon1, align 8
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond