comptime: declaring a struct in an 'inline for' fails to compile

[xxxbxxx]

hi.

This fails to compile:

export fn func() void {
    inline for ([_]u8{1,2}) |phase| {
        const S = struct {
            val: if (phase == 1) u32 else [2]f32,
        };
        const s = S{.val = if (phase== 1) 1 else [2]f32{1,2} };
    }
}

(with error: 6:57: error: array access of non-array type 'u32')

Looks like the second iteration tries to use the struct from the first iteration or something like this.

If I declare both structs before hand, it works:

export fn func2() void {
    const S1 = struct {
        val: u32,
    };
    const S2 = struct {
        val: [2]f32,
    };
    inline for ([_]u8{1,2}) |phase| {
        const S = if (phase == 1) S1 else S2;
        const s = S{.val = if (phase== 1) 1 else [2]f32{1,2} };
    }
}

[Rocknest]

Anon list literal cannot coerce into a type if the type is provided explicitly.

export fn entry() void {
    const T = struct {c: usize, d: usize};
    var x: T = T { .c = 546343, .d = 7};
    var z: struct {a: usize, b: usize} = .{x.c, x.d};
}

Compile error is nonsense and misleading.

source.zig:4:45: error: array access of non-array type 'struct:4:12'
    var z: struct {a: usize, b: usize} = .{x.c, x.d};
                                            ^

[Rocknest]

When using intermediate generic function this code actually works:

export fn func() void {
    inline for ([_]u8{1,2}) |phase| {
        const S = MakeStruct(if (phase == 1) u32 else [2]f32);
        const s = S{.val = if (phase== 1) 1 else [2]f32{1,2} };
    }
}

fn MakeStruct(comptime ArgType: type) type {
    return struct {
        val: ArgType,
    };
}}

[LemonBoy]

Compile error is nonsense and misleading.

The compiler error is correct and on point. The expression .{x.c, x.d} is valid as initializer for array types and the compiler desugars it as:

lhs[0] = x.c;
lhs[1] = x.d;

If lhs is a struct, like it is in your case, you get an error because of that.

The correct way to do what you wanted to do is:

var z: struct {a: usize, b: usize} = .{.a = x.c, .b = x.d};

[Rocknest]

@LemonBoy Why not allow this coercion? By default it will be struct anyway:

export fn entry() void {
    const T = struct {c: usize, d: usize};
    var x: T = T { .c = 546343, .d = 7};
    var z = .{x.c, x.d};
    // @TypeOf(z) is struct {@"0": usize, @"1": usize}
    var z2: @TypeOf(z) = .{.@"0" = x.c, .@"1" = x.d};
}

Anyway the error should be more clear e.g. "use struct literal instead"

Related #4335

[LemonBoy]

Why not allow this coercion?

Because it's a time-bomb, if you swap the order of two entries in a struct definition the initializer will still work but your code will blow up unexpectedly.

Edit: and for non-extern, non-packed struct the field order is unspecified.

Anyway the error should be more clear e.g. "use struct literal instead"

Aye, there's already a initializing array with struct syntax error but not the other way around.

[Rocknest]

Because it's a time-bomb

Same can be said about functions - they are all time-bombs - if you swap order of parameters and the types match then the code will compile but may 'blow up'

Edit: and for non-extern, non-packed struct the field order is unspecified.

Order of fields in memory? How is that related?