[boomlinde]

@fieldParentPtr is not type safe. It assumes that the given pointer is to a field of the given name in the inferred type. Zig can detect at compile time whether the inferred type has a field of that name of the same type as the pointer child. So far, so good: type safe.

The lack of safety stems from the fact it doesn't know that the assumption that the pointer has that parent is true. Here's a very simple illustration. It'll compile.

    const T = struct {
        field: i32 = 0,
    };
    
    pub fn main() void {
        var nonfield: i32 = 0;
    
        _ = @as(*T, @fieldParentPtr("field", &nonfield));
    }

`nonfield` doesn't have a parent T. The use of @fieldParentPtr here causes what the official reference calls "unchecked illegal behavior"; it isn't checked even in the safe build modes.

[grayhatter]

> The use of @fieldParentPtr here [...]

the *hypothetical* use here...

This simple example as written is actually correct, and not actually unchecked illegal behavior. But this is just a bit of pedantry, because it would be unchecked illegal if you use this in a more complicated example.

I mention it because it's important to note, it can be done correctly, as you obviously just did it correctly, by accident. That said, I still agree, there're no guardrails on this pattern.

[boomlinde]

> the hypothetical use here...

No, it's not hypothetical. I just did it, which demonstrates that it's not type safe and that the compiler won't give you an error if you write invalid code, which is what the post I responded to claimed.

> This simple example as written is actually correct

No. The official reference is clear about this: "If field_ptr does not point to the field_name field of an instance of the result type, and the result type has ill-defined layout, invokes unchecked Illegal Behavior."

Because there is no well-defined layout for plain structs in Zig, they satisfy the "ill-defined layout" requirement. Merely invoking the @fieldParentPtr on a pointer that doesn't satisfy the other requirement in that case invokes unchecked illegal behavior according to the language reference.

> I mention it because it's important to note, it can be done correctly,

Ignoring that you can't seem to get the facts straight, the claim I am responding to is that it's "type safe" and that "if you write invalid code the compiler will give you an error". This is not the case, regardless of whether my example invokes unchecked illegal behavior (which it does) or not.

I'm very clearly not saying that it can't be done correctly and I don't think you can argue for that in good faith.

[grayhatter]

> No, it's not hypothetical. I just did it, which demonstrates that it's not type safe and that the compiler won't give you an error if you write invalid code, which is what the post I responded to claimed.

Describe explicitly how your example will trigger illegal behavior? Happy to discuss the behavior of the compiled asm if you'd like to be that pendantic?

Not type safe, and contains an appreciable risk or defect are two distinct concerns. One matters less than the other.

> Because there is no well-defined layout for plain structs in Zig, they satisfy the "ill-defined layout" requirement.

No? Struts have a defined layout, they're not guaranteed between compilations, but they don't change within a compilation unit.

> Merely invoking the @fieldParentPtr on a pointer that doesn't satisfy the other requirement in that case invokes unchecked illegal behavior according to the language reference.

And the failure mode is the compiler will decide to delete your OS?

Unchecked illegal behavior isn't magic, doing something similar to illegal behavior doesn't mean the code will or won't do what you intended. uint rollover is unchecked illegal behavior (when not explict, in release fast) but just because the uint might roll over doesn't make that code invalid.

> I'm very clearly not saying that it can't be done correctly and I don't think you can argue for that in good faith.

I thought you were saying that it's guaranteed to be incorrect. In fact, I think that's what you said in your reply to me. Mostly because you used the word 'mearly'.

The way that I understood what you meant was, the example you provided was guaranteed wrong. In fact it's actually correct. It will have the same semantics and behavior as what I assume was desired.

> Ignoring that you can't seem to get the facts straight [...] and I don't think you can argue for that in good faith.

I'm sorry if I was unclear, I was trying to discuss it in good faith. :(

[boomlinde]

> Describe explicitly how your example will trigger illegal behavior? Happy to discuss the behavior of the compiled asm if you'd like to be that pendantic?

Through calling @fieldParentPtr with a field_ptr not pointing at a field of the given field name in the result type, when the result type has an ill-defined memory layout. I'm essentially just paraphrasing the documentation, which I've already quoted.

Generated code is irrelevant to this end. Illegal behavior can coincidentally result in code that works as intended in practice as a side effect of the implementation. Similarly you may expect a signed integer to wrap around as it overflows in C because of the implementation of the compiler and the code it generates, but it's still undefined behavior.

> No? Struts have a defined layout, they're not guaranteed between compilations, but they don't change within a compilation unit.

This is not the sense in which the Zig language reference uses the term well-defined memory layout. Bare structs, error unions, slices and optionals don't have a well-defined memory layout in the sense the Zig language reference uses it.

> And the failure mode is the compiler will decide to delete your OS?

The failure mode is irrelevant. Unchecked illegal behavior is unchecked illegal behavior regardless of the failure mode. You are moving goalposts now.

> I thought you were saying that it's guaranteed to be incorrect. In fact, I think that's what you said in your reply to me. Mostly because you used the word 'mearly'.

The example I posted is guaranteed to be incorrect, which demonstrates that the use of @fieldParentPtr can result in unchecked illegal behavior, hence not type safe nor giving you an error when you write invalid code. Regarding the use of "merely", you should adopt the habit of reading complete sentences before you draw conclusions about what they imply.

> The way that I understood what you meant was, the example you provided was guaranteed wrong.

The example is guaranteed to cause unchecked illegal behavior.

> I'm sorry if I was unclear, I was trying to discuss it in good faith. :(

If you want to argue in good faith, you can start with a good faith reading of the language reference.