Refactor some generation and parsing for base

Author: BenFordTytherington

crates/cxx-qt-gen/src/generator/rust/fragment.rs

@@ -3,7 +3,7 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use syn::Item;
+use syn::{parse_quote, Item};
 
 #[derive(Default, Eq, PartialEq, Debug)]
 pub struct GeneratedRustFragment {
@@ -19,6 +19,19 @@ impl GeneratedRustFragment {
         self.cxx_qt_mod_contents.extend(other.cxx_qt_mod_contents);
     }
 
+    pub fn qobject_import() -> Self {
+        Self {
+            cxx_mod_contents: vec![parse_quote! {
+                extern "C++" {
+                    #[doc(hidden)]
+                    #[namespace=""]
+                    type QObject = cxx_qt::QObject;
+                }
+            }],
+            cxx_qt_mod_contents: vec![],
+        }
+    }
+
     // Create a singular GeneratedRustFragment from a Vector of multiple
     pub fn flatten(others: Vec<Self>) -> Self {
         let mut this = Self::default();
@@ -34,8 +47,4 @@ impl GeneratedRustFragment {
             ..Default::default()
         }
     }
-
-    pub fn is_empty(&self) -> bool {
-        self.cxx_mod_contents.is_empty() && self.cxx_qt_mod_contents.is_empty()
-    }
 }

crates/cxx-qt-gen/src/generator/rust/mod.rs

@@ -16,8 +16,8 @@ pub mod signals;
 pub mod threading;
 
 use crate::generator::{rust::fragment::GeneratedRustFragment, structuring};
-use crate::parser::externqobject::ParsedExternQObject;
-use crate::parser::{parameter::ParsedFunctionParameter, qobject::ParsedQObject, Parser};
+use crate::parser::cxxqtdata::ParsedCxxQtData;
+use crate::parser::{parameter::ParsedFunctionParameter, Parser};
 use proc_macro2::{Ident, TokenStream};
 use quote::quote;
 use syn::{parse_quote, Item, ItemMod, Result};
