Compiler Crash when Trying to Call a Call-by-Pointer Method on a Member of a Comptime Tuple

[1E0N4RD]

Zig Version

0.12.0-dev.2334+aef1da163

Steps to Reproduce and Observed Behavior

const std = @import("std");

const A = struct {
    value: usize = 0,
    pub fn foo(self: A) void {
        _ = self;
    }
    pub fn bar(self: *A) void {
        _ = self;
    }
    pub fn baz(self: *const A) void {
        _ = self;
    }
};

pub fn B(comptime Child: type) type {
    return struct {
        children: Child,
    };
}

fn createB(children: anytype) B(@TypeOf(children)) {
    return .{ .children = children };
}

pub fn RuntimeTuple(comptime T: type) type {
    const info = @typeInfo(T);
    const len = info.Struct.fields.len;
    var types: [len]type = undefined;
    for (info.Struct.fields, &types) |field, *tp| {
        tp.* = field.type;
    }
    return std.meta.Tuple(&types);
}

fn createRuntimeB(children: anytype) B(RuntimeTuple(@TypeOf(children))) {
    return .{ .children = children }; 
}

pub fn main() !void {
    // creates a value with type B(struct{ comptime A = .{}, comptime A = .{} })
    var a = createB(.{ A{}, A{} });
    // c.children[0].value = 2; fails with reasonable error message.
    switch (.Ptr) {
        .Value => a.children[0].foo(), // Works
        .Ptr => a.children[0].bar(), // Semantically incorrect code. Crashes the compiler
        .ConstPtr => a.children[0].baz(), // Could maybe work?  Crashes the compiler
        else => unreachable,
    }

    // What I meant to do:
    // create a value with type B(struct{A, A})
    var b = createRuntimeB(.{ A{}, A{} });
    b.children[0].foo();
    b.children[0].bar();
    b.children[0].baz();
}

Note that the compiler is correct in rejecting the code but should do so with some kind of error message.

Expected Behavior

Compilation should fail with an error message similar to the one when you try to modify a field of a.

[Vexu]

Duplicate of #12963