This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11396

rust: Make OwningDirstateMap generic and move it into hg-core
ClosedPublic

Authored by SimonSapin on Sep 10 2021, 11:11 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG4afd6cc447b9: rust: Make OwningDirstateMap generic and move it into hg-core
Summary

This will enable using it in rhg too.

The OwningDirstateMap::new_empty constructor is generic and accepts a value
of any type that gives acces to a bytes buffer. That buffer must stay valid
as long as the value hasn’t been dropped, and must keep its memory address
even if the value is moved. The StableDeref marker trait encodes those
constraints. Previously no trait was needed because the value was always
of type PyBytes which we know satisfies those constraints.

The buffer type is ereased in the struct itself through boxing and
dynamic dispatch, in order to simplify other signatures that mention
OwningDirstateMap.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

SimonSapin created this revision.Sep 10 2021, 11:11 AM
Alphare requested changes to this revision.Sep 13 2021, 6:25 AM
Alphare added a subscriber: Alphare.

I feel like the commit message should have a small explanation of why we're switching to using StableDeref and what is does.

Other than that, the change looks good, though the get_mut_pair name might be a little confusing since only the value part of the pair is mutable, but this is obvious enough from the signature of the function (yay static types?).

This revision now requires changes to proceed.Sep 13 2021, 6:25 AM
SimonSapin edited the summary of this revision. (Show Details)Sep 13 2021, 6:38 AM
SimonSapin added a comment.Sep 13 2021, 6:41 AM

I’ve edited the commit message to discuss genericity and StableDeref

Alphare accepted this revision.Sep 13 2021, 6:45 AM

Thanks for the quick fix

This revision is now accepted and ready to land.Sep 13 2021, 6:45 AM

Revision Contents
Changeset List

Diff 30212

rust/Cargo.lock

