Support for struct-scoped type aliases

[johnDeSilencio]

Hello! I hope you are doing well.

Love cbindgen! Phenomenal work that you all have accomplished.

I'm reaching out because I'm looking for very particular code generation behavior. I wanted to know if this is something that cbindgen can already do, is planning to do, or is explicitly not going to be supported.

---

Suppose that I'm trying to replace C++ code class-by-class in an existing codebase. Suppose also that the class definition is very simple and looks like this:

Click to view original C++ code

class FooBar {
public:
  using my_foo_t = uint32_t;

  FooBar(my_foo_t my_foo) : m_favorite_foo(my_foo) {}

  bool is_favorite_foo(const FooBar& foo_under_test) {
    return foo_under_test == m_favorite_foo;
  }

private:
  my_foo_t m_favorite_foo;
}

To port this class, I'd write something like following Rust code:

Click to view Rust port

pub type my_foo_t = u32;

#[repr(C)]
pub struct FooBar {
  favorite_foo: my_foo_t,
}

#[unsafe(no_mangle)]
pub extern "C" fn RUST_is_favorite_foo(foo_bar: &FooBar, foo: my_foo_t) -> bool {
  foo.favorite_foo = other.foo
}

And cbindgen generates the following C++ header:

Click to view generated C++ header

using my_foo_t = uint32_t;

struct FooBar {
  my_foo_t favorite_foo;
};

// ...

However, I would like it instead to generate the following C++ header where the type alias is scoped to the struct:

Click to view the desired generated C++ header

struct FooBar {
  using my_foo_t = uint32_t;
  my_foot_t favorite_foo;
};

// ...

---

If this is not something that can currently be done, I can't imagine it would be that hard (famous last works) to tell cbindgen to put the using statement inside of the struct instead of in the same scope as the struct definition using some kind of annotation in the lib.rs file.

Thank you again for taking the time to read my question!

[johnDeSilencio]

EDIT: I should add, it does appear to be possible to generate this code by using the export.body table in cbindgen.toml, though it's hardly a robust solution:

[export.body]
"FooBar" = """
  using my_foo_t = uint32_t;
"""

This means for every C++ struct that I want to have an associated type alias, I have to maintain this separate list of those structs in this export.body table. Namespaces might also make this more difficult. I'd prefer either proc-macro magic or an annotation that I can put in lib.rs rather than have to keep cbindgen.toml and lib.rs in sync

[johnDeSilencio]

Sorry, one last thing. In addition to scoped type aliases, being able to emit scoped static constants would be really, really helpful.

For example, I would want to be able to emit a struct like the following:

struct FooBar {
  using my_foo_t = uint32_t;
  static EVERYONES_FAVORITE_FOO my_foo_t = 153;
  my_foo_t favorite_foo;
}

[emilio]

We have support for associated constants in rust:

impl Foo { const BAR... }

extending that to types seems like a potential way to go here? But then I don't know how you'd go about using the associated type directly in the struct definition tho.

[johnDeSilencio]

We have support for associated constants in rust:

impl Foo { const BAR... }

extending that to types seems like a potential way to go here? But then I don't know how you'd go about using the associated type directly in the struct definition tho.

So it looks like there is support for what I was thinking of on nightly Rust, called "Inherent Associated Types" (IATs). Unfortunately, they are stuck behind a feature gate and I'm not sure how long, if ever, they will make it on stable. If they were, we could do something really cool like this (Rust Playground Link):

#![allow(unused)]
#![feature(inherent_associated_types)]

pub struct FooBar {
    foo_bar: FooBar::Alias,
}

impl FooBar {
    type Alias = u32;
    const MY_SPECIAL_FOO_BAR: FooBar::Alias = 153;
}

fn main() {
    let my_foo: FooBar::Alias = 153;
    println!("my_foo: {}", my_foo);
}

That would let us refer to the type alias on the Rust side and we could generate the type alias on the C/C++ side in a similar manner:

struct FooBar {
  using Alias = uint32_t;
  Alias foo_bar;
  const Alias MY_SPECIAL_FOO_BAR;
};

const FooBar::Alias FooBar::MY_SPECIAL_FOO_BAR = 153;

// ...

So this feature might be blocked until IATs get stabalized