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

annotate rust/hg-cpython/src/ref_sharing.rs @ 44278:2a24ead003f0

rust-cpython: add panicking version of borrow_mut() and use it The original borrow_mut() is renamed to try_borrow_mut(). Since leak_immutable() no longer incref the borrow count, the caller should know if the underlying value is borrowed or not. No Python world is involved. That's why we can simply use the panicking borrow_mut().

author	Yuya Nishihara <yuya@tcha.org>
date	Sat, 12 Oct 2019 23:34:05 +0900
parents	4a4c3b9fd91b
children	bafdaf4858d8

rev	line source
43082 fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42943 diff changeset	1 // ref_sharing.rs
42768 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: 42943 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: 42943 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: 42943 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: 42943 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: 42943 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: 42943 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: 42943 diff changeset	11 //
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42943 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: 42943 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: 42943 diff changeset	14 //
fdfe5cfb3723 rust-cpython: change license of ref_sharing.rs to MIT Yuya Nishihara <yuya@tcha.org> parents: 42943 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: 42943 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: 42943 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: 42943 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: 42943 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: 42943 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: 42943 diff changeset	21 // IN THE SOFTWARE.
42768 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;
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	26 use cpython::{exc, PyClone, PyErr, PyObject, PyResult, Python};
43480 6c0e47874217 rust-cpython: drop manual management of mutably_borrowed Yuya Nishihara <yuya@tcha.org> parents: 43479 diff changeset	27 use std::cell::{Ref, RefCell, RefMut};
43475 945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	28 use std::ops::{Deref, DerefMut};
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	29 use std::sync::atomic::{AtomicUsize, Ordering};
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	30
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	31 /// Manages the shared state between Python and Rust
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	32 ///
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	33 /// `PySharedState` is owned by `PySharedRefCell`, and is shared across its
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	34 /// derived references. The consistency of these references are guaranteed
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	35 /// as follows:
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	36 ///
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	37 /// - The immutability of `py_class!` object fields. Any mutation of
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	38 /// `PySharedRefCell` is allowed only through its `borrow_mut()`.
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	39 /// - The `py: Python<'_>` token, which makes sure that any data access is
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	40 /// synchronized by the GIL.
43479 b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	41 /// - The underlying `RefCell`, which prevents `PySharedRefCell` data from
b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	42 /// being directly borrowed or leaked while it is mutably borrowed.
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	43 /// - The `borrow_count`, which is the number of references borrowed from
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	44 /// `PyLeaked`. Just like `RefCell`, mutation is prohibited while `PyLeaked`
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	45 /// is borrowed.
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	46 /// - The `generation` counter, which increments on `borrow_mut()`. `PyLeaked`
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	47 /// reference is valid only if the `current_generation()` equals to the
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	48 /// `generation` at the time of `leak_immutable()`.
43173 070a38737334 rust-cpython: move py_shared_state to PySharedRefCell object Yuya Nishihara <yuya@tcha.org> parents: 43082 diff changeset	49 #[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	50 struct PySharedState {
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	51 // The counter variable could be Cell<usize> since any operation on
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	52 // PySharedState is synchronized by the GIL, but being "atomic" makes
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	53 // PySharedState inherently Sync. The ordering requirement doesn't
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	54 // matter thanks to the GIL.
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	55 borrow_count: AtomicUsize,
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	56 generation: AtomicUsize,
42768 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
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	59 impl PySharedState {
44264 4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	60 fn try_borrow_mut<'a, T>(
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	61 &'a self,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	62 py: Python<'a>,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	63 pyrefmut: RefMut<'a, T>,
43481 75b4eb98ad97 rust-cpython: remove useless PyRefMut wrapper Yuya Nishihara <yuya@tcha.org> parents: 43480 diff changeset	64 ) -> PyResult<RefMut<'a, T>> {
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	65 match self.current_borrow_count(py) {
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	66 0 => {
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	67 // Note that this wraps around to the same value if mutably
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	68 // borrowed more than usize::MAX times, which wouldn't happen
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	69 // in practice.
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	70 self.generation.fetch_add(1, Ordering::Relaxed);
43481 75b4eb98ad97 rust-cpython: remove useless PyRefMut wrapper Yuya Nishihara <yuya@tcha.org> parents: 43480 diff changeset	71 Ok(pyrefmut)
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	72 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	73 _ => Err(AlreadyBorrowed::new(
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	74 py,
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	75 "Cannot borrow mutably while immutably borrowed",
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	76 )),
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	77 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	78 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	79
43176 aaec70a5f9a8 rust-cpython: store leaked reference to PySharedState in $leaked struct Yuya Nishihara <yuya@tcha.org> parents: 43175 diff changeset	80 /// 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	81 /// artificial static lifetime.
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	82 /// We need to be protected by the GIL for thread-safety.
42857 64e28b891796 rust-cpython: mark unsafe functions as such Yuya Nishihara <yuya@tcha.org> parents: 42856 diff changeset	83 ///
64e28b891796 rust-cpython: mark unsafe functions as such Yuya Nishihara <yuya@tcha.org> parents: 42856 diff changeset	84 /// # Safety
64e28b891796 rust-cpython: mark unsafe functions as such Yuya Nishihara <yuya@tcha.org> parents: 42856 diff changeset	85 ///
64e28b891796 rust-cpython: mark unsafe functions as such Yuya Nishihara <yuya@tcha.org> parents: 42856 diff changeset	86 /// 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: 42856 diff changeset	87 /// 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	88 unsafe fn leak_immutable<T>(
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	89 &self,
43480 6c0e47874217 rust-cpython: drop manual management of mutably_borrowed Yuya Nishihara <yuya@tcha.org> parents: 43479 diff changeset	90 _py: Python,
43479 b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	91 data: Ref<T>,
43482 8418b77132c1 rust-cpython: remove useless PyResult<> from leak_immutable() Yuya Nishihara <yuya@tcha.org> parents: 43481 diff changeset	92 ) -> (&'static T, &'static PySharedState) {
43479 b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	93 let ptr: const T = &data;
b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	94 let state_ptr: *const PySharedState = self;
43482 8418b77132c1 rust-cpython: remove useless PyResult<> from leak_immutable() Yuya Nishihara <yuya@tcha.org> parents: 43481 diff changeset	95 (&ptr, &state_ptr)
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	96 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	97
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	98 fn current_borrow_count(&self, _py: Python) -> usize {
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	99 self.borrow_count.load(Ordering::Relaxed)
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	100 }
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	101
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	102 fn increase_borrow_count(&self, _py: Python) {
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	103 // Note that this wraps around if there are more than usize::MAX
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	104 // borrowed references, which shouldn't happen due to memory limit.
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	105 self.borrow_count.fetch_add(1, Ordering::Relaxed);
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	106 }
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	107
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	108 fn decrease_borrow_count(&self, _py: Python) {
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	109 let prev_count = self.borrow_count.fetch_sub(1, Ordering::Relaxed);
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	110 assert!(prev_count > 0);
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	111 }
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	112
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	113 fn current_generation(&self, _py: Python) -> usize {
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	114 self.generation.load(Ordering::Relaxed)
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	115 }
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	116 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	117
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	118 /// Helper to keep the borrow count updated while the shared object is
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	119 /// immutably borrowed without using the `RefCell` interface.
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	120 struct BorrowPyShared<'a> {
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	121 py: Python<'a>,
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	122 py_shared_state: &'a PySharedState,
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	123 }
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	124
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	125 impl<'a> BorrowPyShared<'a> {
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	126 fn new(
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	127 py: Python<'a>,
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	128 py_shared_state: &'a PySharedState,
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	129 ) -> BorrowPyShared<'a> {
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	130 py_shared_state.increase_borrow_count(py);
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	131 BorrowPyShared {
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	132 py,
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	133 py_shared_state,
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	134 }
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	135 }
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	136 }
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	137
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	138 impl Drop for BorrowPyShared<'_> {
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	139 fn drop(&mut self) {
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	140 self.py_shared_state.decrease_borrow_count(self.py);
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	141 }
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	142 }
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	143
42855 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	144 /// `RefCell` wrapper to be safely used in conjunction with `PySharedState`.
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	145 ///
43288 434d7a3e92e3 rust-cpython: make inner functions and structs of ref_sharing private Yuya Nishihara <yuya@tcha.org> parents: 43287 diff changeset	146 /// 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	147 /// operation is allowed through the `PySharedRef` interface.
42855 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	148 #[derive(Debug)]
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	149 pub struct PySharedRefCell<T> {
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	150 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	151 py_shared_state: PySharedState,
42855 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	152 }
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	153
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	154 impl<T> PySharedRefCell<T> {
43173 070a38737334 rust-cpython: move py_shared_state to PySharedRefCell object Yuya Nishihara <yuya@tcha.org> parents: 43082 diff changeset	155 pub fn new(value: T) -> PySharedRefCell<T> {
42855 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	156 Self {
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	157 inner: RefCell::new(value),
43173 070a38737334 rust-cpython: move py_shared_state to PySharedRefCell object Yuya Nishihara <yuya@tcha.org> parents: 43082 diff changeset	158 py_shared_state: PySharedState::default(),
42855 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	159 }
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	160 }
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	161
43288 434d7a3e92e3 rust-cpython: make inner functions and structs of ref_sharing private Yuya Nishihara <yuya@tcha.org> parents: 43287 diff changeset	162 fn borrow<'a>(&'a self, _py: Python<'a>) -> Ref<'a, T> {
42855 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	163 // py_shared_state isn't involved since
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	164 // - inner.borrow() would fail if self is mutably borrowed,
44264 4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	165 // - and inner.try_borrow_mut() would fail while self is borrowed.
42855 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	166 self.inner.borrow()
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	167 }
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	168
44264 4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	169 fn try_borrow_mut<'a>(
4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	170 &'a self,
4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	171 py: Python<'a>,
4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	172 ) -> PyResult<RefMut<'a, T>> {
4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	173 let inner_ref = self
4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	174 .inner
4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	175 .try_borrow_mut()
4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	176 .map_err(\|e\| AlreadyBorrowed::new(py, e.to_string()))?;
4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	177 self.py_shared_state.try_borrow_mut(py, inner_ref)
42855 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	178 }
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	179 }
8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	180
43178 1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	181 /// 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	182 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	183 py: Python<'a>,
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	184 owner: &'a PyObject,
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	185 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	186 }
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	187
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	188 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	189 /// # Safety
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	190 ///
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	191 /// 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	192 /// would get wrong.
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	193 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	194 py: Python<'a>,
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	195 owner: &'a PyObject,
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	196 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	197 ) -> Self {
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	198 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	199 }
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	200
43272 00222775d59b rust-refsharing: add missing lifetime parameter in ref_sharing Rapha?l Gom?s <rgomes@octobus.net> parents: 43180 diff changeset	201 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	202 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	203 }
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	204
44278 2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	205 /// Mutably borrows the wrapped value.
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	206 ///
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	207 /// # Panics
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	208 ///
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	209 /// Panics if the value is currently borrowed through `PySharedRef`
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	210 /// or `PyLeaked`.
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	211 pub fn borrow_mut(&self) -> RefMut<'a, T> {
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	212 self.try_borrow_mut().expect("already borrowed")
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	213 }
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	214
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	215 /// Mutably borrows the wrapped value, returning an error if the value
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	216 /// is currently borrowed.
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	217 pub fn try_borrow_mut(&self) -> PyResult<RefMut<'a, T>> {
44264 4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	218 self.data.try_borrow_mut(self.py)
43178 1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	219 }
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	220
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	221 /// Returns a leaked reference.
43479 b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	222 ///
b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	223 /// # Panics
b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	224 ///
b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	225 /// Panics if this is mutably borrowed.
43482 8418b77132c1 rust-cpython: remove useless PyResult<> from leak_immutable() Yuya Nishihara <yuya@tcha.org> parents: 43481 diff changeset	226 pub fn leak_immutable(&self) -> PyLeaked<&'static T> {
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	227 let state = &self.data.py_shared_state;
43479 b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	228 // make sure self.data isn't mutably borrowed; otherwise the
b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	229 // generation number can't be trusted.
b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	230 let data_ref = self.borrow();
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	231 unsafe {
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	232 let (static_ref, static_state_ref) =
43482 8418b77132c1 rust-cpython: remove useless PyResult<> from leak_immutable() Yuya Nishihara <yuya@tcha.org> parents: 43481 diff changeset	233 state.leak_immutable(self.py, data_ref);
8418b77132c1 rust-cpython: remove useless PyResult<> from leak_immutable() Yuya Nishihara <yuya@tcha.org> parents: 43481 diff changeset	234 PyLeaked::new(self.py, self.owner, static_ref, static_state_ref)
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	235 }
43178 1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	236 }
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	237 }
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	238
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	239 /// 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	240 /// data members with Python.
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	241 ///
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	242 /// # Parameters
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 /// * `$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	245 /// * `$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	246 /// * `$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	247 /// 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	248 /// * `$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	249 /// 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	250 ///
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	251 /// # Safety
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	252 ///
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	253 /// `$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	254 /// words, it must be an accessor to a data field of the Python object.
42768 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 /// # Example
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 /// ```
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	259 /// struct MyStruct {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	260 /// inner: Vec<u32>;
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	261 /// }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	262 ///
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	263 /// py_class!(pub class MyType \|py\| {
42855 8db8fa1de2ef rust-cpython: introduce restricted variant of RefCell Yuya Nishihara <yuya@tcha.org> parents: 42849 diff changeset	264 /// data inner: PySharedRefCell<MyStruct>;
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	265 /// });
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	266 ///
43178 1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	267 /// py_shared_ref!(MyType, MyStruct, inner, inner_shared);
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	268 /// ```
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	269 macro_rules! py_shared_ref {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	270 (
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	271 $name: ident,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	272 $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	273 $data_member: ident,
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	274 $shared_accessor: ident
42768 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 impl $name {
43178 1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	277 /// 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	278 ///
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	279 /// 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	280 /// 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	281 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	282 &'a self,
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	283 py: Python<'a>,
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	284 ) -> $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	285 use cpython::PythonObject;
1b2200bd06b6 rust-cpython: add safe wrapper representing shared data borrowed from PyObject Yuya Nishihara <yuya@tcha.org> parents: 43177 diff changeset	286 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	287 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	288 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	289 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	290 }
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	291 }
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	292 };
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	293 }
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	294
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	295 /// Manage immutable references to `PyObject` leaked into Python iterators.
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	296 ///
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	297 /// This reference will be invalidated once the original value is mutably
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	298 /// borrowed.
43474 b9f791090211 rust-cpython: rename PyLeakedRef to PyLeaked Yuya Nishihara <yuya@tcha.org> parents: 43289 diff changeset	299 pub struct PyLeaked<T> {
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	300 inner: PyObject,
44263 1f9e6fbdd3e6 rust-cpython: remove useless wrappers from PyLeaked, just move by map() Yuya Nishihara <yuya@tcha.org> parents: 43482 diff changeset	301 data: T,
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	302 py_shared_state: &'static PySharedState,
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	303 /// Generation counter of data `T` captured when PyLeaked is created.
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	304 generation: usize,
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	305 }
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	306
43474 b9f791090211 rust-cpython: rename PyLeakedRef to PyLeaked Yuya Nishihara <yuya@tcha.org> parents: 43289 diff changeset	307 // DO NOT implement Deref for PyLeaked<T>! Dereferencing PyLeaked
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	308 // without taking Python GIL wouldn't be safe. Also, the underling reference
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	309 // is invalid if generation != py_shared_state.generation.
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	310
43474 b9f791090211 rust-cpython: rename PyLeakedRef to PyLeaked Yuya Nishihara <yuya@tcha.org> parents: 43289 diff changeset	311 impl<T> PyLeaked<T> {
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	312 /// # Safety
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	313 ///
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	314 /// 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	315 fn new(
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	316 py: Python,
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	317 inner: &PyObject,
43284 ce6dd1cee4c8 rust-cpython: put leaked reference in PyLeakedRef Yuya Nishihara <yuya@tcha.org> parents: 43272 diff changeset	318 data: T,
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	319 py_shared_state: &'static PySharedState,
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	320 ) -> Self {
5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	321 Self {
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	322 inner: inner.clone_ref(py),
44263 1f9e6fbdd3e6 rust-cpython: remove useless wrappers from PyLeaked, just move by map() Yuya Nishihara <yuya@tcha.org> parents: 43482 diff changeset	323 data: data,
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	324 py_shared_state,
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	325 generation: py_shared_state.current_generation(py),
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	326 }
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	327 }
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	328
43475 945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	329 /// Immutably borrows the wrapped value.
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	330 ///
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	331 /// Borrowing fails if the underlying reference has been invalidated.
43475 945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	332 pub fn try_borrow<'a>(
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	333 &'a self,
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	334 py: Python<'a>,
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	335 ) -> PyResult<PyLeakedRef<'a, T>> {
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	336 self.validate_generation(py)?;
43475 945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	337 Ok(PyLeakedRef {
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	338 _borrow: BorrowPyShared::new(py, self.py_shared_state),
44263 1f9e6fbdd3e6 rust-cpython: remove useless wrappers from PyLeaked, just move by map() Yuya Nishihara <yuya@tcha.org> parents: 43482 diff changeset	339 data: &self.data,
43475 945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	340 })
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	341 }
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	342
43475 945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	343 /// Mutably borrows the wrapped value.
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	344 ///
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	345 /// Borrowing fails if the underlying reference has been invalidated.
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	346 ///
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	347 /// 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	348 /// `get_mut()` is useless since the inner value can't be mutated.
43475 945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	349 pub fn try_borrow_mut<'a>(
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	350 &'a mut self,
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	351 py: Python<'a>,
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	352 ) -> PyResult<PyLeakedRefMut<'a, T>> {
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	353 self.validate_generation(py)?;
43475 945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	354 Ok(PyLeakedRefMut {
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	355 _borrow: BorrowPyShared::new(py, self.py_shared_state),
44263 1f9e6fbdd3e6 rust-cpython: remove useless wrappers from PyLeaked, just move by map() Yuya Nishihara <yuya@tcha.org> parents: 43482 diff changeset	356 data: &mut self.data,
43475 945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	357 })
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	358 }
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	359
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	360 /// 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	361 ///
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	362 /// 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	363 /// iterator of that container.
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	364 ///
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	365 /// # Panics
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	366 ///
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	367 /// Panics if the underlying reference has been invalidated.
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	368 ///
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	369 /// This is typically called immediately after the `PyLeaked` is obtained.
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	370 /// In which case, the reference must be valid and no panic would occur.
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	371 ///
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	372 /// # Safety
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	373 ///
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	374 /// 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	375 /// It's typically a static reference, but is valid only while the
43474 b9f791090211 rust-cpython: rename PyLeakedRef to PyLeaked Yuya Nishihara <yuya@tcha.org> parents: 43289 diff changeset	376 /// corresponding `PyLeaked` is alive. Do not copy it out of the
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	377 /// function call.
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	378 pub unsafe fn map<U>(
44263 1f9e6fbdd3e6 rust-cpython: remove useless wrappers from PyLeaked, just move by map() Yuya Nishihara <yuya@tcha.org> parents: 43482 diff changeset	379 self,
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	380 py: Python,
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	381 f: impl FnOnce(T) -> U,
43474 b9f791090211 rust-cpython: rename PyLeakedRef to PyLeaked Yuya Nishihara <yuya@tcha.org> parents: 43289 diff changeset	382 ) -> PyLeaked<U> {
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	383 // Needs to test the generation value to make sure self.data reference
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	384 // is still intact.
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	385 self.validate_generation(py)
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	386 .expect("map() over invalidated leaked reference");
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	387
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	388 // 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	389 // 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	390 // 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	391 // returned object back to Something<'static>.
44263 1f9e6fbdd3e6 rust-cpython: remove useless wrappers from PyLeaked, just move by map() Yuya Nishihara <yuya@tcha.org> parents: 43482 diff changeset	392 let new_data = f(self.data);
43474 b9f791090211 rust-cpython: rename PyLeakedRef to PyLeaked Yuya Nishihara <yuya@tcha.org> parents: 43289 diff changeset	393 PyLeaked {
44263 1f9e6fbdd3e6 rust-cpython: remove useless wrappers from PyLeaked, just move by map() Yuya Nishihara <yuya@tcha.org> parents: 43482 diff changeset	394 inner: self.inner,
1f9e6fbdd3e6 rust-cpython: remove useless wrappers from PyLeaked, just move by map() Yuya Nishihara <yuya@tcha.org> parents: 43482 diff changeset	395 data: new_data,
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	396 py_shared_state: self.py_shared_state,
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	397 generation: self.generation,
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	398 }
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	399 }
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	400
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	401 fn validate_generation(&self, py: Python) -> PyResult<()> {
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	402 if self.py_shared_state.current_generation(py) == self.generation {
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	403 Ok(())
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	404 } else {
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	405 Err(PyErr::new::<exc::RuntimeError, _>(
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	406 py,
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	407 "Cannot access to leaked reference after mutation",
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	408 ))
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	409 }
ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	410 }
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	411 }
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	412
43475 945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	413 /// Immutably borrowed reference to a leaked value.
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	414 pub struct PyLeakedRef<'a, T> {
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	415 _borrow: BorrowPyShared<'a>,
43475 945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	416 data: &'a T,
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	417 }
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	418
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	419 impl<T> Deref for PyLeakedRef<'_, T> {
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	420 type Target = T;
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	421
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	422 fn deref(&self) -> &T {
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	423 self.data
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	424 }
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	425 }
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	426
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	427 /// Mutably borrowed reference to a leaked value.
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	428 pub struct PyLeakedRefMut<'a, T> {
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	429 _borrow: BorrowPyShared<'a>,
43475 945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	430 data: &'a mut T,
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	431 }
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	432
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	433 impl<T> Deref for PyLeakedRefMut<'_, T> {
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	434 type Target = T;
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	435
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	436 fn deref(&self) -> &T {
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	437 self.data
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	438 }
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	439 }
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	440
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	441 impl<T> DerefMut for PyLeakedRefMut<'_, T> {
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	442 fn deref_mut(&mut self) -> &mut T {
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	443 self.data
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	444 }
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	445 }
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	446
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	447 /// Defines a `py_class!` that acts as a Python iterator over a Rust iterator.
42894 67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	448 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	449 /// 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: 42893 diff changeset	450 /// 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: 42893 diff changeset	451 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	452 /// # Parameters
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	453 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	454 /// * `$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: 42893 diff changeset	455 /// * `$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: 42893 diff changeset	456 /// * `$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: 42893 diff changeset	457 /// * `$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: 42893 diff changeset	458 /// 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: 42893 diff changeset	459 /// * `$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: 42893 diff changeset	460 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	461 /// # Example
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	462 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	463 /// ```
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	464 /// struct MyStruct {
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	465 /// inner: HashMap<Vec<u8>, Vec<u8>>;
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	466 /// }
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	467 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	468 /// py_class!(pub class MyType \|py\| {
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	469 /// data inner: PySharedRefCell<MyStruct>;
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	470 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	471 /// def __iter__(&self) -> PyResult<MyTypeItemsIterator> {
43482 8418b77132c1 rust-cpython: remove useless PyResult<> from leak_immutable() Yuya Nishihara <yuya@tcha.org> parents: 43481 diff changeset	472 /// let leaked_ref = self.inner_shared(py).leak_immutable();
42897 5ccc08d02280 rust-cpython: leverage py_shared_iterator::from_inner() where appropriate Yuya Nishihara <yuya@tcha.org> parents: 42896 diff changeset	473 /// MyTypeItemsIterator::from_inner(
42894 67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	474 /// py,
43285 ffc1fbd7d1f5 rust-cpython: make PyLeakedRef operations relatively safe Yuya Nishihara <yuya@tcha.org> parents: 43284 diff changeset	475 /// unsafe { leaked_ref.map(py, \|o\| o.iter()) },
42894 67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	476 /// )
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	477 /// }
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	478 /// });
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	479 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	480 /// impl MyType {
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	481 /// fn translate_key_value(
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	482 /// py: Python,
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	483 /// res: (&Vec<u8>, &Vec<u8>),
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	484 /// ) -> PyResult<Option<(PyBytes, PyBytes)>> {
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	485 /// let (f, entry) = res;
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	486 /// Ok(Some((
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	487 /// PyBytes::new(py, f),
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	488 /// PyBytes::new(py, entry),
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	489 /// )))
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	490 /// }
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	491 /// }
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	492 ///
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	493 /// py_shared_ref!(MyType, MyStruct, inner, MyTypeLeakedRef);
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	494 ///
42895 ea91a126c803 rust-cpython: rename py_shared_iterator_impl to py_shared_iterator Yuya Nishihara <yuya@tcha.org> parents: 42894 diff changeset	495 /// py_shared_iterator!(
42894 67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	496 /// MyTypeItemsIterator,
43474 b9f791090211 rust-cpython: rename PyLeakedRef to PyLeaked Yuya Nishihara <yuya@tcha.org> parents: 43289 diff changeset	497 /// PyLeaked<HashMap<'static, Vec<u8>, Vec<u8>>>,
42894 67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	498 /// MyType::translate_key_value,
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	499 /// Option<(PyBytes, PyBytes)>
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	500 /// );
67853749961b rust-cpython: replace dyn Iterator<..> of mapping with concrete type Yuya Nishihara <yuya@tcha.org> parents: 42893 diff changeset	501 /// ```
42895 ea91a126c803 rust-cpython: rename py_shared_iterator_impl to py_shared_iterator Yuya Nishihara <yuya@tcha.org> parents: 42894 diff changeset	502 macro_rules! py_shared_iterator {
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	503 (
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	504 $name: ident,
43177 5cb8867c9e2b rust-cpython: move $leaked struct out of macro Yuya Nishihara <yuya@tcha.org> parents: 43176 diff changeset	505 $leaked: ty,
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	506 $success_func: expr,
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	507 $success_type: ty
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	508 ) => {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	509 py_class!(pub class $name \|py\| {
43478 6f9f15a476a4 rust-cpython: remove useless Option<$leaked> from py_shared_iterator Yuya Nishihara <yuya@tcha.org> parents: 43477 diff changeset	510 data inner: RefCell<$leaked>;
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	511
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	512 def __next__(&self) -> PyResult<$success_type> {
43478 6f9f15a476a4 rust-cpython: remove useless Option<$leaked> from py_shared_iterator Yuya Nishihara <yuya@tcha.org> parents: 43477 diff changeset	513 let mut leaked = self.inner(py).borrow_mut();
6f9f15a476a4 rust-cpython: remove useless Option<$leaked> from py_shared_iterator Yuya Nishihara <yuya@tcha.org> parents: 43477 diff changeset	514 let mut iter = leaked.try_borrow_mut(py)?;
6f9f15a476a4 rust-cpython: remove useless Option<$leaked> from py_shared_iterator Yuya Nishihara <yuya@tcha.org> parents: 43477 diff changeset	515 match iter.next() {
6f9f15a476a4 rust-cpython: remove useless Option<$leaked> from py_shared_iterator Yuya Nishihara <yuya@tcha.org> parents: 43477 diff changeset	516 None => Ok(None),
6f9f15a476a4 rust-cpython: remove useless Option<$leaked> from py_shared_iterator Yuya Nishihara <yuya@tcha.org> parents: 43477 diff changeset	517 Some(res) => $success_func(py, res),
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	518 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	519 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	520
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	521 def __iter__(&self) -> PyResult<Self> {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	522 Ok(self.clone_ref(py))
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	523 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	524 });
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	525
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	526 impl $name {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	527 pub fn from_inner(
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	528 py: Python,
42896 74d67c645278 rust-cpython: remove Option<_> from interface of py_shared_iterator Yuya Nishihara <yuya@tcha.org> parents: 42895 diff changeset	529 leaked: $leaked,
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	530 ) -> PyResult<Self> {
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	531 Self::create_instance(
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	532 py,
43478 6f9f15a476a4 rust-cpython: remove useless Option<$leaked> from py_shared_iterator Yuya Nishihara <yuya@tcha.org> parents: 43477 diff changeset	533 RefCell::new(leaked),
42768 30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	534 )
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	535 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	536 }
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	537 };
30320c7bf79f rust-cpython: add macro for sharing references Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	538 }
43289 8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	539
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	540 #[cfg(test)]
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	541 #[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	542 mod test {
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	543 use super::*;
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	544 use cpython::{GILGuard, Python};
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	545
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	546 py_class!(class Owner \|py\| {
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	547 data string: PySharedRefCell<String>;
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	548 });
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	549 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	550
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	551 fn prepare_env() -> (GILGuard, Owner) {
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	552 let gil = Python::acquire_gil();
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	553 let py = gil.python();
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	554 let owner =
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	555 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	556 .unwrap();
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	557 (gil, owner)
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	558 }
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	559
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	560 #[test]
43475 945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	561 fn test_leaked_borrow() {
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	562 let (gil, owner) = prepare_env();
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	563 let py = gil.python();
43482 8418b77132c1 rust-cpython: remove useless PyResult<> from leak_immutable() Yuya Nishihara <yuya@tcha.org> parents: 43481 diff changeset	564 let leaked = owner.string_shared(py).leak_immutable();
43475 945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	565 let leaked_ref = leaked.try_borrow(py).unwrap();
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	566 assert_eq!(*leaked_ref, "new");
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	567 }
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	568
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	569 #[test]
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	570 fn test_leaked_borrow_mut() {
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	571 let (gil, owner) = prepare_env();
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	572 let py = gil.python();
43482 8418b77132c1 rust-cpython: remove useless PyResult<> from leak_immutable() Yuya Nishihara <yuya@tcha.org> parents: 43481 diff changeset	573 let leaked = owner.string_shared(py).leak_immutable();
43475 945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	574 let mut leaked_iter = unsafe { leaked.map(py, \|s\| s.chars()) };
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	575 let mut leaked_ref = leaked_iter.try_borrow_mut(py).unwrap();
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	576 assert_eq!(leaked_ref.next(), Some('n'));
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	577 assert_eq!(leaked_ref.next(), Some('e'));
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	578 assert_eq!(leaked_ref.next(), Some('w'));
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	579 assert_eq!(leaked_ref.next(), None);
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	580 }
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	581
945d4dba5e78 rust-cpython: add stub wrapper that'll prevent leaked data from being mutated Yuya Nishihara <yuya@tcha.org> parents: 43474 diff changeset	582 #[test]
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	583 fn test_leaked_borrow_after_mut() {
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	584 let (gil, owner) = prepare_env();
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	585 let py = gil.python();
43482 8418b77132c1 rust-cpython: remove useless PyResult<> from leak_immutable() Yuya Nishihara <yuya@tcha.org> parents: 43481 diff changeset	586 let leaked = owner.string_shared(py).leak_immutable();
44278 2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	587 owner.string_shared(py).borrow_mut().clear();
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	588 assert!(leaked.try_borrow(py).is_err());
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	589 }
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	590
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	591 #[test]
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	592 fn test_leaked_borrow_mut_after_mut() {
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	593 let (gil, owner) = prepare_env();
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	594 let py = gil.python();
43482 8418b77132c1 rust-cpython: remove useless PyResult<> from leak_immutable() Yuya Nishihara <yuya@tcha.org> parents: 43481 diff changeset	595 let leaked = owner.string_shared(py).leak_immutable();
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	596 let mut leaked_iter = unsafe { leaked.map(py, \|s\| s.chars()) };
44278 2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	597 owner.string_shared(py).borrow_mut().clear();
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	598 assert!(leaked_iter.try_borrow_mut(py).is_err());
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	599 }
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	600
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	601 #[test]
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	602 #[should_panic(expected = "map() over invalidated leaked reference")]
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	603 fn test_leaked_map_after_mut() {
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	604 let (gil, owner) = prepare_env();
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	605 let py = gil.python();
43482 8418b77132c1 rust-cpython: remove useless PyResult<> from leak_immutable() Yuya Nishihara <yuya@tcha.org> parents: 43481 diff changeset	606 let leaked = owner.string_shared(py).leak_immutable();
44278 2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	607 owner.string_shared(py).borrow_mut().clear();
43476 0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	608 let _leaked_iter = unsafe { leaked.map(py, \|s\| s.chars()) };
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	609 }
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	610
0836efe4967b rust-cpython: add generation counter to leaked reference Yuya Nishihara <yuya@tcha.org> parents: 43475 diff changeset	611 #[test]
44278 2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	612 fn test_try_borrow_mut_while_leaked_ref() {
43289 8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	613 let (gil, owner) = prepare_env();
8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	614 let py = gil.python();
44278 2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	615 assert!(owner.string_shared(py).try_borrow_mut().is_ok());
43482 8418b77132c1 rust-cpython: remove useless PyResult<> from leak_immutable() Yuya Nishihara <yuya@tcha.org> parents: 43481 diff changeset	616 let leaked = owner.string_shared(py).leak_immutable();
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	617 {
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	618 let _leaked_ref = leaked.try_borrow(py).unwrap();
44278 2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	619 assert!(owner.string_shared(py).try_borrow_mut().is_err());
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	620 {
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	621 let _leaked_ref2 = leaked.try_borrow(py).unwrap();
44278 2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	622 assert!(owner.string_shared(py).try_borrow_mut().is_err());
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	623 }
44278 2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	624 assert!(owner.string_shared(py).try_borrow_mut().is_err());
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	625 }
44278 2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	626 assert!(owner.string_shared(py).try_borrow_mut().is_ok());
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	627 }
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	628
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	629 #[test]
44278 2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	630 fn test_try_borrow_mut_while_leaked_ref_mut() {
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	631 let (gil, owner) = prepare_env();
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	632 let py = gil.python();
44278 2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	633 assert!(owner.string_shared(py).try_borrow_mut().is_ok());
43482 8418b77132c1 rust-cpython: remove useless PyResult<> from leak_immutable() Yuya Nishihara <yuya@tcha.org> parents: 43481 diff changeset	634 let leaked = owner.string_shared(py).leak_immutable();
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	635 let mut leaked_iter = unsafe { leaked.map(py, \|s\| s.chars()) };
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	636 {
ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	637 let _leaked_ref = leaked_iter.try_borrow_mut(py).unwrap();
44278 2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	638 assert!(owner.string_shared(py).try_borrow_mut().is_err());
43477 ed50f2c31a4c rust-cpython: allow mutation unless leaked reference is borrowed Yuya Nishihara <yuya@tcha.org> parents: 43476 diff changeset	639 }
44278 2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	640 assert!(owner.string_shared(py).try_borrow_mut().is_ok());
43289 8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	641 }
43479 b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	642
b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	643 #[test]
b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	644 #[should_panic(expected = "mutably borrowed")]
b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	645 fn test_leak_while_borrow_mut() {
b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	646 let (gil, owner) = prepare_env();
b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	647 let py = gil.python();
b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	648 let _mut_ref = owner.string_shared(py).borrow_mut();
43482 8418b77132c1 rust-cpython: remove useless PyResult<> from leak_immutable() Yuya Nishihara <yuya@tcha.org> parents: 43481 diff changeset	649 owner.string_shared(py).leak_immutable();
43479 b7ab3a0a9e57 rust-cpython: leverage RefCell::borrow() to guarantee there's no mutable ref Yuya Nishihara <yuya@tcha.org> parents: 43478 diff changeset	650 }
44264 4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	651
4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	652 #[test]
44278 2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	653 fn test_try_borrow_mut_while_borrow() {
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	654 let (gil, owner) = prepare_env();
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	655 let py = gil.python();
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	656 let _ref = owner.string_shared(py).borrow();
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	657 assert!(owner.string_shared(py).try_borrow_mut().is_err());
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	658 }
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	659
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	660 #[test]
2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	661 #[should_panic(expected = "already borrowed")]
44264 4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	662 fn test_borrow_mut_while_borrow() {
4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	663 let (gil, owner) = prepare_env();
4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	664 let py = gil.python();
4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	665 let _ref = owner.string_shared(py).borrow();
44278 2a24ead003f0 rust-cpython: add panicking version of borrow_mut() and use it Yuya Nishihara <yuya@tcha.org> parents: 44264 diff changeset	666 owner.string_shared(py).borrow_mut();
44264 4a4c3b9fd91b rust-cpython: make sure PySharedRef::borrow_mut() never panics Yuya Nishihara <yuya@tcha.org> parents: 44263 diff changeset	667 }
43289 8d432d3a2d7c rust-cpython: prepare for writing tests that require libpython Yuya Nishihara <yuya@tcha.org> parents: 43288 diff changeset	668 }

Mercurial > public > mercurial-scm > hg-stable

annotate rust/hg-cpython/src/ref_sharing.rs @ 44278:2a24ead003f0