Clarify conditional compilation

[gokhanettin]

Introduction of cfg attribute and cfg! macro operators can be confusing. cfg! macro and cfg attribute behave differently in terms of conditional compilation. While cfg attribute enables conditional compilation of some code, cfg! macro conditionally evaluates to true or false literals for run-time checks.

[rust-highfive]

Thanks for the pull request, and welcome! The Rust team is excited to review your changes, and you should hear from @marioidival (or someone else) soon.

If any changes to this PR are deemed necessary, please add them as extra commits. This ensures that the reviewer can see what has changed since they last reviewed the code. Due to the way GitHub handles out-of-date commits, this should also make it reasonably obvious what issues have or haven't been addressed. Large or tricky changes may require several passes of review and changes.

Please see the contribution instructions for more information.

[gokhanettin]

The Result Reference also describes cfg! macro as one of the ways of conditional compilation. But I still find it a little bit confusing.

For the attribute case, compiler decides what to compile at compile time, which I would call conditional compile. For the macro case, the macro conditionally evaluates to either true or false literals at compile time, which can then be used at run-time.

Obviously following cfg.rs won't compile. Neither rustc cfg.rs nor rustc cfg.rs --cfg "some_condition" works as one of the functions is not (conditionally) compiled.

#[cfg(some_condition)]
fn needs_some_condition() {
}

#[cfg(not(some_condition))]
fn not_needs_some_condition() {
}

fn main() {
    if cfg!(some_condition) {
        needs_some_condition();
    }

    if cfg!(not(some_condition)) {
        not_needs_some_condition();
    }
}

[marioidival]

@gokhanettin Thank you for you clarification