library/core/tests/ptr.rs

   1 use core::cell::RefCell;
   2 use core::ptr;
   3 use core::ptr::*;
   4 use std::fmt::{Debug, Display};
   5
   6 #[test]
   7 fn test_const_from_raw_parts() {
   8     const SLICE: &[u8] = &[1, 2, 3, 4];
   9     const FROM_RAW: &[u8] = unsafe { &*slice_from_raw_parts(SLICE.as_ptr(), SLICE.len()) };
  10     assert_eq!(SLICE, FROM_RAW);
  11
  12     let slice = &[1, 2, 3, 4, 5];
  13     let from_raw = unsafe { &*slice_from_raw_parts(slice.as_ptr(), 2) };
  14     assert_eq!(&slice[..2], from_raw);
  15 }
  16
  17 #[test]
  18 fn test() {
  19     unsafe {
  20         struct Pair {
  21             fst: isize,
  22             snd: isize,
  23         }
  24         let mut p = Pair { fst: 10, snd: 20 };
  25         let pptr: *mut Pair = &mut p;
  26         let iptr: *mut isize = pptr as *mut isize;
  27         assert_eq!(*iptr, 10);
  28         *iptr = 30;
  29         assert_eq!(*iptr, 30);
  30         assert_eq!(p.fst, 30);
  31
  32         *pptr = Pair { fst: 50, snd: 60 };
  33         assert_eq!(*iptr, 50);
  34         assert_eq!(p.fst, 50);
  35         assert_eq!(p.snd, 60);
  36
  37         let v0 = vec![32000u16, 32001u16, 32002u16];
  38         let mut v1 = vec![0u16, 0u16, 0u16];
  39
  40         copy(v0.as_ptr().offset(1), v1.as_mut_ptr().offset(1), 1);
  41         assert!((v1[0] == 0u16 && v1[1] == 32001u16 && v1[2] == 0u16));
  42         copy(v0.as_ptr().offset(2), v1.as_mut_ptr(), 1);
  43         assert!((v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 0u16));
  44         copy(v0.as_ptr(), v1.as_mut_ptr().offset(2), 1);
  45         assert!((v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 32000u16));
  46     }
  47 }
  48
  49 #[test]
  50 fn test_is_null() {
  51     let p: *const isize = null();
  52     assert!(p.is_null());
  53
  54     let q = p.wrapping_offset(1);
  55     assert!(!q.is_null());
  56
  57     let mp: *mut isize = null_mut();
  58     assert!(mp.is_null());
  59
  60     let mq = mp.wrapping_offset(1);
  61     assert!(!mq.is_null());
  62
  63     // Pointers to unsized types -- slices
  64     let s: &mut [u8] = &mut [1, 2, 3];
  65     let cs: *const [u8] = s;
  66     assert!(!cs.is_null());
  67
  68     let ms: *mut [u8] = s;
  69     assert!(!ms.is_null());
  70
  71     let cz: *const [u8] = &[];
  72     assert!(!cz.is_null());
  73
  74     let mz: *mut [u8] = &mut [];
  75     assert!(!mz.is_null());
  76
  77     let ncs: *const [u8] = null::<[u8; 3]>();
  78     assert!(ncs.is_null());
  79
  80     let nms: *mut [u8] = null_mut::<[u8; 3]>();
  81     assert!(nms.is_null());
  82
  83     // Pointers to unsized types -- trait objects
  84     let ci: *const dyn ToString = &3;
  85     assert!(!ci.is_null());
  86
  87     let mi: *mut dyn ToString = &mut 3;
  88     assert!(!mi.is_null());
  89
  90     let nci: *const dyn ToString = null::<isize>();
  91     assert!(nci.is_null());
  92
  93     let nmi: *mut dyn ToString = null_mut::<isize>();
  94     assert!(nmi.is_null());
  95 }
  96
  97 #[test]
  98 fn test_as_ref() {
  99     unsafe {
 100         let p: *const isize = null();
 101         assert_eq!(p.as_ref(), None);
 102
 103         let q: *const isize = &2;
 104         assert_eq!(q.as_ref().unwrap(), &2);
 105
 106         let p: *mut isize = null_mut();
 107         assert_eq!(p.as_ref(), None);
 108
 109         let q: *mut isize = &mut 2;
 110         assert_eq!(q.as_ref().unwrap(), &2);
 111
 112         // Lifetime inference
 113         let u = 2isize;
 114         {
 115             let p = &u as *const isize;
 116             assert_eq!(p.as_ref().unwrap(), &2);
 117         }
 118
 119         // Pointers to unsized types -- slices
 120         let s: &mut [u8] = &mut [1, 2, 3];
 121         let cs: *const [u8] = s;
 122         assert_eq!(cs.as_ref(), Some(&*s));
 123
 124         let ms: *mut [u8] = s;
 125         assert_eq!(ms.as_ref(), Some(&*s));
 126
 127         let cz: *const [u8] = &[];
 128         assert_eq!(cz.as_ref(), Some(&[][..]));
 129
 130         let mz: *mut [u8] = &mut [];
 131         assert_eq!(mz.as_ref(), Some(&[][..]));
 132
 133         let ncs: *const [u8] = null::<[u8; 3]>();
 134         assert_eq!(ncs.as_ref(), None);
 135
 136         let nms: *mut [u8] = null_mut::<[u8; 3]>();
 137         assert_eq!(nms.as_ref(), None);
 138
 139         // Pointers to unsized types -- trait objects
 140         let ci: *const dyn ToString = &3;
 141         assert!(ci.as_ref().is_some());
 142
 143         let mi: *mut dyn ToString = &mut 3;
 144         assert!(mi.as_ref().is_some());
 145
 146         let nci: *const dyn ToString = null::<isize>();
 147         assert!(nci.as_ref().is_none());
 148
 149         let nmi: *mut dyn ToString = null_mut::<isize>();
 150         assert!(nmi.as_ref().is_none());
 151     }
 152 }
 153
 154 #[test]
 155 fn test_as_mut() {
 156     unsafe {
 157         let p: *mut isize = null_mut();
 158         assert!(p.as_mut() == None);
 159
 160         let q: *mut isize = &mut 2;
 161         assert!(q.as_mut().unwrap() == &mut 2);
 162
 163         // Lifetime inference
 164         let mut u = 2isize;
 165         {
 166             let p = &mut u as *mut isize;
 167             assert!(p.as_mut().unwrap() == &mut 2);
 168         }
 169
 170         // Pointers to unsized types -- slices
 171         let s: &mut [u8] = &mut [1, 2, 3];
 172         let ms: *mut [u8] = s;
 173         assert_eq!(ms.as_mut(), Some(&mut [1, 2, 3][..]));
 174
 175         let mz: *mut [u8] = &mut [];
 176         assert_eq!(mz.as_mut(), Some(&mut [][..]));
 177
 178         let nms: *mut [u8] = null_mut::<[u8; 3]>();
 179         assert_eq!(nms.as_mut(), None);
 180
 181         // Pointers to unsized types -- trait objects
 182         let mi: *mut dyn ToString = &mut 3;
 183         assert!(mi.as_mut().is_some());
 184
 185         let nmi: *mut dyn ToString = null_mut::<isize>();
 186         assert!(nmi.as_mut().is_none());
 187     }
 188 }
 189
 190 #[test]
 191 fn test_ptr_addition() {
 192     unsafe {
 193         let xs = vec![5; 16];
 194         let mut ptr = xs.as_ptr();
 195         let end = ptr.offset(16);
 196
 197         while ptr < end {
 198             assert_eq!(*ptr, 5);
 199             ptr = ptr.offset(1);
 200         }
 201
 202         let mut xs_mut = xs;
 203         let mut m_ptr = xs_mut.as_mut_ptr();
 204         let m_end = m_ptr.offset(16);
 205
 206         while m_ptr < m_end {
 207             *m_ptr += 5;
 208             m_ptr = m_ptr.offset(1);
 209         }
 210
 211         assert!(xs_mut == vec![10; 16]);
 212     }
 213 }
 214
 215 #[test]
 216 fn test_ptr_subtraction() {
 217     unsafe {
 218         let xs = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 219         let mut idx = 9;
 220         let ptr = xs.as_ptr();
 221
 222         while idx >= 0 {
 223             assert_eq!(*(ptr.offset(idx as isize)), idx as isize);
 224             idx = idx - 1;
 225         }
 226
 227         let mut xs_mut = xs;
 228         let m_start = xs_mut.as_mut_ptr();
 229         let mut m_ptr = m_start.offset(9);
 230
 231         loop {
 232             *m_ptr += *m_ptr;
 233             if m_ptr == m_start {
 234                 break;
 235             }
 236             m_ptr = m_ptr.offset(-1);
 237         }
 238
 239         assert_eq!(xs_mut, [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]);
 240     }
 241 }
 242
 243 #[test]
 244 fn test_set_memory() {
 245     let mut xs = [0u8; 20];
 246     let ptr = xs.as_mut_ptr();
 247     unsafe {
 248         write_bytes(ptr, 5u8, xs.len());
 249     }
 250     assert!(xs == [5u8; 20]);
 251 }
 252
 253 #[test]
 254 fn test_set_memory_const() {
 255     const XS: [u8; 20] = {
 256         let mut xs = [0u8; 20];
 257         let ptr = xs.as_mut_ptr();
 258         unsafe {
 259             ptr.write_bytes(5u8, xs.len());
 260         }
 261         xs
 262     };
 263
 264     assert!(XS == [5u8; 20]);
 265 }
 266
 267 #[test]
 268 fn test_unsized_nonnull() {
 269     let xs: &[i32] = &[1, 2, 3];
 270     let ptr = unsafe { NonNull::new_unchecked(xs as *const [i32] as *mut [i32]) };
 271     let ys = unsafe { ptr.as_ref() };
 272     let zs: &[i32] = &[1, 2, 3];
 273     assert!(ys == zs);
 274 }
 275
 276 #[test]
 277 fn test_const_nonnull_new() {
 278     const {
 279         assert!(NonNull::new(core::ptr::null_mut::<()>()).is_none());
 280
 281         let value = &mut 0u32;
 282         let mut ptr = NonNull::new(value).unwrap();
 283         unsafe { *ptr.as_mut() = 42 };
 284
 285         let reference = unsafe { &*ptr.as_ref() };
 286         assert!(*reference == *value);
 287         assert!(*reference == 42);
 288     };
 289 }
 290
 291 #[test]
 292 #[allow(warnings)]
 293 // Have a symbol for the test below. It doesn’t need to be an actual variadic function, match the
 294 // ABI, or even point to an actual executable code, because the function itself is never invoked.
 295 #[no_mangle]
 296 pub fn test_variadic_fnptr() {
 297     use core::hash::{Hash, SipHasher};
 298     extern "C" {
 299         fn test_variadic_fnptr(_: u64, ...) -> f64;
 300     }
 301     let p: unsafe extern "C" fn(u64, ...) -> f64 = test_variadic_fnptr;
 302     let q = p.clone();
 303     assert_eq!(p, q);
 304     assert!(!(p < q));
 305     let mut s = SipHasher::new();
 306     assert_eq!(p.hash(&mut s), q.hash(&mut s));
 307 }
 308
 309 #[test]
 310 fn write_unaligned_drop() {
 311     thread_local! {
 312         static DROPS: RefCell<Vec<u32>> = RefCell::new(Vec::new());
 313     }
 314
 315     struct Dropper(u32);
 316
 317     impl Drop for Dropper {
 318         fn drop(&mut self) {
 319             DROPS.with(|d| d.borrow_mut().push(self.0));
 320         }
 321     }
 322
 323     {
 324         let c = Dropper(0);
 325         let mut t = Dropper(1);
 326         unsafe {
 327             write_unaligned(&mut t, c);
 328         }
 329     }
 330     DROPS.with(|d| assert_eq!(*d.borrow(), [0]));
 331 }
 332
 333 #[test]
 334 fn align_offset_zst() {
 335     // For pointers of stride = 0, the pointer is already aligned or it cannot be aligned at
 336     // all, because no amount of elements will align the pointer.
 337     let mut p = 1;
 338     while p < 1024 {
 339         assert_eq!((p as *const ()).align_offset(p), 0);
 340         if p != 1 {
 341             assert_eq!(((p + 1) as *const ()).align_offset(p), !0);
 342         }
 343         p = (p + 1).next_power_of_two();
 344     }
 345 }
 346
 347 #[test]
 348 fn align_offset_stride1() {
 349     // For pointers of stride = 1, the pointer can always be aligned. The offset is equal to
 350     // number of bytes.
 351     let mut align = 1;
 352     while align < 1024 {
 353         for ptr in 1..2 * align {
 354             let expected = ptr % align;
 355             let offset = if expected == 0 { 0 } else { align - expected };
 356             assert_eq!(
 357                 (ptr as *const u8).align_offset(align),
 358                 offset,
 359                 "ptr = {}, align = {}, size = 1",
 360                 ptr,
 361                 align
 362             );
 363         }
 364         align = (align + 1).next_power_of_two();
 365     }
 366 }
 367
 368 #[test]
 369 fn align_offset_weird_strides() {
 370     #[repr(packed)]
 371     struct A3(u16, u8);
 372     struct A4(u32);
 373     #[repr(packed)]
 374     struct A5(u32, u8);
 375     #[repr(packed)]
 376     struct A6(u32, u16);
 377     #[repr(packed)]
 378     struct A7(u32, u16, u8);
 379     #[repr(packed)]
 380     struct A8(u32, u32);
 381     #[repr(packed)]
 382     struct A9(u32, u32, u8);
 383     #[repr(packed)]
 384     struct A10(u32, u32, u16);
 385
 386     unsafe fn test_weird_stride<T>(ptr: *const T, align: usize) -> bool {
 387         let numptr = ptr as usize;
 388         let mut expected = usize::MAX;
 389         // Naive but definitely correct way to find the *first* aligned element of stride::<T>.
 390         for el in 0..align {
 391             if (numptr + el * ::std::mem::size_of::<T>()) % align == 0 {
 392                 expected = el;
 393                 break;
 394             }
 395         }
 396         let got = ptr.align_offset(align);
 397         if got != expected {
 398             eprintln!(
 399                 "aligning {:p} (with stride of {}) to {}, expected {}, got {}",
 400                 ptr,
 401                 ::std::mem::size_of::<T>(),
 402                 align,
 403                 expected,
 404                 got
 405             );
 406             return true;
 407         }
 408         return false;
 409     }
 410
 411     // For pointers of stride != 1, we verify the algorithm against the naivest possible
 412     // implementation
 413     let mut align = 1;
 414     let mut x = false;
 415     // Miri is too slow
 416     let limit = if cfg!(miri) { 32 } else { 1024 };
 417     while align < limit {
 418         for ptr in 1usize..4 * align {
 419             unsafe {
 420                 x |= test_weird_stride::<A3>(ptr as *const A3, align);
 421                 x |= test_weird_stride::<A4>(ptr as *const A4, align);
 422                 x |= test_weird_stride::<A5>(ptr as *const A5, align);
 423                 x |= test_weird_stride::<A6>(ptr as *const A6, align);
 424                 x |= test_weird_stride::<A7>(ptr as *const A7, align);
 425                 x |= test_weird_stride::<A8>(ptr as *const A8, align);
 426                 x |= test_weird_stride::<A9>(ptr as *const A9, align);
 427                 x |= test_weird_stride::<A10>(ptr as *const A10, align);
 428             }
 429         }
 430         align = (align + 1).next_power_of_two();
 431     }
 432     assert!(!x);
 433 }
 434
 435 #[test]
 436 fn offset_from() {
 437     let mut a = [0; 5];
 438     let ptr1: *mut i32 = &mut a[1];
 439     let ptr2: *mut i32 = &mut a[3];
 440     unsafe {
 441         assert_eq!(ptr2.offset_from(ptr1), 2);
 442         assert_eq!(ptr1.offset_from(ptr2), -2);
 443         assert_eq!(ptr1.offset(2), ptr2);
 444         assert_eq!(ptr2.offset(-2), ptr1);
 445     }
 446 }
 447
 448 #[test]
 449 fn ptr_metadata() {
 450     struct Unit;
 451     struct Pair<A, B: ?Sized>(A, B);
 452     extern "C" {
 453         type Extern;
 454     }
 455     let () = metadata(&());
 456     let () = metadata(&Unit);
 457     let () = metadata(&4_u32);
 458     let () = metadata(&String::new());
 459     let () = metadata(&Some(4_u32));
 460     let () = metadata(&ptr_metadata);
 461     let () = metadata(&|| {});
 462     let () = metadata(&[4, 7]);
 463     let () = metadata(&(4, String::new()));
 464     let () = metadata(&Pair(4, String::new()));
 465     let () = metadata(0 as *const Extern);
 466     let () = metadata(0 as *const <&u32 as std::ops::Deref>::Target);
 467
 468     assert_eq!(metadata("foo"), 3_usize);
 469     assert_eq!(metadata(&[4, 7][..]), 2_usize);
 470
 471     let dst_tuple: &(bool, [u8]) = &(true, [0x66, 0x6F, 0x6F]);
 472     let dst_struct: &Pair<bool, [u8]> = &Pair(true, [0x66, 0x6F, 0x6F]);
 473     assert_eq!(metadata(dst_tuple), 3_usize);
 474     assert_eq!(metadata(dst_struct), 3_usize);
 475     unsafe {
 476         let dst_tuple: &(bool, str) = std::mem::transmute(dst_tuple);
 477         let dst_struct: &Pair<bool, str> = std::mem::transmute(dst_struct);
 478         assert_eq!(&dst_tuple.1, "foo");
 479         assert_eq!(&dst_struct.1, "foo");
 480         assert_eq!(metadata(dst_tuple), 3_usize);
 481         assert_eq!(metadata(dst_struct), 3_usize);
 482     }
 483
 484     let vtable_1: DynMetadata<dyn Debug> = metadata(&4_u16 as &dyn Debug);
 485     let vtable_2: DynMetadata<dyn Display> = metadata(&4_u16 as &dyn Display);
 486     let vtable_3: DynMetadata<dyn Display> = metadata(&4_u32 as &dyn Display);
 487     let vtable_4: DynMetadata<dyn Display> = metadata(&(true, 7_u32) as &(bool, dyn Display));
 488     let vtable_5: DynMetadata<dyn Display> =
 489         metadata(&Pair(true, 7_u32) as &Pair<bool, dyn Display>);
 490     unsafe {
 491         let address_1: usize = std::mem::transmute(vtable_1);
 492         let address_2: usize = std::mem::transmute(vtable_2);
 493         let address_3: usize = std::mem::transmute(vtable_3);
 494         let address_4: usize = std::mem::transmute(vtable_4);
 495         let address_5: usize = std::mem::transmute(vtable_5);
 496         // Different trait => different vtable pointer
 497         assert_ne!(address_1, address_2);
 498         // Different erased type => different vtable pointer
 499         assert_ne!(address_2, address_3);
 500         // Same erased type and same trait => same vtable pointer
 501         assert_eq!(address_3, address_4);
 502         assert_eq!(address_3, address_5);
 503     }
 504 }
 505
 506 #[test]
 507 fn ptr_metadata_bounds() {
 508     fn metadata_eq_method_address<T: ?Sized>() -> usize {
 509         // The `Metadata` associated type has an `Ord` bound, so this is valid:
 510         <<T as Pointee>::Metadata as PartialEq>::eq as usize
 511     }
 512     // "Synthetic" trait impls generated by the compiler like those of `Pointee`
 513     // are not checked for bounds of associated type.
 514     // So with a buggy libcore we could have both:
 515     // * `<dyn Display as Pointee>::Metadata == DynMetadata`
 516     // * `DynMetadata: !PartialEq`
 517     // … and cause an ICE here:
 518     metadata_eq_method_address::<dyn Display>();
 519
 520     // For this reason, let’s check here that bounds are satisfied:
 521
 522     let _ = static_assert_expected_bounds_for_metadata::<()>;
 523     let _ = static_assert_expected_bounds_for_metadata::<usize>;
 524     let _ = static_assert_expected_bounds_for_metadata::<DynMetadata<dyn Display>>;
 525     fn _static_assert_associated_type<T: ?Sized>() {
 526         let _ = static_assert_expected_bounds_for_metadata::<<T as Pointee>::Metadata>;
 527     }
 528
 529     fn static_assert_expected_bounds_for_metadata<Meta>()
 530     where
 531         // Keep this in sync with the associated type in `library/core/src/ptr/metadata.rs`
 532         Meta: Copy + Send + Sync + Ord + std::hash::Hash + Unpin,
 533     {
 534     }
 535 }
 536
 537 #[test]
 538 fn dyn_metadata() {
 539     #[derive(Debug)]
 540     #[repr(align(32))]
 541     struct Something([u8; 47]);
 542
 543     let value = Something([0; 47]);
 544     let trait_object: &dyn Debug = &value;
 545     let meta = metadata(trait_object);
 546
 547     assert_eq!(meta.size_of(), 64);
 548     assert_eq!(meta.size_of(), std::mem::size_of::<Something>());
 549     assert_eq!(meta.align_of(), 32);
 550     assert_eq!(meta.align_of(), std::mem::align_of::<Something>());
 551     assert_eq!(meta.layout(), std::alloc::Layout::new::<Something>());
 552
 553     assert!(format!("{meta:?}").starts_with("DynMetadata(0x"));
 554 }
 555
 556 #[test]
 557 fn from_raw_parts() {
 558     let mut value = 5_u32;
 559     let address = &mut value as *mut _ as *mut ();
 560     let trait_object: &dyn Display = &mut value;
 561     let vtable = metadata(trait_object);
 562     let trait_object = NonNull::from(trait_object);
 563
 564     assert_eq!(ptr::from_raw_parts(address, vtable), trait_object.as_ptr());
 565     assert_eq!(ptr::from_raw_parts_mut(address, vtable), trait_object.as_ptr());
 566     assert_eq!(NonNull::from_raw_parts(NonNull::new(address).unwrap(), vtable), trait_object);
 567
 568     let mut array = [5_u32, 5, 5, 5, 5];
 569     let address = &mut array as *mut _ as *mut ();
 570     let array_ptr = NonNull::from(&mut array);
 571     let slice_ptr = NonNull::from(&mut array[..]);
 572
 573     assert_eq!(ptr::from_raw_parts(address, ()), array_ptr.as_ptr());
 574     assert_eq!(ptr::from_raw_parts_mut(address, ()), array_ptr.as_ptr());
 575     assert_eq!(NonNull::from_raw_parts(NonNull::new(address).unwrap(), ()), array_ptr);
 576
 577     assert_eq!(ptr::from_raw_parts(address, 5), slice_ptr.as_ptr());
 578     assert_eq!(ptr::from_raw_parts_mut(address, 5), slice_ptr.as_ptr());
 579     assert_eq!(NonNull::from_raw_parts(NonNull::new(address).unwrap(), 5), slice_ptr);
 580 }
 581
 582 #[test]
 583 fn thin_box() {
 584     let foo = ThinBox::<dyn Display>::new(4);
 585     assert_eq!(foo.to_string(), "4");
 586     drop(foo);
 587     let bar = ThinBox::<dyn Display>::new(7);
 588     assert_eq!(bar.to_string(), "7");
 589
 590     // A slightly more interesting library that could be built on top of metadata APIs.
 591     //
 592     // * It could be generalized to any `T: ?Sized` (not just trait object)
 593     //   if `{size,align}_of_for_meta<T: ?Sized>(T::Metadata)` are added.
 594     // * Constructing a `ThinBox` without consuming and deallocating a `Box`
 595     //   requires either the unstable `Unsize` marker trait,
 596     //   or the unstable `unsized_locals` language feature,
 597     //   or taking `&dyn T` and restricting to `T: Copy`.
 598
 599     use std::alloc::*;
 600     use std::marker::PhantomData;
 601
 602     struct ThinBox<T>
 603     where
 604         T: ?Sized + Pointee<Metadata = DynMetadata<T>>,
 605     {
 606         ptr: NonNull<DynMetadata<T>>,
 607         phantom: PhantomData<T>,
 608     }
 609
 610     impl<T> ThinBox<T>
 611     where
 612         T: ?Sized + Pointee<Metadata = DynMetadata<T>>,
 613     {
 614         pub fn new<Value: std::marker::Unsize<T>>(value: Value) -> Self {
 615             let unsized_: &T = &value;
 616             let meta = metadata(unsized_);
 617             let meta_layout = Layout::for_value(&meta);
 618             let value_layout = Layout::for_value(&value);
 619             let (layout, offset) = meta_layout.extend(value_layout).unwrap();
 620             // `DynMetadata` is pointer-sized:
 621             assert!(layout.size() > 0);
 622             // If `ThinBox<T>` is generalized to any `T: ?Sized`,
 623             // handle ZSTs with a dangling pointer without going through `alloc()`,
 624             // like `Box<T>` does.
 625             unsafe {
 626                 let ptr = NonNull::new(alloc(layout))
 627                     .unwrap_or_else(|| handle_alloc_error(layout))
 628                     .cast::<DynMetadata<T>>();
 629                 ptr.as_ptr().write(meta);
 630                 ptr.cast::<u8>().as_ptr().add(offset).cast::<Value>().write(value);
 631                 Self { ptr, phantom: PhantomData }
 632             }
 633         }
 634
 635         fn meta(&self) -> DynMetadata<T> {
 636             unsafe { *self.ptr.as_ref() }
 637         }
 638
 639         fn layout(&self) -> (Layout, usize) {
 640             let meta = self.meta();
 641             Layout::for_value(&meta).extend(meta.layout()).unwrap()
 642         }
 643
 644         fn value_ptr(&self) -> *const T {
 645             let (_, offset) = self.layout();
 646             let data_ptr = unsafe { self.ptr.cast::<u8>().as_ptr().add(offset) };
 647             ptr::from_raw_parts(data_ptr.cast(), self.meta())
 648         }
 649
 650         fn value_mut_ptr(&mut self) -> *mut T {
 651             let (_, offset) = self.layout();
 652             // FIXME: can this line be shared with the same in `value_ptr()`
 653             // without upsetting Stacked Borrows?
 654             let data_ptr = unsafe { self.ptr.cast::<u8>().as_ptr().add(offset) };
 655             from_raw_parts_mut(data_ptr.cast(), self.meta())
 656         }
 657     }
 658
 659     impl<T> std::ops::Deref for ThinBox<T>
 660     where
 661         T: ?Sized + Pointee<Metadata = DynMetadata<T>>,
 662     {
 663         type Target = T;
 664
 665         fn deref(&self) -> &T {
 666             unsafe { &*self.value_ptr() }
 667         }
 668     }
 669
 670     impl<T> std::ops::DerefMut for ThinBox<T>
 671     where
 672         T: ?Sized + Pointee<Metadata = DynMetadata<T>>,
 673     {
 674         fn deref_mut(&mut self) -> &mut T {
 675             unsafe { &mut *self.value_mut_ptr() }
 676         }
 677     }
 678
 679     impl<T> std::ops::Drop for ThinBox<T>
 680     where
 681         T: ?Sized + Pointee<Metadata = DynMetadata<T>>,
 682     {
 683         fn drop(&mut self) {
 684             let (layout, _) = self.layout();
 685             unsafe {
 686                 drop_in_place::<T>(&mut **self);
 687                 dealloc(self.ptr.cast().as_ptr(), layout);
 688             }
 689         }
 690     }
 691 }