How do I change a function’s qualifiers via conditional compilation?

by

Macros to the rescue!

#![cfg_attr(feature = "const-fn", feature(const_fn))]

#[cfg(not(feature = "const-fn"))]
macro_rules! maybe_const_fn {
    ($($tokens:tt)*) => {
        $($tokens)*
    };
}

#[cfg(feature = "const-fn")]
macro_rules! maybe_const_fn {
    ($(#[$($meta:meta)*])* $vis:vis $ident:ident $($tokens:tt)*) => {
        $(#[$($meta)*])* $vis const $ident $($tokens)*
    };
}

maybe_const_fn! {
    #[allow(unused)] // for demonstration purposes
    pub fn very_complicated_logic(a: u8, b: u8) -> u8 {
        internally_complicated_logic(a, b)
    }
}

maybe_const_fn! {
    fn internally_complicated_logic(a: u8, b: u8) -> u8 {
        a * b
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[cfg(feature = "const-fn")]
    #[test]
    fn use_in_const() {
        const ANSWER: u8 = very_complicated_logic(1, 2);
        drop(ANSWER);
    }

    #[test]
    fn use_in_variable() {
        let answer: u8 = very_complicated_logic(1, 2);
        drop(answer);
    }
}

Along with this in Cargo.toml:

[features]
const-fn = []

Since macros can only expand to complete pieces of syntax (i.e. a macro cannot simply expand to const), we have to wrap the whole function in the macro and leave some parts of it unparsed so that we can inject const in the appropriate place. Then, the parser can parse the whole thing as a function definition.

Attributes and visibility qualifiers need special treatment, because they must appear before const. I am using the vis matcher (available since Rust 1.30.0) to simplify the macro’s implementation.

More Related Contents:

  1. Why can’t I store a value and a reference to that value in the same struct?
  2. The compiler suggests I add a ‘static lifetime because the parameter type may not live long enough, but I don’t think that’s what I want
  3. Does println! borrow or own the variable?
  4. How do I pass disjoint slices from a vector to different threads?
  5. When should I implement std::convert::From vs std::convert::Into?
  6. Why is it possible to implement Read on an immutable reference to File?
  7. Compare enums only by variant, not value
  8. How can I call a mutating method while holding a reference to self?
  9. How do you actually use dynamically sized types in Rust?
  10. “parameter `’a` is never used” error when ‘a is used in type parameter bound
  11. Borrowing references to attributes in a struct
  12. How to operate on 2 mutable slices of a Rust array?
  13. Mutating one field while iterating over another immutable field
  14. How can I use a module from outside the src folder in a binary project, such as for integration tests or benchmarks?
  15. How to match on data type in Rust?
  16. Why does Rust allow mutation through a reference field using an immutable binding?
  17. How can I modify self in a closure called from a member function?
  18. Multiple return types from a method
  19. How to end a borrow in a match or if let expression?
  20. Why does this mutable borrow live beyond its scope?
  21. Why does creating a mutable reference to a dereferenced mutable reference work?
  22. How can I find a subsequence in a &[u8] slice?
  23. Why is Rust’s assert_eq! implemented using a match?
  24. Is there a list of all cfg features?
  25. Comparing every element in a vector with the next one
  26. How to repeat a static string at compile time
  27. Is there a good way to convert a Vec to an array?
  28. How to concatenate static strings in Rust
  29. How can I conditionally provide a default reference without performing unnecessary computation when it isn’t used?
  30. How can I build multiple binaries with Cargo?

Leave a Comment