// #target: linux-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 = allocator::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.new_init();
	io::printfn("Map size: %d", map.count);
	map.set(1, { 1, null });
	io::printfn("Map size: %d", map.count);
	map.set(1, { 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, { 4, null });
	io::printfn("Values: %s", map.value_new_list());
	IntDoubleMap map2;
	map2.new_init();
	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.new_init();
		map3.set(5, 3.2);
		map3.set(7, 5.2);
		io::printfn("%s", map3.key_new_list());
	};
}

/* #expect: test.ll

@"$sel.to_new_string" = linkonce_odr constant [14 x i8] c"to_new_string\00", comdat, align 1
@llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 1, ptr @.c3_dynamic_register, ptr null }]

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
  %ptradd = getelementptr inbounds i8, ptr %allocator, i64 8
  store ptr %2, ptr %ptradd, align 8
  %lo = load i64, ptr %allocator, align 8
  %ptradd1 = getelementptr inbounds i8, ptr %allocator, i64 8
  %hi = load ptr, ptr %ptradd1, align 8
  %3 = call ptr @std.core.dstring.new_with_capacity(i64 128, i64 %lo, ptr %hi)
  store ptr %3, ptr %s, align 8
  %4 = insertvalue %any undef, ptr %0, 0
  %5 = insertvalue %any %4, i64 ptrtoint (ptr @"$ct.int" to i64), 1
  store %any %5, ptr %varargslots, align 16
  %ptradd2 = getelementptr inbounds i8, ptr %0, i64 8
  %6 = insertvalue %any undef, ptr %ptradd2, 0
  %7 = insertvalue %any %6, i64 ptrtoint (ptr @"$ct.p$void" to i64), 1
  %ptradd3 = getelementptr inbounds i8, ptr %varargslots, i64 16
  store %any %7, ptr %ptradd3, align 16
  %8 = call i64 @std.core.dstring.DString.appendf(ptr %retparam, ptr %s, ptr @.str.14, i64 8, ptr %varargslots, i64 2)
  %9 = load ptr, ptr %s, align 8
  %10 = call { ptr, i64 } @std.core.dstring.DString.str_view(ptr %9)
  store { ptr, i64 } %10, ptr %result, align 8
  %11 = load { ptr, i64 }, ptr %result, align 8
  ret { ptr, i64 } %11
}

define void @test.main() #0 {
entry:
  %map = alloca %HashMap, align 8
  %taddr = alloca %any, align 8
  %varargslots = alloca [1 x %any], align 16
  %retparam = alloca i64, align 8
  %literal = alloca %Foo, align 8
  %varargslots5 = alloca [1 x %any], align 16
  %retparam7 = alloca i64, align 8
  %literal8 = alloca %Foo, align 8
  %varargslots12 = alloca [1 x %any], align 16
  %retparam14 = alloca i64, align 8
  %varargslots15 = alloca [1 x %any], align 16
  %retparam16 = alloca %Foo, align 8
  %retparam17 = alloca i64, align 8
  %varargslots20 = alloca [1 x %any], align 16
  %taddr21 = alloca i8, align 1
  %retparam22 = alloca i64, align 8
  %varargslots25 = alloca [1 x %any], align 16
  %taddr26 = alloca i8, align 1
  %retparam27 = alloca i64, align 8
  %literal30 = alloca %Foo, align 8
  %varargslots34 = alloca [1 x %any], align 16
  %result = alloca %"Foo[]", align 8
  %retparam37 = alloca i64, align 8
  %map2 = alloca %HashMap.0, align 8
  %taddr40 = alloca %any, align 8
  %varargslots44 = alloca [1 x %any], align 16
  %taddr45 = alloca i8, align 1
  %retparam46 = alloca i64, align 8
  %varargslots49 = alloca [1 x %any], align 16
  %taddr50 = alloca i8, align 1
  %retparam51 = alloca i64, align 8
  %varargslots54 = alloca [1 x %any], align 16
  %result57 = alloca %"int[]", align 8
  %retparam58 = alloca i64, align 8
  %varargslots61 = alloca [1 x %any], align 16
  %result64 = alloca %"double[]", align 8
  %retparam65 = alloca i64, align 8
  %current = alloca ptr, align 8
  %mark = alloca i64, align 8
  %map3 = alloca %HashMap.0, align 8
  %taddr69 = alloca %any, align 8
  %varargslots73 = alloca [1 x %any], align 16
  %result76 = alloca %"int[]", align 8
  %retparam77 = alloca i64, align 8
  call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 48, i1 false)
  store %any { ptr null, i64 ptrtoint (ptr @"$ct.void" to i64) }, ptr %taddr, align 8
  %lo = load i64, ptr %taddr, align 8
  %ptradd = getelementptr inbounds i8, ptr %taddr, i64 8
  %hi = load ptr, ptr %ptradd, align 8
  %0 = call ptr @"std_collections_map$int$test.Foo$.HashMap.new_init"(ptr %map, i32 16, float 7.500000e-01, i64 %lo, ptr %hi)
  %ptradd1 = getelementptr inbounds i8, ptr %map, i64 32
  %1 = insertvalue %any undef, ptr %ptradd1, 0
  %2 = insertvalue %any %1, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  store %any %2, ptr %varargslots, align 16
  %3 = 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)
  %lo2 = load i32, ptr %literal, align 8
  %ptradd3 = getelementptr inbounds i8, ptr %literal, i64 8
  %hi4 = load ptr, ptr %ptradd3, align 8
  %4 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo2, ptr %hi4)
  %ptradd6 = getelementptr inbounds i8, ptr %map, i64 32
  %5 = insertvalue %any undef, ptr %ptradd6, 0
  %6 = insertvalue %any %5, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  store %any %6, ptr %varargslots5, align 16
  %7 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.1, i64 12, ptr %varargslots5, i64 1)
  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal8, ptr align 8 @.__const.2, i32 16, i1 false)
  %lo9 = load i32, ptr %literal8, align 8
  %ptradd10 = getelementptr inbounds i8, ptr %literal8, i64 8
  %hi11 = load ptr, ptr %ptradd10, align 8
  %8 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo9, ptr %hi11)
  %ptradd13 = getelementptr inbounds i8, ptr %map, i64 32
  %9 = insertvalue %any undef, ptr %ptradd13, 0
  %10 = insertvalue %any %9, i64 ptrtoint (ptr @"$ct.uint" to i64), 1
  store %any %10, ptr %varargslots12, align 16
  %11 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.3, i64 12, ptr %varargslots12, i64 1)
  %12 = call i64 @"std_collections_map$int$test.Foo$.HashMap.get"(ptr %retparam16, ptr %map, i32 1)
  %not_err = icmp eq i64 %12, 0
  %13 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
  br i1 %13, label %after_check, label %after_check19

after_check:                                      ; preds = %entry
  %14 = insertvalue %any undef, ptr %retparam16, 0
  %15 = insertvalue %any %14, i64 ptrtoint (ptr @"$ct.int" to i64), 1
  store %any %15, ptr %varargslots15, align 16
  %16 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.4, i64 7, ptr %varargslots15, i64 1)
  %not_err18 = icmp eq i64 %16, 0
  %17 = call i1 @llvm.expect.i1(i1 %not_err18, i1 true)
  br i1 %17, label %after_check19, label %after_check19

after_check19:                                    ; preds = %entry, %after_check, %after_check
  %18 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 1)
  store i8 %18, ptr %taddr21, align 1
  %19 = insertvalue %any undef, ptr %taddr21, 0
  %20 = insertvalue %any %19, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  store %any %20, ptr %varargslots20, align 16
  %21 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.5, i64 9, ptr %varargslots20, i64 1)
  %22 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 2)
  store i8 %22, ptr %taddr26, align 1
  %23 = insertvalue %any undef, ptr %taddr26, 0
  %24 = insertvalue %any %23, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  store %any %24, ptr %varargslots25, align 16
  %25 = call i64 @std.io.printfn(ptr %retparam27, ptr @.str.6, i64 9, ptr %varargslots25, i64 1)
  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal30, ptr align 8 @.__const.7, i32 16, i1 false)
  %lo31 = load i32, ptr %literal30, align 8
  %ptradd32 = getelementptr inbounds i8, ptr %literal30, i64 8
  %hi33 = load ptr, ptr %ptradd32, align 8
  %26 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i32 %lo31, ptr %hi33)
  %lo35 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
  %hi36 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
  %27 = call { ptr, i64 } @"std_collections_map$int$test.Foo$.HashMap.value_new_list"(ptr %map, i64 %lo35, ptr %hi36)
  store { ptr, i64 } %27, ptr %result, align 8
  %28 = insertvalue %any undef, ptr %result, 0
  %29 = insertvalue %any %28, i64 ptrtoint (ptr @"$ct.sa$test.Foo" to i64), 1
  store %any %29, ptr %varargslots34, align 16
  %30 = call i64 @std.io.printfn(ptr %retparam37, ptr @.str.8, i64 10, ptr %varargslots34, i64 1)
  call void @llvm.memset.p0.i64(ptr align 8 %map2, i8 0, i64 48, i1 false)
  store %any { ptr null, i64 ptrtoint (ptr @"$ct.void" to i64) }, ptr %taddr40, align 8
  %lo41 = load i64, ptr %taddr40, align 8
  %ptradd42 = getelementptr inbounds i8, ptr %taddr40, i64 8
  %hi43 = load ptr, ptr %ptradd42, align 8
  %31 = call ptr @"std_collections_map$int$double$.HashMap.new_init"(ptr %map2, i32 16, float 7.500000e-01, i64 %lo41, ptr %hi43)
  %32 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 4, double 1.300000e+00)
  %33 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.300000e+00)
  store i8 %33, ptr %taddr45, align 1
  %34 = insertvalue %any undef, ptr %taddr45, 0
  %35 = insertvalue %any %34, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  store %any %35, ptr %varargslots44, align 16
  %36 = call i64 @std.io.printfn(ptr %retparam46, ptr @.str.9, i64 12, ptr %varargslots44, i64 1)
  %37 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.200000e+00)
  store i8 %37, ptr %taddr50, align 1
  %38 = insertvalue %any undef, ptr %taddr50, 0
  %39 = insertvalue %any %38, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
  store %any %39, ptr %varargslots49, align 16
  %40 = call i64 @std.io.printfn(ptr %retparam51, ptr @.str.10, i64 12, ptr %varargslots49, i64 1)
  %41 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 100, double 3.400000e+00)
  %lo55 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
  %hi56 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
  %42 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.key_new_list"(ptr %map2, i64 %lo55, ptr %hi56)
  store { ptr, i64 } %42, ptr %result57, align 8
  %43 = insertvalue %any undef, ptr %result57, 0
  %44 = insertvalue %any %43, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
  store %any %44, ptr %varargslots54, align 16
  %45 = call i64 @std.io.printfn(ptr %retparam58, ptr @.str.11, i64 2, ptr %varargslots54, i64 1)
  %lo62 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
  %hi63 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
  %46 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.value_new_list"(ptr %map2, i64 %lo62, ptr %hi63)
  store { ptr, i64 } %46, ptr %result64, align 8
  %47 = insertvalue %any undef, ptr %result64, 0
  %48 = insertvalue %any %47, i64 ptrtoint (ptr @"$ct.sa$double" to i64), 1
  store %any %48, ptr %varargslots61, align 16
  %49 = call i64 @std.io.printfn(ptr %retparam65, ptr @.str.12, i64 2, ptr %varargslots61, i64 1)
  %50 = load ptr, ptr @std.core.mem.allocator.thread_temp_allocator, align 8
  %i2nb = icmp eq ptr %50, null
  br i1 %i2nb, label %if.then, label %if.exit

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

if.exit:                                          ; preds = %if.then, %after_check19
  %51 = load ptr, ptr @std.core.mem.allocator.thread_temp_allocator, align 8
  store ptr %51, ptr %current, align 8
  %52 = load ptr, ptr %current, align 8
  %ptradd68 = getelementptr inbounds i8, ptr %52, i64 24
  %53 = load i64, ptr %ptradd68, align 8
  store i64 %53, ptr %mark, align 8
  call void @llvm.memset.p0.i64(ptr align 8 %map3, i8 0, i64 48, i1 false)
  store %any { ptr null, i64 ptrtoint (ptr @"$ct.void" to i64) }, ptr %taddr69, align 8
  %lo70 = load i64, ptr %taddr69, align 8
  %ptradd71 = getelementptr inbounds i8, ptr %taddr69, i64 8
  %hi72 = load ptr, ptr %ptradd71, align 8
  %54 = call ptr @"std_collections_map$int$double$.HashMap.new_init"(ptr %map3, i32 16, float 7.500000e-01, i64 %lo70, ptr %hi72)
  %55 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 5, double 3.200000e+00)
  %56 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 7, double 5.200000e+00)
  %lo74 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8
  %hi75 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8
  %57 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.key_new_list"(ptr %map3, i64 %lo74, ptr %hi75)
  store { ptr, i64 } %57, ptr %result76, align 8
  %58 = insertvalue %any undef, ptr %result76, 0
  %59 = insertvalue %any %58, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1
  store %any %59, ptr %varargslots73, align 16
  %60 = call i64 @std.io.printfn(ptr %retparam77, ptr @.str.13, i64 2, ptr %varargslots73, i64 1)
  %61 = load ptr, ptr %current, align 8
  %62 = load i64, ptr %mark, align 8
  call void @std.core.mem.allocator.TempAllocator.reset(ptr %61, i64 %62)
  ret void
}

define internal void @.c3_dynamic_register() align 8 {
entry:
  %next_val = load ptr, ptr getelementptr
  %0 = icmp eq ptr %next_val, inttoptr (i64 -1 to ptr)
  br i1 %0, label %dtable_check, label %dtable_skip

dtable_check:                                     ; preds = %dtable_check, %entry
  %dtable_ref = phi ptr [ getelementptr inbounds
  %dtable_ptr = load ptr, ptr %dtable_ref, align 8
  %1 = icmp eq ptr %dtable_ptr, null
  %next_dtable_ref = getelementptr inbounds
  br i1 %1, label %dtable_found, label %dtable_check

dtable_found:                                     ; preds = %dtable_check
  store ptr @"$ct.dyn.test.Foo.to_new_string", ptr %dtable_ref, align 8
  store ptr null, ptr getelementptr inbounds
  br label %dtable_skip

dtable_skip:                                      ; preds = %dtable_found, %entry
  ret void
}