# This file is automatically @generated by Cargo. # This file is automatically @generated by Cargo.
# It is not intended for manual editing. # It is not intended for manual editing.
version = 3
[[package]] [[package]]
name = "adler" name = "adler"
version = "0.2.3" version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee2a4ec343196209d6594e19543ae87a39f96d5534d7174822a3ad825dd6ed7e" checksum = "ee2a4ec343196209d6594e19543ae87a39f96d5534d7174822a3ad825dd6ed7e"
[[package]] [[package]]
name = "aho-corasick" name = "aho-corasick"
"pretty_assertions", "pretty_assertions",
"rand", "rand",
"rand_distr", "rand_distr",
"rand_pcg", "rand_pcg",
"rayon", "rayon",
"regex", "regex",
"same-file", "same-file",
"sha-1", "sha-1",
"stable_deref_trait",
"tempfile", "tempfile",
"twox-hash", "twox-hash",
"zstd", "zstd",
] ]
[[package]] [[package]]
name = "hg-cpython" name = "hg-cpython"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"cpython", "cpython",
"crossbeam-channel 0.4.4", "crossbeam-channel 0.4.4",
"env_logger", "env_logger",
"hg-core", "hg-core",
"libc", "libc",
"log", "log",
"stable_deref_trait",
] ]
[[package]] [[package]]
name = "home" name = "home"
version = "0.5.3" version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2456aef2e6b6a9784192ae780c0f15bc57df0e918585282325e8c8ac27737654" checksum = "2456aef2e6b6a9784192ae780c0f15bc57df0e918585282325e8c8ac27737654"
dependencies = [ dependencies = [
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ec31ceca5644fa6d444cc77548b88b67f46db6f7c71683b0f9336e671830d2f" checksum = "1ec31ceca5644fa6d444cc77548b88b67f46db6f7c71683b0f9336e671830d2f"
dependencies = [ dependencies = [
"bitmaps", "bitmaps",
"typenum", "typenum",
] ]
[[package]] [[package]]
name = "stable_deref_trait"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
[[package]]
name = "static_assertions" name = "static_assertions"
version = "1.1.0" version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
[[package]] [[package]]
name = "strsim" name = "strsim"
version = "0.8.0" version = "0.8.0"

rust/hg-core/Cargo.toml

rand = "0.7.3" rand = "0.7.3"
rand_pcg = "0.2.1" rand_pcg = "0.2.1"
rand_distr = "0.2.2" rand_distr = "0.2.2"
rayon = "1.3.0" rayon = "1.3.0"
regex = "1.3.9" regex = "1.3.9"
sha-1 = "0.9.6" sha-1 = "0.9.6"
twox-hash = "1.5.0" twox-hash = "1.5.0"
same-file = "1.0.6" same-file = "1.0.6"
stable_deref_trait = "1.2.0"
tempfile = "3.1.0" tempfile = "3.1.0"
crossbeam-channel = "0.4" crossbeam-channel = "0.4"
micro-timer = "0.3.0" micro-timer = "0.3.0"
log = "0.4.8" log = "0.4.8"
memmap = "0.7.0" memmap = "0.7.0"
zstd = "0.5.3" zstd = "0.5.3"
format-bytes = "0.2.2" format-bytes = "0.2.2"

rust/hg-core/src/dirstate_tree.rs

pub mod dirstate_map; pub mod dirstate_map;
pub mod dispatch; pub mod dispatch;
pub mod on_disk; pub mod on_disk;
pub mod owning;
mod owning_dispatch;
pub mod path_with_basename; pub mod path_with_basename;
pub mod status; pub mod status;

rust/hg-core/src/dirstate_tree/owning.rs

  • This file was moved from rust/hg-cpython/src/dirstate/owning.rs.
use cpython::PyBytes; use super::dirstate_map::DirstateMap;
use cpython::Python; use stable_deref_trait::StableDeref;
use hg::dirstate_tree::dirstate_map::DirstateMap; use std::ops::Deref;
use hg::DirstateError;
use hg::DirstateParents;
/// Keep a `DirstateMap<'on_disk>` next to the `on_disk` buffer that it /// Keep a `DirstateMap<'on_disk>` next to the `on_disk` buffer that it
/// borrows. This is similar to the owning-ref crate. /// borrows.
/// ///
/// This is similar to [`OwningRef`] which is more limited because it /// This is similar to [`OwningRef`] which is more limited because it
/// represents exactly one `&T` reference next to the value it borrows, as /// represents exactly one `&T` reference next to the value it borrows, as
/// opposed to a struct that may contain an arbitrary number of references in /// opposed to a struct that may contain an arbitrary number of references in
/// arbitrarily-nested data structures. /// arbitrarily-nested data structures.
/// ///
/// [`OwningRef`]: https://docs.rs/owning_ref/0.4.1/owning_ref/struct.OwningRef.html /// [`OwningRef`]: https://docs.rs/owning_ref/0.4.1/owning_ref/struct.OwningRef.html
pub(super) struct OwningDirstateMap { pub struct OwningDirstateMap {
/// Owned handle to a bytes buffer with a stable address. /// Owned handle to a bytes buffer with a stable address.
/// ///
/// 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: PyBytes, 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 `PyBytes`) but touches similar borrow-checker limitations.
ptr: *mut (), ptr: *mut (),
} }
impl OwningDirstateMap { impl OwningDirstateMap {
pub fn new_v1( pub fn new_empty<OnDisk>(on_disk: OnDisk) -> Self
py: Python, where
on_disk: PyBytes, OnDisk: Deref<Target = [u8]> + StableDeref + Send + 'static,
) -> Result<(Self, Option<DirstateParents>), DirstateError> { {
let bytes: &'_ [u8] = on_disk.data(py); let on_disk = Box::new(on_disk);
let (map, parents) = DirstateMap::new_v1(bytes)?; let bytes: &'_ [u8] = &on_disk;
let map = DirstateMap::empty(bytes);
// Like in `bytes` above, this `'_` lifetime parameter borrows from // Like in `bytes` above, this `'_` lifetime parameter borrows from
// the bytes buffer owned by `on_disk`. // the bytes buffer owned by `on_disk`.
let ptr: *mut DirstateMap<'_> = Box::into_raw(Box::new(map)); let ptr: *mut DirstateMap<'_> = Box::into_raw(Box::new(map));
// Erase the pointed type entirely in order to erase the lifetime. // Erase the pointed type entirely in order to erase the lifetime.
let ptr: *mut () = ptr.cast(); let ptr: *mut () = ptr.cast();
Ok((Self { on_disk, ptr }, parents)) Self { on_disk, ptr }
} }
pub fn new_v2( pub fn get_mut_pair<'a>(
py: Python, &'a mut self,
on_disk: PyBytes, ) -> (&'a [u8], &'a mut DirstateMap<'a>) {
data_size: usize,
tree_metadata: PyBytes,
) -> Result<Self, DirstateError> {
let bytes: &'_ [u8] = on_disk.data(py);
let map =
DirstateMap::new_v2(bytes, data_size, tree_metadata.data(py))?;
// Like in `bytes` above, this `'_` lifetime parameter borrows from
// the bytes buffer owned by `on_disk`.
let ptr: *mut DirstateMap<'_> = Box::into_raw(Box::new(map));
// Erase the pointed type entirely in order to erase the lifetime.
let ptr: *mut () = ptr.cast();
Ok(Self { on_disk, ptr })
}
pub fn get_mut<'a>(&'a mut self) -> &'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 `PyBytes` whose buffer `DirstateMap`
// references. That buffer has a stable memory address because the byte // references. That buffer has a stable memory address because the byte
// string value of a `PyBytes` is immutable. // string value of a `PyBytes` is immutable.
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.
unsafe { &mut *ptr } (&self.on_disk, unsafe { &mut *ptr })
}
pub fn get_mut<'a>(&'a mut self) -> &'a mut DirstateMap<'a> {
self.get_mut_pair().1
} }
pub fn get<'a>(&'a self) -> &'a DirstateMap<'a> { pub fn get<'a>(&'a self) -> &'a DirstateMap<'a> {
// SAFETY: same reasoning as in `get_mut` above. // SAFETY: same reasoning as in `get_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] {
&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 _ = &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 nothig 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() {
_static_assert_is_send::<PyBytes>();
_static_assert_is_send::<Box<DirstateMap<'_>>>(); _static_assert_is_send::<Box<DirstateMap<'_>>>();
} }
// SAFETY: we don’t get this impl implicitly because `*mut (): !Send` because // SAFETY: we don’t get this impl implicitly because `*mut (): !Send` because
// thread-safety of raw pointers is unknown in the general case. However this // thread-safety of raw pointers is unknown in the general case. However this
// particular raw pointer represents a `Box<DirstateMap<'on_disk>>` that we // particular raw pointer represents a `Box<DirstateMap<'on_disk>>` that we
// own. Since that `Box` and `PyBytes` are both `Send` as shown in above, it // own. Since that `Box` is `Send` as shown in above, it is sound to mark
// is sound to mark this struct as `Send` too. // this struct as `Send` too.
unsafe impl Send for OwningDirstateMap {} unsafe impl Send for OwningDirstateMap {}

