Show More
@@ -92,7 +92,7 b' py_class!(pub class Dirs |py| {' | |||||
92 | }) |
|
92 | }) | |
93 | } |
|
93 | } | |
94 | def __iter__(&self) -> PyResult<DirsMultisetKeysIterator> { |
|
94 | def __iter__(&self) -> PyResult<DirsMultisetKeysIterator> { | |
95 |
let leaked_ref = self.inner_shared(py).leak_immutable() |
|
95 | let leaked_ref = self.inner_shared(py).leak_immutable(); | |
96 | DirsMultisetKeysIterator::from_inner( |
|
96 | DirsMultisetKeysIterator::from_inner( | |
97 | py, |
|
97 | py, | |
98 | unsafe { leaked_ref.map(py, |o| o.iter()) }, |
|
98 | unsafe { leaked_ref.map(py, |o| o.iter()) }, |
@@ -304,7 +304,7 b' py_class!(pub class DirstateMap |py| {' | |||||
304 | } |
|
304 | } | |
305 |
|
305 | |||
306 | def keys(&self) -> PyResult<DirstateMapKeysIterator> { |
|
306 | def keys(&self) -> PyResult<DirstateMapKeysIterator> { | |
307 |
let leaked_ref = self.inner_shared(py).leak_immutable() |
|
307 | let leaked_ref = self.inner_shared(py).leak_immutable(); | |
308 | DirstateMapKeysIterator::from_inner( |
|
308 | DirstateMapKeysIterator::from_inner( | |
309 | py, |
|
309 | py, | |
310 | unsafe { leaked_ref.map(py, |o| o.iter()) }, |
|
310 | unsafe { leaked_ref.map(py, |o| o.iter()) }, | |
@@ -312,7 +312,7 b' py_class!(pub class DirstateMap |py| {' | |||||
312 | } |
|
312 | } | |
313 |
|
313 | |||
314 | def items(&self) -> PyResult<DirstateMapItemsIterator> { |
|
314 | def items(&self) -> PyResult<DirstateMapItemsIterator> { | |
315 |
let leaked_ref = self.inner_shared(py).leak_immutable() |
|
315 | let leaked_ref = self.inner_shared(py).leak_immutable(); | |
316 | DirstateMapItemsIterator::from_inner( |
|
316 | DirstateMapItemsIterator::from_inner( | |
317 | py, |
|
317 | py, | |
318 | unsafe { leaked_ref.map(py, |o| o.iter()) }, |
|
318 | unsafe { leaked_ref.map(py, |o| o.iter()) }, | |
@@ -320,7 +320,7 b' py_class!(pub class DirstateMap |py| {' | |||||
320 | } |
|
320 | } | |
321 |
|
321 | |||
322 | def __iter__(&self) -> PyResult<DirstateMapKeysIterator> { |
|
322 | def __iter__(&self) -> PyResult<DirstateMapKeysIterator> { | |
323 |
let leaked_ref = self.inner_shared(py).leak_immutable() |
|
323 | let leaked_ref = self.inner_shared(py).leak_immutable(); | |
324 | DirstateMapKeysIterator::from_inner( |
|
324 | DirstateMapKeysIterator::from_inner( | |
325 | py, |
|
325 | py, | |
326 | unsafe { leaked_ref.map(py, |o| o.iter()) }, |
|
326 | unsafe { leaked_ref.map(py, |o| o.iter()) }, | |
@@ -437,7 +437,7 b' py_class!(pub class DirstateMap |py| {' | |||||
437 | } |
|
437 | } | |
438 |
|
438 | |||
439 | def copymapiter(&self) -> PyResult<CopyMapKeysIterator> { |
|
439 | def copymapiter(&self) -> PyResult<CopyMapKeysIterator> { | |
440 |
let leaked_ref = self.inner_shared(py).leak_immutable() |
|
440 | let leaked_ref = self.inner_shared(py).leak_immutable(); | |
441 | CopyMapKeysIterator::from_inner( |
|
441 | CopyMapKeysIterator::from_inner( | |
442 | py, |
|
442 | py, | |
443 | unsafe { leaked_ref.map(py, |o| o.copy_map.iter()) }, |
|
443 | unsafe { leaked_ref.map(py, |o| o.copy_map.iter()) }, | |
@@ -445,7 +445,7 b' py_class!(pub class DirstateMap |py| {' | |||||
445 | } |
|
445 | } | |
446 |
|
446 | |||
447 | def copymapitemsiter(&self) -> PyResult<CopyMapItemsIterator> { |
|
447 | def copymapitemsiter(&self) -> PyResult<CopyMapItemsIterator> { | |
448 |
let leaked_ref = self.inner_shared(py).leak_immutable() |
|
448 | let leaked_ref = self.inner_shared(py).leak_immutable(); | |
449 | CopyMapItemsIterator::from_inner( |
|
449 | CopyMapItemsIterator::from_inner( | |
450 | py, |
|
450 | py, | |
451 | unsafe { leaked_ref.map(py, |o| o.copy_map.iter()) }, |
|
451 | unsafe { leaked_ref.map(py, |o| o.copy_map.iter()) }, |
@@ -89,10 +89,10 b' impl PySharedState {' | |||||
89 | &self, |
|
89 | &self, | |
90 | _py: Python, |
|
90 | _py: Python, | |
91 | data: Ref<T>, |
|
91 | data: Ref<T>, | |
92 |
) -> |
|
92 | ) -> (&'static T, &'static PySharedState) { | |
93 | let ptr: *const T = &*data; |
|
93 | let ptr: *const T = &*data; | |
94 | let state_ptr: *const PySharedState = self; |
|
94 | let state_ptr: *const PySharedState = self; | |
95 |
|
|
95 | (&*ptr, &*state_ptr) | |
96 | } |
|
96 | } | |
97 |
|
97 | |||
98 | fn current_borrow_count(&self, _py: Python) -> usize { |
|
98 | fn current_borrow_count(&self, _py: Python) -> usize { | |
@@ -208,20 +208,15 b" impl<'a, T> PySharedRef<'a, T> {" | |||||
208 | /// # Panics |
|
208 | /// # Panics | |
209 | /// |
|
209 | /// | |
210 | /// Panics if this is mutably borrowed. |
|
210 | /// Panics if this is mutably borrowed. | |
211 |
pub fn leak_immutable(&self) -> |
|
211 | pub fn leak_immutable(&self) -> PyLeaked<&'static T> { | |
212 | let state = &self.data.py_shared_state; |
|
212 | let state = &self.data.py_shared_state; | |
213 | // make sure self.data isn't mutably borrowed; otherwise the |
|
213 | // make sure self.data isn't mutably borrowed; otherwise the | |
214 | // generation number can't be trusted. |
|
214 | // generation number can't be trusted. | |
215 | let data_ref = self.borrow(); |
|
215 | let data_ref = self.borrow(); | |
216 | unsafe { |
|
216 | unsafe { | |
217 | let (static_ref, static_state_ref) = |
|
217 | let (static_ref, static_state_ref) = | |
218 |
state.leak_immutable(self.py, data_ref) |
|
218 | state.leak_immutable(self.py, data_ref); | |
219 | Ok(PyLeaked::new( |
|
219 | PyLeaked::new(self.py, self.owner, static_ref, static_state_ref) | |
220 | self.py, |
|
|||
221 | self.owner, |
|
|||
222 | static_ref, |
|
|||
223 | static_state_ref, |
|
|||
224 | )) |
|
|||
225 | } |
|
220 | } | |
226 | } |
|
221 | } | |
227 | } |
|
222 | } | |
@@ -459,7 +454,7 b" impl<T> DerefMut for PyLeakedRefMut<'_, " | |||||
459 | /// data inner: PySharedRefCell<MyStruct>; |
|
454 | /// data inner: PySharedRefCell<MyStruct>; | |
460 | /// |
|
455 | /// | |
461 | /// def __iter__(&self) -> PyResult<MyTypeItemsIterator> { |
|
456 | /// def __iter__(&self) -> PyResult<MyTypeItemsIterator> { | |
462 |
/// let leaked_ref = self.inner_shared(py).leak_immutable() |
|
457 | /// let leaked_ref = self.inner_shared(py).leak_immutable(); | |
463 | /// MyTypeItemsIterator::from_inner( |
|
458 | /// MyTypeItemsIterator::from_inner( | |
464 | /// py, |
|
459 | /// py, | |
465 | /// unsafe { leaked_ref.map(py, |o| o.iter()) }, |
|
460 | /// unsafe { leaked_ref.map(py, |o| o.iter()) }, | |
@@ -551,7 +546,7 b' mod test {' | |||||
551 | fn test_leaked_borrow() { |
|
546 | fn test_leaked_borrow() { | |
552 | let (gil, owner) = prepare_env(); |
|
547 | let (gil, owner) = prepare_env(); | |
553 | let py = gil.python(); |
|
548 | let py = gil.python(); | |
554 |
let leaked = owner.string_shared(py).leak_immutable() |
|
549 | let leaked = owner.string_shared(py).leak_immutable(); | |
555 | let leaked_ref = leaked.try_borrow(py).unwrap(); |
|
550 | let leaked_ref = leaked.try_borrow(py).unwrap(); | |
556 | assert_eq!(*leaked_ref, "new"); |
|
551 | assert_eq!(*leaked_ref, "new"); | |
557 | } |
|
552 | } | |
@@ -560,7 +555,7 b' mod test {' | |||||
560 | fn test_leaked_borrow_mut() { |
|
555 | fn test_leaked_borrow_mut() { | |
561 | let (gil, owner) = prepare_env(); |
|
556 | let (gil, owner) = prepare_env(); | |
562 | let py = gil.python(); |
|
557 | let py = gil.python(); | |
563 |
let leaked = owner.string_shared(py).leak_immutable() |
|
558 | let leaked = owner.string_shared(py).leak_immutable(); | |
564 | let mut leaked_iter = unsafe { leaked.map(py, |s| s.chars()) }; |
|
559 | let mut leaked_iter = unsafe { leaked.map(py, |s| s.chars()) }; | |
565 | let mut leaked_ref = leaked_iter.try_borrow_mut(py).unwrap(); |
|
560 | let mut leaked_ref = leaked_iter.try_borrow_mut(py).unwrap(); | |
566 | assert_eq!(leaked_ref.next(), Some('n')); |
|
561 | assert_eq!(leaked_ref.next(), Some('n')); | |
@@ -573,7 +568,7 b' mod test {' | |||||
573 | fn test_leaked_borrow_after_mut() { |
|
568 | fn test_leaked_borrow_after_mut() { | |
574 | let (gil, owner) = prepare_env(); |
|
569 | let (gil, owner) = prepare_env(); | |
575 | let py = gil.python(); |
|
570 | let py = gil.python(); | |
576 |
let leaked = owner.string_shared(py).leak_immutable() |
|
571 | let leaked = owner.string_shared(py).leak_immutable(); | |
577 | owner.string_shared(py).borrow_mut().unwrap().clear(); |
|
572 | owner.string_shared(py).borrow_mut().unwrap().clear(); | |
578 | assert!(leaked.try_borrow(py).is_err()); |
|
573 | assert!(leaked.try_borrow(py).is_err()); | |
579 | } |
|
574 | } | |
@@ -582,7 +577,7 b' mod test {' | |||||
582 | fn test_leaked_borrow_mut_after_mut() { |
|
577 | fn test_leaked_borrow_mut_after_mut() { | |
583 | let (gil, owner) = prepare_env(); |
|
578 | let (gil, owner) = prepare_env(); | |
584 | let py = gil.python(); |
|
579 | let py = gil.python(); | |
585 |
let leaked = owner.string_shared(py).leak_immutable() |
|
580 | let leaked = owner.string_shared(py).leak_immutable(); | |
586 | let mut leaked_iter = unsafe { leaked.map(py, |s| s.chars()) }; |
|
581 | let mut leaked_iter = unsafe { leaked.map(py, |s| s.chars()) }; | |
587 | owner.string_shared(py).borrow_mut().unwrap().clear(); |
|
582 | owner.string_shared(py).borrow_mut().unwrap().clear(); | |
588 | assert!(leaked_iter.try_borrow_mut(py).is_err()); |
|
583 | assert!(leaked_iter.try_borrow_mut(py).is_err()); | |
@@ -593,7 +588,7 b' mod test {' | |||||
593 | fn test_leaked_map_after_mut() { |
|
588 | fn test_leaked_map_after_mut() { | |
594 | let (gil, owner) = prepare_env(); |
|
589 | let (gil, owner) = prepare_env(); | |
595 | let py = gil.python(); |
|
590 | let py = gil.python(); | |
596 |
let leaked = owner.string_shared(py).leak_immutable() |
|
591 | let leaked = owner.string_shared(py).leak_immutable(); | |
597 | owner.string_shared(py).borrow_mut().unwrap().clear(); |
|
592 | owner.string_shared(py).borrow_mut().unwrap().clear(); | |
598 | let _leaked_iter = unsafe { leaked.map(py, |s| s.chars()) }; |
|
593 | let _leaked_iter = unsafe { leaked.map(py, |s| s.chars()) }; | |
599 | } |
|
594 | } | |
@@ -603,7 +598,7 b' mod test {' | |||||
603 | let (gil, owner) = prepare_env(); |
|
598 | let (gil, owner) = prepare_env(); | |
604 | let py = gil.python(); |
|
599 | let py = gil.python(); | |
605 | assert!(owner.string_shared(py).borrow_mut().is_ok()); |
|
600 | assert!(owner.string_shared(py).borrow_mut().is_ok()); | |
606 |
let leaked = owner.string_shared(py).leak_immutable() |
|
601 | let leaked = owner.string_shared(py).leak_immutable(); | |
607 | { |
|
602 | { | |
608 | let _leaked_ref = leaked.try_borrow(py).unwrap(); |
|
603 | let _leaked_ref = leaked.try_borrow(py).unwrap(); | |
609 | assert!(owner.string_shared(py).borrow_mut().is_err()); |
|
604 | assert!(owner.string_shared(py).borrow_mut().is_err()); | |
@@ -621,7 +616,7 b' mod test {' | |||||
621 | let (gil, owner) = prepare_env(); |
|
616 | let (gil, owner) = prepare_env(); | |
622 | let py = gil.python(); |
|
617 | let py = gil.python(); | |
623 | assert!(owner.string_shared(py).borrow_mut().is_ok()); |
|
618 | assert!(owner.string_shared(py).borrow_mut().is_ok()); | |
624 |
let leaked = owner.string_shared(py).leak_immutable() |
|
619 | let leaked = owner.string_shared(py).leak_immutable(); | |
625 | let mut leaked_iter = unsafe { leaked.map(py, |s| s.chars()) }; |
|
620 | let mut leaked_iter = unsafe { leaked.map(py, |s| s.chars()) }; | |
626 | { |
|
621 | { | |
627 | let _leaked_ref = leaked_iter.try_borrow_mut(py).unwrap(); |
|
622 | let _leaked_ref = leaked_iter.try_borrow_mut(py).unwrap(); | |
@@ -636,6 +631,6 b' mod test {' | |||||
636 | let (gil, owner) = prepare_env(); |
|
631 | let (gil, owner) = prepare_env(); | |
637 | let py = gil.python(); |
|
632 | let py = gil.python(); | |
638 | let _mut_ref = owner.string_shared(py).borrow_mut(); |
|
633 | let _mut_ref = owner.string_shared(py).borrow_mut(); | |
639 |
|
|
634 | owner.string_shared(py).leak_immutable(); | |
640 | } |
|
635 | } | |
641 | } |
|
636 | } |
General Comments 0
You need to be logged in to leave comments.
Login now