Access unions through Ptr<Self> (#474)

Fixes #311

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -3346,46 +3346,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)) {
@@ -3397,7 +3357,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, isLValue() ? ExprKind::LValue : 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()
     }
 }
 

tests/unit/out/refcount/tag_vs_identifier_collision.rs

@@ -34,11 +34,11 @@ pub struct point {
     __bytes: Value<Box<[u8]>>,
 }
 impl point {
-    pub fn whole(&self) -> Ptr<i32> {
-        (self.__bytes.as_pointer() as Ptr<u8>).reinterpret_cast()
+    pub fn whole(this: Ptr<Self>) -> Ptr<i32> {
+        this.reinterpret_cast()
     }
-    pub fn half(&self) -> Ptr<i16> {
-        (self.__bytes.as_pointer() as Ptr<u8>).reinterpret_cast()
+    pub fn half(this: Ptr<Self>) -> Ptr<i16> {
+        this.reinterpret_cast()
     }
 }
 impl Default for point {
@@ -56,11 +56,11 @@ pub struct slot_union {
     __bytes: Value<Box<[u8]>>,
 }
 impl slot_union {
-    pub fn i(&self) -> Ptr<i32> {
-        (self.__bytes.as_pointer() as Ptr<u8>).reinterpret_cast()
+    pub fn i(this: Ptr<Self>) -> Ptr<i32> {
+        this.reinterpret_cast()
     }
-    pub fn u(&self) -> Ptr<u32> {
-        (self.__bytes.as_pointer() as Ptr<u8>).reinterpret_cast()
+    pub fn u(this: Ptr<Self>) -> Ptr<u32> {
+        this.reinterpret_cast()
     }
 }
 impl Default for slot_union {
@@ -114,11 +114,11 @@ fn main_0() -> i32 {
     p.y = 4;
     assert!(((((p.x + p.y) == 7) as i32) != 0));
     let up: Value<point> = <Value<point>>::default();
-    (*up.borrow_mut()).whole().write(5);
-    assert!((((((*up.borrow()).whole().read()) == 5) as i32) != 0));
+    point::whole(up.as_pointer()).write(5);
+    assert!(((((point::whole(up.as_pointer()).read()) == 5) as i32) != 0));
     let b: Value<slot_union> = <Value<slot_union>>::default();
-    (*b.borrow_mut()).i().write(9);
-    assert!((((((*b.borrow()).i().read()) == 9) as i32) != 0));
+    slot_union::i(b.as_pointer()).write(9);
+    assert!(((((slot_union::i(b.as_pointer()).read()) == 9) as i32) != 0));
     let mut e: slot = slot_SLOT_B;
     assert!(((((e as u32) == ((slot_SLOT_B as i32) as u32)) as i32) != 0));
     let mut inner_tag: Inner = <Inner>::default();

tests/unit/out/refcount/union_addrof_external.rs

@@ -37,11 +37,11 @@ pub struct anon_0 {
     __bytes: Value<Box<[u8]>>,
 }
 impl anon_0 {
-    pub fn h(&self) -> Ptr<record> {
-        (self.__bytes.as_pointer() as Ptr<u8>).reinterpret_cast()
+    pub fn h(this: Ptr<Self>) -> Ptr<record> {
+        this.reinterpret_cast()
     }
-    pub fn raw_(&self) -> Ptr<i8> {
-        (self.__bytes.as_pointer() as Ptr<u8>).reinterpret_cast()
+    pub fn raw_(this: Ptr<Self>) -> Ptr<i8> {
+        this.reinterpret_cast()
     }
 }
 impl Default for anon_0 {
@@ -101,10 +101,14 @@ fn main_0() -> i32 {
         let _cap: usize = 128usize;
         fill_1(_out, _cap)
     });
-    assert!((((((*c.borrow()).view.h().with(|__s| __s.code) as i32) == 2) as i32) != 0));
+    assert!(
+        ((((anon_0::h(field_ptr!(c.as_pointer(), view)).with(|__s| __s.code) as i32) == 2) as i32)
+            != 0)
+    );
     assert!(
         (((((elem!(
-            ((field_ptr!((*c.borrow()).view.h(), lo)).reinterpret_cast::<u8>()),
+            ((field_ptr!(anon_0::h(field_ptr!(c.as_pointer(), view)), lo))
+                .reinterpret_cast::<u8>()),
             0
         )
         .read()) as i32)
@@ -113,7 +117,8 @@ fn main_0() -> i32 {
     );
     assert!(
         (((((elem!(
-            ((field_ptr!((*c.borrow()).view.h(), lo)).reinterpret_cast::<u8>()),
+            ((field_ptr!(anon_0::h(field_ptr!(c.as_pointer(), view)), lo))
+                .reinterpret_cast::<u8>()),
             1
         )
         .read()) as i32)
@@ -122,7 +127,7 @@ fn main_0() -> i32 {
     );
     assert!(
         (((((elem!(
-            ((*c.borrow()).view.raw_().reinterpret_cast::<i8>() as Ptr::<i8>),
+            (anon_0::raw_(field_ptr!(c.as_pointer(), view)).reinterpret_cast::<i8>() as Ptr::<i8>),
             0
         )
         .read()) as i32)
@@ -131,7 +136,7 @@ fn main_0() -> i32 {
     );
     assert!(
         ((((((elem!(
-            ((*c.borrow()).view.raw_().reinterpret_cast::<i8>() as Ptr::<i8>),
+            (anon_0::raw_(field_ptr!(c.as_pointer(), view)).reinterpret_cast::<i8>() as Ptr::<i8>),
             3
         )
         .read()) as u8) as i32)

tests/unit/out/refcount/union_basic.rs

@@ -14,11 +14,11 @@ pub struct basic {
     __bytes: Value<Box<[u8]>>,
 }
 impl basic {
-    pub fn i(&self) -> Ptr<i32> {
-        (self.__bytes.as_pointer() as Ptr<u8>).reinterpret_cast()
+    pub fn i(this: Ptr<Self>) -> Ptr<i32> {
+        this.reinterpret_cast()
     }
-    pub fn f(&self) -> Ptr<f32> {
-        (self.__bytes.as_pointer() as Ptr<u8>).reinterpret_cast()
+    pub fn f(this: Ptr<Self>) -> Ptr<f32> {
+        this.reinterpret_cast()
     }
 }
 impl Default for basic {
@@ -51,10 +51,26 @@ fn main_0() -> i32 {
     let u: Value<basic> = Rc::new(RefCell::new(<basic>::default()));
     let e: Value<empty> = Rc::new(RefCell::new(<empty>::default()));
     &(*e.borrow_mut());
-    (*u.borrow_mut()).i().write(42);
-    assert!((((*u.borrow()).i().read()) == 42));
-    (*u.borrow_mut()).f().write(3.140000105E+0);
-    assert!((((*u.borrow()).f().read()) == 3.140000105E+0));
+    basic::i(u.as_pointer()).write(42);
+    assert!(((basic::i(u.as_pointer()).read()) == 42));
+    basic::f(u.as_pointer()).write(3.140000105E+0);
+    assert!(((basic::f(u.as_pointer()).read()) == 3.140000105E+0));
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new((0..4).map(|_| 0_u8).collect::<Box<[u8]>>()));
+    {
+        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+            .to_any()
+            .memset((0) as u8, ::std::mem::size_of::<[u8; 4]>() as usize);
+        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any()
+    };
+    let mut ru: Ptr<basic> = (buf.as_pointer() as Ptr<u8>).reinterpret_cast::<basic>();
+    let mut pi: Ptr<i32> = (basic::i(ru.clone())).clone();
+    let mut pf: Ptr<f32> = (basic::f(ru.clone())).clone();
+    basic::i(ru.clone()).write(7);
+    assert!(((pi.read()) == 7));
+    pi.write(1065353216);
+    assert!(((basic::i(ru.clone()).read()) == 1065353216));
+    assert!(((pf.read()) == 1.0E+0));
+    assert!((((*buf.borrow())[(3) as usize] as i32) == 63));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}