Is #by_ptr really necessary ?

[VoidStarCaster]

Hi !

I have a hard time understanding the necessity of #by_ptr. I get that it is used for const reference parameters, but:

• If the parameter is an opaque structure, it won't work (as in sdl3/ttf: Using any #by_ptr procedure seems to corrupt the font #5278)

OpaqueStruct :: {}
create_opaque :: proc() -> ^OpaqueStruct ---
use_opaque :: proc(#by_ptr s: OpaqueStruct) ---

main :: proc() {
    opaque := create_opaque()
    use_opaque(opaque^) // Will crash or lead to undefined behavior
}

• If the parameter is a partially opaque structure, it won't work either (and you have to know the library internal to understand why)

struct Private {
    int a;
    int b;
}
struct Public {
    int a;
}
Public* c_func() {
    Private *p = (Private*)malloc(sizeof(Private));
    return (Public*)p;
}

Public :: struct {
   a: c.int
}
create_public :: proc() -> ^Public ---
use_public :: proc(#by_ptr p: Public) ---

main :: proc() {
    public := create_public()
    use_public(public^)  // Will crash or lead to undefined behavior
}

• If after a library update, the library accepts nil as a valid value, it means rewriting the binding (which wouldn't be necessary without it) and all the code using it needs to be rewritten too.

use_struct :: proc(#by_ptr s: Struct) --- // need to be rewritten as use_struct :: proc(s: ^Struct)

main :: proc() {
    s := Struct{ ... }
    use_struct(s^) // need to be rewritten as use_struct(&s)
}

In the end, it's only use case seems to be for structure that can be created on the stack, to avoid using one '&', which seems really narrow to have it integrated in the language. Especially with all the case where using it can go wrong if you're not cautious enough when writing your bindings.

Should it really be in Odin ? Is there use case I'm not seeing where it is really necessary to have it ?