Skip to content

Commit f8d5f90

Browse files
author
Clar Charr
committedJun 9, 2017
Move Drop to module.
·
1.86.01.20.0
1 parent b099e0e commit f8d5f90

File tree

2 files changed

+103
-90
lines changed

2 files changed

+103
-90
lines changed
 

‎src/libcore/ops/drop.rs

+99
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,99 @@
1+
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
2+
// file at the top-level directory of this distribution and at
3+
// http://rust-lang.org/COPYRIGHT.
4+
//
5+
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6+
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7+
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8+
// option. This file may not be copied, modified, or distributed
9+
// except according to those terms.
10+
11+
/// The `Drop` trait is used to run some code when a value goes out of scope.
12+
/// This is sometimes called a 'destructor'.
13+
///
14+
/// When a value goes out of scope, if it implements this trait, it will have
15+
/// its `drop` method called. Then any fields the value contains will also
16+
/// be dropped recursively.
17+
///
18+
/// Because of the recursive dropping, you do not need to implement this trait
19+
/// unless your type needs its own destructor logic.
20+
///
21+
/// # Examples
22+
///
23+
/// A trivial implementation of `Drop`. The `drop` method is called when `_x`
24+
/// goes out of scope, and therefore `main` prints `Dropping!`.
25+
///
26+
/// ```
27+
/// struct HasDrop;
28+
///
29+
/// impl Drop for HasDrop {
30+
/// fn drop(&mut self) {
31+
/// println!("Dropping!");
32+
/// }
33+
/// }
34+
///
35+
/// fn main() {
36+
/// let _x = HasDrop;
37+
/// }
38+
/// ```
39+
///
40+
/// Showing the recursive nature of `Drop`. When `outer` goes out of scope, the
41+
/// `drop` method will be called first for `Outer`, then for `Inner`. Therefore
42+
/// `main` prints `Dropping Outer!` and then `Dropping Inner!`.
43+
///
44+
/// ```
45+
/// struct Inner;
46+
/// struct Outer(Inner);
47+
///
48+
/// impl Drop for Inner {
49+
/// fn drop(&mut self) {
50+
/// println!("Dropping Inner!");
51+
/// }
52+
/// }
53+
///
54+
/// impl Drop for Outer {
55+
/// fn drop(&mut self) {
56+
/// println!("Dropping Outer!");
57+
/// }
58+
/// }
59+
///
60+
/// fn main() {
61+
/// let _x = Outer(Inner);
62+
/// }
63+
/// ```
64+
///
65+
/// Because variables are dropped in the reverse order they are declared,
66+
/// `main` will print `Declared second!` and then `Declared first!`.
67+
///
68+
/// ```
69+
/// struct PrintOnDrop(&'static str);
70+
///
71+
/// fn main() {
72+
/// let _first = PrintOnDrop("Declared first!");
73+
/// let _second = PrintOnDrop("Declared second!");
74+
/// }
75+
/// ```
76+
#[lang = "drop"]
77+
#[stable(feature = "rust1", since = "1.0.0")]
78+
pub trait Drop {
79+
/// A method called when the value goes out of scope.
80+
///
81+
/// When this method has been called, `self` has not yet been deallocated.
82+
/// If it were, `self` would be a dangling reference.
83+
///
84+
/// After this function is over, the memory of `self` will be deallocated.
85+
///
86+
/// This function cannot be called explicitly. This is compiler error
87+
/// [E0040]. However, the [`std::mem::drop`] function in the prelude can be
88+
/// used to call the argument's `Drop` implementation.
89+
///
90+
/// [E0040]: ../../error-index.html#E0040
91+
/// [`std::mem::drop`]: ../../std/mem/fn.drop.html
92+
///
93+
/// # Panics
94+
///
95+
/// Given that a `panic!` will call `drop()` as it unwinds, any `panic!` in
96+
/// a `drop()` implementation will likely abort.
97+
#[stable(feature = "rust1", since = "1.0.0")]
98+
fn drop(&mut self);
99+
}

‎src/libcore/ops/mod.rs

