OwningDirstateMap used to own a PyBytes, but was generalized to be
more generic when it was moved from hg-cpython to hg-core.
This fixes some comments that were still referencing PyBytes.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| /// | /// | ||||
| /// See <https://docs.rs/owning_ref/0.4.1/owning_ref/trait.StableAddress.html>. | /// See <https://docs.rs/owning_ref/0.4.1/owning_ref/trait.StableAddress.html>. | ||||
| on_disk: Box<dyn Deref<Target = [u8]> + Send>, | on_disk: Box<dyn Deref<Target = [u8]> + Send>, | ||||
| /// Pointer for `Box<DirstateMap<'on_disk>>`, typed-erased because the | /// Pointer for `Box<DirstateMap<'on_disk>>`, typed-erased because the | ||||
| /// language cannot represent a lifetime referencing a sibling field. | /// language cannot represent a lifetime referencing a sibling field. | ||||
| /// This is not quite a self-referencial struct (moving this struct is not | /// This is not quite a self-referencial struct (moving this struct is not | ||||
| /// a problem as it doesn’t change the address of the bytes buffer owned | /// a problem as it doesn’t change the address of the bytes buffer owned | ||||
| /// by `PyBytes`) but touches similar borrow-checker limitations. | /// by `on_disk`) but touches similar borrow-checker limitations. | ||||
| ptr: *mut (), | ptr: *mut (), | ||||
| } | } | ||||
| impl OwningDirstateMap { | impl OwningDirstateMap { | ||||
| pub fn new_empty<OnDisk>(on_disk: OnDisk) -> Self | pub fn new_empty<OnDisk>(on_disk: OnDisk) -> Self | ||||
| where | where | ||||
| OnDisk: Deref<Target = [u8]> + StableDeref + Send + 'static, | OnDisk: Deref<Target = [u8]> + StableDeref + Send + 'static, | ||||
| { | { | ||||
| } | } | ||||
| pub fn get_pair_mut<'a>( | pub fn get_pair_mut<'a>( | ||||
| &'a mut self, | &'a mut self, | ||||
| ) -> (&'a [u8], &'a mut DirstateMap<'a>) { | ) -> (&'a [u8], &'a mut DirstateMap<'a>) { | ||||
| // SAFETY: We cast the type-erased pointer back to the same type it had | // SAFETY: We cast the type-erased pointer back to the same type it had | ||||
| // in `new`, except with a different lifetime parameter. This time we | // in `new`, except with a different lifetime parameter. This time we | ||||
| // connect the lifetime to that of `self`. This cast is valid because | // connect the lifetime to that of `self`. This cast is valid because | ||||
| // `self` owns the same `PyBytes` whose buffer `DirstateMap` | // `self` owns the same `on_disk` whose buffer `DirstateMap` | ||||
| // references. That buffer has a stable memory address because the byte | // references. That buffer has a stable memory address because our | ||||
| // string value of a `PyBytes` is immutable. | // `Self::new_empty` counstructor requires `StableDeref`. | ||||
| let ptr: *mut DirstateMap<'a> = self.ptr.cast(); | let ptr: *mut DirstateMap<'a> = self.ptr.cast(); | ||||
| // SAFETY: we dereference that pointer, connecting the lifetime of the | // SAFETY: we dereference that pointer, connecting the lifetime of the | ||||
| // new `&mut` to that of `self`. This is valid because the | // new `&mut` to that of `self`. This is valid because the | ||||
| // raw pointer is to a boxed value, and `self` owns that box. | // raw pointer is to a boxed value, and `self` owns that box. | ||||
| (&self.on_disk, unsafe { &mut *ptr }) | (&self.on_disk, unsafe { &mut *ptr }) | ||||
| } | } | ||||
| pub fn get_map_mut<'a>(&'a mut self) -> &'a mut DirstateMap<'a> { | pub fn get_map_mut<'a>(&'a mut self) -> &'a mut DirstateMap<'a> { | ||||
| self.get_pair_mut().1 | self.get_pair_mut().1 | ||||
| } | } | ||||
| pub fn get_map<'a>(&'a self) -> &'a DirstateMap<'a> { | pub fn get_map<'a>(&'a self) -> &'a DirstateMap<'a> { | ||||
| // SAFETY: same reasoning as in `get_mut` above. | // SAFETY: same reasoning as in `get_pair_mut` above. | ||||
| let ptr: *mut DirstateMap<'a> = self.ptr.cast(); | let ptr: *mut DirstateMap<'a> = self.ptr.cast(); | ||||
| unsafe { &*ptr } | unsafe { &*ptr } | ||||
| } | } | ||||
| pub fn on_disk<'a>(&'a self) -> &'a [u8] { | pub fn on_disk<'a>(&'a self) -> &'a [u8] { | ||||
| &self.on_disk | &self.on_disk | ||||
| } | } | ||||
| } | } | ||||
| impl Drop for OwningDirstateMap { | impl Drop for OwningDirstateMap { | ||||
| fn drop(&mut self) { | fn drop(&mut self) { | ||||
| // Silence a "field is never read" warning, and demonstrate that this | // Silence a "field is never read" warning, and demonstrate that this | ||||
| // value is still alive. | // value is still alive. | ||||
| let _ = &self.on_disk; | let _: &Box<dyn Deref<Target = [u8]> + Send> = &self.on_disk; | ||||
| // SAFETY: this cast is the same as in `get_mut`, and is valid for the | // SAFETY: this cast is the same as in `get_mut`, and is valid for the | ||||
| // same reason. `self.on_disk` still exists at this point, drop glue | // same reason. `self.on_disk` still exists at this point, drop glue | ||||
| // will drop it implicitly after this `drop` method returns. | // will drop it implicitly after this `drop` method returns. | ||||
| let ptr: *mut DirstateMap<'_> = self.ptr.cast(); | let ptr: *mut DirstateMap<'_> = self.ptr.cast(); | ||||
| // SAFETY: `Box::from_raw` takes ownership of the box away from `self`. | // SAFETY: `Box::from_raw` takes ownership of the box away from `self`. | ||||
| // This is fine because drop glue does nothig for `*mut ()` and we’re | // This is fine because drop glue does nothing for `*mut ()` and we’re | ||||
| // in `drop`, so `get` and `get_mut` cannot be called again. | // in `drop`, so `get` and `get_mut` cannot be called again. | ||||
| unsafe { drop(Box::from_raw(ptr)) } | unsafe { drop(Box::from_raw(ptr)) } | ||||
| } | } | ||||
| } | } | ||||
| fn _static_assert_is_send<T: Send>() {} | fn _static_assert_is_send<T: Send>() {} | ||||
| fn _static_assert_fields_are_send() { | fn _static_assert_fields_are_send() { | ||||