rust/hg-core/src/dirstate_tree/owning_dispatch.rs

  • This file was moved from rust/hg-cpython/src/dirstate/dispatch.rs.
use crate::dirstate::owning::OwningDirstateMap; use crate::dirstate::parsers::Timestamp;
use hg::dirstate::parsers::Timestamp; use crate::dirstate_tree::dispatch::DirstateMapMethods;
use hg::dirstate_tree::dispatch::DirstateMapMethods; use crate::dirstate_tree::on_disk::DirstateV2ParseError;
use hg::dirstate_tree::on_disk::DirstateV2ParseError; use crate::dirstate_tree::owning::OwningDirstateMap;
use hg::matchers::Matcher; use crate::matchers::Matcher;
use hg::utils::hg_path::{HgPath, HgPathBuf}; use crate::utils::hg_path::{HgPath, HgPathBuf};
use hg::CopyMapIter; use crate::CopyMapIter;
use hg::DirstateEntry; use crate::DirstateEntry;
use hg::DirstateError; use crate::DirstateError;
use hg::DirstateParents; use crate::DirstateParents;
use hg::DirstateStatus; use crate::DirstateStatus;
use hg::PatternFileWarning; use crate::PatternFileWarning;
use hg::StateMapIter; use crate::StateMapIter;
use hg::StatusError; use crate::StatusError;
use hg::StatusOptions; use crate::StatusOptions;
use std::path::PathBuf; use std::path::PathBuf;
impl DirstateMapMethods for OwningDirstateMap { impl DirstateMapMethods for OwningDirstateMap {
fn clear(&mut self) { fn clear(&mut self) {
self.get_mut().clear() self.get_mut().clear()
} }
fn set_v1(&mut self, filename: &HgPath, entry: DirstateEntry) { fn set_v1(&mut self, filename: &HgPath, entry: DirstateEntry) {

rust/hg-cpython/Cargo.toml

python3-bin = ["cpython/python3-sys"] python3-bin = ["cpython/python3-sys"]
[dependencies] [dependencies]
crossbeam-channel = "0.4" crossbeam-channel = "0.4"
hg-core = { path = "../hg-core"} hg-core = { path = "../hg-core"}
libc = '*' libc = '*'
log = "0.4.8" log = "0.4.8"
env_logger = "0.7.1" env_logger = "0.7.1"
stable_deref_trait = "1.2.0"
[dependencies.cpython] [dependencies.cpython]
version = "0.6.0" version = "0.6.0"
default-features = false default-features = false

rust/hg-cpython/src/dirstate.rs

// dirstate.rs // dirstate.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Bindings for the `hg::dirstate` module provided by the //! Bindings for the `hg::dirstate` module provided by the
//! `hg-core` package. //! `hg-core` package.
//! //!
//! From Python, this will be seen as `mercurial.rustext.dirstate` //! From Python, this will be seen as `mercurial.rustext.dirstate`
mod copymap; mod copymap;
mod dirs_multiset; mod dirs_multiset;
mod dirstate_map; mod dirstate_map;
mod dispatch;
mod non_normal_entries; mod non_normal_entries;
mod owning;
mod status; mod status;
use crate::{ use crate::{
dirstate::{ dirstate::{
dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper, dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper,
}, },
exceptions, exceptions,
}; };
use cpython::{ use cpython::{

rust/hg-cpython/src/dirstate/dirstate_map.rs

use crate::{ use crate::{
dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator}, dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},
dirstate::make_dirstate_item, dirstate::make_dirstate_item,
dirstate::make_dirstate_item_raw, dirstate::make_dirstate_item_raw,
dirstate::non_normal_entries::{ dirstate::non_normal_entries::{
NonNormalEntries, NonNormalEntriesIterator, NonNormalEntries, NonNormalEntriesIterator,
}, },
dirstate::owning::OwningDirstateMap,
parsers::dirstate_parents_to_pytuple, parsers::dirstate_parents_to_pytuple,
pybytes_deref::PyBytesDeref,
}; };
use hg::{ use hg::{
dirstate::parsers::Timestamp, dirstate::parsers::Timestamp,
dirstate::MTIME_UNSET, dirstate::MTIME_UNSET,
dirstate::SIZE_NON_NORMAL, dirstate::SIZE_NON_NORMAL,
dirstate_tree::dirstate_map::DirstateMap as TreeDirstateMap,
dirstate_tree::dispatch::DirstateMapMethods, dirstate_tree::dispatch::DirstateMapMethods,
dirstate_tree::on_disk::DirstateV2ParseError, dirstate_tree::on_disk::DirstateV2ParseError,
dirstate_tree::owning::OwningDirstateMap,
revlog::Node, revlog::Node,
utils::files::normalize_case, utils::files::normalize_case,
utils::hg_path::{HgPath, HgPathBuf}, utils::hg_path::{HgPath, HgPathBuf},
DirstateEntry, DirstateError, DirstateMap as RustDirstateMap, DirstateEntry, DirstateError, DirstateMap as RustDirstateMap,
DirstateParents, EntryState, StateMapIter, DirstateParents, EntryState, StateMapIter,
}; };
// TODO // TODO
/// Returns a `(dirstate_map, parents)` tuple /// Returns a `(dirstate_map, parents)` tuple
@staticmethod @staticmethod
def new_v1( def new_v1(
use_dirstate_tree: bool, use_dirstate_tree: bool,
on_disk: PyBytes, on_disk: PyBytes,
) -> PyResult<PyObject> { ) -> PyResult<PyObject> {
let (inner, parents) = if use_dirstate_tree { let (inner, parents) = if use_dirstate_tree {
let (map, parents) = OwningDirstateMap::new_v1(py, on_disk) let on_disk = PyBytesDeref::new(py, on_disk);
let mut map = OwningDirstateMap::new_empty(on_disk);
let (on_disk, map_placeholder) = map.get_mut_pair();
let (actual_map, parents) = TreeDirstateMap::new_v1(on_disk)
.map_err(|e| dirstate_error(py, e))?; .map_err(|e| dirstate_error(py, e))?;
*map_placeholder = actual_map;
(Box::new(map) as _, parents) (Box::new(map) as _, parents)
} else { } else {
let bytes = on_disk.data(py); let bytes = on_disk.data(py);
let mut map = RustDirstateMap::default(); let mut map = RustDirstateMap::default();
let parents = map.read(bytes).map_err(|e| dirstate_error(py, e))?; let parents = map.read(bytes).map_err(|e| dirstate_error(py, e))?;
(Box::new(map) as _, parents) (Box::new(map) as _, parents)
}; };
let map = Self::create_instance(py, inner)?; let map = Self::create_instance(py, inner)?;
let parents = parents.map(|p| dirstate_parents_to_pytuple(py, &p)); let parents = parents.map(|p| dirstate_parents_to_pytuple(py, &p));
Ok((map, parents).to_py_object(py).into_object()) Ok((map, parents).to_py_object(py).into_object())
} }
/// Returns a DirstateMap /// Returns a DirstateMap
@staticmethod @staticmethod
def new_v2( def new_v2(
on_disk: PyBytes, on_disk: PyBytes,
data_size: usize, data_size: usize,
tree_metadata: PyBytes, tree_metadata: PyBytes,
) -> PyResult<PyObject> { ) -> PyResult<PyObject> {
let dirstate_error = |e: DirstateError| { let dirstate_error = |e: DirstateError| {
PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e)) PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e))
}; };
let inner = OwningDirstateMap::new_v2( let on_disk = PyBytesDeref::new(py, on_disk);
py, on_disk, data_size, tree_metadata, let mut map = OwningDirstateMap::new_empty(on_disk);
let (on_disk, map_placeholder) = map.get_mut_pair();
*map_placeholder = TreeDirstateMap::new_v2(
on_disk, data_size, tree_metadata.data(py),
).map_err(dirstate_error)?; ).map_err(dirstate_error)?;
let map = Self::create_instance(py, Box::new(inner))?; let map = Self::create_instance(py, Box::new(map))?;
Ok(map.into_object()) Ok(map.into_object())
} }
def clear(&self) -> PyResult<PyObject> { def clear(&self) -> PyResult<PyObject> {
self.inner(py).borrow_mut().clear(); self.inner(py).borrow_mut().clear();
Ok(py.None()) Ok(py.None())
} }

