c3c/test/test_suite2/statements/foreach_more_implementations.c3t

// #target: macos-x64
module test;

import std::io;
struct Vector
{
    usz size;
    int* elements;
}

macro int Vector.get(Vector* vector, usz element) @operator([])
{
    return vector.elements[element];
}

macro int* Vector.get_ref(Vector* vector, usz element) @operator(&[])
{
    return &vector.elements[element];
}

macro usz Vector.size(Vector vector) @operator(len) {
    return vector.size;
}

fn void main()
{
	int[2] x = { 1, 2 };
    Vector v = { 2, &x };

    foreach (int* &ref : v)
    {
        std::io::printf("%d\n", *ref);
        *ref += 2;
    }
    foreach (int i : v)
    {
        std::io::printf("%d\n", i);
    }
}

/* #expect: test.ll

define void @test_main() #0 {
entry:
  %x = alloca [2 x i32], align 4
  %v = alloca %Vector, align 8
  %.anon = alloca i64, align 8
  %vector = alloca %Vector, align 8
  %.anon1 = alloca i64, align 8
  %ref = alloca ptr, align 8
  %vector2 = alloca ptr, align 8
  %element = alloca i64, align 8
  %retparam = alloca i64, align 8
  %varargslots = alloca [1 x %variant], align 16
  %.anon4 = alloca i64, align 8
  %vector5 = alloca %Vector, align 8
  %.anon6 = alloca i64, align 8
  %i = alloca i32, align 4
  %vector10 = alloca ptr, align 8
  %element11 = alloca i64, align 8
  %retparam13 = alloca i64, align 8
  %varargslots14 = alloca [1 x %variant], align 16
  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %x, ptr align 4 @.__const, i32 8, i1 false)
  %0 = getelementptr inbounds %Vector, ptr %v, i32 0, i32 0
  store i64 2, ptr %0, align 8
  %1 = getelementptr inbounds %Vector, ptr %v, i32 0, i32 1
  store ptr %x, ptr %1, align 8
  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %vector, ptr align 8 %v, i32 16, i1 false)
  %2 = getelementptr inbounds %Vector, ptr %vector, i32 0, i32 0
  %3 = load i64, ptr %2, align 8
  store i64 %3, ptr %.anon, align 8
  store i64 0, ptr %.anon1, align 8
  br label %loop.cond

loop.cond:                                        ; preds = %voiderr, %entry
  %4 = load i64, ptr %.anon1, align 8
  %5 = load i64, ptr %.anon, align 8
  %lt = icmp ult i64 %4, %5
  br i1 %lt, label %loop.body, label %loop.exit

loop.body:                                        ; preds = %loop.cond
  store ptr %v, ptr %vector2, align 8
  %6 = load i64, ptr %.anon1, align 8
  store i64 %6, ptr %element, align 8
  %7 = load ptr, ptr %vector2, align 8
  %8 = getelementptr inbounds %Vector, ptr %7, i32 0, i32 1
  %9 = load ptr, ptr %8, align 8
  %10 = load i64, ptr %element, align 8
  %ptroffset = getelementptr inbounds i32, ptr %9, i64 %10
  store ptr %ptroffset, ptr %ref, align 8
  %11 = load ptr, ptr %ref, align 8
  %12 = insertvalue %variant undef, ptr %11, 0
  %13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$int" to i64), 1
  %14 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
  store %variant %13, ptr %14, align 16
  %15 = call i64 @std_io_printf(ptr %retparam, ptr @.str, i64 3, ptr %varargslots, i64 1)
  %not_err = icmp eq i64 %15, 0
  br i1 %not_err, label %after_check, label %voiderr

after_check:                                      ; preds = %loop.body
  br label %voiderr

voiderr:                                          ; preds = %after_check, %loop.body
  %16 = load ptr, ptr %ref, align 8
  %17 = load i32, ptr %16, align 8
  %add = add i32 %17, 2
  store i32 %add, ptr %16, align 8
  %18 = load i64, ptr %.anon1, align 8
  %add3 = add i64 %18, 1
  store i64 %add3, ptr %.anon1, align 8
  br label %loop.cond

loop.exit:                                        ; preds = %loop.cond
  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %vector5, ptr align 8 %v, i32 16, i1 false)
  %19 = getelementptr inbounds %Vector, ptr %vector5, i32 0, i32 0
  %20 = load i64, ptr %19, align 8
  store i64 %20, ptr %.anon4, align 8
  store i64 0, ptr %.anon6, align 8
  br label %loop.cond7

loop.cond7:                                       ; preds = %voiderr17, %loop.exit
  %21 = load i64, ptr %.anon6, align 8
  %22 = load i64, ptr %.anon4, align 8
  %lt8 = icmp ult i64 %21, %22
  br i1 %lt8, label %loop.body9, label %loop.exit19

loop.body9:                                       ; preds = %loop.cond7
  store ptr %v, ptr %vector10, align 8
  %23 = load i64, ptr %.anon6, align 8
  store i64 %23, ptr %element11, align 8
  %24 = load ptr, ptr %vector10, align 8
  %25 = getelementptr inbounds %Vector, ptr %24, i32 0, i32 1
  %26 = load ptr, ptr %25, align 8
  %27 = load i64, ptr %element11, align 8
  %ptroffset12 = getelementptr inbounds i32, ptr %26, i64 %27
  %28 = load i32, ptr %ptroffset12, align 4
  store i32 %28, ptr %i, align 4
  %29 = insertvalue %variant undef, ptr %i, 0
  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$int" to i64), 1
  %31 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0
  store %variant %30, ptr %31, align 16
  %32 = call i64 @std_io_printf(ptr %retparam13, ptr @.str.1, i64 3, ptr %varargslots14, i64 1)
  %not_err15 = icmp eq i64 %32, 0
  br i1 %not_err15, label %after_check16, label %voiderr17

after_check16:                                    ; preds = %loop.body9
  br label %voiderr17

voiderr17:                                        ; preds = %after_check16, %loop.body9
  %33 = load i64, ptr %.anon6, align 8
  %add18 = add i64 %33, 1
  store i64 %add18, ptr %.anon6, align 8
  br label %loop.cond7

loop.exit19:                                      ; preds = %loop.cond7
  ret void
}