// #target: macos-x64

module test;
import std::io;
import std::collections::map;

struct Foo (Printable) { int x; void* bar; }

def IntFooMap = HashMap(<int, Foo>);
def IntDoubleMap = HashMap(<int, double>);

fn String Foo.to_new_string(Foo* foo, Allocator* allocator = mem::heap()) @dynamic
{
	DString s = dstring::new_with_capacity(128, allocator);
	s.appendf("{%s, %p}", foo.x, foo.bar);
	return s.str_view();
}



fn void main()
{
	IntFooMap map;
	map.init_new();
	io::printfn("Map size: %d", map.count);
	map.set(1, Foo { 1, null });
	io::printfn("Map size: %d", map.count);
	map.set(1, Foo { 2, null });
	io::printfn("Map size: %d", map.count);
	(void)io::printfn("Val: %d", map.get(1).x);
	io::printfn("Has 1: %s", map.has_key(1));
	io::printfn("Has 2: %s", map.has_key(2));
	map.set(7, Foo { 4, null });
	io::printfn("Values: %s", map.value_new_list());
	IntDoubleMap map2;
	map2.init_new();
	map2.set(4, 1.3);
	io::printfn("Map find: %s", map2.has_value(1.3));
	io::printfn("Map find: %s", map2.has_value(1.2));
	map2.set(100, 3.4);
	io::printfn("%s", map2.key_new_list());
	io::printfn("%s", map2.value_new_list());
	@pool()
	{
		IntDoubleMap map3;
		map3.init_new();
		map3.set(5, 3.2);
		map3.set(7, 5.2);
		io::printfn("%s", map3.key_new_list());
	};
}

