Allow enums to have byterepr

lucic71 · lucic71 · commit e6a5b18eaf9c · 2026-06-25T16:39:00.000+01:00
diff --git a/cpp2rust/converter/converter_lib.cpp b/cpp2rust/converter/converter_lib.cpp
@@ -201,10 +201,7 @@ bool IsMut(clang::QualType qual_type) {
 }
 
 bool TypeImplementsByteRepr(clang::QualType qt) {
-  if (qt->isEnumeralType()) {
-    return false;
-  }
-  if (qt->isIntegerType() || qt->isFloatingType()) {
+  if (qt->isIntegerType() || qt->isFloatingType() || qt->isEnumeralType()) {
     return true;
   }
   if (const auto *arr = qt->getAsArrayTypeUnsafe()) {
diff --git a/libcc2rs/src/rc.rs b/libcc2rs/src/rc.rs
@@ -84,8 +84,8 @@ impl<T> fmt::Debug for PtrKind<T> {
             PtrKind::HeapSingle(w) => write!(f, "HeapSingle({:?})", w.as_ptr()),
             PtrKind::StackArray(w) => write!(f, "StackArray({:?})", w.as_ptr()),
             PtrKind::HeapArray(w) => write!(f, "HeapArray({:?})", w.as_ptr()),
-            PtrKind::Reinterpreted(view) => {
-                write!(f, "Reinterpreted(0x{:x})", view.alloc.address())
+            PtrKind::Reinterpreted(data) => {
+                write!(f, "Reinterpreted(0x{:x})", data.alloc.address())
             }
         }
     }
@@ -100,7 +100,7 @@ impl<T> Clone for PtrKind<T> {
             PtrKind::HeapSingle(weak) => PtrKind::HeapSingle(weak.clone()),
             PtrKind::StackArray(weak) => PtrKind::StackArray(weak.clone()),
             PtrKind::HeapArray(weak) => PtrKind::HeapArray(weak.clone()),
-            PtrKind::Reinterpreted(view) => PtrKind::Reinterpreted(Rc::clone(view)),
+            PtrKind::Reinterpreted(data) => PtrKind::Reinterpreted(Rc::clone(data)),
         }
     }
 }
@@ -112,7 +112,7 @@ impl<T> PtrKind<T> {
             PtrKind::StackSingle(w) | PtrKind::HeapSingle(w) => w.as_ptr() as usize,
             PtrKind::Vec(w) => w.as_ptr() as usize,
             PtrKind::StackArray(w) | PtrKind::HeapArray(w) => w.as_ptr() as usize,
-            PtrKind::Reinterpreted(view) => view.alloc.address(),
+            PtrKind::Reinterpreted(data) => data.alloc.address(),
         }
     }
 }
@@ -258,7 +258,7 @@ impl<T> Ptr<T> {
     #[inline]
     fn elem_step(&self) -> usize {
         match &self.kind {
-            PtrKind::Reinterpreted(view) => view.elem_byte_size,
+            PtrKind::Reinterpreted(data) => data.elem_byte_size,
             _ => 1,
         }
     }
@@ -272,7 +272,7 @@ impl<T> Ptr<T> {
             PtrKind::StackArray(weak) | PtrKind::HeapArray(weak) => {
                 weak.upgrade().expect("ub: dangling pointer").borrow().len()
             }
-            PtrKind::Reinterpreted(view) => view.alloc.total_byte_len() / view.elem_byte_size,
+            PtrKind::Reinterpreted(data) => data.alloc.total_byte_len() / data.elem_byte_size,
         }
     }
 
@@ -291,7 +291,7 @@ impl<T> Ptr<T> {
                 .expect("ub: dangling pointer")
                 .borrow()
                 .is_empty(),
-            PtrKind::Reinterpreted(view) => self.offset >= view.alloc.total_byte_len(),
+            PtrKind::Reinterpreted(data) => self.offset >= data.alloc.total_byte_len(),
         }
     }
 
@@ -346,8 +346,8 @@ impl<T> Ptr<T> {
                 rc: weak.upgrade().expect("ub: dangling pointer"),
                 offset: self.offset,
             },
