Group traits and impls one after another in the generated code

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -26,8 +26,7 @@ std::unordered_set<std::string> Converter::decl_ids_;
 std::unordered_set<std::string> Converter::globals_;
 std::unordered_set<std::string> Converter::abstract_structs_;
 Converter::RecordIndex Converter::record_decls_;
-std::map<Converter::DeferredImplHeader, Converter::DeferredImplBody>
-    Converter::deferred_impls_;
+std::map<std::string, Converter::MethodsOnPtr> Converter::methods_on_ptr_;
 
 void Converter::ConvertUniquePtrDeref(clang::CXXOperatorCallExpr *expr) {
   bool is_star = expr->getOperator() == clang::OverloadedOperatorKind::OO_Star;
@@ -58,12 +57,16 @@ use std::rc::Rc;
 )");
 }
 
-std::string Converter::EmitDeferredImpls() {
+std::string Converter::EmitMethodsOnPtr() {
   std::string out;
-  for (const auto &[header, body] : deferred_impls_) {
-    out += header;
+  for (const auto &[name, methods] : methods_on_ptr_) {
+    out += methods.trait_header;
     out += " {\n";
-    out += body;
+    out += methods.trait_body;
+    out += "}\n";
+    out += methods.impl_header;
+    out += " {\n";
+    out += methods.impl_body;
     out += "}\n";
   }
   return out;

cpp2rust/converter/converter.h

@@ -54,7 +54,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   static std::string EmitOpaqueRecords();
 
-  static std::string EmitDeferredImpls();
+  static std::string EmitMethodsOnPtr();
 
   virtual bool VisitBuiltinType(clang::BuiltinType *type);
 
@@ -847,9 +847,15 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
     std::unordered_map<std::string, bool> entries_;
   };
   static RecordIndex record_decls_;
-  using DeferredImplHeader = std::string;
-  using DeferredImplBody = std::string;
-  static std::map<DeferredImplHeader, DeferredImplBody> deferred_impls_;
+  struct MethodsOnPtr {
+    std::string trait_header;
+    std::string trait_body;
+    std::string impl_header;
+    std::string impl_body;
+  };
+  // record name -> trait and impl for Ptr<record>, emitted after all
+  // translation units.
+  static std::map<std::string, MethodsOnPtr> methods_on_ptr_;
 
   enum class ExprKind : uint8_t {
     Callee,

cpp2rust/converter/models/converter_refcount.cpp

@@ -2604,15 +2604,16 @@ ConverterRefCount::TraitName(const clang::CXXRecordDecl *decl) const {
   return GetRecordName(decl) + "Impl";
 }
 
-std::string
-ConverterRefCount::TraitHeader(const clang::CXXRecordDecl *decl) const {
-  return std::format("pub trait {}", TraitName(decl));
-}
-
-std::string
-ConverterRefCount::ImplHeader(const clang::CXXRecordDecl *decl) const {
-  return std::format("impl {} for Ptr<{}>", TraitName(decl),
-                     GetRecordName(decl));
+Converter::MethodsOnPtr &
+ConverterRefCount::MethodsOnPtrFor(const clang::CXXRecordDecl *decl) {
+  auto name = GetRecordName(decl);
+  auto [it, inserted] = methods_on_ptr_.try_emplace(name);
+  if (inserted) {
+    it->second.trait_header = std::format("pub trait {}", TraitName(decl));
+    it->second.impl_header =
+        std::format("impl {} for Ptr<{}>", TraitName(decl), name);
+  }
+  return it->second;
 }
 
 bool ConverterRefCount::ConvertOutOfLineMethod(clang::CXXMethodDecl *decl) {
@@ -2624,7 +2625,7 @@ bool ConverterRefCount::ConvertOutOfLineMethod(clang::CXXMethodDecl *decl) {
     PushMethodTarget push(*this, MethodTarget::PtrImpl);
     ConvertCXXMethodDecl(decl);
   }
-  deferred_impls_[ImplHeader(decl->getParent())] += std::move(buf).str();
+  MethodsOnPtrFor(decl->getParent()).impl_body += std::move(buf).str();
   return false;
 }
 
@@ -2637,7 +2638,7 @@ void ConverterRefCount::ConvertMethodOnPtr(clang::CXXMethodDecl *method) {
       PushMethodTarget push(*this, MethodTarget::TraitDecl);
       ConvertCXXMethodDecl(method);
     }
-    deferred_impls_[TraitHeader(record)] += std::move(buf).str();
+    MethodsOnPtrFor(record).trait_body += std::move(buf).str();
   }
   if (!method->isThisDeclarationADefinition()) {
     return;
@@ -2647,7 +2648,7 @@ void ConverterRefCount::ConvertMethodOnPtr(clang::CXXMethodDecl *method) {
     PushMethodTarget push(*this, MethodTarget::PtrImpl);
     VisitCXXMethodDecl(method);
   }
-  deferred_impls_[ImplHeader(record)] += std::move(buf).str();
+  MethodsOnPtrFor(record).impl_body += std::move(buf).str();
 }
 
 void ConverterRefCount::ConvertLateInstantiatedMethods(
@@ -2683,9 +2684,9 @@ void ConverterRefCount::ConvertCXXRecordMethods(clang::CXXRecordDecl *decl) {
   }
 
   if (!GetUserDefinedDestructor(decl) && HasFieldsNeedingDestruction(decl)) {
-    deferred_impls_[TraitHeader(decl)] +=
+    MethodsOnPtrFor(decl).trait_body +=
         std::format("fn {}(&self);\n", kDestructorName);
-    deferred_impls_[ImplHeader(decl)] += std::format(
+    MethodsOnPtrFor(decl).impl_body += std::format(
         "fn {}(&self) {{ {} }}\n", kDestructorName, DestroyMembers(decl));
   }
 }

cpp2rust/converter/models/converter_refcount.h

@@ -219,8 +219,7 @@ class ConverterRefCount final : public Converter {
 
 private:
   std::string TraitName(const clang::CXXRecordDecl *decl) const;
-  std::string TraitHeader(const clang::CXXRecordDecl *decl) const;
-  std::string ImplHeader(const clang::CXXRecordDecl *decl) const;
+  MethodsOnPtr &MethodsOnPtrFor(const clang::CXXRecordDecl *decl);
   std::string DestroyMembers(const clang::CXXRecordDecl *decl) override;
   void EmitScopedDestructor(const clang::VarDecl *decl) override;
 

cpp2rust/cpp2rust_lib.cpp

@@ -31,7 +31,7 @@ std::string TranspileSrc(std::string_view cc_code, Model model,
       cc_code, tool_args, std::filesystem::path(filename).filename().string(),
       filename.ends_with(".c") ? CLANG_C_COMPILER : CLANG_CXX_COMPILER);
   rs_code += Converter::EmitOpaqueRecords();
-  rs_code += Converter::EmitDeferredImpls();
+  rs_code += Converter::EmitMethodsOnPtr();
   return rs_code;
 }
 
@@ -72,7 +72,7 @@ std::string TranspileDir(std::string_view build_dir, Model model,
   FrontendActionFactory factory(rs_code, model, rules_dir);
   Tool.run(&factory);
   rs_code += Converter::EmitOpaqueRecords();
-  rs_code += Converter::EmitDeferredImpls();
+  rs_code += Converter::EmitMethodsOnPtr();
   return rs_code;
 }
 } // namespace cpp2rust

tests/multi-file/template_method_late_instantiation/out/refcount/template_method_late_instantiation.rs

@@ -45,6 +45,10 @@ pub fn f_0(p: Ptr<S_int_>) -> i32 {
     let p: Value<Ptr<S_int_>> = Rc::new(RefCell::new(p));
     return ({ S_int_Impl::get(&(*p.borrow())) });
 }
+pub trait S_int_Impl {
+    fn set(&self, v: i32);
+    fn get(&self) -> i32;
+}
 impl S_int_Impl for Ptr<S_int_> {
     fn set(&self, v: i32) {
         let v: Value<i32> = Rc::new(RefCell::new(v));
@@ -54,7 +58,3 @@ impl S_int_Impl for Ptr<S_int_> {
         return (*(*(*self).upgrade().deref()).x.borrow());
     }
 }
-pub trait S_int_Impl {
-    fn set(&self, v: i32);
-    fn get(&self) -> i32;
-}

tests/unit/out/refcount/10_struct.rs

@@ -76,6 +76,9 @@ fn main_0() -> i32 {
     }));
     return 0;
 }
+pub trait GraphImpl {
+    fn push(&self, src: u32, dst: u32);
+}
 impl GraphImpl for Ptr<Graph> {
     fn push(&self, src: u32, dst: u32) {
         let src: Value<u32> = Rc::new(RefCell::new(src));
@@ -106,6 +109,3 @@ impl GraphImpl for Ptr<Graph> {
             .write(__rhs);
     }
 }
-pub trait GraphImpl {
-    fn push(&self, src: u32, dst: u32);
-}

tests/unit/out/refcount/class.rs

@@ -116,6 +116,14 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub trait PairImpl {
+    fn NOP(&self);
+    fn GetFirst(&self) -> i32;
+    fn GetSecond(&self) -> i32;
+    fn Set(&self, field: Ptr<i32>, new_val: i32) -> i32;
+    fn SetFirst(&self, new_first: i32) -> i32;
+    fn SetSecond(&self, new_second: i32) -> i32;
+}
 impl PairImpl for Ptr<Pair> {
     fn NOP(&self) {}
     fn GetFirst(&self) -> i32 {
@@ -149,6 +157,9 @@ impl PairImpl for Ptr<Pair> {
             }));
     }
 }
