cxx-qt-gen: add support for passing in CfgEvaluator (#1168)

This adds support for a basic subset of `#[cfg()]` directives into the CXX-Qt bridges.

It also fixes some issues with Code Coverage that came up during development of this PR.

This commit squashes multiple commits of PR #1168:

* cxx-qt-gen: add support for passing in CfgEvaluator

* codecov: ensure we use host llvm version and clear coverage data

* codecov: disable incremental builds as these files slow scanning

And may confuse the results.

* codecov: keep only crates/ and do not include crates registry

This avoids collisions between paths, we were seeing odd issues
around some files having a different tracked amount in codecov vs
lcov. It appears to be due to having coverage results from cxx_gen
with the same file paths. We do not want coverage data for anything
else anyway so filter them out.

* codecov: add extra notes around important args

* cxx-qt-gen: add snapshot test for cfg evaluator

* cxx-qt-gen: add support for extern C++Qt QObject's to cfg

* cxx-qt-gen: simplify cfg evaluator tests  by having shared assert

* cxx-qt-gen: ensure that we return for non cfg attributes

* cxx-qt-gen: add support for cfg on a qobject in RustQt

* cxx-qt-gen: add more variants for snapshot test of cfgs

* cxx-qt-gen: add assert between every assert

Author: ahayzen-kdab

.github/workflows/github-cxx-qt-tests.yml

@@ -71,31 +71,54 @@ jobs:
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
+      # Note we need to match the LLVM and Rust versions
+      #
+      # See versions from the table in this link
+      # https://github.com/taiki-e/cargo-llvm-cov?tab=readme-ov-file#get-coverage-of-cc-code-linked-to-rust-librarybinary
+      - name: Install llvm 17
+        run: |
+          sudo apt-get update && sudo apt-get install -y llvm-17
+          test -d /usr/lib/llvm-17/bin/
       - name: Setup toolchain
         run: |
+          # Note that the llvm version needs to match, see the link above
           rustup default 1.77.2
           cargo install grcov
-          rustup component add llvm-tools rustfmt
+          rustup component add rustfmt
+      # Ensure we do not have any existing coverage files
+      - run: rm -f coverage/*.profraw
       - name: build
         env:
+          CARGO_INCREMENTAL: 0
           RUSTFLAGS: -Cinstrument-coverage
           LLVM_PROFILE_FILE: coverage/coverage_data-%p-%m.profraw
         run: cargo build --package cxx-qt-gen
       - name: test
         env:
+          CARGO_INCREMENTAL: 0
           RUSTFLAGS: -Cinstrument-coverage
           LLVM_PROFILE_FILE: coverage/coverage_data-%p-%m.profraw
         run: cargo test --lib --package cxx-qt-gen
       - name: generate-report
-        run: grcov . -s . --binary-path ./target/debug/ -t lcov --branch --ignore-not-existing -o ./target/debug/lcov.info --excl-start CODECOV_EXCLUDE_START --excl-stop CODECOV_EXCLUDE_STOP
+        # Note that --llvm-path is important here to ensure the matching llvm version to the Rust version (1.77.x)
+        # Note that --keep-only is important here to ensure crates.io paths don't conflict
+        run: grcov . -s . --binary-path ./target/debug/ -t lcov --branch --ignore-not-existing --llvm --llvm-path /usr/lib/llvm-17/bin/ --keep-only "crates/*" -o ./target/debug/lcov.info --excl-start CODECOV_EXCLUDE_START --excl-stop CODECOV_EXCLUDE_STOP
       - name: upload-report
         uses: codecov/codecov-action@v5
         with:
           directory: ./target/debug/
+          disable-search: true
           files: lcov.info
           fail_ci_if_error: true
           token: ${{ secrets.CODECOV_TOKEN }}
           verbose: true
+      - name: Upload GitHub Actions artifacts of lcov
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: lcov
+          path: ./target/debug/lcov.info
+          if-no-files-found: ignore
 
   build-wasm:
     name: Ubuntu 24.04 (wasm_32) Qt 6

CHANGELOG.md

@@ -23,6 +23,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Support for further types: `QUuid`
 - New example: Basic greeter app
 - Support for further types: `qreal`, `qint64`, `qintptr`, `qsizetype`, `quint64`, `quintptr`
+- Support for `cfg` attributes through to C++ generation
 
 ### Fixed
 

crates/cxx-qt-build/src/lib.rs

@@ -43,7 +43,7 @@ use std::{
 };
 
 use cxx_qt_gen::{
-    parse_qt_file, write_cpp, write_rust, CppFragment, CxxQtItem, GeneratedCppBlocks,
+    parse_qt_file, write_cpp, write_rust, CppFragment, CxxQtItem, GeneratedCppBlocks, GeneratedOpt,
     GeneratedRustBlocks, Parser,
 };
 
@@ -103,6 +103,9 @@ impl GeneratedCpp {
         // The include path we inject needs any prefix (eg the crate name) too
         let include_ident = format!("{include_prefix}/{file_ident}");
 
+        let mut cxx_qt_opt = GeneratedOpt::default();
+        cxx_qt_opt.cfg_evaluator = Box::new(cfg_evaluator::CargoEnvCfgEvaluator);
+
         // Loop through the items looking for any CXX or CXX-Qt blocks
         let mut found_bridge = false;
         for item in &file.items {
@@ -132,7 +135,7 @@ impl GeneratedCpp {
                     let parser = Parser::from(m.clone())
                         .map_err(GeneratedError::from)
                         .map_err(to_diagnostic)?;
-                    let generated_cpp = GeneratedCppBlocks::from(&parser)
+                    let generated_cpp = GeneratedCppBlocks::from(&parser, &cxx_qt_opt)
                         .map_err(GeneratedError::from)
                         .map_err(to_diagnostic)?;
                     let generated_rust = GeneratedRustBlocks::from(&parser)

crates/cxx-qt-gen/Cargo.toml

@@ -20,6 +20,7 @@ exclude = ["update_expected.sh"]
 rust-version = "1.64.0"
 
 [dependencies]
+cxx-gen.workspace = true
 proc-macro2.workspace = true
 syn.workspace = true
 quote.workspace = true

crates/cxx-qt-gen/src/generator/cfg.rs

@@ -0,0 +1,197 @@
+// SPDX-FileCopyrightText: CXX Authors
+// SPDX-FileContributor: Andrew Hayzen <[email protected]>
+// SPDX-FileContributor: David Tolnay <[email protected]>
+//
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+use crate::syntax::cfg::{parse_attribute, CfgExpr};
+use cxx_gen::{CfgEvaluator, CfgResult};
+use quote::quote;
+use syn::{Attribute, Error, LitStr};
+
+pub(crate) fn try_eval_attributes(
+    cfg_evaluator: &dyn CfgEvaluator,
+    attrs: &[Attribute],
+) -> Result<bool, Error> {
+    // Build a single CfgExpr from the Attributes
+    let cfg_expr = attrs
+        .iter()
+        .map(parse_attribute)
+        .collect::<Result<Vec<CfgExpr>, Error>>()?
+        .into_iter()
+        .reduce(|mut acc, e| {
+            acc.merge(e);
+            acc
+        });
+
+    // Evaluate the CfgExpr against the CfgEvaluator
+    if let Some(cfg_expr) = cfg_expr {
+        try_eval(cfg_evaluator, &cfg_expr).map_err(|errs| {
+            errs.into_iter()
+                .reduce(|mut acc, e| {
+                    acc.combine(e);
+                    acc
+                })
+                .expect("There should be at least one error")
+        })
+    } else {
+        Ok(true)
+    }
+}
+
+fn try_eval(cfg_evaluator: &dyn CfgEvaluator, expr: &CfgExpr) -> Result<bool, Vec<Error>> {
+    match expr {
+        CfgExpr::Unconditional => Ok(true),
+        CfgExpr::Eq(ident, string) => {
+            let key = ident.to_string();
+            let value = string.as_ref().map(LitStr::value);
+            match cfg_evaluator.eval(&key, value.as_deref()) {
+                CfgResult::True => Ok(true),
+                CfgResult::False => Ok(false),
+                CfgResult::Undetermined { msg } => {
+                    let span = quote!(#ident #string);
+                    Err(vec![Error::new_spanned(span, msg)])
+                }
+            }
+        }
+        CfgExpr::All(list) => {
+            let mut all_errors = Vec::new();
+            for subexpr in list {
+                match try_eval(cfg_evaluator, subexpr) {
+                    Ok(true) => {}
+                    Ok(false) => return Ok(false),
+                    Err(errors) => all_errors.extend(errors),
+                }
+            }
+            if all_errors.is_empty() {
+                Ok(true)
+            } else {
+                Err(all_errors)
+            }
+        }
+        CfgExpr::Any(list) => {
+            let mut all_errors = Vec::new();
+            for subexpr in list {
+                match try_eval(cfg_evaluator, subexpr) {
+                    Ok(true) => return Ok(true),
+                    Ok(false) => {}
+                    Err(errors) => all_errors.extend(errors),
+                }
+            }
+            if all_errors.is_empty() {
+                Ok(false)
+            } else {
+                Err(all_errors)
+            }
+        }
+        CfgExpr::Not(subexpr) => match try_eval(cfg_evaluator, subexpr) {
+            Ok(value) => Ok(!value),
+            Err(errors) => Err(errors),
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::{generator::UnsupportedCfgEvaluator, tests::CfgEvaluatorTest};
+    use syn::{parse_quote, ItemMod};
+
+    fn assert_eval_insert(module: ItemMod, cfgs: &[&str], [before, after]: [bool; 2]) {
+        let mut cfg_evaluator = Box::new(CfgEvaluatorTest::default());
+        assert_eq!(
+            try_eval_attributes(cfg_evaluator.as_ref(), &module.attrs).unwrap(),
+            before
+        );
+
+        for chunk in cfgs.chunks(2) {
+            assert_eq!(
+                try_eval_attributes(cfg_evaluator.as_ref(), &module.attrs).unwrap(),
+                before
+            );
+
+            if let [key, value] = chunk {
+                cfg_evaluator.cfgs.insert(key, Some(value));
+            }
+        }
+
+        assert_eq!(
+            try_eval_attributes(cfg_evaluator.as_ref(), &module.attrs).unwrap(),
+            after
+        );
+    }
+
+    fn assert_eval_insert_false_true(module: ItemMod, cfgs: &[&str]) {
+        assert_eval_insert(module, cfgs, [false, true]);
+    }
+
+    #[test]
+    fn test_try_eval_attributes_eq() {
+        assert_eval_insert_false_true(
+            parse_quote! {
+                #[cfg(a = "1")]
+                #[cfg(b = "2")]
+                mod module;
+            },
+            &["c", "3", "a", "1", "b", "2"],
+        );
+    }
+
+    #[test]
+    fn test_try_eval_attributes_any() {
+        assert_eval_insert_false_true(
+            parse_quote! {
+                #[cfg(any(a = "1", b = "2"))]
+                mod module;
+            },
+            &["c", "3", "a", "1"],
+        );
+    }
+
+    #[test]
+    fn test_try_eval_attributes_all() {
+        assert_eval_insert_false_true(
+            parse_quote! {
+                #[cfg(all(a = "1", b = "2"))]
+                mod module;
+            },
+            &["c", "3", "a", "1", "b", "2"],
+        );
+    }
+
+    #[test]
+    fn test_try_eval_attributes_not() {
+        assert_eval_insert(
+            parse_quote! {
+                #[cfg(not(a = "1"))]
+                mod module;
+            },
+            &["c", "3", "a", "1"],
+            [true, false],
+        );
+    }
+
+    #[test]
+    fn test_try_eval_unconditional() {
+        let cfg_expr = CfgExpr::Unconditional;
+        let cfg_evaluator = Box::new(UnsupportedCfgEvaluator);
+        assert_eq!(try_eval(cfg_evaluator.as_ref(), &cfg_expr).unwrap(), true);
+    }
+
+    #[test]
+    fn test_try_eval_attributes_undetermined_err() {
+        let module: ItemMod = parse_quote! {
+            #[cfg(a = "1")]
+            #[cfg(all(a = "1", b = "2"))]
+            #[cfg(any(a = "1", b = "2"))]
+            #[cfg(not(a = "1"))]
+            mod module;
+        };
+        let cfg_evaluator = Box::new(UnsupportedCfgEvaluator);
+        assert!(try_eval_attributes(cfg_evaluator.as_ref(), &module.attrs[0..1]).is_err());
+        assert!(try_eval_attributes(cfg_evaluator.as_ref(), &module.attrs[1..2]).is_err());
+        assert!(try_eval_attributes(cfg_evaluator.as_ref(), &module.attrs[2..3]).is_err());
+        assert!(try_eval_attributes(cfg_evaluator.as_ref(), &module.attrs[3..4]).is_err());
+    }
+}

crates/cxx-qt-gen/src/generator/cpp/externcxxqt.rs

@@ -4,8 +4,10 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
 use crate::{
-    generator::cpp::signal::generate_cpp_signal, naming::TypeNames,
-    parser::externcxxqt::ParsedExternCxxQt, CppFragment,
+    generator::{cpp::signal::generate_cpp_signal, GeneratedOpt},
+    naming::TypeNames,
+    parser::externcxxqt::ParsedExternCxxQt,
+    CppFragment,
 };
 use std::collections::BTreeSet;
 use syn::Result;
@@ -23,18 +25,20 @@ pub struct GeneratedCppExternCxxQtBlocks {
 pub fn generate(
     blocks: &[ParsedExternCxxQt],
     type_names: &TypeNames,
+    opt: &GeneratedOpt,
 ) -> Result<Vec<GeneratedCppExternCxxQtBlocks>> {
     let mut out = vec![];
 
     for block in blocks {
         for signal in &block.signals {
-            let mut block = GeneratedCppExternCxxQtBlocks::default();
             let qobject_name = type_names.lookup(&signal.qobject_ident)?;
-            let data = generate_cpp_signal(signal, qobject_name, type_names)?;
-            block.includes = data.includes;
-            block.forward_declares = data.forward_declares;
-            block.fragments = data.fragments;
+            let data = generate_cpp_signal(signal, qobject_name, type_names, opt)?;
             debug_assert!(data.methods.is_empty());
+            let block = GeneratedCppExternCxxQtBlocks {
+                includes: data.includes,
+                forward_declares: data.forward_declares,
+                fragments: data.fragments,
+            };
             out.push(block);
         }
     }
@@ -70,9 +74,10 @@ mod tests {
         .unwrap()];
 
         // Unknown types
-        assert!(generate(&blocks, &TypeNames::default()).is_err());
+        let opt = GeneratedOpt::default();
+        assert!(generate(&blocks, &TypeNames::default(), &opt).is_err());
 
-        let generated = generate(&blocks, &TypeNames::mock()).unwrap();
+        let generated = generate(&blocks, &TypeNames::mock(), &opt).unwrap();
         assert_eq!(generated.len(), 2);
     }
 
@@ -97,7 +102,7 @@ mod tests {
         let mut type_names = TypeNames::default();
         type_names.mock_insert("ObjRust", None, Some("ObjCpp"), Some("mynamespace"));
 
-        let generated = generate(&blocks, &type_names).unwrap();
+        let generated = generate(&blocks, &type_names, &GeneratedOpt::default()).unwrap();
         assert_eq!(generated.len(), 1);
     }
 }