Extract former CXXMappings into TypeNames struct

This is the first stage of the Naming phase (#835) refactor.
All associations between types and their fully qualified names are now
stored in one central database, the TypeNames struct.

The final goal for this struct is to include all fully qualified names
for each nameable type in the bridge.
Therefore the generator can use this to lookup any references from e.g.
arguments.

This is not quite done yet, as this isn't yet used everywhere, but it's
a good first step

Author: LeonMatthesKDAB

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

@@ -6,7 +6,7 @@
 use super::qobject::GeneratedCppQObjectBlocks;
 use crate::{
     generator::{cpp::GeneratedCppQObject, utils::cpp::syn_type_to_cpp_type},
-    parser::{constructor::Constructor, mappings::ParsedCxxMappings},
+    parser::{constructor::Constructor, naming::TypeNames},
     CppFragment,
 };
 
@@ -48,11 +48,11 @@ fn argument_names(arguments: &[Type]) -> Vec<String> {
         .collect()
 }
 
-fn expand_arguments(arguments: &[Type], cxx_mappings: &ParsedCxxMappings) -> Result<String> {
+fn expand_arguments(arguments: &[Type], type_names: &TypeNames) -> Result<String> {
     Ok(arguments
         .iter()
         .zip(argument_names(arguments).into_iter())
-        .map(|(ty, name)| syn_type_to_cpp_type(ty, cxx_mappings).map(|ty| format!("{ty} {name}")))
+        .map(|(ty, name)| syn_type_to_cpp_type(ty, type_names).map(|ty| format!("{ty} {name}")))
         .collect::<Result<Vec<_>>>()?
         .join(", "))
 }
@@ -62,7 +62,7 @@ pub fn generate(
     constructors: &[Constructor],
     base_class: String,
     class_initializers: &[String],
-    cxx_mappings: &ParsedCxxMappings,
+    type_names: &TypeNames,
 ) -> Result<GeneratedCppQObjectBlocks> {
     let initializers = class_initializers
         .iter()
@@ -80,7 +80,7 @@ pub fn generate(
     let rust_obj = qobject.rust_ident.as_str();
     let namespace_internals = &qobject.namespace_internals;
     for (index, constructor) in constructors.iter().enumerate() {
-        let argument_list = expand_arguments(&constructor.arguments, cxx_mappings)?;
+        let argument_list = expand_arguments(&constructor.arguments, type_names)?;
         let constructor_argument_names = argument_names(&constructor.arguments);
 
         generated.methods.push(CppFragment::Pair {
@@ -171,7 +171,7 @@ mod tests {
             &[],
             "BaseClass".to_owned(),
             &["member1(1)".to_string(), "member2{ 2 }".to_string()],
-            &ParsedCxxMappings::default(),
+            &TypeNames::default(),
         )
         .unwrap();
 
@@ -201,7 +201,7 @@ mod tests {
             &[],
             "BaseClass".to_owned(),
             &[],
-            &ParsedCxxMappings::default(),
+            &TypeNames::default(),
         )
         .unwrap();
 
@@ -233,7 +233,7 @@ mod tests {
             }],
             "BaseClass".to_owned(),
             &[],
-            &ParsedCxxMappings::default(),
+            &TypeNames::default(),
         )
         .unwrap();
 
@@ -283,7 +283,7 @@ mod tests {
             }],
             "BaseClass".to_owned(),
             &["initializer".to_string()],
-            &ParsedCxxMappings::default(),
+            &TypeNames::default(),
         )
         .unwrap();
 
@@ -337,7 +337,7 @@ mod tests {
             ],
             "BaseClass".to_owned(),
             &["initializer".to_string()],
-            &ParsedCxxMappings::default(),
+            &TypeNames::default(),
         )
         .unwrap();
 

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

@@ -5,7 +5,7 @@
 
 use crate::{
     generator::cpp::signal::generate_cpp_signal,
-    parser::{externcxxqt::ParsedExternCxxQt, mappings::ParsedCxxMappings},
+    parser::{externcxxqt::ParsedExternCxxQt, naming::TypeNames},
     CppFragment,
 };
 use std::collections::BTreeSet;
@@ -23,14 +23,14 @@ pub struct GeneratedCppExternCxxQtBlocks {
 
 pub fn generate(
     blocks: &[ParsedExternCxxQt],
-    cxx_mappings: &ParsedCxxMappings,
+    type_names: &TypeNames,
 ) -> Result<Vec<GeneratedCppExternCxxQtBlocks>> {
     let mut out = vec![];
 
     for block in blocks {
         for signal in &block.signals {
             let mut block = GeneratedCppExternCxxQtBlocks::default();
-            let data = generate_cpp_signal(signal, &signal.qobject_ident, cxx_mappings)?;
+            let data = generate_cpp_signal(signal, &signal.qobject_ident, type_names)?;
             block.includes = data.includes;
             // Ensure that we include MaybeLockGuard<T> that is used in multiple places
             block
@@ -66,7 +66,7 @@ mod tests {
             }
         })
         .unwrap()];
-        let generated = generate(&blocks, &ParsedCxxMappings::default()).unwrap();
+        let generated = generate(&blocks, &TypeNames::default()).unwrap();
         assert_eq!(generated.len(), 2);
     }
 
@@ -83,15 +83,15 @@ mod tests {
             }
         })
         .unwrap()];
