[WIP] Add safe translation for unions

cpp2rust/converter/converter.cpp

@@ -55,12 +55,15 @@ use std::rc::Rc;
 )");
 }
 
-std::string Converter::EmitOpaqueRecords() {
+std::string Converter::EmitOpaqueRecords(bool emit_byte_repr) {
   std::string out;
   record_decls_.ForEachUndefined([&](const std::string &name) {
     out += "pub struct ";
     out += name;
     out += ";\n";
+    if (emit_byte_repr) {
+      out += "impl ByteRepr for " + name + " {}\n";
+    }
   });
   return out;
 }
@@ -753,6 +756,11 @@ void Converter::EmitRustStructOrUnion(clang::RecordDecl *decl) {
     }
   }
 
+  if (decl->isUnion()) {
+    EmitRustUnion(decl);
+    return;
+  }
+
   // Derived traits
   if (EmitsReprCForRecords()) {
     StrCat("#[repr(C)]");
@@ -770,8 +778,7 @@ void Converter::EmitRustStructOrUnion(clang::RecordDecl *decl) {
   auto access = clang::dyn_cast<clang::CXXRecordDecl>(decl)
                     ? AccessSpecifierAsString(decl->getAccess())
                     : keyword::kPub;
-  StrCat(access, decl->isUnion() ? keyword::kUnion : keyword::kStruct,
-         GetRecordName(decl));
+  StrCat(access, keyword::kStruct, GetRecordName(decl));
   {
     PushBrace brace(*this);
     for (auto *field : decl->fields()) {
@@ -817,6 +824,31 @@ void Converter::EmitRustStructOrUnion(clang::RecordDecl *decl) {
   AddByteReprTrait(decl);
 }
 
+void Converter::EmitRustUnion(clang::RecordDecl *decl) {
+  if (EmitsReprCForRecords()) {
+    StrCat("#[repr(C)]");
+  }
+  auto attrs = GetStructAttributes(decl);
+  Mapper::SetDerives(ctx_.getCanonicalTagType(decl),
+                     std::vector<std::string>(attrs.begin(), attrs.end()));
+  StrCat("#[derive(");
+  for (auto *attr : attrs) {
+    StrCat(attr, ',');
+  }
+  StrCat(")]");
+
+  StrCat(keyword::kPub, keyword::kUnion, GetRecordName(decl));
+  {
+    PushBrace brace(*this);
+    for (auto *field : decl->fields()) {
+      VisitFieldDecl(field);
+    }
+  }
+
+  AddDefaultTrait(decl);
+  AddByteReprTrait(decl);
+}
+
 bool Converter::VisitCXXRecordDecl(clang::CXXRecordDecl *decl) {
   if (clang::isa<clang::ClassTemplateSpecializationDecl>(decl)) {
     materializeTemplateSpecialization(decl);
@@ -3136,6 +3168,7 @@ bool Converter::VisitEnumDecl(clang::EnumDecl *decl) {
 
   AddFromImpl(decl);
   AddIncDecImpls(decl);
+  AddByteReprTrait(decl);
   return false;
 }
 
@@ -3918,6 +3951,8 @@ void Converter::EmitDefaultStructLiteral(const clang::RecordDecl *decl) {
 
 void Converter::AddByteReprTrait(const clang::RecordDecl *decl) {}
 
+void Converter::AddByteReprTrait(const clang::EnumDecl *decl) {}
+
 void Converter::ConvertUnsignedArithBinaryOperator(clang::BinaryOperator *op,
                                                    clang::Expr *expr) {
   StrCat(token::kDot);

cpp2rust/converter/converter.h

@@ -50,7 +50,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual void EmitFilePreamble();
 
-  static std::string EmitOpaqueRecords();
+  static std::string EmitOpaqueRecords(bool emit_byte_repr);
 
   virtual bool VisitBuiltinType(clang::BuiltinType *type);
 
@@ -112,6 +112,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual void EmitRustStructOrUnion(clang::RecordDecl *decl);
 
+  virtual void EmitRustUnion(clang::RecordDecl *decl);
+
   virtual bool EmitsReprCForRecords() const { return true; }
 
   virtual bool VisitCXXMethodDecl(clang::CXXMethodDecl *decl);
@@ -539,6 +541,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual void AddByteReprTrait(const clang::RecordDecl *decl);
 
+  virtual void AddByteReprTrait(const clang::EnumDecl *decl);
+
   virtual void
   ConvertUnsignedArithBinaryOperator(clang::BinaryOperator *binary_operator,
                                      clang::Expr *expr);

cpp2rust/converter/converter_lib.cpp

@@ -199,6 +199,42 @@ bool IsMut(clang::QualType qual_type) {
            qual_type->getPointeeType().isConstQualified());
 }
 
+bool TypeImplementsByteRepr(clang::QualType qt) {
+  if (qt->isIntegerType() || qt->isFloatingType()) {
+    return true;
+  }
+  if (qt->isPointerType()) {
+    return true;
+  }
+  if (const auto *arr = qt->getAsArrayTypeUnsafe()) {
+    return TypeImplementsByteRepr(arr->getElementType());
+  }
+  if (const auto *rd = qt->getAsRecordDecl()) {
+    if (rd->isUnion()) {
+      return true;
+    }
+    for (const auto *field : rd->fields()) {
+      if (!TypeImplementsByteRepr(field->getType())) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+
+bool RustSizeDivergesFromC(clang::QualType qt) {
+  qt = qt.getCanonicalType();
+  // Records have Rc<RefCell<>> fields that diverge from the C size
+  if (qt->isRecordType()) {
+    return true;
+  }
+  if (auto *arr = qt->getAsArrayTypeUnsafe()) {
+    return RustSizeDivergesFromC(arr->getElementType());
+  }
+  return false;
+}
+
 bool IsMutatingCall(const clang::CallExpr *expr) {
   if (auto *callee = expr->getDirectCallee()) {
     if (auto *method = clang::dyn_cast<clang::CXXMethodDecl>(callee)) {

cpp2rust/converter/converter_lib.h

@@ -51,6 +51,10 @@ bool IsUnsignedArithOp(const clang::BinaryOperator *expr);
 
 bool IsMut(clang::QualType qual_type);
 
+bool TypeImplementsByteRepr(clang::QualType qt);
+
+bool RustSizeDivergesFromC(clang::QualType qt);
+
 bool IsMutatingCall(const clang::CallExpr *expr);
 
 bool IsOverloadedFunction(const clang::FunctionDecl *decl);