Support translation of C macros to Rust about c2rust

[rinon]

I'm going to start taking a look into (simple) macro translation. The current plan is:

• #define CONSTANT 1 -> Rust const
• #ifdef CONSTANT -> Rust cfg! macro and attribute
  Constants that we recognize as compiler-provided platform constants should be translated to native rust versions when available, otherwise we emit these constants as feature flags.

[harpocrates]

Dealing with macros in a sensible fashion is a long-term goal - but there is still a lot of design work to do.

For instance, it would be necessary to work (at least partially) with the un-preprocessed C source. That poses a pretty big challenge, since most of our current translation works on top of a Clang-produced C AST - which has to run the preprocessor in order to successfully parse and type check.

On possible approach to detecting C macros (and mapping them onto calls to Rust macros) might be to look for subtrees in the expanded C AST that were constructed entirely from tokens that map back to one macro call...

As for variadic functions, we're holding out for Rust language features (like rust-lang/rust#49878).

[martin-t]

One possible approach to detecting C macros (and mapping them onto calls to Rust macros) might be to look for subtrees in the expanded C AST that were constructed entirely from tokens that map back to one macro call...

I can confirm that this approach works and can even support nested macros (taking other macros as arguments, calling other macros in the body or both combined). I have a proof of concept (only supports expressions) for a C-like lang here.

One downside is that there's no way to translate macros that are not used, is that acceptable for c2rust? (I am thinking about implementing this properly in c2rust, then forking it and using it as a basis for qc2rust. Not sure if/when i'll have the time so no promises.)

[thedataking]

@martin-t unexpanded macros might be a problem when translating libraries. On the other hand, translating only used macros is better than what we do today, so yes, this is indeed acceptable. If you do get the time to implement this, I'd recommend you feature gate it like we did with const macros.

[XVilka]

This issue is quite old and relatively common in the code. Was there any progress with this? Or maybe some unmerged branch/PR somewhere? If not, where in the code it is probably should be implemented? Thank you for the answer.

[nacaclanga]

One other way to translate macros would be to use some sort of custom preprocessor:
Within the C code, we replace, (after checking if a macro forms a valid expression)

#define MACRONAME macroexpression

by

const _c2rust_macrotype _c2rust_mconst_MACRONAME = macroexpression;
#define MACRONAME _c2rust_mconst_MACRONAME

When translating the AST to rust, we truncate the _c2rust_mconst_ prefex from variables. If we found the const _c2rust_macrotype _c2rust_mconst_MACRONAME declaration, we walk the AST to guess the correct type and emit a Rust const declaration.