Figure out what to do with flexible array members

[tgross35]

A number of C structures make use of a flexible array member:

struct sockaddr {
     sa_family_t     sa_family;      /* Address family */
     char            sa_data[];      /* Socket address */
 };

When mapped to Rust, most of these are a public field of type [T; 0]. We could instead map them to Rust unsized [c_char] fields.

The current pattern has a few advantages over using DSTs:

• size_of works to get you the base size
• You can offset_of the field to get the start of the array if you need it
• You can work with the type through references, they don't need to be constructed as fat pointers
• Rust's flexible array members aren't all that convenient to work with

I expect we'll probably want to stick with the current pattern, but it's worth double checking that there isn't something better for 1.0.

[ChrisDenton]

I expect we'll probably want to stick with the current pattern, but it's worth double checking that there isn't something better for 1.0.

Yeah, I think DSTs are still an area of the language which are undercooked. I'd love for us to use DSTs in 1.0 seeing as how it's likely to be around for a long time but I think it'll be a hard sell given the current limitations.

[tgross35]

Any general ideas about what features are missing to make them worth it? I think they're strictly less nice for a lot of libc things without a way to work through thin references, and not having an obvious way to compute the base size (though offset_of! works).

I wonder if the sized_hierarchy work will improve things here.

[ChrisDenton]

I would also add that they're awkward to even construct on the Rust side so I'd want to see that improved. I mean, zero-length slices aren't ideal either but they're at least a bit easier to work with.