Feature explicit case conversion

[BenFordTytherington]

Add an attribute for extern blocks which specifies all the items inside can have their names automatically converted to the correct case.

[codecov]

Codecov Report

All modified and coverable lines are covered by tests ✅

Project coverage is 100.00%. Comparing base (fd558d5) to head (1d3d5e9).

Additional details and impacted files

@@            Coverage Diff             @@
##              main     #1108    +/-   ##
==========================================
  Coverage   100.00%   100.00%            
==========================================
  Files           71        71            
  Lines        11949     12050   +101     
==========================================
+ Hits         11949     12050   +101     

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

[ahayzen-kdab]

@LeonMatthesKDAB did we want to have camelCase and snake_case conversion depending on the block type?

eg a RustQt block you write from the perspective of Rust and we auto convert to C++. And a C++Qt block you write from the perspective of C++ and you auto convert to Rust

#[auto_case]
unsafe extern "RustQt" {
  fn function_name(); // ends up as functionName in C++
}

#[auto_case]
unsafe extern "C++Qt" {
  fn functionName(); // ends up as function_name in Rust?! (but this is means the rust name is magic?)
}

Or do we already want to introduce the type of the conversion, then leave it up to the developer to decide the direction ?

#[auto_case = Camel]
unsafe extern "RustQt" {
  fn function_name(); // ends up as functionName in C++
}

#[auto_case = Snake]
unsafe extern "C++Qt" {
  fn functionName(); // ends up as function_name in C++
}

And when do we do the auto conversion ? Do we do it when we see there are no custom cxx_name and rust_name ?

How do we know where to apply it to ? Do we always do it to the cxx_name and never the rust name ?

Or is the whole thing just #[auto_case] which just converts any Rust name to a camel case name in C++ ? And never changes the Rust name ? 🤔

[BenFordTytherington]

My plan was going to be to include both, so like you said camel for rust blocks, and snake for c++ blocks, but then also allowing the developer to specify if they wanted, so that auto_case would be a shorthand.

[ahayzen-kdab]

Right, i just wonder if any of this is confusing if we start modifying effectively the rust_name, or maybe that is fine 🤔

As then the question becomes

#[auto_camel]
unsafe extern "RustQt" {
   fn my_function1();  // becomes cxx_name = myFunction1
}
#[auto_camel]
unsafe extern "C++Qt" {
   fn myFunction2();  // becomes rust_name my_function2
}

But then this is curious, if you specify the Camel / Snake as opposites.

#[auto_camel = Snake]
unsafe extern "RustQt" {
   fn my_function1();
   fn myFunction3();  // becomes cxx_name = my_function3
}
#[auto_camel = Camel]
unsafe extern "C++Qt" {
   fn myFunction2();
   fn my_Function4();  // becomes rust_name = myFunction4
}

[ahayzen-kdab]

Another route to avoid the confusion over whether the "auto" affects the cxx or rust name is to encode that into the attribute. So you could have auto_cxx_case and auto_rust_case.

Then this at least makes sense with what it does and gives you full flexibility

#[auto_cxx_case = Snake]
unsafe extern "RustQt" {
   fn my_function1();
   fn myFunction3();  // becomes cxx_name = my_function3
}
#[auto_rust_case = Camel]
unsafe extern "C++Qt" {
   fn myFunction2();
   fn my_Function4();  // becomes rust_name = myFunction4
}

[ahayzen-kdab]

So then we could start with #[auto_cxx_case] and #[auto_rust_case] which default to Camel and Snake for now. If we need to pick a non-default case later we can still do this without breaking API.