/* #expect: test.ll

define { ptr, i64 } @test.Foo.to_new_string(ptr %0, i64 %1, ptr %2) #0 {
entry:
  %allocator = alloca %"any*", align 8
  %s = alloca ptr, align 8
  %varargslots = alloca [2 x %"any*"], align 16
  %retparam = alloca i64, align 8
  %result = alloca %"char[]", align 8
  store i64 %1, ptr %allocator, align 8
  %ptroffset = getelementptr inbounds ptr, ptr %allocator, i64 1
  store ptr %2, ptr %ptroffset, align 8
  %3 = getelementptr inbounds { i64, ptr }, ptr %allocator, i32 0, i32 0
  %lo = load i64, ptr %3, align 8
  %4 = getelementptr inbounds { i64, ptr }, ptr %allocator, i32 0, i32 1
  %hi = load ptr, ptr %4, align 8
  %5 = call ptr @std.core.dstring.new_with_capacity(i64 128, i64 %lo, ptr %hi)
  store ptr %5, ptr %s, align 8
  %6 = getelementptr inbounds %Foo, ptr %0, i32 0, i32 0
  %7 = insertvalue %"any*" undef, ptr %6, 0
  %8 = insertvalue %"any*" %7, i64 ptrtoint (ptr @"$ct.int" to i64), 1
  %9 = getelementptr inbounds [2 x %"any*"], ptr %varargslots, i64 0, i64 0
  store %"any*" %8, ptr %9, align 16
  %10 = getelementptr inbounds %Foo, ptr %0, i32 0, i32 1
  %11 = insertvalue %"any*" undef, ptr %10, 0
  %12 = insertvalue %"any*" %11, i64 ptrtoint (ptr @"$ct.p$void" to i64), 1
  %13 = getelementptr inbounds [2 x %"any*"], ptr %varargslots, i64 0, i64 1
  store %"any*" %12, ptr %13, align 16
  %14 = call i64 @std.core.dstring.DString.appendf(ptr %retparam, ptr %s, ptr @.str.14, i64 8, ptr %varargslots, i64 2)
  %15 = load ptr, ptr %s, align 8
  %16 = call { ptr, i64 } @std.core.dstring.DString.str_view(ptr %15)
  store { ptr, i64 } %16, ptr %result, align 8
  %17 = load { ptr, i64 }, ptr %result, align 8
  ret { ptr, i64 } %17
}


define void @test.main() #0 {
entry:
  %map = alloca %HashMap, align 8
  %varargslots = alloca [1 x %"any*"], align 16
  %retparam = alloca i64, align 8
  %literal = alloca %Foo, align 8
  %varargslots3 = alloca [1 x %"any*"], align 16
  %retparam4 = alloca i64, align 8
  %literal5 = alloca %Foo, align 8
  %varargslots8 = alloca [1 x %"any*"], align 16
  %retparam9 = alloca i64, align 8
  %varargslots10 = alloca [1 x %"any*"], align 16
  %retparam11 = alloca %Foo, align 8
  %retparam12 = alloca i64, align 8
  %varargslots15 = alloca [1 x %"any*"], align 16
  %taddr = alloca i8, align 1
  %retparam16 = alloca i64, align 8
  %varargslots19 = alloca [1 x %"any*"], align 16
  %taddr20 = alloca i8, align 1
  %retparam21 = alloca i64, align 8
  %literal24 = alloca %Foo, align 8
  %varargslots27 = alloca [1 x %"any*"], align 16
  %result = alloca %"Foo[]", align 8
  %retparam30 = alloca i64, align 8
  %map2 = alloca %HashMap.0, align 8
  %varargslots35 = alloca [1 x %"any*"], align 16
  %taddr36 = alloca i8, align 1
  %retparam37 = alloca i64, align 8
  %varargslots40 = alloca [1 x %"any*"], align 16
  %taddr41 = alloca i8, align 1
  %retparam42 = alloca i64, align 8
  %varargslots45 = alloca [1 x %"any*"], align 16
  %result48 = alloca %"int[]", align 8
  %retparam49 = alloca i64, align 8
  %varargslots52 = alloca [1 x %"any*"], align 16
  %result55 = alloca %"double[]", align 8
  %retparam56 = alloca i64, align 8
  %current = alloca ptr, align 8
  %mark = alloca i64, align 8
  %map3 = alloca %HashMap.0, align 8
  %varargslots61 = alloca [1 x %"any*"], align 16
  %result64 = alloca %"int[]", align 8
  %retparam65 = alloca i64, align 8
  call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 48, i1 false)
  %lo = load i64, ptr @std.core.mem.thread_allocator, align 8
  %hi = load ptr, ptr getelementptr inbounds ({ i64, ptr }, ptr @std.core.mem.thread_allocator, i32 0, i32 1), align 8
  %0 = call ptr @"std.collections.map$int$test.Foo$.HashMap.init_new"(ptr %map, i32 16, float 7.500000e-01, i64 %lo, ptr %hi)
  %1 = getelementptr inbounds %HashMap, ptr %map, i32 0, i32 2
  %2 = insertvalue %"any*" undef, ptr %1, 0
  %3 = insertvalue %"any*" %2, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %4 = getelementptr inbounds [1 x %"any*"], ptr %varargslots, i64 0, i64 0
  store %"any*" %3, ptr %4, align 16
  %5 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 12, ptr %varargslots, i64 1)
  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal, ptr align 8 @.__const, i32 16, i1 false)
  %6 = getelementptr inbounds { i64, ptr }, ptr %literal, i32 0, i32 0
  %lo1 = load i64, ptr %6, align 8
  %7 = getelementptr inbounds { i64, ptr }, ptr %literal, i32 0, i32 1
  %hi2 = load ptr, ptr %7, align 8
  %8 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i64 %lo1, ptr %hi2)
  %9 = getelementptr inbounds %HashMap, ptr %map, i32 0, i32 2
  %10 = insertvalue %"any*" undef, ptr %9, 0
  %11 = insertvalue %"any*" %10, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %12 = getelementptr inbounds [1 x %"any*"], ptr %varargslots3, i64 0, i64 0
  store %"any*" %11, ptr %12, align 16
  %13 = call i64 @std.io.printfn(ptr %retparam4, ptr @.str.1, i64 12, ptr %varargslots3, i64 1)
  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal5, ptr align 8 @.__const.2, i32 16, i1 false)
  %14 = getelementptr inbounds { i64, ptr }, ptr %literal5, i32 0, i32 0
  %lo6 = load i64, ptr %14, align 8
  %15 = getelementptr inbounds { i64, ptr }, ptr %literal5, i32 0, i32 1
  %hi7 = load ptr, ptr %15, align 8
  %16 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i64 %lo6, ptr %hi7)
  %17 = getelementptr inbounds %HashMap, ptr %map, i32 0, i32 2
  %18 = insertvalue %"any*" undef, ptr %17, 0
  %19 = insertvalue %"any*" %18, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  %20 = getelementptr inbounds [1 x %"any*"], ptr %varargslots8, i64 0, i64 0
  store %"any*" %19, ptr %20, align 16
  %21 = call i64 @std.io.printfn(ptr %retparam9, ptr @.str.3, i64 12, ptr %varargslots8, i64 1)
  %22 = call i64 @"std.collections.map$int$test.Foo$.HashMap.get"(ptr %retparam11, ptr %map, i32 1)
  %not_err = icmp eq i64 %22, 0
  %23 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
  br i1 %23, label %after_check, label %after_check14

after_check:                                      ; preds = %entry
  %24 = getelementptr inbounds %Foo, ptr %retparam11, i32 0, i32 0
  %25 = insertvalue %"any*" undef, ptr %24, 0
  %26 = insertvalue %"any*" %25, i64 ptrtoint (ptr @"$ct.int" to i64), 1
  %27 = getelementptr inbounds [1 x %"any*"], ptr %varargslots10, i64 0, i64 0
  store %"any*" %26, ptr %27, align 16
  %28 = call i64 @std.io.printfn(ptr %retparam12, ptr @.str.4, i64 7, ptr %varargslots10, i64 1)
  %not_err13 = icmp eq i64 %28, 0
  %29 = call i1 @llvm.expect.i1(i1 %not_err13, i1 true)
  br i1 %29, label %after_check14, label %after_check14

after_check14:                                    ; preds = %entry, %after_check, %after_check
  %30 = call i8 @"std.collections.map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 1)
  store i8 %30, ptr %taddr, align 1
  %31 = insertvalue %"any*" undef, ptr %taddr, 0
  %32 = insertvalue %"any*" %31, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %33 = getelementptr inbounds [1 x %"any*"], ptr %varargslots15, i64 0, i64 0
  store %"any*" %32, ptr %33, align 16
  %34 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.5, i64 9, ptr %varargslots15, i64 1)
  %35 = call i8 @"std.collections.map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 2)
  store i8 %35, ptr %taddr20, align 1
  %36 = insertvalue %"any*" undef, ptr %taddr20, 0
  %37 = insertvalue %"any*" %36, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %38 = getelementptr inbounds [1 x %"any*"], ptr %varargslots19, i64 0, i64 0
  store %"any*" %37, ptr %38, align 16
  %39 = call i64 @std.io.printfn(ptr %retparam21, ptr @.str.6, i64 9, ptr %varargslots19, i64 1)
  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal24, ptr align 8 @.__const.7, i32 16, i1 false)
  %40 = getelementptr inbounds { i64, ptr }, ptr %literal24, i32 0, i32 0
  %lo25 = load i64, ptr %40, align 8
  %41 = getelementptr inbounds { i64, ptr }, ptr %literal24, i32 0, i32 1
  %hi26 = load ptr, ptr %41, align 8
  %42 = call i8 @"std.collections.map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i64 %lo25, ptr %hi26)
  %lo28 = load i64, ptr @std.core.mem.thread_allocator, align 8
  %hi29 = load ptr, ptr getelementptr inbounds ({ i64, ptr }, ptr @std.core.mem.thread_allocator, i32 0, i32 1), align 8
  %43 = call { ptr, i64 } @"std.collections.map$int$test.Foo$.HashMap.value_new_list"(ptr %map, i64 %lo28, ptr %hi29)
  store { ptr, i64 } %43, ptr %result, align 8
  %44 = insertvalue %"any*" undef, ptr %result, 0
  %45 = insertvalue %"any*" %44, i64 ptrtoint (ptr @"$ct.sa$test.Foo" to i64), 1
  %46 = getelementptr inbounds [1 x %"any*"], ptr %varargslots27, i64 0, i64 0
  store %"any*" %45, ptr %46, align 16
  %47 = call i64 @std.io.printfn(ptr %retparam30, ptr @.str.8, i64 10, ptr %varargslots27, i64 1)
  call void @llvm.memset.p0.i64(ptr align 8 %map2, i8 0, i64 48, i1 false)
  %lo33 = load i64, ptr @std.core.mem.thread_allocator, align 8
  %hi34 = load ptr, ptr getelementptr inbounds ({ i64, ptr }, ptr @std.core.mem.thread_allocator, i32 0, i32 1), align 8
  %48 = call ptr @"std.collections.map$int$double$.HashMap.init_new"(ptr %map2, i32 16, float 7.500000e-01, i64 %lo33, ptr %hi34)
  %49 = call i8 @"std.collections.map$int$double$.HashMap.set"(ptr %map2, i32 4, double 1.300000e+00)
  %50 = call i8 @"std.collections.map$int$double$.HashMap.has_value"(ptr %map2, double 1.300000e+00)
  store i8 %50, ptr %taddr36, align 1
  %51 = insertvalue %"any*" undef, ptr %taddr36, 0
  %52 = insertvalue %"any*" %51, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %53 = getelementptr inbounds [1 x %"any*"], ptr %varargslots35, i64 0, i64 0
  store %"any*" %52, ptr %53, align 16
  %54 = call i64 @std.io.printfn(ptr %retparam37, ptr @.str.9, i64 12, ptr %varargslots35, i64 1)
  %55 = call i8 @"std.collections.map$int$double$.HashMap.has_value"(ptr %map2, double 1.200000e+00)
  store i8 %55, ptr %taddr41, align 1
  %56 = insertvalue %"any*" undef, ptr %taddr41, 0
  %57 = insertvalue %"any*" %56, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  %58 = getelementptr inbounds [1 x %"any*"], ptr %varargslots40, i64 0, i64 0
  store %"any*" %57, ptr %58, align 16
  %59 = call i64 @std.io.printfn(ptr %retparam42, ptr @.str.10, i64 12, ptr %varargslots40, i64 1)
  %60 = call i8 @"std.collections.map$int$double$.HashMap.set"(ptr %map2, i32 100, double 3.400000e+00)
  %lo46 = load i64, ptr @std.core.mem.thread_allocator, align 8
  %hi47 = load ptr, ptr getelementptr inbounds ({ i64, ptr }, ptr @std.core.mem.thread_allocator, i32 0, i32 1), align 8
  %61 = call { ptr, i64 } @"std.collections.map$int$double$.HashMap.key_new_list"(ptr %map2, i64 %lo46, ptr %hi47)
  store { ptr, i64 } %61, ptr %result48, align 8
  %62 = insertvalue %"any*" undef, ptr %result48, 0
  %63 = insertvalue %"any*" %62, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
  %64 = getelementptr inbounds [1 x %"any*"], ptr %varargslots45, i64 0, i64 0
  store %"any*" %63, ptr %64, align 16
  %65 = call i64 @std.io.printfn(ptr %retparam49, ptr @.str.11, i64 2, ptr %varargslots45, i64 1)
  %lo53 = load i64, ptr @std.core.mem.thread_allocator, align 8
  %hi54 = load ptr, ptr getelementptr inbounds ({ i64, ptr }, ptr @std.core.mem.thread_allocator, i32 0, i32 1), align 8
  %66 = call { ptr, i64 } @"std.collections.map$int$double$.HashMap.value_new_list"(ptr %map2, i64 %lo53, ptr %hi54)
  store { ptr, i64 } %66, ptr %result55, align 8
  %67 = insertvalue %"any*" undef, ptr %result55, 0
  %68 = insertvalue %"any*" %67, i64 ptrtoint (ptr @"$ct.sa$double" to i64), 1
  %69 = getelementptr inbounds [1 x %"any*"], ptr %varargslots52, i64 0, i64 0
  store %"any*" %68, ptr %69, align 16
  %70 = call i64 @std.io.printfn(ptr %retparam56, ptr @.str.12, i64 2, ptr %varargslots52, i64 1)
  %71 = load ptr, ptr @std.core.mem.thread_temp_allocator, align 8
  %not = icmp eq ptr %71, null
  br i1 %not, label %if.then, label %if.exit

if.then:                                          ; preds = %after_check14
  call void @std.core.mem.init_default_temp_allocators()
  br label %if.exit

if.exit:                                          ; preds = %if.then, %after_check14
  %72 = load ptr, ptr @std.core.mem.thread_temp_allocator, align 8
  store ptr %72, ptr %current, align 8
  %73 = load ptr, ptr %current, align 8
  %74 = getelementptr inbounds %TempAllocator, ptr %73, i32 0, i32 2
  %75 = load i64, ptr %74, align 8
  store i64 %75, ptr %mark, align 8
  call void @llvm.memset.p0.i64(ptr align 8 %map3, i8 0, i64 48, i1 false)
  %lo59 = load i64, ptr @std.core.mem.thread_allocator, align 8
  %hi60 = load ptr, ptr getelementptr inbounds ({ i64, ptr }, ptr @std.core.mem.thread_allocator, i32 0, i32 1), align 8
  %76 = call ptr @"std.collections.map$int$double$.HashMap.init_new"(ptr %map3, i32 16, float 7.500000e-01, i64 %lo59, ptr %hi60)
  %77 = call i8 @"std.collections.map$int$double$.HashMap.set"(ptr %map3, i32 5, double 3.200000e+00)
  %78 = call i8 @"std.collections.map$int$double$.HashMap.set"(ptr %map3, i32 7, double 5.200000e+00)
  %lo62 = load i64, ptr @std.core.mem.thread_allocator, align 8
  %hi63 = load ptr, ptr getelementptr inbounds ({ i64, ptr }, ptr @std.core.mem.thread_allocator, i32 0, i32 1), align 8
  %79 = call { ptr, i64 } @"std.collections.map$int$double$.HashMap.key_new_list"(ptr %map3, i64 %lo62, ptr %hi63)
  store { ptr, i64 } %79, ptr %result64, align 8
  %80 = insertvalue %"any*" undef, ptr %result64, 0
  %81 = insertvalue %"any*" %80, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
  %82 = getelementptr inbounds [1 x %"any*"], ptr %varargslots61, i64 0, i64 0
  store %"any*" %81, ptr %82, align 16
  %83 = call i64 @std.io.printfn(ptr %retparam65, ptr @.str.13, i64 2, ptr %varargslots61, i64 1)
  %84 = load ptr, ptr %current, align 8
  %85 = load i64, ptr %mark, align 8
  call void @std.core.mem.allocator.TempAllocator.reset(ptr %84, i64 %85)
  ret void
}
define internal void @.static_initialize.0() {
entry:
  br label %dtable_check

dtable_check:                                     ; preds = %dtable_next, %entry
  %dtable_ref = phi ptr [ getelementptr inbounds (%.introspect, ptr @"$ct.test.Foo", i32 0, i32 2), %entry ], [ %next_dtable_ref, %dtable_next ]
  %dtable_ptr = load ptr, ptr %dtable_ref, align 8
  %0 = icmp eq ptr %dtable_ptr, null
  br i1 %0, label %dtable_found, label %dtable_next

dtable_next:                                      ; preds = %dtable_check
  %next_dtable_ref = getelementptr inbounds { ptr, ptr, ptr }, ptr %dtable_ptr, i32 0, i32 2
  br label %dtable_check

dtable_found:                                     ; preds = %dtable_check
  store ptr @"$ct.dyn.test.Foo.to_new_string", ptr %dtable_ref, align 8
  ret void
}