+4-90
Original file line numberDiff line numberDiff line change
@@ -150,6 +150,7 @@
150150
mod arith;
151151
mod bit;
152152
mod deref;
153+
mod drop;
153154
mod function;
154155
mod index;
155156
mod place;
@@ -170,6 +171,9 @@ pub use self::bit::{BitAndAssign, BitOrAssign, BitXorAssign, ShlAssign, ShrAssig
170171
#[stable(feature = "rust1", since = "1.0.0")]
171172
pub use self::deref::{Deref, DerefMut};
172173

174+
#[stable(feature = "rust1", since = "1.0.0")]
175+
pub use self::drop::Drop;
176+
173177
#[stable(feature = "rust1", since = "1.0.0")]
174178
pub use self::function::{Fn, FnMut, FnOnce};
175179

@@ -193,93 +197,3 @@ pub use self::place::{Place, Placer, InPlace, Boxed, BoxPlace};
193197

194198
#[unstable(feature = "coerce_unsized", issue = "27732")]
195199
pub use self::unsize::CoerceUnsized;
196-
197-
/// The `Drop` trait is used to run some code when a value goes out of scope.
198-
/// This is sometimes called a 'destructor'.
199-
///
200-
/// When a value goes out of scope, if it implements this trait, it will have
201-
/// its `drop` method called. Then any fields the value contains will also
202-
/// be dropped recursively.
203-
///
204-
/// Because of the recursive dropping, you do not need to implement this trait
205-
/// unless your type needs its own destructor logic.
206-
///
207-
/// # Examples
208-
///
209-
/// A trivial implementation of `Drop`. The `drop` method is called when `_x`
210-
/// goes out of scope, and therefore `main` prints `Dropping!`.
211-
///
212-
/// ```
213-
/// struct HasDrop;
214-
///
215-
/// impl Drop for HasDrop {
216-
/// fn drop(&mut self) {
217-
/// println!("Dropping!");
218-
/// }
219-
/// }
220-
///
221-
/// fn main() {
222-
/// let _x = HasDrop;
223-
/// }
224-
/// ```
225-
///
226-
/// Showing the recursive nature of `Drop`. When `outer` goes out of scope, the
227-
/// `drop` method will be called first for `Outer`, then for `Inner`. Therefore
228-
/// `main` prints `Dropping Outer!` and then `Dropping Inner!`.
229-
///
230-
/// ```
231-
/// struct Inner;
232-
/// struct Outer(Inner);
233-
///
234-
/// impl Drop for Inner {
235-
/// fn drop(&mut self) {
236-
/// println!("Dropping Inner!");
237-
/// }
238-
/// }
239-
///
240-
/// impl Drop for Outer {
241-
/// fn drop(&mut self) {
242-
/// println!("Dropping Outer!");
243-
/// }
244-
/// }
245-
///
246-
/// fn main() {
247-
/// let _x = Outer(Inner);
248-
/// }
249-
/// ```
250-
///
251-
/// Because variables are dropped in the reverse order they are declared,
252-
/// `main` will print `Declared second!` and then `Declared first!`.
253-
///
254-
/// ```
255-
/// struct PrintOnDrop(&'static str);
256-
///
257-
/// fn main() {
258-
/// let _first = PrintOnDrop("Declared first!");
259-
/// let _second = PrintOnDrop("Declared second!");
260-
/// }
261-
/// ```
262-
#[lang = "drop"]
263-
#[stable(feature = "rust1", since = "1.0.0")]
264-
pub trait Drop {
265-
/// A method called when the value goes out of scope.
266-
///
267-
/// When this method has been called, `self` has not yet been deallocated.
268-
/// If it were, `self` would be a dangling reference.
269-
///
270-
/// After this function is over, the memory of `self` will be deallocated.
271-
///
272-
/// This function cannot be called explicitly. This is compiler error
273-
/// [E0040]. However, the [`std::mem::drop`] function in the prelude can be
274-
/// used to call the argument's `Drop` implementation.
275-
///
276-
/// [E0040]: ../../error-index.html#E0040
277-
/// [`std::mem::drop`]: ../../std/mem/fn.drop.html
278-
///
279-
/// # Panics
280-
///
281-
/// Given that a `panic!` will call `drop()` as it unwinds, any `panic!` in
282-
/// a `drop()` implementation will likely abort.
283-
#[stable(feature = "rust1", since = "1.0.0")]
284-
fn drop(&mut self);
285-
}

0 commit comments

Comments
 (0)
Please sign in to comment.