rust/hg-cpython/src/dirstate/dispatch.rs

  • This file was moved to rust/hg-core/src/dirstate_tree/owning_dispatch.rs.

rust/hg-cpython/src/dirstate/owning.rs

  • This file was moved to rust/hg-core/src/dirstate_tree/owning.rs.

rust/hg-cpython/src/pybytes_deref.rs

use cpython::{PyBytes, Python}; use cpython::{PyBytes, Python};
use stable_deref_trait::StableDeref;
/// Safe abstraction over a `PyBytes` together with the `&[u8]` slice /// Safe abstraction over a `PyBytes` together with the `&[u8]` slice
/// that borrows it. Implements `Deref<Target = [u8]>`. /// that borrows it. Implements `Deref<Target = [u8]>`.
/// ///
/// Calling `PyBytes::data` requires a GIL marker but we want to access the /// Calling `PyBytes::data` requires a GIL marker but we want to access the
/// data in a thread that (ideally) does not need to acquire the GIL. /// data in a thread that (ideally) does not need to acquire the GIL.
/// This type allows separating the call an the use. /// This type allows separating the call an the use.
/// ///
fn deref(&self) -> &[u8] { fn deref(&self) -> &[u8] {
// Safety: the raw pointer is valid as long as the PyBytes is still // Safety: the raw pointer is valid as long as the PyBytes is still
// alive, and the returned slice borrows `self`. // alive, and the returned slice borrows `self`.
unsafe { &*self.data } unsafe { &*self.data }
} }
} }
unsafe impl StableDeref for PyBytesDeref {}
fn require_send<T: Send>() {} fn require_send<T: Send>() {}
#[allow(unused)] #[allow(unused)]
fn static_assert_pybytes_is_send() { fn static_assert_pybytes_is_send() {
require_send::<PyBytes>; require_send::<PyBytes>;
} }
// Safety: PyBytes is Send. Raw pointers are not by default, // Safety: PyBytes is Send. Raw pointers are not by default,
// but here sending one to another thread is fine since we ensure it stays // but here sending one to another thread is fine since we ensure it stays
// valid. // valid.
unsafe impl Send for PyBytesDeref {} unsafe impl Send for PyBytesDeref {}