Fully qualify CXX types without namespace

These types are assumed to be within the global namespace.

Author: Leon Matthes

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

@@ -411,12 +411,15 @@ mod tests {
         } else {
             panic!("Expected pair")
         };
-        assert_str_eq!(header, "Q_INVOKABLE B2 trivialInvokable(A1 param) const;");
+        assert_str_eq!(
+            header,
+            "Q_INVOKABLE ::B2 trivialInvokable(::A1 param) const;"
+        );
         assert_str_eq!(
             source,
             indoc! {r#"
-            B2
-            MyObject::trivialInvokable(A1 param) const
+            ::B2
+            MyObject::trivialInvokable(::A1 param) const
             {
                 const ::rust::cxxqt1::MaybeLockGuard<MyObject> guard(*this);
                 return trivialInvokableWrapper(param);
@@ -434,7 +437,7 @@ mod tests {
         };
         assert_str_eq!(
             header,
-            "B2 trivialInvokableWrapper(A1 param) const noexcept;"
+            "::B2 trivialInvokableWrapper(::A1 param) const noexcept;"
         );
     }
 }

crates/cxx-qt-gen/src/naming/cpp.rs

@@ -373,7 +373,7 @@ mod tests {
         let ty = parse_quote! { A };
         let mut type_names = TypeNames::default();
         type_names.insert("A", None, Some("A1"), None);
-        assert_eq!(syn_type_to_cpp_type(&ty, &type_names).unwrap(), "A1");
+        assert_eq!(syn_type_to_cpp_type(&ty, &type_names).unwrap(), "::A1");
     }
 
     #[test]

crates/cxx-qt-gen/src/naming/type_names.rs

@@ -192,7 +192,7 @@ impl TypeNames {
         if let Some(namespace) = &name.namespace {
             format!("::{namespace}::{cxx_name}")
         } else {
-            cxx_name.clone()
+            format!("::{cxx_name}")
         }
     }
 
@@ -284,7 +284,7 @@ mod tests {
 
         assert_eq!(types.num_types(), 1);
         assert_eq!(types.rust_qualified(&ident), parse_quote! { ffi::A });
-        assert_eq!(types.cxx_qualified(&ident), "A"); // TODO Should this be "::A"?
+        assert_eq!(types.cxx_qualified(&ident), "::A");
         assert!(types.namespace(&ident).is_none());
     }
 
@@ -302,7 +302,7 @@ mod tests {
             .is_ok());
 
         assert_eq!(types.num_types(), 1);
-        assert_eq!(types.cxx_qualified(&ident), "B");
+        assert_eq!(types.cxx_qualified(&ident), "::B");
         assert!(types.namespace(&ident).is_none());
         assert_eq!(types.rust_qualified(&ident), parse_quote! { ffi::A });
     }
@@ -397,7 +397,7 @@ mod tests {
         let type_names = parse_cxx_item(item);
         let ident = format_ident!("A");
         assert_eq!(type_names.num_types(), 1);
-        assert_eq!(type_names.cxx_qualified(&ident), "B");
+        assert_eq!(type_names.cxx_qualified(&ident), "::B");
 
         assert_eq!(type_names.rust_qualified(&ident), parse_quote! { ffi::A });
     }

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

@@ -1,14 +1,14 @@
 #include "cxx-qt-gen/inheritance.cxxqt.h"
 
-QVariant
-MyObject::data(QModelIndex const& _index, ::std::int32_t _role) const
+::QVariant
+MyObject::data(::QModelIndex const& _index, ::std::int32_t _role) const
 {
   const ::rust::cxxqt1::MaybeLockGuard<MyObject> guard(*this);
   return dataWrapper(_index, _role);
 }
 
 bool