@@ -61,12 +61,7 @@ impl GeneratedRustBlocks {
         let namespace = parser.cxx_qt_data.namespace.clone().unwrap_or_default();
         let passthrough_mod = &parser.passthrough_module;
 
-        let qobject_import = add_qobject_import(&parser.cxx_qt_data.qobjects);
-        if qobject_import.is_empty() {
-            for block in &parser.cxx_qt_data.extern_cxxqt_blocks {
-                fragments.push(add_extern_qobject_import(&block.qobjects))
-            }
-        } else {
+        if let Some(qobject_import) = add_qobject_import(&parser.cxx_qt_data) {
             fragments.push(qobject_import);
         }
 
@@ -105,48 +100,23 @@ impl GeneratedRustBlocks {
     }
 }
 
-fn add_qobject_import(qobjects: &[ParsedQObject]) -> GeneratedRustFragment {
-    let includes = qobjects
+// Generate a type declaration for `QObject` if necessary
+fn add_qobject_import(cxx_qt_data: &ParsedCxxQtData) -> Option<GeneratedRustFragment> {
+    let includes = cxx_qt_data
+        .qobjects
         .iter()
         .any(|obj| obj.has_qobject_macro && obj.base_class.is_none());
-    if includes {
-        GeneratedRustFragment {
-            cxx_mod_contents: vec![parse_quote! {
-                extern "C++" {
-                    #[doc(hidden)]
-                    #[namespace=""]
-                    type QObject = cxx_qt::QObject;
-                }
-            }],
-            cxx_qt_mod_contents: vec![],
-        }
-    } else {
-        GeneratedRustFragment {
-            cxx_mod_contents: vec![],
-            cxx_qt_mod_contents: vec![],
-        }
-    }
-}
-
-fn add_extern_qobject_import(qobjects: &[ParsedExternQObject]) -> GeneratedRustFragment {
-    // All extern C++Qt types must have QObject macro
-    let includes = qobjects.iter().any(|obj| obj.base_class.is_none());
-    if includes {
-        GeneratedRustFragment {
-            cxx_mod_contents: vec![parse_quote! {
-                extern "C++" {
-                    #[doc(hidden)]
-                    #[namespace=""]
-                    type QObject = cxx_qt::QObject;
-                }
-            }],
-            cxx_qt_mod_contents: vec![],
-        }
+    if includes
+        || cxx_qt_data
+            .extern_cxxqt_blocks
+            .iter()
+            .filter(|block| !block.qobjects.is_empty())
+            .count()
+            > 0
+    {
+        Some(GeneratedRustFragment::qobject_import())
     } else {
-        GeneratedRustFragment {
-            cxx_mod_contents: vec![],
-            cxx_qt_mod_contents: vec![],
-        }
+        None
     }
 }
 

crates/cxx-qt-gen/src/parser/externqobject.rs

@@ -3,8 +3,8 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 use crate::naming::Name;
-use crate::parser::{require_attributes, CaseConversion};
-use syn::{Error, Expr, ForeignItemType, Ident, Result};
+use crate::parser::{parse_base_type, require_attributes, CaseConversion};
+use syn::{ForeignItemType, Ident, Result};
 
 /// A representation of a QObject to be generated in an extern C++ block
 pub struct ParsedExternQObject {
@@ -34,20 +34,7 @@ impl ParsedExternQObject {
     ) -> Result<ParsedExternQObject> {
         let attributes = require_attributes(&ty.attrs, &Self::ALLOWED_ATTRS)?;
 
-        let base_class = attributes
-            .get("base")
-            .map(|attr| -> Result<Ident> {
-                let expr = &attr.meta.require_name_value()?.value;
-                if let Expr::Path(path_expr) = expr {
-                    Ok(path_expr.path.require_ident()?.clone())
-                } else {
-                    Err(Error::new_spanned(
-                        expr,
-                        "Base must be a identifier and cannot be empty!",
-                    ))
-                }
-            })
-            .transpose()?;
+        let base_class = parse_base_type(&attributes)?;
 
         Ok(Self {
             name: Name::from_ident_and_attrs(

crates/cxx-qt-gen/src/parser/mod.rs

@@ -140,6 +140,24 @@ pub fn require_attributes<'a>(
     Ok(output)
 }
 
+// Extract base identifier from attribute
+pub fn parse_base_type(attributes: &BTreeMap<&str, &Attribute>) -> Result<Option<Ident>> {
+    attributes
+        .get("base")
+        .map(|attr| -> Result<Ident> {
+            let expr = &attr.meta.require_name_value()?.value;
+            if let Expr::Path(path_expr) = expr {
+                Ok(path_expr.path.require_ident()?.clone())
+            } else {
+                Err(Error::new_spanned(
+                    expr,
+                    "Base must be a identifier and cannot be empty!",
+                ))
+            }
+        })
+        .transpose()
+}
+
 /// Struct representing the necessary components of a cxx mod to be passed through to generation
 pub struct PassthroughMod {
     pub(crate) items: Option<Vec<Item>>,

crates/cxx-qt-gen/src/parser/qobject.rs

@@ -11,8 +11,8 @@ use crate::{
 #[cfg(test)]
 use quote::format_ident;
 
-use crate::parser::CaseConversion;
-use syn::{Attribute, Error, Expr, Ident, Meta, Result};
+use crate::parser::{parse_base_type, CaseConversion};
+use syn::{Attribute, Error, Ident, Meta, Result};
 
 /// Metadata for registering QML element
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
@@ -91,20 +91,7 @@ impl ParsedQObject {
 
         let has_qobject_macro = attributes.contains_key("qobject");
 
-        let base_class = attributes
-            .get("base")
-            .map(|attr| -> Result<Ident> {
-                let expr = &attr.meta.require_name_value()?.value;
-                if let Expr::Path(path_expr) = expr {
-                    Ok(path_expr.path.require_ident()?.clone())
-                } else {
-                    Err(Error::new_spanned(
-                        expr,
-                        "Base must be a identifier and cannot be empty!",
-                    ))
-                }
-            })
-            .transpose()?;
+        let base_class = parse_base_type(&attributes)?;
 
         // Ensure that if there is no qobject macro that a base class is specificed
         if !has_qobject_macro && base_class.is_none() {

crates/cxx-qt-gen/test_inputs/inheritance.rs

@@ -15,6 +15,12 @@ mod inheritance {
         type QPushButton;
     }
 
+    extern "C++Qt" {
+        #[base = QPushButton]
+        #[qobject]
+        type QPushButtonChild;
+    }
+
     extern "RustQt" {
         #[qobject]
         #[base = QAbstractItemModel]

crates/cxx-qt-gen/test_outputs/inheritance.rs

@@ -107,6 +107,23 @@ mod inheritance {
     extern "C++" {
         include ! (< QtWidgets / QPushButton >);
     }
+    extern "C++" {
+        #[doc(hidden)]
+        #[cxx_name = "upcastPtr"]
+        #[namespace = "rust::cxxqt1"]
+        unsafe fn cxx_qt_ffi_QPushButtonChild_upcastPtr(
+            thiz: *const QPushButtonChild,
+        ) -> *const QPushButton;
+        #[doc(hidden)]
+        #[cxx_name = "downcastPtr"]
+        #[namespace = "rust::cxxqt1"]
+        unsafe fn cxx_qt_ffi_QPushButtonChild_downcastPtr(
+            base: *const QPushButton,
+        ) -> *const QPushButtonChild;
+    }
+    extern "C++" {
+        type QPushButtonChild;
+    }
     extern "C++" {
         #[doc(hidden)]
         #[namespace = ""]
@@ -149,3 +166,11 @@ impl ::cxx_qt::Upcast<::cxx_qt::QObject> for inheritance::QPushButton {
         inheritance::cxx_qt_ffi_QPushButton_downcastPtr(base)
     }
 }
+impl ::cxx_qt::Upcast<inheritance::QPushButton> for inheritance::QPushButtonChild {
+    unsafe fn upcast_ptr(this: *const Self) -> *const inheritance::QPushButton {
+        inheritance::cxx_qt_ffi_QPushButtonChild_upcastPtr(this)
+    }
+    unsafe fn from_base_ptr(base: *const inheritance::QPushButton) -> *const Self {
+        inheritance::cxx_qt_ffi_QPushButtonChild_downcastPtr(base)
+    }
+}