Translate records that contain declared but not defined methods (#394)

```cpp
struct S {
  int a;
  void declared_but_never_defined();
];

int main() {
  S s{1};
  assert(s.a == 1);
}
```

S is a valid record that can be translated to Rust. This PR translates
it like this:

```rs
struct S {
  a: i32
}

trait SImpl {
  fn declared_but_never_defined(&self) { unimplemented!() }
}
```

The function gets a default `unimplemented` implementation. Other TU
might offer a definition for the declared-only method.

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1114,6 +1114,9 @@ bool Converter::ConvertCXXMethodDecl(clang::CXXMethodDecl *decl) {
   ConvertFunctionReturnType(decl);
   if (decl->isPureVirtual() || method_target_ == MethodTarget::TraitDecl) {
     StrCat(token::kSemiColon);
+  } else if (method_target_ == MethodTarget::TraitDefault) {
+    PushBrace body(*this);
+    StrCat("unimplemented!()");
   } else {
     PushBrace body(*this);
     EmitFunctionPreamble(decl);

cpp2rust/converter/converter.h

@@ -691,6 +691,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   enum class MethodTarget : uint8_t {
     ValueImpl,
     TraitDecl,
+    TraitDefault,
     PtrImpl,
   };
   MethodTarget method_target_ = MethodTarget::ValueImpl;

cpp2rust/converter/converter_lib.cpp

@@ -357,6 +357,10 @@ bool HasDefaultedCopyConstructor(const clang::RecordDecl *decl) {
   return !cxx->defaultedCopyConstructorIsDeleted();
 }
 
+bool RecordDerivesByteRepr(const clang::RecordDecl *decl) {
+  return !decl->isUnion() && decl->field_empty();
+}
+
 bool RecordHasOnlyReferenceFields(const clang::RecordDecl *decl) {
   for (auto *field : decl->fields()) {
     if (!field->getType()->isReferenceType()) {
@@ -418,17 +422,7 @@ bool IsPassThroughConstructor(const clang::CXXConstructorDecl *ctor) {
 }
 
 bool IsConvertibleCXXRecordDecl(const clang::CXXRecordDecl *decl) {
-  return decl->isThisDeclarationADefinition() &&
-         std::all_of(
-             decl->method_begin(), decl->method_end(), [](auto *method) {
-               auto *ctor = clang::dyn_cast<clang::CXXConstructorDecl>(method);
-               return method->getDefinition() || method->isPureVirtual() ||
-                      method->getTemplateInstantiationPattern() ||
-                      method->getDescribedFunctionTemplate() ||
-                      (ctor ? ctor->isCopyOrMoveConstructor()
-                            : method->isCopyAssignmentOperator() ||
-                                  method->isMoveAssignmentOperator());
-             });
+  return decl->isThisDeclarationADefinition() && !decl->isDependentContext();
 }
 
 bool IsConvertibleCXXMethodDecl(const clang::CXXMethodDecl *decl) {
@@ -1039,8 +1033,8 @@ bool IsMethodOnPtr(const clang::CXXMethodDecl *method) {
       !IsComparisonOperator(method)) {
     return false;
   }
-  if (clang::isa<clang::CXXDestructorDecl>(method)) {
-    return GetUserDefinedDestructor(method->getParent()) != nullptr;
+  if (auto *dtor = clang::dyn_cast<clang::CXXDestructorDecl>(method)) {
+    return !dtor->isImplicit() && !dtor->isDefaulted();
   }
   return true;
 }

cpp2rust/converter/converter_lib.h

@@ -91,6 +91,8 @@ bool HasDefaultedCopyConstructor(const clang::RecordDecl *decl);
 
 bool RecordHasOnlyReferenceFields(const clang::RecordDecl *decl);
 
+bool RecordDerivesByteRepr(const clang::RecordDecl *decl);
+
 bool HasDefaultedCopyAssignment(const clang::RecordDecl *decl);
 
 bool IsRValueConvertingConstructor(const clang::CXXConstructorDecl *ctor);

cpp2rust/converter/models/converter_refcount.cpp

@@ -574,6 +574,10 @@ void ConverterRefCount::EmitRustUnion(clang::RecordDecl *decl) {
 }
 
 void ConverterRefCount::AddByteReprTrait(const clang::RecordDecl *decl) {
+  if (RecordDerivesByteRepr(decl)) {
+    return;
+  }
+
   auto struct_name = GetRecordName(decl);
 
   if (!TypeImplementsByteRepr(ctx_.getCanonicalTagType(decl))) {
@@ -2152,6 +2156,10 @@ ConverterRefCount::GetStructAttributes(const clang::RecordDecl *decl) {
     attrs.emplace_back("Clone");
   }
 
+  if (RecordDerivesByteRepr(decl)) {
+    attrs.emplace_back("ByteRepr");
+  }
+
   if (RecordDerivesDefault(decl)) {
     attrs.emplace_back("Default");
   }
@@ -2855,17 +2863,20 @@ bool ConverterRefCount::ConvertOutOfLineMethod(clang::CXXMethodDecl *decl) {
   return false;
 }
 
-void ConverterRefCount::ConvertMethodOnPtr(clang::CXXMethodDecl *method) {
-  auto *record = method->getParent();
+void ConverterRefCount::ConvertMethodOnPtrTraitDecl(
+    clang::CXXMethodDecl *method) {
+  Buffer buf(*this);
   {
-    Buffer buf(*this);
-    {
-      PushCurrFunction push_fn(*this, method);
-      PushMethodTarget push(*this, MethodTarget::TraitDecl);
-      ConvertCXXMethodDecl(method);
-    }
-    MethodsOnPtrFor(record).trait_body += std::move(buf).str();
+    PushCurrFunction push_fn(*this, method);
+    PushMethodTarget push(*this, method->getDefinition()
+                                     ? MethodTarget::TraitDecl
+                                     : MethodTarget::TraitDefault);
+    ConvertCXXMethodDecl(method);
   }
+  MethodsOnPtrFor(method->getParent()).trait_body += std::move(buf).str();
+}
+
+void ConverterRefCount::ConvertMethodOnPtr(clang::CXXMethodDecl *method) {
   if (!method->isThisDeclarationADefinition()) {
     return;
   }
@@ -2874,7 +2885,7 @@ void ConverterRefCount::ConvertMethodOnPtr(clang::CXXMethodDecl *method) {
     PushMethodTarget push(*this, MethodTarget::PtrImpl);
     VisitCXXMethodDecl(method);
   }
-  MethodsOnPtrFor(record).impl_body += std::move(buf).str();
+  MethodsOnPtrFor(method->getParent()).impl_body += std::move(buf).str();
 }
 
 void ConverterRefCount::ConvertLateInstantiatedMethods(
@@ -2908,7 +2919,8 @@ void ConverterRefCount::ConvertCXXRecordMethods(clang::CXXRecordDecl *decl) {
                         });
 
   auto convert_method = [&](clang::CXXMethodDecl *method) {
-    if (IsMethodOnPtr(method) && method->getDefinition()) {
+    if (IsMethodOnPtr(method)) {
+      ConvertMethodOnPtrTraitDecl(method);
       ConvertMethodOnPtr(method);
     }
   };

cpp2rust/converter/models/converter_refcount.h

@@ -66,6 +66,7 @@ class ConverterRefCount final : public Converter {
 
   void ConvertLateInstantiatedMethods(clang::CXXRecordDecl *decl) override;
 
+  void ConvertMethodOnPtrTraitDecl(clang::CXXMethodDecl *method);
   void ConvertMethodOnPtr(clang::CXXMethodDecl *method);
 
   bool VisitCXXThisExpr(clang::CXXThisExpr *expr) override;

tests/multi-file/out_of_line_methods_cross_tu/CMakeLists.txt

@@ -0,0 +1,3 @@
+cmake_minimum_required(VERSION 3.16)
+project(out_of_line_methods_cross_tu LANGUAGES CXX)
+add_executable(app a.cpp b.cpp)

tests/multi-file/out_of_line_methods_cross_tu/a.cpp

@@ -0,0 +1,12 @@
+#include <assert.h>
+
+#include "s.h"
+
+int main() {
+  S s(1);
+  assert(s.get() == 1);
+  s.set(4);
+  assert(s.get() == 4);
+  assert(s.add(2) == 6);
+  return 0;
+}

tests/multi-file/out_of_line_methods_cross_tu/b.cpp

@@ -0,0 +1,12 @@
+#include "s.h"
+
+S::S(int x) : v(x) {}
+
+S::~S() {}
+
+void S::set(int x) { v = x; }
+
+int S::add(int x) {
+  v += x;
+  return v;
+}

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

@@ -0,0 +1,86 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(Default)]
+pub struct S {
+    pub v: Value<i32>,
+}
+impl S {}
+impl Clone for S {
+    fn clone(&self) -> Self {
+        let __this: Value<S> = Rc::new(RefCell::new(Self {
+            v: Rc::new(RefCell::new((*self.v.borrow()))),
+        }));
+        let this: Ptr<S> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl ByteRepr for S {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.v.borrow()).to_bytes(&mut buf[0..4]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            v: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+        }
+    }
+}
+pub fn main() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let s: Value<S> = Rc::new(RefCell::new(S::S({ 1 })));
+    assert!((({ SImpl::get(&s.as_pointer(),) }) == 1));
+    ({ SImpl::set(&s.as_pointer(), 4) });
+    assert!((({ SImpl::get(&s.as_pointer(),) }) == 4));
+    assert!((({ SImpl::add(&s.as_pointer(), 2,) }) == 6));
+    return 0;
+}
+impl S {
+    pub fn S(x: i32) -> Self {
+        let x: Value<i32> = Rc::new(RefCell::new(x));
+        let __this: Value<S> = Rc::new(RefCell::new(Self {
+            v: Rc::new(RefCell::new((*x.borrow()))),
+        }));
+        let this: Ptr<S> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl S {}
+pub trait SImpl {
+    fn destructor(&self) {
+        unimplemented!()
+    }
+    fn get(&self) -> i32;
+    fn set(&self, x: i32) {
+        unimplemented!()
+    }
+    fn add(&self, x: i32) -> i32 {
+        unimplemented!()
+    }
+}
+impl SImpl for Ptr<S> {
+    fn get(&self) -> i32 {
+        return (*(*(*self).upgrade().deref()).v.borrow());
+    }
+    fn destructor(&self) {}
+    fn set(&self, x: i32) {
+        let x: Value<i32> = Rc::new(RefCell::new(x));
+        (*(*(*self).upgrade().deref()).v.borrow_mut()) = (*x.borrow());
+    }
+    fn add(&self, x: i32) -> i32 {
+        let x: Value<i32> = Rc::new(RefCell::new(x));
+        (*(*(*self).upgrade().deref()).v.borrow_mut()) += (*x.borrow());
+        return (*(*(*self).upgrade().deref()).v.borrow());
+    }
+}
+pub fn __cpp2rust_init_globals() {}