Support r#raw_identifiers

[kovaxis]

Hello!

I wanted to have a function named box, so my first natural instinct was to do:

#[godot_api]
impl MyType {
    #[func]
    fn r#box() {}
}

Using raw identifiers.

When I went to use the function from GDScript, I expected to see a function named box, but instead I got a function named r#box.

Note: I then learned that you can do this instead:

#[godot_api]
impl MyType {
    #[func(rename=box)]
    fn box_func() {}
}

Which is not bad at all, but it is not the "native" way to use reserved names in Rust.

[Bromeon]

Thanks! Looks like venial returns the r# prefix; not sure if we should address it there or on our side.

The one thing I'm worried about: we technically need to do this for all possible identifiers, whether functions, fields, constants, types, parameters, structs, enums, maybe even macros or attributes? This would require huge changes for very little benefit (and using keywords for identifiers is typically not best practice, plus it can be worked around with rename). 🤔

[PgBiel]

I'd say this isn't our fault. There should be a way in venial to retrieve the identifier regardless of the r# prefix.

[kovaxis]

I hadn't heard of venial before. I believe venial should be stripping the r# prefix before handing out the identifier, since in rust r#identifier is supposed to be identical to identifier.

[kovaxis]

I'm not sure what is the best way to report this in venial. I think it's best if you open up an issue on their repo, since you know more details about their API.

[Bromeon]

There aren't many contributors to venial at the moment, a while ago I helped out with lots of large-scale additions. So your best chances are to open a PR, I could also help review it 😉

[lilizoey]

I hadn't heard of venial before. I believe venial should be stripping the r# prefix before handing out the identifier, since in rust r#identifier is supposed to be identical to identifier.

i dont think you could really do this, since then you'd get an error if you then tried to use the raw identifier in a macro somewhere. like say you had a macro identity that just gives the exact same code out as it takes in. then this code would break:

fn main() {
  let identity!(r#let) = 10;
}

since it'd become let let = 10 (which doesnt compile) as opposed to let r#let = 10 (which compiles).

[Bromeon]

The one thing I'm worried about: we technically need to do this for all possible identifiers, whether functions, fields, constants, types, parameters, structs, enums, maybe even macros or attributes? This would require huge changes for very little benefit (and using keywords for identifiers is typically not best practice, plus it can be worked around with rename).

This still stands. Unless someone is willing to demonstrate that this is possible to implement without significantly worsening maintenance, I don't think the small benefit is worth the downsides.