Propagating 'const' to struct fields

[daurnimator]

As noted in #2326: we have both

iovec = extern struct {
    iov_base: [*]u8,
    iov_len: usize,
};

and

iovec_const = extern struct {
    iov_base: [*]const u8,
    iov_len: usize,
};

Where the only difference is the const property on the iov_base field. This is done so that e.g. functions that don't modify their arguments (like writev) can take a [*]iovec_const, but functions that modify their arguments (like readv) take an [*]iovec.

However this gets extended: sendmsg/recvmsg take a msghdr which not only has a msg_iov member different that points to the relevant iovec, but the field msg_name gains a const across non-const/const variants.

pub const msghdr = extern struct {
    msg_name: ?*sockaddr,
    msg_namelen: socklen_t,
    msg_iov: [*]iovec,
    msg_iovlen: i32,
    __pad1: i32,
    msg_control: ?*c_void,
    msg_controllen: socklen_t,
    __pad2: socklen_t,
    msg_flags: i32,
};

pub const msghdr_const = extern struct {
    msg_name: ?*const sockaddr,
    msg_namelen: socklen_t,
    msg_iov: [*]iovec_const,
    msg_iovlen: i32,
    __pad1: i32,
    msg_control: ?*c_void,
    msg_controllen: socklen_t,
    __pad2: socklen_t,
    msg_flags: i32,
};

[daurnimator]

From IRC today: why isn't const sometype a valid type?
That would remove the requirement for both the e.g. mem.toSlice and mem.toSliceConst variants.

Idea:

const T is a type that has the same layout as T, but all child indirections are const-ified.
e.g. using the example in the original post, iovec_const = const iovec; and msghdr_const = const msghdr would be equivalent to the definitions given.

[andrewrk]

I agree with the problem statement, but don't find the solution satisfactory.

[daurnimator]

Shouldn't we keep the issue open as a known problem that needs fixing?

[BarabasGitHub]

The idea proposed earlier seems like a bad idea. It's propagating const to types pointers point to. I think that's wrong, because just because you don't want the pointer to be modifiable doesn't mean you also don't want the pointed to data to be modifiable. And same the other way around. You can have a modifiable pointer that points to constant data.

However, this does seem related to an issue I ran into. #6897