mercurial-scm/hg: rust/hg-cpython/src/ref

annotate rust/hg-cpython/src/ref_sharing.rs @ 43289:8d432d3a2d7c

rust-cpython: prepare for writing tests that require libpython What I wanted is to disable the "cpython/extension-module<ver>" feature while building tests executable, but that seems not doable. Instead, this patch adds new features dedicated for tests. The make rule is extracted so that we can easily run cargo tests. Added a minimal test of ref-sharing as an example. More tests will follow.

author	Yuya Nishihara <yuya@tcha.org>
date	Mon, 14 Oct 2019 16:15:19 +0900
parents	434d7a3e92e3
children	b9f791090211

rev	line source
43082 fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	1 // ref_sharing.rs
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	2 //
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	3 // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	4 //
43082 fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	5 // Permission is hereby granted, free of charge, to any person obtaining a copy
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	6 // of this software and associated documentation files (the "Software"), to
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	7 // deal in the Software without restriction, including without limitation the
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	8 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	9 // sell copies of the Software, and to permit persons to whom the Software is
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	10 // furnished to do so, subject to the following conditions:
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	11 //
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	12 // The above copyright notice and this permission notice shall be included in
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	13 // all copies or substantial portions of the Software.
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	14 //
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	16 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	17 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	18 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	19 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	20 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42939 diff changeset	21 // IN THE SOFTWARE.
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	22
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	23 //! Macros for use in the `hg-cpython` bridge library.
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	24
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	25 use crate::exceptions::AlreadyBorrowed;
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	26 use cpython::{PyClone, PyObject, PyResult, Python};
42849 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	27 use std::cell::{Cell, Ref, RefCell, RefMut};
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	28
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	29 /// Manages the shared state between Python and Rust
43173 070a38737334 rust-cpython: move py_shared_state to PySharedRefCell object Yuya Nishihara <yuya@tcha.org> parents: 43082 diff changeset	30 #[derive(Debug, Default)]
43288 434d7a3e92e3 rust-cpython: make inner functions and structs of ref_sharing private Yuya Nishihara <yuya@tcha.org> parents: 43287 diff changeset	31 struct PySharedState {
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	32 leak_count: Cell<usize>,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	33 mutably_borrowed: Cell<bool>,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	34 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	35
43175 a1908eb08342 rust-cpython: mark PySharedState as Sync so &'PySharedState can be Send Yuya Nishihara <yuya@tcha.org> parents: 43174 diff changeset	36 // &PySharedState can be Send because any access to inner cells is
a1908eb08342 rust-cpython: mark PySharedState as Sync so &'PySharedState can be Send Yuya Nishihara <yuya@tcha.org> parents: 43174 diff changeset	37 // synchronized by the GIL.
a1908eb08342 rust-cpython: mark PySharedState as Sync so &'PySharedState can be Send Yuya Nishihara <yuya@tcha.org> parents: 43174 diff changeset	38 unsafe impl Sync for PySharedState {}
a1908eb08342 rust-cpython: mark PySharedState as Sync so &'PySharedState can be Send Yuya Nishihara <yuya@tcha.org> parents: 43174 diff changeset	39
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	40 impl PySharedState {
43288 434d7a3e92e3 rust-cpython: make inner functions and structs of ref_sharing private Yuya Nishihara <yuya@tcha.org> parents: 43287 diff changeset	41 fn borrow_mut<'a, T>(
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	42 &'a self,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	43 py: Python<'a>,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	44 pyrefmut: RefMut<'a, T>,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	45 ) -> PyResult<PyRefMut<'a, T>> {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	46 if self.mutably_borrowed.get() {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	47 return Err(AlreadyBorrowed::new(
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	48 py,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	49 "Cannot borrow mutably while there exists another \
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	50 mutable reference in a Python object",
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	51 ));
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	52 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	53 match self.leak_count.get() {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	54 0 => {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	55 self.mutably_borrowed.replace(true);
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	56 Ok(PyRefMut::new(py, pyrefmut, self))
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	57 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	58 // TODO
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	59 // For now, this works differently than Python references
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	60 // in the case of iterators.
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	61 // Python does not complain when the data an iterator
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	62 // points to is modified if the iterator is never used
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	63 // afterwards.
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	64 // Here, we are stricter than this by refusing to give a
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	65 // mutable reference if it is already borrowed.
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	66 // While the additional safety might be argued for, it
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	67 // breaks valid programming patterns in Python and we need
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	68 // to fix this issue down the line.
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	69 _ => Err(AlreadyBorrowed::new(
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	70 py,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	71 "Cannot borrow mutably while there are \
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	72 immutable references in Python objects",
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	73 )),
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	74 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	75 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	76
43176 aaec70a5f9a8 rust-cpython: store leaked reference to PySharedState in $leaked struct Yuya Nishihara <yuya@tcha.org> parents: 43175 diff changeset	77 /// Return a reference to the wrapped data and its state with an
aaec70a5f9a8 rust-cpython: store leaked reference to PySharedState in $leaked struct Yuya Nishihara <yuya@tcha.org> parents: 43175 diff changeset	78 /// artificial static lifetime.
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	79 /// We need to be protected by the GIL for thread-safety.
42851 64e28b891796 rust-cpython: mark unsafe functions as such Yuya Nishihara <yuya@tcha.org> parents: 42850 diff changeset	80 ///
64e28b891796 rust-cpython: mark unsafe functions as such Yuya Nishihara <yuya@tcha.org> parents: 42850 diff changeset	81 /// # Safety
64e28b891796 rust-cpython: mark unsafe functions as such Yuya Nishihara <yuya@tcha.org> parents: 42850 diff changeset	82 ///
64e28b891796 rust-cpython: mark unsafe functions as such Yuya Nishihara <yuya@tcha.org> parents: 42850 diff changeset	83 /// This is highly unsafe since the lifetime of the given data can be
64e28b891796 rust-cpython: mark unsafe functions as such Yuya Nishihara <yuya@tcha.org> parents: 42850 diff changeset	84 /// extended. Do not call this function directly.
43288 434d7a3e92e3 rust-cpython: make inner functions and structs of ref_sharing private Yuya Nishihara <yuya@tcha.org> parents: 43287 diff changeset	85 unsafe fn leak_immutable<T>(
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	86 &self,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	87 py: Python,
42849 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	88 data: &PySharedRefCell<T>,
43176 aaec70a5f9a8 rust-cpython: store leaked reference to PySharedState in $leaked struct Yuya Nishihara <yuya@tcha.org> parents: 43175 diff changeset	89 ) -> PyResult<(&'static T, &'static PySharedState)> {
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	90 if self.mutably_borrowed.get() {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	91 return Err(AlreadyBorrowed::new(
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	92 py,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	93 "Cannot borrow immutably while there is a \
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	94 mutable reference in Python objects",
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	95 ));
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	96 }
43176 aaec70a5f9a8 rust-cpython: store leaked reference to PySharedState in $leaked struct Yuya Nishihara <yuya@tcha.org> parents: 43175 diff changeset	97 // TODO: it's weird that self is data.py_shared_state. Maybe we
aaec70a5f9a8 rust-cpython: store leaked reference to PySharedState in $leaked struct Yuya Nishihara <yuya@tcha.org> parents: 43175 diff changeset	98 // can move stuff to PySharedRefCell?
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	99 let ptr = data.as_ptr();
43176 aaec70a5f9a8 rust-cpython: store leaked reference to PySharedState in $leaked struct Yuya Nishihara <yuya@tcha.org> parents: 43175 diff changeset	100 let state_ptr: *const PySharedState = &data.py_shared_state;
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	101 self.leak_count.replace(self.leak_count.get() + 1);
43176 aaec70a5f9a8 rust-cpython: store leaked reference to PySharedState in $leaked struct Yuya Nishihara <yuya@tcha.org> parents: 43175 diff changeset	102 Ok((&ptr, &state_ptr))
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	103 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	104
42851 64e28b891796 rust-cpython: mark unsafe functions as such Yuya Nishihara <yuya@tcha.org> parents: 42850 diff changeset	105 /// # Safety
64e28b891796 rust-cpython: mark unsafe functions as such Yuya Nishihara <yuya@tcha.org> parents: 42850 diff changeset	106 ///
43288 434d7a3e92e3 rust-cpython: make inner functions and structs of ref_sharing private Yuya Nishihara <yuya@tcha.org> parents: 43287 diff changeset	107 /// It's up to you to make sure the reference is about to be deleted
434d7a3e92e3 rust-cpython: make inner functions and structs of ref_sharing private Yuya Nishihara <yuya@tcha.org> parents: 43287 diff changeset	108 /// when updating the leak count.
434d7a3e92e3 rust-cpython: make inner functions and structs of ref_sharing private Yuya Nishihara <yuya@tcha.org> parents: 43287 diff changeset	109 fn decrease_leak_count(&self, _py: Python, mutable: bool) {
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	110 if mutable {
42939 06080afd0565 rust-cpython: add sanity check to PySharedState::decrease_leak_count() Yuya Nishihara <yuya@tcha.org> parents: 42891 diff changeset	111 assert_eq!(self.leak_count.get(), 0);
06080afd0565 rust-cpython: add sanity check to PySharedState::decrease_leak_count() Yuya Nishihara <yuya@tcha.org> parents: 42891 diff changeset	112 assert!(self.mutably_borrowed.get());
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	113 self.mutably_borrowed.replace(false);
42939 06080afd0565 rust-cpython: add sanity check to PySharedState::decrease_leak_count() Yuya Nishihara <yuya@tcha.org> parents: 42891 diff changeset	114 } else {
06080afd0565 rust-cpython: add sanity check to PySharedState::decrease_leak_count() Yuya Nishihara <yuya@tcha.org> parents: 42891 diff changeset	115 let count = self.leak_count.get();
06080afd0565 rust-cpython: add sanity check to PySharedState::decrease_leak_count() Yuya Nishihara <yuya@tcha.org> parents: 42891 diff changeset	116 assert!(count > 0);
06080afd0565 rust-cpython: add sanity check to PySharedState::decrease_leak_count() Yuya Nishihara <yuya@tcha.org> parents: 42891 diff changeset	117 self.leak_count.replace(count - 1);
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	118 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	119 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	120 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	121
42849 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	122 /// `RefCell` wrapper to be safely used in conjunction with `PySharedState`.
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	123 ///
43288 434d7a3e92e3 rust-cpython: make inner functions and structs of ref_sharing private Yuya Nishihara <yuya@tcha.org> parents: 43287 diff changeset	124 /// This object can be stored in a `py_class!` object as a data field. Any
434d7a3e92e3 rust-cpython: make inner functions and structs of ref_sharing private Yuya Nishihara <yuya@tcha.org> parents: 43287 diff changeset	125 /// operation is allowed through the `PySharedRef` interface.
42849 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	126 #[derive(Debug)]
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	127 pub struct PySharedRefCell<T> {
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	128 inner: RefCell<T>,
43178 1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	129 py_shared_state: PySharedState,
42849 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	130 }
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	131
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	132 impl<T> PySharedRefCell<T> {
43173 070a38737334 rust-cpython: move py_shared_state to PySharedRefCell object Yuya Nishihara <yuya@tcha.org> parents: 43082 diff changeset	133 pub fn new(value: T) -> PySharedRefCell<T> {
42849 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	134 Self {
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	135 inner: RefCell::new(value),
43173 070a38737334 rust-cpython: move py_shared_state to PySharedRefCell object Yuya Nishihara <yuya@tcha.org> parents: 43082 diff changeset	136 py_shared_state: PySharedState::default(),
42849 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	137 }
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	138 }
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	139
43288 434d7a3e92e3 rust-cpython: make inner functions and structs of ref_sharing private Yuya Nishihara <yuya@tcha.org> parents: 43287 diff changeset	140 fn borrow<'a>(&'a self, _py: Python<'a>) -> Ref<'a, T> {
42849 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	141 // py_shared_state isn't involved since
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	142 // - inner.borrow() would fail if self is mutably borrowed,
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	143 // - and inner.borrow_mut() would fail while self is borrowed.
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	144 self.inner.borrow()
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	145 }
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	146
43288 434d7a3e92e3 rust-cpython: make inner functions and structs of ref_sharing private Yuya Nishihara <yuya@tcha.org> parents: 43287 diff changeset	147 fn as_ptr(&self) -> *mut T {
42849 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	148 self.inner.as_ptr()
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	149 }
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	150
43174 1c675c5fe5fe rust-cpython: move borrow_mut() to PySharedRefCell Yuya Nishihara <yuya@tcha.org> parents: 43173 diff changeset	151 // TODO: maybe this should be named as try_borrow_mut(), and use
1c675c5fe5fe rust-cpython: move borrow_mut() to PySharedRefCell Yuya Nishihara <yuya@tcha.org> parents: 43173 diff changeset	152 // inner.try_borrow_mut(). The current implementation panics if
1c675c5fe5fe rust-cpython: move borrow_mut() to PySharedRefCell Yuya Nishihara <yuya@tcha.org> parents: 43173 diff changeset	153 // self.inner has been borrowed, but returns error if py_shared_state
1c675c5fe5fe rust-cpython: move borrow_mut() to PySharedRefCell Yuya Nishihara <yuya@tcha.org> parents: 43173 diff changeset	154 // refuses to borrow.
43288 434d7a3e92e3 rust-cpython: make inner functions and structs of ref_sharing private Yuya Nishihara <yuya@tcha.org> parents: 43287 diff changeset	155 fn borrow_mut<'a>(&'a self, py: Python<'a>) -> PyResult<PyRefMut<'a, T>> {
43174 1c675c5fe5fe rust-cpython: move borrow_mut() to PySharedRefCell Yuya Nishihara <yuya@tcha.org> parents: 43173 diff changeset	156 self.py_shared_state.borrow_mut(py, self.inner.borrow_mut())
42849 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	157 }
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	158 }
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	159
43178 1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	160 /// Sharable data member of type `T` borrowed from the `PyObject`.
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	161 pub struct PySharedRef<'a, T> {
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	162 py: Python<'a>,
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	163 owner: &'a PyObject,
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	164 data: &'a PySharedRefCell<T>,
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	165 }
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	166
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	167 impl<'a, T> PySharedRef<'a, T> {
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	168 /// # Safety
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	169 ///
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	170 /// The `data` must be owned by the `owner`. Otherwise, the leak count
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	171 /// would get wrong.
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	172 pub unsafe fn new(
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	173 py: Python<'a>,
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	174 owner: &'a PyObject,
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	175 data: &'a PySharedRefCell<T>,
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	176 ) -> Self {
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	177 Self { py, owner, data }
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	178 }
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	179
43272 00222775d59b rust-refsharing: add missing lifetime parameter in ref_sharing Rapha?l Gom?s <rgomes@octobus.net> parents: 43180 diff changeset	180 pub fn borrow(&self) -> Ref<'a, T> {
43286 f8c114f20d2d rust-cpython: require GIL to borrow immutable reference from PySharedRefCell Yuya Nishihara <yuya@tcha.org> parents: 43285 diff changeset	181 self.data.borrow(self.py)
43178 1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	182 }
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	183
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	184 pub fn borrow_mut(&self) -> PyResult<PyRefMut<'a, T>> {
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	185 self.data.borrow_mut(self.py)
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	186 }
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	187
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	188 /// Returns a leaked reference.
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	189 pub fn leak_immutable(&self) -> PyResult<PyLeakedRef<&'static T>> {
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	190 let state = &self.data.py_shared_state;
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	191 unsafe {
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	192 let (static_ref, static_state_ref) =
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	193 state.leak_immutable(self.py, self.data)?;
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	194 Ok(PyLeakedRef::new(
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	195 self.py,
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	196 self.owner,
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	197 static_ref,
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	198 static_state_ref,
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	199 ))
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	200 }
43178 1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	201 }
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	202 }
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	203
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	204 /// Holds a mutable reference to data shared between Python and Rust.
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	205 pub struct PyRefMut<'a, T> {
43287 0df8312463ae rust-cpython: keep Python<'a> token in PyRefMut Yuya Nishihara <yuya@tcha.org> parents: 43286 diff changeset	206 py: Python<'a>,
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	207 inner: RefMut<'a, T>,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	208 py_shared_state: &'a PySharedState,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	209 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	210
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	211 impl<'a, T> PyRefMut<'a, T> {
42851 64e28b891796 rust-cpython: mark unsafe functions as such Yuya Nishihara <yuya@tcha.org> parents: 42850 diff changeset	212 // Must be constructed by PySharedState after checking its leak_count.
64e28b891796 rust-cpython: mark unsafe functions as such Yuya Nishihara <yuya@tcha.org> parents: 42850 diff changeset	213 // Otherwise, drop() would incorrectly update the state.
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	214 fn new(
43287 0df8312463ae rust-cpython: keep Python<'a> token in PyRefMut Yuya Nishihara <yuya@tcha.org> parents: 43286 diff changeset	215 py: Python<'a>,
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	216 inner: RefMut<'a, T>,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	217 py_shared_state: &'a PySharedState,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	218 ) -> Self {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	219 Self {
43287 0df8312463ae rust-cpython: keep Python<'a> token in PyRefMut Yuya Nishihara <yuya@tcha.org> parents: 43286 diff changeset	220 py,
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	221 inner,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	222 py_shared_state,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	223 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	224 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	225 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	226
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	227 impl<'a, T> std::ops::Deref for PyRefMut<'a, T> {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	228 type Target = RefMut<'a, T>;
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	229
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	230 fn deref(&self) -> &Self::Target {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	231 &self.inner
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	232 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	233 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	234 impl<'a, T> std::ops::DerefMut for PyRefMut<'a, T> {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	235 fn deref_mut(&mut self) -> &mut Self::Target {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	236 &mut self.inner
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	237 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	238 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	239
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	240 impl<'a, T> Drop for PyRefMut<'a, T> {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	241 fn drop(&mut self) {
43288 434d7a3e92e3 rust-cpython: make inner functions and structs of ref_sharing private Yuya Nishihara <yuya@tcha.org> parents: 43287 diff changeset	242 self.py_shared_state.decrease_leak_count(self.py, true);
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	243 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	244 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	245
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	246 /// Allows a `py_class!` generated struct to share references to one of its
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	247 /// data members with Python.
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	248 ///
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	249 /// # Warning
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	250 ///
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	251 /// TODO allow Python container types: for now, integration with the garbage
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	252 /// collector does not extend to Rust structs holding references to Python
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	253 /// objects. Should the need surface, `__traverse__` and `__clear__` will
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	254 /// need to be written as per the `rust-cpython` docs on GC integration.
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	255 ///
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	256 /// # Parameters
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	257 ///
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	258 /// * `$name` is the same identifier used in for `py_class!` macro call.
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	259 /// * `$inner_struct` is the identifier of the underlying Rust struct
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	260 /// * `$data_member` is the identifier of the data member of `$inner_struct`
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	261 /// that will be shared.
43178 1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	262 /// * `$shared_accessor` is the function name to be generated, which allows
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	263 /// safe access to the data member.
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	264 ///
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	265 /// # Safety
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	266 ///
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	267 /// `$data_member` must persist while the `$name` object is alive. In other
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	268 /// words, it must be an accessor to a data field of the Python object.
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	269 ///
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	270 /// # Example
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	271 ///
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	272 /// ```
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	273 /// struct MyStruct {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	274 /// inner: Vec<u32>;
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	275 /// }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	276 ///
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	277 /// py_class!(pub class MyType \|py\| {
42849 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42839 diff changeset	278 /// data inner: PySharedRefCell<MyStruct>;
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	279 /// });
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	280 ///
43178 1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	281 /// py_shared_ref!(MyType, MyStruct, inner, inner_shared);
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	282 /// ```
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	283 macro_rules! py_shared_ref {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	284 (
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	285 $name: ident,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	286 $inner_struct: ident,
43178 1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	287 $data_member: ident,
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	288 $shared_accessor: ident
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	289 ) => {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	290 impl $name {
43178 1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	291 /// Returns a safe reference to the shared `$data_member`.
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	292 ///
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	293 /// This function guarantees that `PySharedRef` is created with
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	294 /// the valid `self` and `self.$data_member(py)` pair.
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	295 fn $shared_accessor<'a>(
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	296 &'a self,
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	297 py: Python<'a>,
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	298 ) -> $crate::ref_sharing::PySharedRef<'a, $inner_struct> {
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	299 use cpython::PythonObject;
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	300 use $crate::ref_sharing::PySharedRef;
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	301 let owner = self.as_object();
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	302 let data = self.$data_member(py);
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	303 unsafe { PySharedRef::new(py, owner, data) }
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	304 }
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	305 }
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	306 };
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	307 }
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	308
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	309 /// Manage immutable references to `PyObject` leaked into Python iterators.
43284 ce6dd1cee4c8 rust-cpython: put leaked reference in PyLeakedRef Yuya Nishihara <yuya@tcha.org> parents: 43272 diff changeset	310 pub struct PyLeakedRef<T> {
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	311 inner: PyObject,
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	312 data: Option<T>,
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	313 py_shared_state: &'static PySharedState,
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	314 }
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	315
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	316 // DO NOT implement Deref for PyLeakedRef<T>! Dereferencing PyLeakedRef
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	317 // without taking Python GIL wouldn't be safe.
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	318
43284 ce6dd1cee4c8 rust-cpython: put leaked reference in PyLeakedRef Yuya Nishihara <yuya@tcha.org> parents: 43272 diff changeset	319 impl<T> PyLeakedRef<T> {
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	320 /// # Safety
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	321 ///
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	322 /// The `py_shared_state` must be owned by the `inner` Python object.
43288 434d7a3e92e3 rust-cpython: make inner functions and structs of ref_sharing private Yuya Nishihara <yuya@tcha.org> parents: 43287 diff changeset	323 fn new(
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	324 py: Python,
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	325 inner: &PyObject,
43284 ce6dd1cee4c8 rust-cpython: put leaked reference in PyLeakedRef Yuya Nishihara <yuya@tcha.org> parents: 43272 diff changeset	326 data: T,
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	327 py_shared_state: &'static PySharedState,
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	328 ) -> Self {
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	329 Self {
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	330 inner: inner.clone_ref(py),
43284 ce6dd1cee4c8 rust-cpython: put leaked reference in PyLeakedRef Yuya Nishihara <yuya@tcha.org> parents: 43272 diff changeset	331 data: Some(data),
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	332 py_shared_state,
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	333 }
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	334 }
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	335
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	336 /// Returns an immutable reference to the inner value.
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	337 pub fn get_ref<'a>(&'a self, _py: Python<'a>) -> &'a T {
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	338 self.data.as_ref().unwrap()
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	339 }
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	340
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	341 /// Returns a mutable reference to the inner value.
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	342 ///
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	343 /// Typically `T` is an iterator. If `T` is an immutable reference,
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	344 /// `get_mut()` is useless since the inner value can't be mutated.
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	345 pub fn get_mut<'a>(&'a mut self, _py: Python<'a>) -> &'a mut T {
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	346 self.data.as_mut().unwrap()
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	347 }
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	348
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	349 /// Converts the inner value by the given function.
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	350 ///
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	351 /// Typically `T` is a static reference to a container, and `U` is an
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	352 /// iterator of that container.
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	353 ///
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	354 /// # Safety
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	355 ///
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	356 /// The lifetime of the object passed in to the function `f` is cheated.
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	357 /// It's typically a static reference, but is valid only while the
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	358 /// corresponding `PyLeakedRef` is alive. Do not copy it out of the
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	359 /// function call.
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	360 pub unsafe fn map<U>(
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	361 mut self,
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	362 py: Python,
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	363 f: impl FnOnce(T) -> U,
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	364 ) -> PyLeakedRef<U> {
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	365 // f() could make the self.data outlive. That's why map() is unsafe.
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	366 // In order to make this function safe, maybe we'll need a way to
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	367 // temporarily restrict the lifetime of self.data and translate the
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	368 // returned object back to Something<'static>.
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	369 let new_data = f(self.data.take().unwrap());
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	370 PyLeakedRef {
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	371 inner: self.inner.clone_ref(py),
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	372 data: Some(new_data),
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	373 py_shared_state: self.py_shared_state,
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	374 }
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	375 }
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	376 }
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	377
43284 ce6dd1cee4c8 rust-cpython: put leaked reference in PyLeakedRef Yuya Nishihara <yuya@tcha.org> parents: 43272 diff changeset	378 impl<T> Drop for PyLeakedRef<T> {
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	379 fn drop(&mut self) {
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	380 // py_shared_state should be alive since we do have
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	381 // a Python reference to the owner object. Taking GIL makes
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	382 // sure that the state is only accessed by this thread.
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	383 let gil = Python::acquire_gil();
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	384 let py = gil.python();
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	385 if self.data.is_none() {
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	386 return; // moved to another PyLeakedRef
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	387 }
43288 434d7a3e92e3 rust-cpython: make inner functions and structs of ref_sharing private Yuya Nishihara <yuya@tcha.org> parents: 43287 diff changeset	388 self.py_shared_state.decrease_leak_count(py, false);
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	389 }
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	390 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	391
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	392 /// Defines a `py_class!` that acts as a Python iterator over a Rust iterator.
42888 67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	393 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	394 /// TODO: this is a bit awkward to use, and a better (more complicated)
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	395 /// procedural macro would simplify the interface a lot.
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	396 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	397 /// # Parameters
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	398 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	399 /// * `$name` is the identifier to give to the resulting Rust struct.
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	400 /// * `$leaked` corresponds to `$leaked` in the matching `py_shared_ref!` call.
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	401 /// * `$iterator_type` is the type of the Rust iterator.
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	402 /// * `$success_func` is a function for processing the Rust `(key, value)`
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	403 /// tuple on iteration success, turning it into something Python understands.
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	404 /// * `$success_func` is the return type of `$success_func`
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	405 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	406 /// # Example
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	407 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	408 /// ```
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	409 /// struct MyStruct {
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	410 /// inner: HashMap<Vec<u8>, Vec<u8>>;
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	411 /// }
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	412 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	413 /// py_class!(pub class MyType \|py\| {
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	414 /// data inner: PySharedRefCell<MyStruct>;
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	415 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	416 /// def __iter__(&self) -> PyResult<MyTypeItemsIterator> {
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	417 /// let leaked_ref = self.inner_shared(py).leak_immutable()?;
42891 5ccc08d02280 rust-cpython: leverage py_shared_iterator::from_inner() where appropriate Yuya Nishihara <yuya@tcha.org> parents: 42890 diff changeset	418 /// MyTypeItemsIterator::from_inner(
42888 67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	419 /// py,
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	420 /// unsafe { leaked_ref.map(py, \|o\| o.iter()) },
42888 67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	421 /// )
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	422 /// }
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	423 /// });
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	424 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	425 /// impl MyType {
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	426 /// fn translate_key_value(
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	427 /// py: Python,
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	428 /// res: (&Vec<u8>, &Vec<u8>),
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	429 /// ) -> PyResult<Option<(PyBytes, PyBytes)>> {
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	430 /// let (f, entry) = res;
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	431 /// Ok(Some((
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	432 /// PyBytes::new(py, f),
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	433 /// PyBytes::new(py, entry),
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	434 /// )))
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	435 /// }
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	436 /// }
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	437 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	438 /// py_shared_ref!(MyType, MyStruct, inner, MyTypeLeakedRef);
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	439 ///
42889 ea91a126c803 rust-cpython: rename py_shared_iterator_impl to py_shared_iterator Yuya Nishihara <yuya@tcha.org> parents: 42888 diff changeset	440 /// py_shared_iterator!(
42888 67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	441 /// MyTypeItemsIterator,
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	442 /// PyLeakedRef<HashMap<'static, Vec<u8>, Vec<u8>>>,
42888 67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	443 /// MyType::translate_key_value,
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	444 /// Option<(PyBytes, PyBytes)>
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	445 /// );
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42887 diff changeset	446 /// ```
42889 ea91a126c803 rust-cpython: rename py_shared_iterator_impl to py_shared_iterator Yuya Nishihara <yuya@tcha.org> parents: 42888 diff changeset	447 macro_rules! py_shared_iterator {
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	448 (
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	449 $name: ident,
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	450 $leaked: ty,
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	451 $success_func: expr,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	452 $success_type: ty
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	453 ) => {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	454 py_class!(pub class $name \|py\| {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	455 data inner: RefCell<Option<$leaked>>;
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	456
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	457 def __next__(&self) -> PyResult<$success_type> {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	458 let mut inner_opt = self.inner(py).borrow_mut();
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	459 if let Some(leaked) = inner_opt.as_mut() {
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	460 match leaked.get_mut(py).next() {
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	461 None => {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	462 // replace Some(inner) by None, drop $leaked
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	463 inner_opt.take();
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	464 Ok(None)
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	465 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	466 Some(res) => {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	467 $success_func(py, res)
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	468 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	469 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	470 } else {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	471 Ok(None)
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	472 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	473 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	474
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	475 def __iter__(&self) -> PyResult<Self> {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	476 Ok(self.clone_ref(py))
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	477 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	478 });
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	479
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	480 impl $name {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	481 pub fn from_inner(
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	482 py: Python,
42890 74d67c645278 rust-cpython: remove Option<_> from interface of py_shared_iterator Yuya Nishihara <yuya@tcha.org> parents: 42889 diff changeset	483 leaked: $leaked,
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	484 ) -> PyResult<Self> {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	485 Self::create_instance(
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	486 py,
42890 74d67c645278 rust-cpython: remove Option<_> from interface of py_shared_iterator Yuya Nishihara <yuya@tcha.org> parents: 42889 diff changeset	487 RefCell::new(Some(leaked)),
42752 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	488 )
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	489 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	490 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	491 };
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	492 }
43289 8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	493
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	494 #[cfg(test)]
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	495 #[cfg(any(feature = "python27-bin", feature = "python3-bin"))]
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	496 mod test {
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	497 use super::*;
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	498 use cpython::{GILGuard, Python};
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	499
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	500 py_class!(class Owner \|py\| {
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	501 data string: PySharedRefCell<String>;
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	502 });
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	503 py_shared_ref!(Owner, String, string, string_shared);
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	504
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	505 fn prepare_env() -> (GILGuard, Owner) {
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	506 let gil = Python::acquire_gil();
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	507 let py = gil.python();
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	508 let owner =
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	509 Owner::create_instance(py, PySharedRefCell::new("new".to_owned()))
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	510 .unwrap();
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	511 (gil, owner)
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	512 }
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	513
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	514 #[test]
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	515 fn test_borrow_mut_while_leaked() {
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	516 let (gil, owner) = prepare_env();
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	517 let py = gil.python();
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	518 assert!(owner.string_shared(py).borrow_mut().is_ok());
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	519 let _leaked = owner.string_shared(py).leak_immutable().unwrap();
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	520 // TODO: will be allowed
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	521 assert!(owner.string_shared(py).borrow_mut().is_err());
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	522 }
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	523 }

Mercurial > public > mercurial-scm > hg

annotate rust/hg-cpython/src/ref_sharing.rs @ 43289:8d432d3a2d7c