-            PtrKind::Reinterpreted(view) => StrongPtr::Reinterpreted {
-                alloc: Rc::clone(&view.alloc),
+            PtrKind::Reinterpreted(data) => StrongPtr::Reinterpreted {
+                alloc: Rc::clone(&data.alloc),
                 byte_offset: self.offset,
                 cell: RefCell::new(None),
             },
@@ -372,10 +372,10 @@ impl<T> Ptr<T> {
                 let rc = weak.upgrade().expect("ub: dangling pointer");
                 rc.borrow_mut()[self.offset] = value;
             }
-            PtrKind::Reinterpreted(view) => {
+            PtrKind::Reinterpreted(data) => {
                 let mut buf = vec![0u8; T::byte_size()];
                 value.to_bytes(&mut buf);
-                view.alloc.write_bytes(self.offset, &buf);
+                data.alloc.write_bytes(self.offset, &buf);
             }
         }
     }
@@ -417,7 +417,7 @@ impl<T> Ptr<T> {
                 Rc::new(SliceOriginalAlloc { weak: weak.clone() }),
                 src_byte_off,
             ),
-            PtrKind::Reinterpreted(view) => (Rc::clone(&view.alloc), self.offset),
+            PtrKind::Reinterpreted(data) => (Rc::clone(&data.alloc), self.offset),
         };
 
         Ptr {
@@ -452,13 +452,13 @@ impl<T> Ptr<T> {
                 let mut borrow = rc.borrow_mut();
                 f(&mut borrow[self.offset])
             }
-            PtrKind::Reinterpreted(view) => {
+            PtrKind::Reinterpreted(data) => {
                 let mut buf = vec![0u8; T::byte_size()];
-                view.alloc.read_bytes(self.offset, &mut buf);
+                data.alloc.read_bytes(self.offset, &mut buf);
                 let mut val = T::from_bytes(&buf);
                 let ret = f(&mut val);
                 val.to_bytes(&mut buf);
-                view.alloc.write_bytes(self.offset, &buf);
+                data.alloc.write_bytes(self.offset, &buf);
                 ret
             }
         }
@@ -485,9 +485,9 @@ impl<T> Ptr<T> {
                 let borrow = rc.borrow();
                 f(&borrow[self.offset])
             }
-            PtrKind::Reinterpreted(view) => {
+            PtrKind::Reinterpreted(data) => {
                 let mut buf = vec![0u8; T::byte_size()];
-                view.alloc.read_bytes(self.offset, &mut buf);
+                data.alloc.read_bytes(self.offset, &mut buf);
                 let val = T::from_bytes(&buf);
                 f(&val)
             }
@@ -512,9 +512,9 @@ impl<T: Clone + ByteRepr> Ptr<T> {
             PtrKind::StackArray(ref weak) | PtrKind::HeapArray(ref weak) => {
                 weak.upgrade().expect("ub: dangling pointer").borrow()[self.offset].clone()
             }
-            PtrKind::Reinterpreted(ref view) => {
+            PtrKind::Reinterpreted(ref data) => {
                 let mut buf = vec![0u8; T::byte_size()];
-                view.alloc.read_bytes(self.offset, &mut buf);
+                data.alloc.read_bytes(self.offset, &mut buf);
                 T::from_bytes(&buf)
             }
         }
@@ -909,7 +909,7 @@ impl<T> fmt::Debug for Ptr<T> {
                 (Weak::as_ptr(w) as usize).wrapping_add(self.byte_offset())
             }
             PtrKind::Vec(w) => (Weak::as_ptr(w) as usize).wrapping_add(self.byte_offset()),
-            PtrKind::Reinterpreted(view) => view.alloc.address().wrapping_add(self.byte_offset()),
+            PtrKind::Reinterpreted(data) => data.alloc.address().wrapping_add(self.byte_offset()),
         };
         write!(f, "0x{:x}", addr)
     }
@@ -1005,9 +1005,9 @@ impl Ptr<u8> {
                 let raw = strong.borrow();
                 raw[start..end].to_vec()
             }
-            PtrKind::Reinterpreted(ref view) => {
+            PtrKind::Reinterpreted(ref data) => {
                 let mut buf = vec![0u8; end.wrapping_sub(start)];
-                view.alloc.read_bytes(start, &mut buf);
+                data.alloc.read_bytes(start, &mut buf);
                 buf
             }
         }
diff --git a/tests/unit/out/refcount/anonymous_enum.rs b/tests/unit/out/refcount/anonymous_enum.rs
@@ -22,6 +22,14 @@ impl From<i32> for anon_0 {
     }
 }
 libcc2rs::impl_enum_inc_dec!(anon_0);