-MyObject::hasChildren(QModelIndex const& _parent) const
+MyObject::hasChildren(::QModelIndex const& _parent) const
 {
   const ::rust::cxxqt1::MaybeLockGuard<MyObject> guard(*this);
   return hasChildrenWrapper(_parent);

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

@@ -18,9 +18,9 @@ class MyObject
   virtual ~MyObject() = default;
 
 public:
-  Q_INVOKABLE QVariant data(QModelIndex const& _index,
-                            ::std::int32_t _role) const override;
-  Q_INVOKABLE bool hasChildren(QModelIndex const& _parent) const override;
+  Q_INVOKABLE ::QVariant data(::QModelIndex const& _index,
+                              ::std::int32_t _role) const override;
+  Q_INVOKABLE bool hasChildren(::QModelIndex const& _parent) const override;
   template<class... Args>
   bool hasChildrenCxxQtInherit(Args... args) const
   {
@@ -34,9 +34,9 @@ class MyObject
   explicit MyObject(QObject* parent = nullptr);
 
 private:
-  QVariant dataWrapper(QModelIndex const& _index,
-                       ::std::int32_t _role) const noexcept;
-  bool hasChildrenWrapper(QModelIndex const& _parent) const noexcept;
+  ::QVariant dataWrapper(::QModelIndex const& _index,
+                         ::std::int32_t _role) const noexcept;
+  bool hasChildrenWrapper(::QModelIndex const& _parent) const noexcept;
 };
 
 static_assert(::std::is_base_of<QObject, MyObject>::value,

crates/cxx-qt-gen/test_outputs/invokables.cpp

@@ -23,8 +23,8 @@ MyObject::invokableMutable()
 }
 
 void
-MyObject::invokableParameters(QColor const& opaque,
-                              QPoint const& trivial,
+MyObject::invokableParameters(::QColor const& opaque,
+                              ::QPoint const& trivial,
                               ::std::int32_t primitive) const
 {
   const ::rust::cxxqt1::MaybeLockGuard<MyObject> guard(*this);
@@ -38,7 +38,7 @@ MyObject::invokableReturnOpaque()
   return invokableReturnOpaqueWrapper();
 }
 
-QPoint
+::QPoint
 MyObject::invokableReturnTrivial()
 {
   const ::rust::cxxqt1::MaybeLockGuard<MyObject> guard(*this);

crates/cxx-qt-gen/test_outputs/invokables.h

@@ -26,11 +26,11 @@ class MyObject
   void cppMethod() const;
   Q_INVOKABLE void invokable() const;
   Q_INVOKABLE void invokableMutable();
-  Q_INVOKABLE void invokableParameters(QColor const& opaque,
-                                       QPoint const& trivial,
+  Q_INVOKABLE void invokableParameters(::QColor const& opaque,
+                                       ::QPoint const& trivial,
                                        ::std::int32_t primitive) const;
   Q_INVOKABLE ::std::unique_ptr<Opaque> invokableReturnOpaque();
-  Q_INVOKABLE QPoint invokableReturnTrivial();
+  Q_INVOKABLE ::QPoint invokableReturnTrivial();
   Q_INVOKABLE void invokableFinal() const final;
   Q_INVOKABLE void invokableOverride() const override;
   Q_INVOKABLE virtual void invokableVirtual() const;
@@ -43,11 +43,11 @@ class MyObject
   void cppMethodWrapper() const noexcept;
   void invokableWrapper() const noexcept;
   void invokableMutableWrapper() noexcept;
-  void invokableParametersWrapper(QColor const& opaque,
-                                  QPoint const& trivial,
+  void invokableParametersWrapper(::QColor const& opaque,
+                                  ::QPoint const& trivial,
                                   ::std::int32_t primitive) const noexcept;
   ::std::unique_ptr<Opaque> invokableReturnOpaqueWrapper() noexcept;
-  QPoint invokableReturnTrivialWrapper() noexcept;
+  ::QPoint invokableReturnTrivialWrapper() noexcept;
   void invokableFinalWrapper() const noexcept;
   void invokableOverrideWrapper() const noexcept;
   void invokableVirtualWrapper() const noexcept;

crates/cxx-qt-gen/test_outputs/passthrough_and_naming.cpp

@@ -18,7 +18,7 @@ template<>
 template<>
 void
 SignalHandler<::rust::cxxqtgen1::QPushButtonCxxQtSignalParamsclicked*>::
-operator()<QPushButton&, bool>(QPushButton& self, bool checked)
+operator()<::QPushButton&, bool>(::QPushButton& self, bool checked)
 {
   call_QPushButton_signal_handler_clicked(*this, self, ::std::move(checked));
 }
@@ -38,18 +38,18 @@ static_assert(
 namespace rust::cxxqtgen1 {
 ::QMetaObject::Connection
 QPushButton_clickedConnect(
-  QPushButton& self,
+  ::QPushButton& self,
   ::rust::cxxqtgen1::QPushButtonCxxQtSignalHandlerclicked closure,
   ::Qt::ConnectionType type)
 {
   return ::QObject::connect(
     &self,
-    &QPushButton::clicked,
+    &::QPushButton::clicked,
     &self,
     [&, closure = ::std::move(closure)](bool checked) mutable {
-      const ::rust::cxxqt1::MaybeLockGuard<QPushButton> guard(self);
-      closure.template operator()<QPushButton&, bool>(self,
-                                                      ::std::move(checked));
+      const ::rust::cxxqt1::MaybeLockGuard<::QPushButton> guard(self);
+      closure.template operator()<::QPushButton&, bool>(self,
+                                                        ::std::move(checked));
     },
     type);
 }

crates/cxx-qt-gen/test_outputs/passthrough_and_naming.h

@@ -58,7 +58,7 @@ using ExternObjectCxxQtSignalHandlererrorOccurred =
 namespace rust::cxxqtgen1 {
 ::QMetaObject::Connection
 QPushButton_clickedConnect(
-  QPushButton& self,
+  ::QPushButton& self,
   ::rust::cxxqtgen1::QPushButtonCxxQtSignalHandlerclicked closure,
   ::Qt::ConnectionType type);
 } // namespace rust::cxxqtgen1

crates/cxx-qt-gen/test_outputs/properties.cpp

@@ -131,15 +131,15 @@ MyObject::setPrimitive(::std::int32_t const& value)
   setPrimitiveWrapper(value);
 }
 
-QPoint const&
+::QPoint const&
 MyObject::getTrivial() const
 {
   const ::rust::cxxqt1::MaybeLockGuard<MyObject> guard(*this);
   return getTrivialWrapper();
 }
 
 void
-MyObject::setTrivial(QPoint const& value)
+MyObject::setTrivial(::QPoint const& value)
 {
   const ::rust::cxxqt1::MaybeLockGuard<MyObject> guard(*this);
   setTrivialWrapper(value);