Access unions through Ptr<Self>

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -3336,46 +3336,6 @@ void Converter::SetUFCSReceiver(clang::Expr *base, bool is_arrow,
   ufcs_receiver_ = std::move(buf).str();
 }
 
-// Returns the inner member and the replacement string.
-static std::pair<clang::MemberExpr *, std::string>
-replaceNonUniformLibcField(clang::MemberExpr *expr) {
-  // Example: ::struct stat::st_mtim::tv_sec -> ::libc::stat::st_mtime
-  struct Mapping {
-    const char *record;
-    const char *inner_field;
-    const char *leaf_field;
-    const char *replacement;
-  };
-  static constexpr Mapping kFields[] = {
-      {"stat", "st_mtim", "tv_sec", "st_mtime"},      // Linux
-      {"stat", "st_mtimespec", "tv_sec", "st_mtime"}, // macOS
-      {"in6_addr", "__in6_u", "__u6_addr8", "s6_addr"},
-  };
-
-  auto getNamedIdentifierOrNull = [](auto *decl) {
-    return decl && decl->getDeclName().isIdentifier() ? decl : nullptr;
-  };
-
-  if (auto leaf = getNamedIdentifierOrNull(expr->getMemberDecl())) {
-    if (auto inner = clang::dyn_cast<clang::MemberExpr>(
-            expr->getBase()->IgnoreParenImpCasts())) {
-      if (auto field = getNamedIdentifierOrNull(
-              clang::dyn_cast<clang::FieldDecl>(inner->getMemberDecl()))) {
-        if (getNamedIdentifierOrNull(field->getParent())) {
-          for (const auto &m : kFields) {
-            if (field->getParent()->getName() == m.record &&
-                field->getName() == m.inner_field &&
-                leaf->getName() == m.leaf_field) {
-              return {inner, m.replacement};
-            }
-          }
-        }
-      }
-    }
-  }
-  return {nullptr, ""};
-}
-
 void Converter::ConvertMemberExpr(clang::MemberExpr *expr) {
   if (auto mapped = GetMappedAsString(expr); !mapped.empty()) {
     if (RuleRegistry::ReturnsPointer(ctx_, expr)) {
@@ -3387,7 +3347,7 @@ void Converter::ConvertMemberExpr(clang::MemberExpr *expr) {
   }
 
   auto *member = expr->getMemberDecl();
-  auto [inner, name_override] = replaceNonUniformLibcField(expr);
+  auto [inner, record, name_override] = ReplaceNonUniformLibcField(expr);
   if (inner) {
     expr = inner;
   }

cpp2rust/converter/converter_lib.cpp

@@ -211,6 +211,46 @@ bool IsUnionArrayMember(const clang::Expr *base) {
   return false;
 }
 
+// TODO: this will be gone when the AST matcher lands
+std::tuple<clang::MemberExpr *, clang::RecordDecl *, std::string>
+ReplaceNonUniformLibcField(clang::MemberExpr *expr) {
+  // Example: ::struct stat::st_mtim::tv_sec -> ::libc::stat::st_mtime
+  struct Mapping {
+    const char *record;
+    const char *inner_field;
+    const char *leaf_field;
+    const char *replacement;
+  };
+  static constexpr Mapping kFields[] = {
+      {"stat", "st_mtim", "tv_sec", "st_mtime"},      // Linux
+      {"stat", "st_mtimespec", "tv_sec", "st_mtime"}, // macOS
+      {"in6_addr", "__in6_u", "__u6_addr8", "s6_addr"},
+  };
+
+  auto getNamedIdentifierOrNull = [](auto *decl) {
+    return decl && decl->getDeclName().isIdentifier() ? decl : nullptr;
+  };
+
+  if (auto leaf = getNamedIdentifierOrNull(expr->getMemberDecl())) {
+    if (auto inner = clang::dyn_cast<clang::MemberExpr>(
+            expr->getBase()->IgnoreParenImpCasts())) {
+      if (auto field = getNamedIdentifierOrNull(
+              clang::dyn_cast<clang::FieldDecl>(inner->getMemberDecl()))) {
+        if (getNamedIdentifierOrNull(field->getParent())) {
+          for (const auto &m : kFields) {
+            if (field->getParent()->getName() == m.record &&
+                field->getName() == m.inner_field &&
+                leaf->getName() == m.leaf_field) {
+              return {inner, field->getParent(), m.replacement};
+            }
+          }
+        }
+      }
+    }
+  }
+  return {nullptr, nullptr, ""};
+}
+
 bool IsStringLiteralExpr(const clang::Expr *expr) {
   const auto *stripped = expr->IgnoreParens()->IgnoreImplicit();
   return clang::isa<clang::StringLiteral>(stripped) ||

cpp2rust/converter/converter_lib.h

@@ -15,6 +15,7 @@
 #include <optional>
 #include <string>
 #include <string_view>
+#include <tuple>
 #include <unordered_set>
 #include <vector>
 
@@ -56,6 +57,9 @@ bool IsInMainFile(const clang::Decl *decl);
 
 bool IsUnionArrayMember(const clang::Expr *base);
 
+std::tuple<clang::MemberExpr *, clang::RecordDecl *, std::string>
+ReplaceNonUniformLibcField(clang::MemberExpr *expr);
+
 bool IsStringLiteralExpr(const clang::Expr *expr);
 
 bool IsCodeUnitStringLiteral(const clang::StringLiteral *expr);

cpp2rust/converter/models/boxed_vars.cpp

@@ -214,8 +214,9 @@ class AddressTakenVisitor
   void AddValueUse(clang::Expr *expr, bool write = false) {
     expr = expr->IgnoreParens();
     if (auto *member = clang::dyn_cast<clang::MemberExpr>(expr)) {
-      if (!member->isArrow() &&
-          clang::isa<clang::FieldDecl>(member->getMemberDecl())) {
+      auto *field = clang::dyn_cast<clang::FieldDecl>(member->getMemberDecl());
+      // A union member is accessed through a pointer to the union.
+      if (!member->isArrow() && field && !field->getParent()->isUnion()) {
         AddValueUse(member->getBase(), write);
       }
     } else if (auto *subscript =

cpp2rust/converter/models/converter_refcount.cpp

@@ -726,8 +726,7 @@ void ConverterRefCount::EmitRustUnion(clang::RecordDecl *decl) {
                     field->getType()->getAsArrayTypeUnsafe()->getElementType())
               : ToString(field->getType());
       StrCat(std::format(
-          "pub fn {}(&self) -> Ptr<{}> {{ (self.__bytes.as_pointer() "
-          "as Ptr<u8>).reinterpret_cast() }}",
+          "pub fn {}(this: Ptr<Self>) -> Ptr<{}> {{ this.reinterpret_cast() }}",
           GetNamedDeclAsString(field), ty));
     }
   }
@@ -1918,14 +1917,18 @@ bool ConverterRefCount::VisitCXXStdInitializerListExpr(
 
 void ConverterRefCount::ConvertUnionMemberAccessor(clang::MemberExpr *expr) {
   auto member = expr->getMemberDecl();
-  std::string str;
-  {
-    Buffer buf(*this);
-    PushExprKind push(*this, ExprKind::RValue);
-    Converter::ConvertMemberExpr(expr);
-    str = std::move(buf).str();
-  }
-  str += "()";
+  auto *record = clang::cast<clang::RecordDecl>(member->getDeclContext());
+  auto name = GetNamedDeclAsString(member);
+  auto *accessed = expr;
+  if (auto [inner, libc_record, libc_name] = ReplaceNonUniformLibcField(expr);
+      inner) {
+    record = libc_record;
+    name = libc_name;
+    accessed = inner;
+  }
+  auto ptr = ConvertRecordPtr(accessed);
+  auto str = std::format("{}::{}({}{})", GetRecordName(record), name, ptr,
+                         isFresh() ? "" : ".clone()");
 
   if (isAddrOf()) {
     if (member->getType()->isArrayType()) {

rules/ip/shim.rs

@@ -1,7 +1,7 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-use crate::{AsPointer, ByteRepr, DeepClone, Ptr, Record, Value};
+use crate::{ByteRepr, DeepClone, Ptr, Record, Value};
 use std::cell::RefCell;
 use std::rc::Rc;
 
@@ -21,8 +21,8 @@ pub struct In6Addr {
 }
 
 impl In6Addr {
-    pub fn s6_addr(&self) -> Ptr<u8> {
-        self.s6_addr.as_pointer()
+    pub fn s6_addr(this: Ptr<Self>) -> Ptr<u8> {
+        this.reinterpret_cast()
     }
 }