Make substring field test independent of std::string layout

The field-receiver case kept a std::string by value in a struct, so the
refcount expected output recorded libstdc++'s 32-byte layout and failed
on libc++, where std::string is 24 bytes. Reach the string through a
reference member instead: substr still takes its receiver from a struct
field, and the emitted layout is only the pointer-sized field.

Signed-off-by: Perfloop Agent <agent@perfloop.ai>
Signed-off-by: Tomás Senart <ts@perfloop.ai>

Author: perfloop-agent

tests/unit/out/refcount/string_substr.rs

@@ -6,24 +6,12 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, MoveAssign)]
-#[byte_size(32)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[byte_size(8)]
 pub struct Text {
     #[offset(0)]
-    #[byte_size(32)]
-    pub value: Vec<i8>,
-}
-impl Text {
-    pub fn move_from(_a0: Ptr<Text>) -> Self {
-        Self {
-            value: field!(_a0, value).with_mut(std::mem::take),
-        }
-    }
-}
-impl Default for Text {
-    fn default() -> Self {
-        { Text { value: vec![0] } }
-    }
+    #[byte_size(8)]
+    pub value: Ptr<Vec<i8>>,
 }
 pub fn receiver_0(s: Ptr<Vec<i8>>, calls: Ptr<i32>) -> Ptr<Vec<i8>> {
     calls.with_mut(|__v| __v.prefix_inc());
@@ -181,16 +169,17 @@ fn main_0() -> i32 {
             }),
         });
     println!("empty: {}", ((*out.borrow()).len() - 1));
+    let field: Value<Vec<i8>> = Rc::new(RefCell::new({
+        let mut __bytes = Ptr::<i8>::from_string_literal(b"hello").to_c_bytes();
+        __bytes.push(0);
+        __bytes
+    }));
     let text: Value<Text> = Rc::new(RefCell::new(Text {
-        value: {
-            let mut __bytes = Ptr::<i8>::from_string_literal(b"hello").to_c_bytes();
-            __bytes.push(0);
-            __bytes
-        },
+        value: field.as_pointer(),
     }));
     out.as_pointer().write(
         match (
-            field_ref!(text.as_pointer(), value).as_pointer(),
+            ({ (*text.borrow()).value.clone() }).clone(),
             1_usize,
             2_usize,
         ) {
@@ -206,7 +195,7 @@ fn main_0() -> i32 {
     println!(
         "field: {} {}",
         out.decay(),
-        field_ref!(text.as_pointer(), value).decay()
+        { (*text.borrow()).value.clone() }.decay()
     );
     let strings: Value<Vec<Vec<i8>>> = Rc::new(RefCell::new(Vec::from([
         {
@@ -239,13 +228,4 @@ fn main_0() -> i32 {
     println!("element: {} {}", out.decay(), index);
     return 0;
 }
-pub trait TextImpl {
-    fn move_assign(&self, _a0: Ptr<Text>) -> Ptr<Text>;
-}
-impl TextImpl for Ptr<Text> {
-    fn move_assign(&self, _a0: Ptr<Text>) -> Ptr<Text> {
-        field!((*self), value).write({ { (*_a0.upgrade().deref()).value.clone() } });
-        return (*self).clone();
-    }
-}
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/string_substr.rs

@@ -7,26 +7,9 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 #[repr(C)]
-#[derive(Clone, VaArg, FnPtrArg, MoveCtorUnsafe, MoveAssignUnsafe)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
 pub struct Text {
-    pub value: Vec<libc::c_char>,
-}
-impl Text {
-    pub unsafe fn move_from(_a0: *mut Text) -> Self {
-        let mut this = Self {
-            value: std::mem::take(&mut (*_a0).value),
-        };
-        this
-    }
-    pub unsafe fn move_assign(&mut self, _a0: *mut Text) -> *mut Text {
-        self.value = ((*_a0).value).clone();
-        return &mut (*(self as *mut Text));
-    }
-}
-impl Default for Text {
-    fn default() -> Self {
-        unsafe { Text { value: vec![0] } }
-    }
+    pub value: *mut Vec<libc::c_char>,
 }
 pub unsafe fn receiver_0(s: *mut Vec<libc::c_char>, calls: *mut i32) -> *mut Vec<libc::c_char> {
     (*calls).prefix_inc();
@@ -206,18 +189,12 @@ unsafe fn main_0() -> i32 {
             (out.len() - 1),
         )
     });
-    let mut text: Text = Text {
-        value: {
-            let s = c"hello".as_ptr();
-            std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1)
-                .to_vec()
-        },
+    let mut field: Vec<libc::c_char> = {
+        let s = c"hello".as_ptr();
+        std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
     };
-    out = match (
-        (&mut text.value as *const Vec<libc::c_char>),
-        1_usize,
-        2_usize,
-    ) {
+    let mut text: Text = Text { value: &mut field };
+    out = match ((text.value as *const Vec<libc::c_char>), 1_usize, 2_usize) {
         (__source, __pos, __count) => {
             let __s = &*__source;
             let mut __tmp1 = __s[__pos..::std::cmp::min(__pos + __count, __s.len() - 1)].to_vec();
@@ -229,7 +206,7 @@ unsafe fn main_0() -> i32 {
         libc::printf(
             c"field: %s %s\n".as_ptr() as *const libc::c_char,
             (out.as_ptr()),
-            (text.value.as_ptr()),
+            ((*text.value).as_ptr()),
         )
     });
     let mut strings: Vec<Vec<libc::c_char>> = Vec::from([

tests/unit/string_substr.cpp

@@ -4,7 +4,7 @@
 #include <vector>
 
 struct Text {
-  std::string value;
+  std::string &value;
 };
 
 std::string &receiver(std::string &s, int &calls) {
@@ -44,7 +44,8 @@ int main() {
   out = s.substr(s.size(), 0);
   printf("empty: %zu\n", out.size());
 
-  Text text{"hello"};
+  std::string field = "hello";
+  Text text{field};
   out = text.value.substr(1, 2);
   printf("field: %s %s\n", out.c_str(), text.value.c_str());
   std::vector<std::string> strings = {"hello", "world"};