-        let mut cxx_mappings = ParsedCxxMappings::default();
-        cxx_mappings
+        let mut type_names = TypeNames::default();
+        type_names
             .cxx_names
             .insert("ObjRust".to_owned(), "ObjCpp".to_owned());
-        cxx_mappings
+        type_names
             .namespaces
             .insert("ObjRust".to_owned(), "mynamespace".to_owned());
 
-        let generated = generate(&blocks, &cxx_mappings).unwrap();
+        let generated = generate(&blocks, &type_names).unwrap();
         assert_eq!(generated.len(), 1);
     }
 }

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

@@ -9,20 +9,20 @@ use crate::{
         cpp::{fragment::CppFragment, qobject::GeneratedCppQObjectBlocks},
         utils::cpp::syn_type_to_cpp_return_type,
     },
-    parser::{inherit::ParsedInheritedMethod, mappings::ParsedCxxMappings},
+    parser::{inherit::ParsedInheritedMethod, naming::TypeNames},
 };
 
 use syn::Result;
 
 pub fn generate(
     inherited_methods: &[ParsedInheritedMethod],
     base_class: &Option<String>,
-    cxx_mappings: &ParsedCxxMappings,
+    type_names: &TypeNames,
 ) -> Result<GeneratedCppQObjectBlocks> {
     let mut result = GeneratedCppQObjectBlocks::default();
 
     for method in inherited_methods {
-        let return_type = syn_type_to_cpp_return_type(&method.method.sig.output, cxx_mappings)?;
+        let return_type = syn_type_to_cpp_return_type(&method.method.sig.output, type_names)?;
         let base_class = base_class.as_deref().unwrap_or("QObject");
 
         result.methods.push(CppFragment::Header(formatdoc! {
@@ -58,11 +58,7 @@ mod tests {
     ) -> Result<GeneratedCppQObjectBlocks> {
         let inherited_methods = vec![ParsedInheritedMethod::parse(method, Safety::Safe).unwrap()];
         let base_class = base_class.map(|s| s.to_owned());
-        generate(
-            &inherited_methods,
-            &base_class,
-            &ParsedCxxMappings::default(),
-        )
+        generate(&inherited_methods, &base_class, &TypeNames::default())
     }
 
     fn assert_generated_eq(expected: &str, generated: &GeneratedCppQObjectBlocks) {

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

@@ -15,8 +15,8 @@ use crate::{
         },
     },
     parser::{
-        mappings::ParsedCxxMappings,
         method::{ParsedMethod, ParsedQInvokableSpecifiers},
+        naming::TypeNames,
     },
 };
 use indoc::formatdoc;
@@ -25,14 +25,13 @@ use syn::{spanned::Spanned, Error, FnArg, Pat, PatIdent, PatType, Result};
 pub fn generate_cpp_methods(
     invokables: &Vec<ParsedMethod>,
     qobject_idents: &QObjectName,
-    cxx_mappings: &ParsedCxxMappings,
+    type_names: &TypeNames,
 ) -> Result<GeneratedCppQObjectBlocks> {
     let mut generated = GeneratedCppQObjectBlocks::default();
     let qobject_ident = qobject_idents.cpp_class.cpp.to_string();
     for invokable in invokables {
         let idents = QMethodName::from(invokable);
-        let return_cxx_ty =
-            syn_type_to_cpp_return_type(&invokable.method.sig.output, cxx_mappings)?;
+        let return_cxx_ty = syn_type_to_cpp_return_type(&invokable.method.sig.output, type_names)?;
 
         let parameters: Vec<CppNamedType> = invokable
             .method
@@ -54,7 +53,7 @@ pub fn generate_cpp_methods(
                     } else {
                         Ok(Some(CppNamedType {
                             ident: ident.to_string(),
-                            ty: syn_type_to_cpp_type(ty, cxx_mappings)?,
+                            ty: syn_type_to_cpp_type(ty, type_names)?,
                         }))
                     }
                 } else {
@@ -232,8 +231,7 @@ mod tests {
         let qobject_idents = create_qobjectname();
 
         let generated =
-            generate_cpp_methods(&invokables, &qobject_idents, &ParsedCxxMappings::default())
-                .unwrap();
+            generate_cpp_methods(&invokables, &qobject_idents, &TypeNames::default()).unwrap();
 
         // methods
         assert_eq!(generated.methods.len(), 5);
@@ -401,15 +399,11 @@ mod tests {
         }];
         let qobject_idents = create_qobjectname();
 
-        let mut cxx_mappings = ParsedCxxMappings::default();
-        cxx_mappings
-            .cxx_names
-            .insert("A".to_owned(), "A1".to_owned());
-        cxx_mappings
-            .cxx_names
-            .insert("B".to_owned(), "B2".to_owned());
+        let mut type_names = TypeNames::default();
+        type_names.cxx_names.insert("A".to_owned(), "A1".to_owned());
+        type_names.cxx_names.insert("B".to_owned(), "B2".to_owned());
 
-        let generated = generate_cpp_methods(&invokables, &qobject_idents, &cxx_mappings).unwrap();
+        let generated = generate_cpp_methods(&invokables, &qobject_idents, &type_names).unwrap();
 
         // methods
         assert_eq!(generated.methods.len(), 1);

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

@@ -63,11 +63,11 @@ impl GeneratedCppBlocks {
                 .cxx_qt_data
                 .qobjects
                 .values()
-                .map(|qobject| GeneratedCppQObject::from(qobject, &parser.cxx_qt_data.cxx_mappings))
+                .map(|qobject| GeneratedCppQObject::from(qobject, &parser.type_names))
                 .collect::<Result<Vec<GeneratedCppQObject>>>()?,
             extern_cxx_qt: externcxxqt::generate(
                 &parser.cxx_qt_data.extern_cxxqt_blocks,
-                &parser.cxx_qt_data.cxx_mappings,
+                &parser.type_names,
             )?,
         })
     }

crates/cxx-qt-gen/src/generator/cpp/property/mod.rs

@@ -8,7 +8,7 @@ use crate::generator::{
     naming::{property::QPropertyName, qobject::QObjectName},
     utils::cpp::syn_type_to_cpp_type,
 };
-use crate::parser::{mappings::ParsedCxxMappings, property::ParsedQProperty};
+use crate::parser::{naming::TypeNames, property::ParsedQProperty};
 use syn::Result;
 
 mod getter;
@@ -19,7 +19,7 @@ mod signal;
 pub fn generate_cpp_properties(
     properties: &Vec<ParsedQProperty>,
     qobject_idents: &QObjectName,
-    cxx_mappings: &ParsedCxxMappings,
+    type_names: &TypeNames,
 ) -> Result<GeneratedCppQObjectBlocks> {
     let mut generated = GeneratedCppQObjectBlocks::default();
     let mut signals = vec![];
@@ -28,7 +28,7 @@ pub fn generate_cpp_properties(
     for property in properties {
         // Cache the idents as they are used in multiple places
         let idents = QPropertyName::from(property);
-        let cxx_ty = syn_type_to_cpp_type(&property.ty, cxx_mappings)?;
+        let cxx_ty = syn_type_to_cpp_type(&property.ty, type_names)?;
 
         generated.metaobjects.push(meta::generate(&idents, &cxx_ty));
         generated
@@ -49,7 +49,7 @@ pub fn generate_cpp_properties(
     generated.append(&mut generate_cpp_signals(
         &signals,
         qobject_idents,
-        cxx_mappings,
+        type_names,
     )?);
 
     Ok(generated)
@@ -81,8 +81,7 @@ mod tests {
         let qobject_idents = create_qobjectname();
 
         let generated =
-            generate_cpp_properties(&properties, &qobject_idents, &ParsedCxxMappings::default())
-                .unwrap();
+            generate_cpp_properties(&properties, &qobject_idents, &TypeNames::default()).unwrap();
 
         // metaobjects
         assert_eq!(generated.metaobjects.len(), 2);
@@ -360,13 +359,10 @@ mod tests {
         }];
         let qobject_idents = create_qobjectname();
 
-        let mut cxx_mapping = ParsedCxxMappings::default();
-        cxx_mapping
-            .cxx_names
-            .insert("A".to_owned(), "A1".to_owned());
+        let mut type_names = TypeNames::default();
+        type_names.cxx_names.insert("A".to_owned(), "A1".to_owned());
 
-        let generated =
-            generate_cpp_properties(&properties, &qobject_idents, &cxx_mapping).unwrap();
+        let generated = generate_cpp_properties(&properties, &qobject_idents, &type_names).unwrap();
 
         // metaobjects
         assert_eq!(generated.metaobjects.len(), 1);

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

@@ -10,7 +10,7 @@ use syn::Result;
 
 use crate::{
     generator::utils::cpp::Indent,
-    parser::{mappings::ParsedCxxMappings, qenum::ParsedQEnum},
+    parser::{naming::TypeNames, qenum::ParsedQEnum},
     writer::cpp::namespaced,
 };
 
@@ -52,15 +52,15 @@ pub fn generate_declaration(qenum: &ParsedQEnum, includes: &mut BTreeSet<String>
 
 pub fn generate(
     qenums: &[ParsedQEnum],
-    cxx_mappings: &ParsedCxxMappings,
+    type_names: &TypeNames,
 ) -> Result<GeneratedCppQObjectBlocks> {
     let mut generated = GeneratedCppQObjectBlocks::default();
 
     for qenum in qenums {
         let enum_name = &qenum.ident.to_string();
 
-        let mut qualified_name = cxx_mappings.cxx(enum_name);
-        // TODO: this is a workaround for cxx_mappings.cxx not always returning a fully-qualified
+        let mut qualified_name = type_names.cxx(enum_name);
+        // TODO: this is a workaround for type_names.cxx not always returning a fully-qualified
         // identifier.
         // Once https://github.com/KDAB/cxx-qt/issues/619 is fixed, this can be removed.
         if !qualified_name.starts_with("::") {
@@ -102,7 +102,7 @@ mod tests {
         })
         .unwrap()];
 
-        let generated = generate(&qenums, &ParsedCxxMappings::default()).unwrap();
+        let generated = generate(&qenums, &TypeNames::default()).unwrap();
         assert_eq!(generated.includes.len(), 1);
         assert!(generated.includes.contains("#include <cstdint>"));
         assert_eq!(generated.metaobjects.len(), 1);