+pub trait RouteImpl {
+    fn SetCost(&self, new_cost: f64) -> f64;
+}
 impl RouteImpl for Ptr<Route> {
     fn SetCost(&self, new_cost: f64) -> f64 {
         let new_cost: Value<f64> = Rc::new(RefCell::new(new_cost));
@@ -158,14 +169,3 @@ impl RouteImpl for Ptr<Route> {
         return (*old_cost.borrow());
     }
 }
-pub trait PairImpl {
-    fn NOP(&self);
-    fn GetFirst(&self) -> i32;
-    fn GetSecond(&self) -> i32;
-    fn Set(&self, field: Ptr<i32>, new_val: i32) -> i32;
-    fn SetFirst(&self, new_first: i32) -> i32;
-    fn SetSecond(&self, new_second: i32) -> i32;
-}
-pub trait RouteImpl {
-    fn SetCost(&self, new_cost: f64) -> f64;
-}

tests/unit/out/refcount/class_template_lazy_member.rs

@@ -100,20 +100,20 @@ fn main_0() -> i32 {
     assert!(((*({ Box_Point_Impl::get(&p.as_pointer(),) }).x.borrow()) == 4));
     return 0;
 }
+pub trait Box_Point_Impl {
+    fn get(&self) -> Point;
+}
 impl Box_Point_Impl for Ptr<Box_Point_> {
     fn get(&self) -> Point {
         return (*(*(*self).upgrade().deref()).val.borrow()).clone();
     }
 }
+pub trait Box_int_Impl {
+    fn twice(&self) -> i32;
+}
 impl Box_int_Impl for Ptr<Box_int_> {
     fn twice(&self) -> i32 {
         return ((*(*(*self).upgrade().deref()).val.borrow())
             + (*(*(*self).upgrade().deref()).val.borrow()));
     }
 }
-pub trait Box_Point_Impl {
-    fn get(&self) -> Point;
-}
-pub trait Box_int_Impl {
-    fn twice(&self) -> i32;
-}

tests/unit/out/refcount/class_templates.rs

@@ -127,6 +127,13 @@ fn main_0() -> i32 {
     assert!(({ MyContainer_float_Impl::empty(&fmc.as_pointer(),) }));
     return 0;
 }
+pub trait MyContainer_char_Impl {
+    fn empty(&self) -> bool;
+    fn size(&self) -> usize;
+    fn back(&self) -> Ptr<u8>;
+    fn pop_back(&self);
+    fn push_back(&self, item: Ptr<u8>);
+}
 impl MyContainer_char_Impl for Ptr<MyContainer_char_> {
     fn empty(&self) -> bool {
         return (*(*(*self).upgrade().deref()).vec_.borrow()).is_empty();
@@ -148,6 +155,13 @@ impl MyContainer_char_Impl for Ptr<MyContainer_char_> {
         };
     }
 }
+pub trait MyContainer_float_Impl {
+    fn empty(&self) -> bool;
+    fn size(&self) -> usize;
+    fn back(&self) -> Ptr<f32>;
+    fn pop_back(&self);
+    fn push_back(&self, item: Ptr<f32>);
+}
 impl MyContainer_float_Impl for Ptr<MyContainer_float_> {
     fn empty(&self) -> bool {
         return (*(*(*self).upgrade().deref()).vec_.borrow()).is_empty();
@@ -169,6 +183,13 @@ impl MyContainer_float_Impl for Ptr<MyContainer_float_> {
         };
     }
 }
+pub trait MyContainer_int_Impl {
+    fn empty(&self) -> bool;
+    fn size(&self) -> usize;
+    fn back(&self) -> Ptr<i32>;
+    fn pop_back(&self);
+    fn push_back(&self, item: Ptr<i32>);
+}
 impl MyContainer_int_Impl for Ptr<MyContainer_int_> {
     fn empty(&self) -> bool {
         return (*(*(*self).upgrade().deref()).vec_.borrow()).is_empty();
@@ -190,24 +211,3 @@ impl MyContainer_int_Impl for Ptr<MyContainer_int_> {
         };
     }
 }
-pub trait MyContainer_char_Impl {
-    fn empty(&self) -> bool;
-    fn size(&self) -> usize;
-    fn back(&self) -> Ptr<u8>;
-    fn pop_back(&self);
-    fn push_back(&self, item: Ptr<u8>);
-}
-pub trait MyContainer_float_Impl {
-    fn empty(&self) -> bool;
-    fn size(&self) -> usize;
-    fn back(&self) -> Ptr<f32>;
-    fn pop_back(&self);
-    fn push_back(&self, item: Ptr<f32>);
-}
-pub trait MyContainer_int_Impl {
-    fn empty(&self) -> bool;
-    fn size(&self) -> usize;
-    fn back(&self) -> Ptr<i32>;
-    fn pop_back(&self);
-    fn push_back(&self, item: Ptr<i32>);
-}