Lines Matching defs:drop
1072 fn drop(&mut self) {
3132 fn drop(&mut self) {
3138 panic!("panic in `drop`");
3153 catch_unwind(AssertUnwindSafe(|| drop(q.drain_filter(|_| true)))).ok();
3167 fn drop(&mut self) {
3185 drop(q.drain_filter(|item| if item.0 >= 2 { panic!() } else { true }))
3198 fn drop(&mut self) {
3210 drop(ring);
3220 fn drop(&mut self) {
3233 drop(ring.pop_back());
3234 drop(ring.pop_front());
3237 drop(ring);
3246 fn drop(&mut self) {
3261 drop(ring);
3272 fn drop(&mut self) {
3278 panic!("panic in `drop`");
3293 catch_unwind(move || drop(q)).ok();
3441 let iter = (0..SHARED_ITER_MAX).map(drop);
6547 fn drop(&mut self) {
6570 // If Vec had a drop flag, here is where it would be zeroed.
6573 drop(tv.x);
6680 // Double drop
6857 fn drop(&mut self) {
6876 // Other elements are dropped when `drop` of one element panicked.
7025 fn drop(&mut self) {
7045 fn drop(&mut self) {
7291 fn drop(&mut self) {
7297 panic!("panic in `drop`");
7483 fn drop(&mut self) {
7489 panic!("panic in `drop`");
7496 catch_unwind(move || drop(v.into_iter())).ok();
7593 fn drop(&mut self) {
7623 drop(Vec::from_raw_parts(to_free, 0, cap));
7851 fn drop(&mut self) {
7853 println!("drop: {}", self.index);
7879 drain.for_each(drop);
7886 assert_eq!(1, count, "unexpected drop count at index: {} (count: {})", index, count);
7903 fn drop(&mut self) {
7905 println!("drop: {}", self.index);
7937 assert_eq!(1, count, "unexpected drop count at index: {} (count: {})", index, count);
7945 drop(drain);
8191 /// Pull an element from the iterator, then drop it.
8192 /// Useful to cover both the `next` and `drop` paths of an iterator.
8195 drop(i);
8768 fn drop(&mut self) {
8824 fn drop(&mut self) {
8837 // cloning second Panic{..}. This means that `Panic::drop` should be called
9194 let iter = (0..SHARED_ITER_MAX).map(drop);
9549 // If the unsafe block didn't drop things properly, we blow up here.
9557 // If the unsafe block didn't drop things properly, we blow up here.
10739 fn drop(&mut self) {
10913 fn drop(&mut self) {
10957 assert!(count == 1, "found drop count == {} for i == {}, len == {}", count, i, len);
11018 drop(panic::take_hook());
11864 fn drop(&mut self) {
11876 drop(ring);
11886 fn drop(&mut self) {
11899 drop(ring.pop_back());
11900 drop(ring.pop_front());
11903 drop(ring);
11912 fn drop(&mut self) {
11927 drop(ring);
11938 fn drop(&mut self) {
11944 panic!("panic in `drop`");
11959 catch_unwind(move || drop(q)).ok();
12233 fn drop(&mut self) {
12802 fn drop(&mut self) {
12808 panic!("panic in `drop`");
12836 fn drop(&mut self) {
12842 panic!("panic in `drop`");
12863 drop(v);
13280 drop(borrow);
13582 fn drop(&mut self) {
13586 panic!("panic in `drop`");
13600 catch_unwind(AssertUnwindSafe(|| drop(q.drain_sorted()))).ok();
13711 fn drop(&mut self) {
13712 // update global drop count
13759 assert!(drops == 0, "Must not drop items. drops={}", drops);
13761 drop(heap);
13907 /// This will still evaluate `expr`, however, and immediately drop the resulting value, so
14464 /// free its memory, but it *won't* try to drop its contents. It is up to the user of `RawVec`
14928 /// Frees the memory owned by the `RawVec` *without* trying to drop its contents.
14929 fn drop(&mut self) {
15557 use std::mem::drop;
15573 fn drop(&mut self) {
15610 drop(y);
15630 drop(w);
15636 drop(a2);
15637 drop(a);
15640 drop(w2);
15661 drop(y);
15706 drop(y_up);
15807 drop(x);
15828 drop(x);
15838 drop(arc);
15840 drop(arc_weak);
15852 drop(w);
15853 drop(a);
15870 drop(w);
15871 drop(x);
15881 drop(a);
15882 drop(c);
15883 drop(d);
15903 drop(x);
15915 drop(x);
15919 // But we still need to be able to get the alloc layout to drop.
15920 // CStr has no drop glue, but custom DSTs might, and need to work.
15921 drop(y);
17470 fn drop(&mut self) {
17500 drop(guard);
17815 /// This will drop any excess capacity.
18733 fn drop(&mut self) {
19621 //! drop(gadget_owner);
20098 // pointer while also handling drop logic by just crafting a
20437 // Now increase refcount, but don't drop new refcount either
20472 unsafe { mem::drop(Rc::from_raw(ptr)) };
20815 fn drop(&mut self) {
20887 /// [`Weak`], so we `drop` the inner value.
20897 /// fn drop(&mut self) {
20905 /// drop(foo); // Doesn't print anything
20906 /// drop(foo2); // Prints "dropped!"
20908 fn drop(&mut self) {
21515 /// drop(strong);
21559 /// drop(unsafe { Weak::from_raw(raw) });
21605 /// drop(strong);
21652 /// drop(strong_five);
21653 /// drop(five);
21769 /// fn drop(&mut self) {
21778 /// drop(weak_foo); // Doesn't print anything
21779 /// drop(foo); // Prints "dropped!"
21783 fn drop(&mut self) {
22152 fn drop(&mut self) {
22789 // drop anything in target that will not be overwritten
22865 fn drop(&mut self) {
22978 fn drop(&mut self) {
23261 // Decrement the reference count of the Arc on drop
23667 // - It can drop those clones, decreasing the weak reference count (but never to zero).
24254 // Now increase refcount, but don't drop new refcount either
24291 unsafe { mem::drop(Arc::from_raw(ptr)) };
24304 // Non-inlined part of `drop`.
24312 drop(Weak { ptr: self.ptr });
24467 fn drop(&mut self) {
24755 // of the `weak` count (via `Weak::drop`, which uses release). If the upgraded
24759 // counter in `drop` -- the only access that happens when any but the last reference
24780 /// [`Weak`], so we `drop` the inner value.
24790 /// fn drop(&mut self) {
24798 /// drop(foo); // Doesn't print anything
24799 /// drop(foo2); // Prints "dropped!"
24802 fn drop(&mut self) {
24927 /// drop(strong);
24971 /// drop(unsafe { Weak::from_raw(raw) });
25016 /// drop(strong);
25066 /// drop(strong_five);
25067 /// drop(five);
25277 /// fn drop(&mut self) {
25286 /// drop(weak_foo); // Doesn't print anything
25287 /// drop(foo); // Prints "dropped!"
25291 fn drop(&mut self) {
25293 // deallocate the data entirely. See the discussion in Arc::drop() about
25298 // meaning that drop could only subsequently run ON that remaining weak
26390 use std::mem::drop;
26433 drop(x);
26456 drop(y);
26460 drop(w);
26473 drop(w);
26474 drop(a);
26489 drop(w);
26495 drop(c);
26512 drop(w);
26518 drop(a2);
26519 drop(a);
26522 drop(w2);
26543 drop(y);
26588 drop(y_up);
26625 drop(y);
26712 drop(x);
26716 // But we still need to be able to get the alloc layout to drop.
26717 // CStr has no drop glue, but custom DSTs might, and need to work.
26718 drop(y);
27921 fn drop(&mut self) {
27925 fn drop(&mut self) {
27934 drop(node);
28510 fn drop(&mut self) {
28519 fn drop(&mut self) {
28520 self.0.for_each(drop);
28526 drop(item);
28939 // This caused the RHS's dtor to walk up into the LHS at drop and delete all of
29194 /// easier for the caller to avoid a leak when a drop handler panicks.
29294 /// Events are `clone`, `drop` or some anonymous `query`.
29380 fn drop(&mut self) {
29383 panic!("panic in `drop`");
29942 fn drop(&mut self) {
30126 /// purpose: to drop the remainder of an `IntoIter`. Therefore it also serves to
30127 /// drop an entire tree without the need to first look up a `back` leaf edge.
31234 fn drop(&mut self) {
31249 fn drop(&mut self) {
31258 drop(pair);
31266 fn drop(&mut self) {
31420 /// Wrapped in `Option` to allow drop handler to `take` it.
31433 fn drop(&mut self) {
31434 self.for_each(drop);
32082 fn drop(&mut self) {
33273 fn drop(&mut self) {
33274 self.for_each(drop);
34127 /// The only safe way to proceed with the updated handle is to compare it, drop it,
34145 /// The only safe way to proceed with the updated handle is to compare it, drop it,
34646 catch_unwind(move || drop(set.drain_filter(|dummy| dummy.query(true)))).ok();
34666 catch_unwind(AssertUnwindSafe(|| drop(set.drain_filter(|dummy| dummy.query(true))))).ok();
35367 drop(ins.left);
36490 // Explicitly consumes the iterator, where most test cases drop it instantly.
36499 // Explicitly consumes the iterator, where most test cases drop it instantly.
36702 catch_unwind(move || drop(map.drain_filter(|dummy, _| dummy.query(true)))).unwrap_err();
36722 catch_unwind(AssertUnwindSafe(|| drop(map.drain_filter(|dummy, _| dummy.query(true)))))
37003 drop(map);
37074 drop(map);
37653 catch_unwind(move || drop(map.into_iter())).unwrap_err();
37673 catch_unwind(move || drop(map.into_iter())).unwrap_err();
40085 // and thus we can't implement drop-handling
40149 fn drop(&mut self) {
40153 fn drop(&mut self) {
40154 self.0.for_each(drop);
40200 drop(item);
40475 fn drop(&mut self) {
40481 fn drop(&mut self) {
40491 // use drop for [T]
41097 /// It will drop down as close as possible to the length but the allocator may still inform the
41226 fn drop(&mut self) {
43218 // the `Vec` so the items will drop on panic.
44033 fn drop(&mut self) {
44544 fn drop(&mut self) {
44915 drop(hole);
45005 /// The remaining elements will be removed on drop in heap order.
45022 /// drop(heap.drain_sorted()); // removes all elements in heap order
45383 /// In drop, `Hole` will restore the slice by filling the hole
45443 fn drop(&mut self) {
45680 fn drop(&mut self) {
45684 fn drop(&mut self) {
45691 drop(item);
45940 /// (&mut into_iter).for_each(core::mem::drop);
46065 // and thus we can't implement drop-handling
46087 fn drop(&mut self) {
46091 fn drop(&mut self) {
46385 fn drop(&mut self) {
46391 fn drop(&mut self) {
46394 self.0.for_each(drop);
46416 drop(item);
46734 // drop any remaining values at the tail of the source
46735 // but prevent drop of the allocation itself once IntoIter goes out of scope
46736 // if the drop panics then we also leak any elements collected into dst_buf
46781 // iteration succeeded, don't drop head
47156 /// removed data to be erased for security purposes. Even if you drop a `Vec`, its
47699 /// It will drop down as close as possible to the length but the allocator
47751 /// Note that this will drop any excess capacity.
48039 /// Normally, here, one would use [`clear`] instead to correctly drop
48218 // Avoid double drop if the drop guard is not executed,
48230 // This drop guard will be invoked when predicate or `drop` of element panicked.
48232 // In cases when predicate and `drop` never panick, it will be optimized out.
48241 fn drop(&mut self) {
48265 // Advance early to avoid double drop if `drop_in_place` panicked.
48285 drop(g);
48354 fn drop(&mut self) {
48400 /* We have found duplicate, drop it in-place */
49161 // drop anything that will not be overwritten
49470 fn drop(&mut self) {
49472 // use drop for [T]
49700 // The items will not double-drop as the `set_len`
49701 // tells the `Vec` not to also drop them.
49730 fn drop(&mut self) {
49773 /// This is used as a hint in the drop implementation to prevent consumption
49835 fn drop(&mut self) {
49847 fn drop(&mut self) {
49854 // is required to prevent a double-drop of the last successfully
49873 backshift.drain.for_each(drop);
50009 fn drop(&mut self) {
50010 self.drain.by_ref().for_each(drop);
50044 // Let `Drain::drop` move the tail back if necessary and restore `vec.len`.
50048 /// Private helper methods for `Splice::drop`
50106 fn drop(&mut self) {
50175 //! drop their contents when they go out of scope. Boxes also ensure that they
51173 fn drop(&mut self) {
51174 // FIXME: Do nothing, drop is currently performed by compiler.