require = fn (ok: u1) void
{
    if (!ok)
    {
        #trap();
    }
}

return_constant = fn () s32 // This is a comment
// This is a comment
{ // This is a comment
    // This is a comment
    return 0; // This is a comment
}// This is a comment
// This is a comment

constant_add = fn () s32
{
    return -1 + 1;
}

constant_and = fn () s32
{
    return 1 & 2;
}

constant_div = fn () s32
{
    return 0 / 5;
}

constant_mul = fn () s32
{
    return 1 * 0;
}

constant_rem = fn () s32
{
    return 5 % 5;
}

constant_or = fn () s32
{
    return 0 | 0;
}

constant_sub = fn () s32
{
    return 1 - 1;
}

constant_xor = fn () s32
{
    return 0 ^ 0;
}

constant_shift_left = fn () s32
{
    return 0 << 1;
}

constant_shift_right = fn () s32
{
    return 0 >> 1;
}

minimal_stack = fn () s32
{
    >a: s32 = 0;
    return a;
}

minimal_stack_arithmetic0 = fn () s32
{
    >a: s32 = 1;
    return a - 1;
}

minimal_stack_arithmetic1 = fn () s32
{
    >a: s32 = 1;
    >b = a - 1;
    return b;
}

minimal_stack_arithmetic2 = fn () s32
{
    >a: s32 = 1;
    >b = 1 - a;
    return b;
}

stack_negation = fn () s32
{
    >v: s32 = 0;
    return -v;
}

stack_add = fn () s32
{
    >a: s32 = -1;
    >b: s32 = 1;
    return a + b;
}

stack_sub = fn () s32
{
    >a: s32 = 1;
    >b: s32 = 1;
    return a - b;
}

extend = fn () s32
{
    >a: s8 = 0;
    return #extend(a);
}

integer_max = fn () s32
{
    >a = #integer_max(u64);
    return #truncate(a + 1);
}

integer_hex = fn () s32
{
    >result: s32 = 0x0;
    return result;
}

basic_pointer = fn () s32
{
    >a: s32 = 0;
    >pointer = &a;
    return pointer.&;
}

basic_call_foo = fn () s32
{
    return 0;
}

basic_call = fn () s32
{
    return basic_call_foo();
}