+impl ByteRepr for anon_0 {
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <anon_0>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum anon_1 {
     #[default]
@@ -38,6 +46,14 @@ impl From<i32> for anon_1 {
     }
 }
 libcc2rs::impl_enum_inc_dec!(anon_1);
+impl ByteRepr for anon_1 {
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <anon_1>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Default)]
 pub struct S {
     pub a: Value<i32>,
@@ -79,6 +95,14 @@ impl From<i32> for TdEnum {
     }
 }
 libcc2rs::impl_enum_inc_dec!(TdEnum);
+impl ByteRepr for TdEnum {
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <TdEnum>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum anon_2 {
     #[default]
@@ -95,6 +119,14 @@ impl From<i32> for anon_2 {
     }
 }
 libcc2rs::impl_enum_inc_dec!(anon_2);
+impl ByteRepr for anon_2 {
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <anon_2>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Default)]
 pub struct WithAnonField {
     pub a: Value<i32>,
@@ -109,7 +141,21 @@ impl Clone for WithAnonField {
         this
     }
 }
-impl ByteRepr for WithAnonField {}
+impl ByteRepr for WithAnonField {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.a.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.field.borrow()).to_bytes(&mut buf[4..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            a: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            field: Rc::new(RefCell::new(<anon_2>::from_bytes(&buf[4..8]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
@@ -130,6 +176,14 @@ fn main_0() -> i32 {
         }
     }
     libcc2rs::impl_enum_inc_dec!(anon_3);
+    impl ByteRepr for anon_3 {
+        fn to_bytes(&self, buf: &mut [u8]) {
+            (*self as i32).to_bytes(buf);
+        }
+        fn from_bytes(buf: &[u8]) -> Self {
+            <anon_3>::from(i32::from_bytes(buf))
+        }
+    };
     assert!(((anon_0::FIRST_A as i32) != (anon_0::FIRST_B as i32)));
     assert!(((anon_1::SECOND_A as i32) != (anon_1::SECOND_B as i32)));
     assert!(((anon_3::THIRD_A as i32) != (anon_3::THIRD_B as i32)));
diff --git a/tests/unit/out/refcount/anonymous_enum_c.rs b/tests/unit/out/refcount/anonymous_enum_c.rs
@@ -22,6 +22,14 @@ impl From<i32> for anon_0 {
     }
 }
 libcc2rs::impl_enum_inc_dec!(anon_0);
+impl ByteRepr for anon_0 {
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <anon_0>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum anon_1 {
     #[default]
@@ -38,6 +46,14 @@ impl From<i32> for anon_1 {
     }
 }
 libcc2rs::impl_enum_inc_dec!(anon_1);
+impl ByteRepr for anon_1 {
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <anon_1>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Default)]
 pub struct S {
     pub a: Value<i32>,
@@ -71,6 +87,14 @@ impl From<i32> for TdEnum_enum {
     }
 }
 libcc2rs::impl_enum_inc_dec!(TdEnum_enum);
+impl ByteRepr for TdEnum_enum {
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <TdEnum_enum>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum anon_2 {
     #[default]
@@ -87,12 +111,34 @@ impl From<i32> for anon_2 {
     }
 }
 libcc2rs::impl_enum_inc_dec!(anon_2);
+impl ByteRepr for anon_2 {
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <anon_2>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Default)]
 pub struct WithAnonField {
     pub a: Value<i32>,
     pub field: Value<anon_2>,
 }
-impl ByteRepr for WithAnonField {}
+impl ByteRepr for WithAnonField {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.a.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.field.borrow()).to_bytes(&mut buf[4..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            a: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            field: Rc::new(RefCell::new(<anon_2>::from_bytes(&buf[4..8]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
@@ -113,6 +159,14 @@ fn main_0() -> i32 {
         }
     }
     libcc2rs::impl_enum_inc_dec!(anon_3);
+    impl ByteRepr for anon_3 {
+        fn to_bytes(&self, buf: &mut [u8]) {
+            (*self as i32).to_bytes(buf);
+        }
+        fn from_bytes(buf: &[u8]) -> Self {
+            <anon_3>::from(i32::from_bytes(buf))
+        }
+    };
     assert!(((((anon_0::FIRST_A as i32) != (anon_0::FIRST_B as i32)) as i32) != 0));
     assert!(((((anon_1::SECOND_A as i32) != (anon_1::SECOND_B as i32)) as i32) != 0));
     assert!(((((anon_3::THIRD_A as i32) != (anon_3::THIRD_B as i32)) as i32) != 0));
diff --git a/tests/unit/out/refcount/c_struct.rs b/tests/unit/out/refcount/c_struct.rs
@@ -70,6 +70,14 @@ impl From<i32> for Color {
     }
 }
 libcc2rs::impl_enum_inc_dec!(Color);
+impl ByteRepr for Color {
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Color>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Default)]
 pub struct Inner {
     pub a: Value<i32>,
@@ -96,7 +104,23 @@ pub struct Container {
     pub color: Value<Color>,
     pub count: Value<i32>,
 }
-impl ByteRepr for Container {}
+impl ByteRepr for Container {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.inner.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.color.borrow()).to_bytes(&mut buf[8..12]);
+        (*self.count.borrow()).to_bytes(&mut buf[12..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            inner: Rc::new(RefCell::new(<Inner>::from_bytes(&buf[0..8]))),
+            color: Rc::new(RefCell::new(<Color>::from_bytes(&buf[8..12]))),
+            count: Rc::new(RefCell::new(<i32>::from_bytes(&buf[12..16]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/enum_default_in_static.rs b/tests/unit/out/refcount/enum_default_in_static.rs

Original file line number	Diff line number	Diff line change
`@@ -201,10 +201,7 @@ bool IsMut(clang::QualType qual_type) {`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	`bool TypeImplementsByteRepr(clang::QualType qt) {`
`204`		`- if (qt->isEnumeralType()) {`
`205`		`- return false;`
`206`		`- }`
`207`		`- if (qt->isIntegerType() \|\| qt->isFloatingType()) {`
	`204`	`+ if (qt->isIntegerType() \|\| qt->isFloatingType() \|\| qt->isEnumeralType()) {`
`208`	`205`	`return true;`
`209`	`206`	`}`
`210`	`207`	`if (const auto *arr = qt->getAsArrayTypeUnsafe()) {`
Original file line number	Diff line number	Diff line change
`@@ -84,8 +84,8 @@ impl<T> fmt::Debug for PtrKind<T> {`
`84`	`84`	`PtrKind::HeapSingle(w) => write!(f, "HeapSingle({:?})", w.as_ptr()),`
`85`	`85`	`PtrKind::StackArray(w) => write!(f, "StackArray({:?})", w.as_ptr()),`
`86`	`86`	`PtrKind::HeapArray(w) => write!(f, "HeapArray({:?})", w.as_ptr()),`
`87`		`- PtrKind::Reinterpreted(view) => {`
`88`		`- write!(f, "Reinterpreted(0x{:x})", view.alloc.address())`
	`87`	`+ PtrKind::Reinterpreted(data) => {`
	`88`	`+ write!(f, "Reinterpreted(0x{:x})", data.alloc.address())`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`	`}`
`@@ -100,7 +100,7 @@ impl<T> Clone for PtrKind<T> {`
`100`	`100`	`PtrKind::HeapSingle(weak) => PtrKind::HeapSingle(weak.clone()),`
`101`	`101`	`PtrKind::StackArray(weak) => PtrKind::StackArray(weak.clone()),`
`102`	`102`	`PtrKind::HeapArray(weak) => PtrKind::HeapArray(weak.clone()),`
`103`		`- PtrKind::Reinterpreted(view) => PtrKind::Reinterpreted(Rc::clone(view)),`
	`103`	`+ PtrKind::Reinterpreted(data) => PtrKind::Reinterpreted(Rc::clone(data)),`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`	`}`
`@@ -112,7 +112,7 @@ impl<T> PtrKind<T> {`
`112`	`112`	`PtrKind::StackSingle(w) \| PtrKind::HeapSingle(w) => w.as_ptr() as usize,`
`113`	`113`	`PtrKind::Vec(w) => w.as_ptr() as usize,`
`114`	`114`	`PtrKind::StackArray(w) \| PtrKind::HeapArray(w) => w.as_ptr() as usize,`
`115`		`- PtrKind::Reinterpreted(view) => view.alloc.address(),`
	`115`	`+ PtrKind::Reinterpreted(data) => data.alloc.address(),`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`	`}`
`@@ -258,7 +258,7 @@ impl<T> Ptr<T> {`
`258`	`258`	`#[inline]`
`259`	`259`	`fn elem_step(&self) -> usize {`
`260`	`260`	`match &self.kind {`
`261`		`- PtrKind::Reinterpreted(view) => view.elem_byte_size,`
	`261`	`+ PtrKind::Reinterpreted(data) => data.elem_byte_size,`
`262`	`262`	`_ => 1,`
`263`	`263`	`}`
`264`	`264`	`}`
`@@ -272,7 +272,7 @@ impl<T> Ptr<T> {`
`272`	`272`	`PtrKind::StackArray(weak) \| PtrKind::HeapArray(weak) => {`
`273`	`273`	`weak.upgrade().expect("ub: dangling pointer").borrow().len()`
`274`	`274`	`}`
`275`		`- PtrKind::Reinterpreted(view) => view.alloc.total_byte_len() / view.elem_byte_size,`
	`275`	`+ PtrKind::Reinterpreted(data) => data.alloc.total_byte_len() / data.elem_byte_size,`
`276`	`276`	`}`
`277`	`277`	`}`
`278`	`278`
`@@ -291,7 +291,7 @@ impl<T> Ptr<T> {`
`291`	`291`	`.expect("ub: dangling pointer")`
`292`	`292`	`.borrow()`
`293`	`293`	`.is_empty(),`
`294`		`- PtrKind::Reinterpreted(view) => self.offset >= view.alloc.total_byte_len(),`
	`294`	`+ PtrKind::Reinterpreted(data) => self.offset >= data.alloc.total_byte_len(),`
`295`	`295`	`}`
`296`	`296`	`}`
`297`	`297`
`@@ -346,8 +346,8 @@ impl<T> Ptr<T> {`
`346`	`346`	`rc: weak.upgrade().expect("ub: dangling pointer"),`
`347`	`347`	`offset: self.offset,`
`348`	`348`	`},`
`349`		`- PtrKind::Reinterpreted(view) => StrongPtr::Reinterpreted {`
`350`		`- alloc: Rc::clone(&view.alloc),`
	`349`	`+ PtrKind::Reinterpreted(data) => StrongPtr::Reinterpreted {`
	`350`	`+ alloc: Rc::clone(&data.alloc),`
`351`	`351`	`byte_offset: self.offset,`
`352`	`352`	`cell: RefCell::new(None),`
`353`	`353`	`},`
`@@ -372,10 +372,10 @@ impl<T> Ptr<T> {`
`372`	`372`	`let rc = weak.upgrade().expect("ub: dangling pointer");`
`373`	`373`	`rc.borrow_mut()[self.offset] = value;`
`374`	`374`	`}`
`375`		`- PtrKind::Reinterpreted(view) => {`
	`375`	`+ PtrKind::Reinterpreted(data) => {`
`376`	`376`	`let mut buf = vec![0u8; T::byte_size()];`
`377`	`377`	`value.to_bytes(&mut buf);`
`378`		`- view.alloc.write_bytes(self.offset, &buf);`
	`378`	`+ data.alloc.write_bytes(self.offset, &buf);`
`379`	`379`	`}`
`380`	`380`	`}`
`381`	`381`	`}`
`@@ -417,7 +417,7 @@ impl<T> Ptr<T> {`
`417`	`417`	`Rc::new(SliceOriginalAlloc { weak: weak.clone() }),`
`418`	`418`	`src_byte_off,`
`419`	`419`	`),`
`420`		`- PtrKind::Reinterpreted(view) => (Rc::clone(&view.alloc), self.offset),`
	`420`	`+ PtrKind::Reinterpreted(data) => (Rc::clone(&data.alloc), self.offset),`
`421`	`421`	`};`
`422`	`422`
`423`	`423`	`Ptr {`
`@@ -452,13 +452,13 @@ impl<T> Ptr<T> {`
`452`	`452`	`let mut borrow = rc.borrow_mut();`
`453`	`453`	`f(&mut borrow[self.offset])`
`454`	`454`	`}`
`455`		`- PtrKind::Reinterpreted(view) => {`
	`455`	`+ PtrKind::Reinterpreted(data) => {`
`456`	`456`	`let mut buf = vec![0u8; T::byte_size()];`
`457`		`- view.alloc.read_bytes(self.offset, &mut buf);`
	`457`	`+ data.alloc.read_bytes(self.offset, &mut buf);`
`458`	`458`	`let mut val = T::from_bytes(&buf);`
`459`	`459`	`let ret = f(&mut val);`
`460`	`460`	`val.to_bytes(&mut buf);`
`461`		`- view.alloc.write_bytes(self.offset, &buf);`
	`461`	`+ data.alloc.write_bytes(self.offset, &buf);`
`462`	`462`	`ret`
`463`	`463`	`}`
`464`	`464`	`}`
`@@ -485,9 +485,9 @@ impl<T> Ptr<T> {`
`485`	`485`	`let borrow = rc.borrow();`
`486`	`486`	`f(&borrow[self.offset])`
`487`	`487`	`}`
`488`		`- PtrKind::Reinterpreted(view) => {`
	`488`	`+ PtrKind::Reinterpreted(data) => {`
`489`	`489`	`let mut buf = vec![0u8; T::byte_size()];`
`490`		`- view.alloc.read_bytes(self.offset, &mut buf);`
	`490`	`+ data.alloc.read_bytes(self.offset, &mut buf);`
`491`	`491`	`let val = T::from_bytes(&buf);`
`492`	`492`	`f(&val)`
`493`	`493`	`}`
`@@ -512,9 +512,9 @@ impl<T: Clone + ByteRepr> Ptr<T> {`
`512`	`512`	`PtrKind::StackArray(ref weak) \| PtrKind::HeapArray(ref weak) => {`
`513`	`513`	`weak.upgrade().expect("ub: dangling pointer").borrow()[self.offset].clone()`
`514`	`514`	`}`
`515`		`- PtrKind::Reinterpreted(ref view) => {`
	`515`	`+ PtrKind::Reinterpreted(ref data) => {`
`516`	`516`	`let mut buf = vec![0u8; T::byte_size()];`
`517`		`- view.alloc.read_bytes(self.offset, &mut buf);`
	`517`	`+ data.alloc.read_bytes(self.offset, &mut buf);`
`518`	`518`	`T::from_bytes(&buf)`
`519`	`519`	`}`
`520`	`520`	`}`
`@@ -909,7 +909,7 @@ impl<T> fmt::Debug for Ptr<T> {`
`909`	`909`	`(Weak::as_ptr(w) as usize).wrapping_add(self.byte_offset())`
`910`	`910`	`}`
`911`	`911`	`PtrKind::Vec(w) => (Weak::as_ptr(w) as usize).wrapping_add(self.byte_offset()),`
`912`		`- PtrKind::Reinterpreted(view) => view.alloc.address().wrapping_add(self.byte_offset()),`
	`912`	`+ PtrKind::Reinterpreted(data) => data.alloc.address().wrapping_add(self.byte_offset()),`
`913`	`913`	`};`
`914`	`914`	`write!(f, "0x{:x}", addr)`
`915`	`915`	`}`
`@@ -1005,9 +1005,9 @@ impl Ptr<u8> {`
`1005`	`1005`	`let raw = strong.borrow();`
`1006`	`1006`	`raw[start..end].to_vec()`
`1007`	`1007`	`}`
`1008`		`- PtrKind::Reinterpreted(ref view) => {`
	`1008`	`+ PtrKind::Reinterpreted(ref data) => {`
`1009`	`1009`	`let mut buf = vec![0u8; end.wrapping_sub(start)];`
`1010`		`- view.alloc.read_bytes(start, &mut buf);`
	`1010`	`+ data.alloc.read_bytes(start, &mut buf);`
`1011`	`1011`	`buf`
`1012`	`1012`	`}`
`1013`	`1013`	`}`