basic_branch = fn () s32
{
    >result: s32 = 1;
    if (result != 1)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

basic_array = fn () s32
{
    >array: [_]s32 = [3, 2, 1, 0];
    return array[3];
}

BasicEnum = enum
{
    zero = 0,
    one = 1,
    two = 2,
    three = 3,
}

basic_enum = fn () s32
{
    >a: BasicEnum = .three;
    >b: BasicEnum = .two;
    >c: BasicEnum = .one;
    >a_int: s32 = #extend(#int_from_enum(a));
    >b_int: s32 = #extend(#int_from_enum(b));
    >c_int: s32 = #extend(#int_from_enum(c));

    return a_int - (b_int + c_int);
}

basic_slice_receiver = fn (slice: []u8) void
{
    require(slice.length == 3);
    require(slice[0] == 0);
    require(slice[1] == 1);
    require(slice[2] == 2);
}

basic_slice = fn () void
{
    >a: [_]u8 = [0, 1, 2];
    basic_slice_receiver(a[..]);
}

basic_string = fn () void
{
    >string = "abc";
    require(string[0] == 'a');
    require(string[1] == 'b');
    require(string[2] == 'c');
}

basic_varargs_function = fn [cc(c)] (first_arg: u32, ...) void
{
    require(first_arg == 123456789);

    >va = #va_start();

    >a = #va_arg(&va, u32);

    require(a == 987654321);

    >first_arg_b = #va_arg(&va, u32);
    require(first_arg == first_arg_b);
}

basic_varargs = fn () void
{
    >first_arg: u32 = 123456789;
    >a: u32 = 987654321;
    basic_varargs_function(first_arg, a, first_arg);
}

c_string_length = fn (c_string: &u8) u64
{
    >it = c_string;

    while (it.&)
    {
        it = it + 1;
    }

    return #int_from_pointer(it) - #int_from_pointer(c_string);
}

basic_while = fn (argc: s32, argv: &&u8) void
{
    require(argc != 0);

    >first_arg = argv[0];
    require(first_arg != zero);

    >arg_length = c_string_length(first_arg);
    require(arg_length != 0);

    require(first_arg[arg_length] == 0);
}

pointer_function = fn (v: &s32) void
{
    v.& = 1;
}

pointer = fn () s32
{
    >value: s32 = 0;
    pointer_function(&value);
    return #extend(value == 0);
}

pointer_cast = fn () s32
{
    >result: u32 = 0;
    >p = &result;
    >signed_pointer: &s32 = #pointer_cast(p);
    return signed_pointer.&;
}

u1_return_foo = fn () u1
{
    >result: u1 = 0;
    return result;
}

u1_return = fn () s32
{
    >result = u1_return_foo();
    return #extend(result);
}

local_type_inference_foo = fn () s32
{
    return 0;
}

local_type_inference = fn () s32
{
    >a: s32 = 0;
    >result = local_type_inference_foo() + a;
    return result;
}

basic_global_foo: s32 = 0;

basic_global = fn () s32
{
    return basic_global_foo;
}

basic_function_pointer_callback = fn () s32
{
    return 123;
}

basic_function_pointer = fn () s32
{
    >function_pointer = &basic_function_pointer_callback;
    return function_pointer() - 123;
}

[extern] strlen = fn [cc(c)] (string: &u8) s64;

basic_extern = fn () void
{
    >length = strlen("abc");
    require(length == 3);
}

basic_byte_size = fn () void
{
    >sizeofu8: u8 = #byte_size(u8);
    require(sizeofu8 == 1);
    >sizeofu16: u8 = #byte_size(u16);
    require(sizeofu16 == 2);
    >sizeofs32: s32 = #byte_size(s32);
    require(sizeofs32 == 4);
    >sizeofs64: s32 = #byte_size(s64);
    require(sizeofs64 == 8);
}

unsigned_assignment_operators = fn(n: s32) s32
{
    >result: u32 = #extend(n);
    result >>= 1;
    result <<= 1;
    result ^= 1;
    result |= 1;
    result &= 1;
    result += 1;
    result -= 1;
    result /= 1;
    result %= 1;
    result *= 0;

    return #extend(result);
}

assignment_operators = fn () s32
{
    >result: s32 = 0;
    >pointer = &result;
    pointer -= 1;
    pointer += 1;
    result >>= 1;
    result <<= 1;
    result ^= 1;
    result |= 1;
    result &= 1;
    result += 1;
    result -= 1;
    result /= 1;
    result %= 1;
    result *= 0;
    return unsigned_assignment_operators(result);
}

not_pointer = fn () s32
{
    >a: s32 = 0;
    >ptr = &a;
    >b = !ptr;
    return #extend(b);
}

BasicBitField = bits u8
{
    a: u2,
    b: u2,
    c: u2,
    d: u2,
}

basic_bits = fn () void
{
    >bf: BasicBitField = {
        .a = 3,
        .b = 2,
        .c = 2,
        .d = 3,
    };

    require(bf.a == 3);
    require(bf.b == 2);
    require(bf.c == 2);
    require(bf.d == 3);
}

BitsNoBackingType = bits
{
    a: u1,
    b: u1,
}

bits_no_backing_type = fn () void
{
    >bf: BitsNoBackingType = {
        .a = 1,
        .b = 1,
    };

    require(bf.a == 1);
    require(bf.b == 1);
}

BitsU1 = bits u32
{
    a: u1,
    b: u1,
    c: u1,
}

bits_return_u1_function = fn () u1
{
    >b1: BitsU1 = {
        .a = 1,
        .b = 1,
        .c = 0,
    };

    return b1.c;
}

bits_return_u1 = fn () void
{
    >b1 = bits_return_u1_function();
    require(b1 == 0);
}

BitsZero = bits
{
    a: u1,
    b: u1,
    c: u1,
}

bits_zero = fn () void
{
    >a_bz: BitsZero = zero;

    require(a_bz.a == 0);
    require(a_bz.b == 0);
    require(a_bz.c == 0);

    >b_bz: BitsZero = {
        .a = 1,
        .b = 1,
        zero,
    };

    require(b_bz.a == 1);
    require(b_bz.b == 1);
    require(b_bz.c == 0);
}

basic_comparison_trivial = fn (a: s32, b: s32) u1
{
    return a + 1 == b + 1;
}

basic_comparison = fn (argument_count: s32) void
{
    require(basic_comparison_trivial(argument_count, argument_count));
}

BasicGlobalStruct = struct
{
    a: u32,
    b: u32,
    c: u32,
}

basic_global_struct_variable: BasicGlobalStruct = {
    .a = 1,
    .b = 2,
    .c = 3,
};

basic_global_struct = fn () void
{
    require(basic_global_struct_variable.a == 1);
    require(basic_global_struct_variable.b == 2);
    require(basic_global_struct_variable.c == 3);
}

if_no_else = fn () s32
{
    >a: s32 = 5;
    if (a == 2)
    {
        return 1;
    }

    return 0;
}

if_no_else_void = fn () void
{
    >result: s32 = 0;
    if (result != 0)
    {
        #trap();
    }
}

Indirect = struct
{
    a: u32,
    b: u32,
    c: u32,
    d: u32,
    e: u32,
    f: u32,
}

indirect_ret = fn [cc(c)] () Indirect
{
    return { .a = 56, .b = 57, .c = 58, .d = 59, .e = 60, .f = 61 };
}

indirect_arg = fn [cc(c)] (s: Indirect) void
{
    require(s.a == 56);
    require(s.b == 57);
    require(s.c == 58);
    require(s.d == 59);
    require(s.e == 60);
    require(s.f == 61);
}

basic_indirect = fn () void
{
    >s = indirect_ret();
    require(s.a == 56);
    require(s.b == 57);
    require(s.c == 58);
    require(s.d == 59);
    require(s.e == 60);
    require(s.f == 61);
    indirect_arg(s);
}

IndirectVarArgs = struct
{
    a: u64,
    b: u64,
    c: u64,
    d: u64,
    e: u64
    f: u64,
    g: u64,
    h: u64,
    i: u64,
    j: u64
}

indirect_varargs_function = fn [cc(c)] (first_arg: u32, ...) void
{
    if (first_arg != 123456789)
    {
        #trap();
    }

    >va = #va_start();

    >s = #va_arg(&va, IndirectVarArgs);
    require(s.a == 9);
    require(s.b == 8);
    require(s.c == 7);
    require(s.d == 6);
    require(s.e == 5);
    require(s.f == 4);
    require(s.g == 3);
    require(s.h == 2);
    require(s.i == 1);
    require(s.j == 0);
}

indirect_varargs = fn () void
{
    >first_arg: u32 = 123456789;
    >s: IndirectVarArgs = {
        .a = 9,
        .b = 8,
        .c = 7,
        .d = 6,
        .e = 5,
        .f = 4,
        .g = 3,
        .h = 2,
        .i = 1,
        .j = 0,
    };
    indirect_varargs_function(first_arg, s);
}

return_type_builtin = fn () s32
{
    >result: #ReturnType = 0;
    return result;
}

Struct_u64_u64 = struct
{
    a: u64,
    b: u64,
}

return_struct_u64_u64_function = fn [cc(c)] () Struct_u64_u64
{
    return { .a = 1, .b = 2 };
}

return_struct_u64_u64 = fn [cc(c)] () s32
{
    >r = return_struct_u64_u64_function();
    return #truncate(r.a + r.b - 3);
}

select = fn () s32
{
    >boolean: u1 = 1;
    >left: s32 = 0;
    >right: s32 = 1;
    return #select(boolean, left, right);
}

slice2 = fn (argc: s32, argv: &&u8) void
{
    require(argc != 0);
    >arg_ptr = argv[0];
    >a1 = arg_ptr[0..c_string_length(arg_ptr)];
    >a2 = a1[1..];

    require(a1.pointer == a2.pointer - 1);
    require(a1.length == a2.length + 1);
}

SA1 = struct
{
    a: u8,
    b: u8,
    c: u8,
}

SA2 = struct
{
    a: u8,
    b: u8,
    c: u8,
}

struct_assignment = fn () void
{
    >s1: SA1 = {
        .a = 255,
        .b = 254,
        .c = 253,
    };
    >s2: SA2 = {
        .a = s1.a,
        .b = s1.b,
        .c = s1.c,
    };

    require(s1.a == 255);
    require(s1.b == 254);
    require(s1.c == 253);

    require(s2.a == 255);
    require(s2.b == 254);
    require(s2.c == 253);
}

BasicStruct = struct
{
    x: s32,
    y: s32,
    z: s32,
}

basic_struct_fn = fn (s: BasicStruct) s32
{
    return s.z;
}

basic_struct = fn () s32
{
    >a: BasicStruct = {
        .x = 2,
        .y = 1,
        .z = 0,
    };

    return basic_struct_fn(a);
}

struct_zero = fn () void
{
    >a: SA1 = zero;

    require(a.a == 0);
    require(a.b == 0);
    require(a.c == 0);

    >b: SA1 = {
        .a = 1,
        .b = 1,
        zero,
    };

    require(b.a == 1);
    require(b.b == 1);
    require(b.c == 0);
}

basic_unreachable = fn () s32
{
    >result: s32 = 0;

    if (result != 0)
    {
        unreachable;
    }

    return result;
}

S = struct
{
    a: u32,
    b: u32,
    c: u64,
    d: u64,
    e: u64
}

va_arg_function = fn [cc(c)] (first_arg: u32, ...) void
{
    >va = #va_start();

    >a = #va_arg(&va, u32);
    >b = #va_arg(&va, S);
    >c = #va_arg(&va, s64); 
    >d = #va_arg(&va, s32); 

    require(first_arg == 123456789);
    require(a == 123);
    require(c == -1);
    require(d == -2);
    require(b.a == 1);
    require(b.b == 2);
    require(b.c == 3);
    require(b.d == 4);
    require(b.e == 5);

    #va_end(&va);
}

S2 = struct
{
    a: u64,
    b: u64,
}

va_arg_function2 = fn [cc(c)] (...) void
{
    >va = #va_start();
    >s2 = #va_arg(&va, S2);
    require(s2.a == 8);
    require(s2.b == 9);
    #va_end(&va);
}

va_args = fn [cc(c)] () void
{
    >first_arg: u32 = 123456789;
    >a: u32 = 123;
    >b: S = { .a = 1, .b = 2, .c = 3, .d = 4, .e = 5 };
    >c: s64 = -1;
    >d: s32 = -2;
    va_arg_function(first_arg, a, b, c, d);
    >s2: S2 = { .a = 8, .b = 9 };
    va_arg_function2(s2);
}

[export] main = fn [cc(c)] (argc: s32, argv: &&u8, envp: &&u8) s32
{
    >rc = return_constant();
    require(rc == 0);

    >const_add = constant_add();
    require(const_add == 0);

    >const_and = constant_and();
    require(const_and == 0);

    >const_div = constant_div();
    require(const_div == 0);

    >const_mul = constant_mul();
    require(const_mul == 0);

    >const_rem = constant_rem();
    require(const_rem == 0);

    >const_or = constant_or();
    require(const_or == 0);

    >const_sub = constant_sub();
    require(const_sub == 0);

    >const_xor = constant_xor();
    require(const_xor == 0);

    >const_shift_left = constant_shift_left();
    require(const_shift_left == 0);

    >const_shift_right = constant_shift_right();
    require(const_shift_right == 0);

    >min_stack = minimal_stack();
    require(min_stack == 0);

    >min_stack_arithmetic0 = minimal_stack_arithmetic0(); 
    require(min_stack_arithmetic0 == 0);

    >min_stack_arithmetic1 = minimal_stack_arithmetic1(); 
    require(min_stack_arithmetic1 == 0);

    >min_stack_arithmetic2 = minimal_stack_arithmetic2(); 
    require(min_stack_arithmetic2 == 0);

    >st_neg = stack_negation();
    require(st_neg == 0);

    >st_add = stack_add();
    require(st_add == 0);

    >st_sub = stack_sub();
    require(st_sub == 0);

    >ext = extend();
    require(ext == 0);

    >int_max = integer_max();
    require(int_max == 0);

    >int_hex = integer_hex();
    require(int_hex == 0);

    >b_pointer = basic_pointer();
    require(b_pointer == 0);

    >b_call = basic_call();
    require(b_call == 0);

    >b_branch = basic_branch();
    require(b_branch == 0);

    >b_array = basic_array();
    require(b_array == 0);

    >b_enum = basic_enum();
    require(b_enum == 0);

    basic_slice();

    basic_string();

    basic_varargs();

    basic_while(argc, argv);

    >p = pointer();
    require(p == 0);

    >pc = pointer_cast();
    require(pc == 0);

    >u1_ret = u1_return();
    require(u1_ret == 0);

    >lti = local_type_inference();
    require(lti == 0);

    >bg = basic_global();
    require(bg == 0);

    >bfp = basic_function_pointer();
    require(bfp == 0);

    basic_extern();

    basic_byte_size();

    >assignment_ops = assignment_operators();
    require(assignment_ops == 0);

    >np = not_pointer();
    require(np == 0);

    basic_bits();

    bits_no_backing_type();

    bits_return_u1();

    bits_zero();

    basic_comparison(argc);

    basic_global_struct();

    >if_ne = if_no_else();
    require(if_ne == 0);

    if_no_else_void();

    basic_indirect();

    indirect_varargs();

    >rtb = return_type_builtin();
    require(rtb == 0);

    >rs6464 = return_struct_u64_u64();
    require(rs6464 == 0);

    >sel = select();
    require(sel == 0);

    slice2(argc, argv);

    struct_assignment();

    >bs = basic_struct();
    require(bs == 0);

    struct_zero();

    >bu = basic_unreachable();
    require(bu == 0);

    va_args();

    return 0;
}