mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merged drop_forget_ref.rs with drop_forget_copy.rs.

Browse Source 
Moved constant message strings out of declare_lint! macros.
This commit is contained in:
Tristian Celestin 2017-02-26 21:32:41 -05:00
parent 3075b01d8c
commit 75e28610a7
5 changed files with 108 additions and 426 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
clippy_lints/src/drop_forget_copy.rs
View File

@ -1,94 +0,0 @@
use rustc::lint::*;
use rustc::hir::*;
use utils::{match_def_path, paths, span_note_and_lint, is_copy};
const DROP_COPY_SUMMARY:&'static str = "calls to `std::mem::drop` with a value that implements Copy";
const FORGET_COPY_SUMMARY:&'static str = "calls to `std::mem::forget` with a value that implements Copy";
/// **What it does:** Checks for calls to `std::mem::drop` with a value
/// that derives the Copy trait
///
/// **Why is this bad?** Calling `std::mem::drop` [does nothing for types that
/// implement Copy](https://doc.rust-lang.org/std/mem/fn.drop.html), since the
/// value will be copied and moved into the function on invocation.
///
/// **Known problems:** None.
///
/// **Example:**
/// ```rust
/// let x:i32 = 42; // i32 implements Copy
/// std::mem::drop(x) // A copy of x is passed to the function, leaving the original unaffected
/// ```
declare_lint! {
pub DROP_COPY,
Warn,
DROP_COPY_SUMMARY
}
/// **What it does:** Checks for calls to `std::mem::forget` with a value that
/// derives the Copy trait
///
/// **Why is this bad?** Calling `std::mem::forget` [does nothing for types that
/// implement Copy](https://doc.rust-lang.org/std/mem/fn.drop.html) since the
/// value will be copied and moved into the function on invocation.
///
/// An alternative, but also valid, explanation is that Copy types do not implement
/// the Drop trait, which means they have no destructors. Without a destructor, there
/// is nothing for `std::mem::forget` to ignore.
///
/// **Known problems:** None.
///
/// **Example:**
/// ```rust
/// let x:i32 = 42; // i32 implements Copy
/// std::mem::forget(x) // A copy of x is passed to the function, leaving the original unaffected
/// ```
declare_lint! {
pub FORGET_COPY,
Warn,
FORGET_COPY_SUMMARY
}
#[allow(missing_copy_implementations)]
pub struct Pass;
impl LintPass for Pass {
fn get_lints(&self) -> LintArray {
lint_array!(DROP_COPY, FORGET_COPY)
}
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
if_let_chain!{[
let ExprCall(ref path, ref args) = expr.node,
let ExprPath(ref qpath) = path.node,
args.len() == 1,
], {
let def_id = cx.tables.qpath_def(qpath, path.id).def_id();
let lint;
let msg;
if match_def_path(cx.tcx, def_id, &paths::DROP) {
lint = DROP_COPY;
msg = DROP_COPY_SUMMARY.to_string() + ". Dropping a copy leaves the original intact.";
} else if match_def_path(cx.tcx, def_id, &paths::MEM_FORGET) {
lint = FORGET_COPY;
msg = FORGET_COPY_SUMMARY.to_string() + ". Forgetting a copy leaves the original intact.";
} else {
return;
}
let arg = &args[0];
let arg_ty = cx.tables.expr_ty(arg);
if is_copy(cx, arg_ty, cx.tcx.hir.get_parent(arg.id)) {
span_note_and_lint(cx,
lint,
expr.span,
&msg,
arg.span,
&format!("argument has type {}", arg_ty.sty));
}
}}
}
}

94
clippy_lints/src/drop_forget_ref.rs
View File

@ -1,7 +1,7 @@
use rustc::lint::*;
use rustc::ty;
use rustc::hir::*;
use utils::{match_def_path, paths, span_note_and_lint};
use utils::{match_def_path, paths, span_note_and_lint, is_copy};
/// **What it does:** Checks for calls to `std::mem::drop` with a reference
/// instead of an owned value.
@ -45,6 +45,59 @@ declare_lint! {
"calls to `std::mem::forget` with a reference instead of an owned value"
}
/// **What it does:** Checks for calls to `std::mem::drop` with a value
/// that derives the Copy trait
///
/// **Why is this bad?** Calling `std::mem::drop` [does nothing for types that
/// implement Copy](https://doc.rust-lang.org/std/mem/fn.drop.html), since the
/// value will be copied and moved into the function on invocation.
///
/// **Known problems:** None.
///
/// **Example:**
/// ```rust
/// let x:i32 = 42; // i32 implements Copy
/// std::mem::drop(x) // A copy of x is passed to the function, leaving the original unaffected
/// ```
declare_lint! {
pub DROP_COPY,
Warn,
"calls to `std::mem::drop` with a value that implements Copy"
}
/// **What it does:** Checks for calls to `std::mem::forget` with a value that
/// derives the Copy trait
///
/// **Why is this bad?** Calling `std::mem::forget` [does nothing for types that
/// implement Copy](https://doc.rust-lang.org/std/mem/fn.drop.html) since the
/// value will be copied and moved into the function on invocation.
///
/// An alternative, but also valid, explanation is that Copy types do not implement
/// the Drop trait, which means they have no destructors. Without a destructor, there
/// is nothing for `std::mem::forget` to ignore.
///
/// **Known problems:** None.
///
/// **Example:**
/// ```rust
/// let x:i32 = 42; // i32 implements Copy
/// std::mem::forget(x) // A copy of x is passed to the function, leaving the original unaffected
/// ```
declare_lint! {
pub FORGET_COPY,
Warn,
"calls to `std::mem::forget` with a value that implements Copy"
}
const DROP_REF_SUMMARY:&str = "calls to `std::mem::drop` with a reference instead of an owned value. \
Dropping a reference does nothing.";
const FORGET_REF_SUMMARY:&str = "calls to `std::mem::forget` with a reference instead of an owned value. \
Forgetting a reference does nothing.";
const DROP_COPY_SUMMARY:&str = "calls to `std::mem::drop` with a value that implements Copy. \
Dropping a copy leaves the original intact.";
const FORGET_COPY_SUMMARY:&str = "calls to `std::mem::forget` with a value that implements Copy. \
Forgetting a copy leaves the original intact.";
#[allow(missing_copy_implementations)]
pub struct Pass;
@ -64,24 +117,39 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
let def_id = cx.tables.qpath_def(qpath, path.id).def_id();
let lint;
let msg;
if match_def_path(cx.tcx, def_id, &paths::DROP) {
lint = DROP_REF;
msg = "call to `std::mem::drop` with a reference argument. \
Dropping a reference does nothing";
} else if match_def_path(cx.tcx, def_id, &paths::MEM_FORGET) {
lint = FORGET_REF;
msg = "call to `std::mem::forget` with a reference argument. \
Forgetting a reference does nothing";
} else {
return;
}
let arg = &args[0];
let arg_ty = cx.tables.expr_ty(arg);
if let ty::TyRef(..) = arg_ty.sty {
if match_def_path(cx.tcx, def_id, &paths::DROP) {
lint = DROP_REF;
msg = DROP_REF_SUMMARY.to_string();
} else if match_def_path(cx.tcx, def_id, &paths::MEM_FORGET) {
lint = FORGET_REF;
msg = FORGET_REF_SUMMARY.to_string();
} else {
return;
}
span_note_and_lint(cx,
lint,
expr.span,
msg,
&msg,
arg.span,
&format!("argument has type {}", arg_ty.sty));
} else if is_copy(cx, arg_ty, cx.tcx.hir.get_parent(arg.id)) {
if match_def_path(cx.tcx, def_id, &paths::DROP) {
lint = DROP_COPY;
msg = DROP_COPY_SUMMARY.to_string();
} else if match_def_path(cx.tcx, def_id, &paths::MEM_FORGET) {
lint = FORGET_COPY;
msg = FORGET_COPY_SUMMARY.to_string();
} else {
return;
}
span_note_and_lint(cx,
lint,
expr.span,
&msg,
arg.span,
&format!("argument has type {}", arg_ty.sty));
}

6
clippy_lints/src/lib.rs
View File

@ -72,7 +72,6 @@ pub mod cyclomatic_complexity;
pub mod derive;
pub mod doc;
pub mod double_parens;
pub mod drop_forget_copy;
pub mod drop_forget_ref;
pub mod empty_enum;
pub mod entry;
@ -270,7 +269,6 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry) {
max_single_char_names: conf.max_single_char_names,
});
reg.register_late_lint_pass(box drop_forget_ref::Pass);
reg.register_late_lint_pass(box drop_forget_copy::Pass);
reg.register_late_lint_pass(box empty_enum::EmptyEnum);
reg.register_late_lint_pass(box types::AbsurdExtremeComparisons);
reg.register_late_lint_pass(box types::InvalidUpcastComparisons);
@ -377,9 +375,9 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry) {
derive::EXPL_IMPL_CLONE_ON_COPY,
doc::DOC_MARKDOWN,
double_parens::DOUBLE_PARENS,
drop_forget_copy::DROP_COPY,
drop_forget_copy::FORGET_COPY,
drop_forget_ref::DROP_COPY,
drop_forget_ref::DROP_REF,
drop_forget_ref::FORGET_COPY,
drop_forget_ref::FORGET_REF,
entry::MAP_ENTRY,
enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT,

122
tests/ui/drop_forget_copy.stderr
View File

@ -1,4 +1,4 @@
error: call to `std::mem::drop` with a value that implements Copy. Dropping a copy leaves the original intact.
error: calls to `std::mem::drop` with a value that implements Copy. Dropping a copy leaves the original intact.
--> $DIR/drop_forget_copy.rs:33:5
|
33 | drop(s1);
@ -15,7 +15,7 @@ note: argument has type SomeStruct
33 | drop(s1);
| ^^
error: call to `std::mem::drop` with a value that implements Copy. Dropping a copy leaves the original intact.
error: calls to `std::mem::drop` with a value that implements Copy. Dropping a copy leaves the original intact.
--> $DIR/drop_forget_copy.rs:34:5
|
34 | drop(s2);
@ -27,19 +27,7 @@ note: argument has type SomeStruct
34 | drop(s2);
| ^^
error: call to `std::mem::drop` with a value that implements Copy. Dropping a copy leaves the original intact.
--> $DIR/drop_forget_copy.rs:35:5
|
35 | drop(s3);
| ^^^^^^^^
|
note: argument has type &SomeStruct
--> $DIR/drop_forget_copy.rs:35:10
|
35 | drop(s3);
| ^^
error: call to `std::mem::drop` with a value that implements Copy. Dropping a copy leaves the original intact.
error: calls to `std::mem::drop` with a value that implements Copy. Dropping a copy leaves the original intact.
--> $DIR/drop_forget_copy.rs:36:5
|
36 | drop(s4);
@ -51,19 +39,7 @@ note: argument has type SomeStruct
36 | drop(s4);
| ^^
error: call to `std::mem::drop` with a value that implements Copy. Dropping a copy leaves the original intact.
--> $DIR/drop_forget_copy.rs:37:5
|
37 | drop(s5);
| ^^^^^^^^
|
note: argument has type &SomeStruct
--> $DIR/drop_forget_copy.rs:37:10
|
37 | drop(s5);
| ^^
error: call to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
error: calls to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
--> $DIR/drop_forget_copy.rs:39:5
|
39 | forget(s1);
@ -80,7 +56,7 @@ note: argument has type SomeStruct
39 | forget(s1);
| ^^
error: call to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
error: calls to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
--> $DIR/drop_forget_copy.rs:40:5
|
40 | forget(s2);
@ -92,19 +68,7 @@ note: argument has type SomeStruct
40 | forget(s2);
| ^^
error: call to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
--> $DIR/drop_forget_copy.rs:41:5
|
41 | forget(s3);
| ^^^^^^^^^^
|
note: argument has type &SomeStruct
--> $DIR/drop_forget_copy.rs:41:12
|
41 | forget(s3);
| ^^
error: call to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
error: calls to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
--> $DIR/drop_forget_copy.rs:42:5
|
42 | forget(s4);
@ -116,77 +80,5 @@ note: argument has type SomeStruct
42 | forget(s4);
| ^^
error: call to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
--> $DIR/drop_forget_copy.rs:43:5
|
43 | forget(s5);
| ^^^^^^^^^^
|
note: argument has type &SomeStruct
--> $DIR/drop_forget_copy.rs:43:12
|
43 | forget(s5);
| ^^
error: call to `std::mem::drop` with a value that implements Copy. Dropping a copy leaves the original intact.
--> $DIR/drop_forget_copy.rs:51:5
|
51 | drop(a2);
| ^^^^^^^^
|
note: argument has type &AnotherStruct
--> $DIR/drop_forget_copy.rs:51:10
|
51 | drop(a2);
| ^^
error: call to `std::mem::drop` with a value that implements Copy. Dropping a copy leaves the original intact.
--> $DIR/drop_forget_copy.rs:53:5
|
53 | drop(a4);
| ^^^^^^^^
|
note: argument has type &AnotherStruct
--> $DIR/drop_forget_copy.rs:53:10
|
53 | drop(a4);
| ^^
error: call to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
--> $DIR/drop_forget_copy.rs:56:5
|
56 | forget(a2);
| ^^^^^^^^^^
|
note: argument has type &AnotherStruct
--> $DIR/drop_forget_copy.rs:56:12
|
56 | forget(a2);
| ^^
error: call to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
--> $DIR/drop_forget_copy.rs:58:5
|
58 | forget(a3);
| ^^^^^^^^^^
|
note: argument has type &AnotherStruct
--> $DIR/drop_forget_copy.rs:58:12
|
58 | forget(a3);
| ^^
error: call to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
--> $DIR/drop_forget_copy.rs:59:5
|
59 | forget(a4);
| ^^^^^^^^^^
|
note: argument has type &AnotherStruct
--> $DIR/drop_forget_copy.rs:59:12
|
59 | forget(a4);
| ^^
error: aborting due to 15 previous errors
error: aborting due to 6 previous errors

218
tests/ui/drop_forget_ref.stderr
View File

@ -1,4 +1,4 @@
error: call to `std::mem::drop` with a reference argument. Dropping a reference does nothing
error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
--> $DIR/drop_forget_ref.rs:12:5
|
12 | drop(&SomeStruct);
@ -15,20 +15,7 @@ note: argument has type &SomeStruct
12 | drop(&SomeStruct);
| ^^^^^^^^^^^
warning: call to `std::mem::drop` with a value that implements Copy. Dropping a copy leaves the original intact.
--> $DIR/drop_forget_ref.rs:12:5
|
12 | drop(&SomeStruct);
| ^^^^^^^^^^^^^^^^^
|
= note: #[warn(drop_copy)] on by default
note: argument has type &SomeStruct
--> $DIR/drop_forget_ref.rs:12:10
|
12 | drop(&SomeStruct);
| ^^^^^^^^^^^
error: call to `std::mem::forget` with a reference argument. Forgetting a reference does nothing
error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
--> $DIR/drop_forget_ref.rs:13:5
|
13 | forget(&SomeStruct);
@ -45,20 +32,7 @@ note: argument has type &SomeStruct
13 | forget(&SomeStruct);
| ^^^^^^^^^^^
warning: call to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
--> $DIR/drop_forget_ref.rs:13:5
|
13 | forget(&SomeStruct);
| ^^^^^^^^^^^^^^^^^^^
|
= note: #[warn(forget_copy)] on by default
note: argument has type &SomeStruct
--> $DIR/drop_forget_ref.rs:13:12
|
13 | forget(&SomeStruct);
| ^^^^^^^^^^^
error: call to `std::mem::drop` with a reference argument. Dropping a reference does nothing
error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
--> $DIR/drop_forget_ref.rs:16:5
|
16 | drop(&owned1);
@ -70,20 +44,7 @@ note: argument has type &SomeStruct
16 | drop(&owned1);
| ^^^^^^^
warning: call to `std::mem::drop` with a value that implements Copy. Dropping a copy leaves the original intact.
--> $DIR/drop_forget_ref.rs:16:5
|
16 | drop(&owned1);
| ^^^^^^^^^^^^^
|
= note: #[warn(drop_copy)] on by default
note: argument has type &SomeStruct
--> $DIR/drop_forget_ref.rs:16:10
|
16 | drop(&owned1);
| ^^^^^^^
error: call to `std::mem::drop` with a reference argument. Dropping a reference does nothing
error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
--> $DIR/drop_forget_ref.rs:17:5
|
17 | drop(&&owned1);
@ -95,20 +56,7 @@ note: argument has type &&SomeStruct
17 | drop(&&owned1);
| ^^^^^^^^
warning: call to `std::mem::drop` with a value that implements Copy. Dropping a copy leaves the original intact.
--> $DIR/drop_forget_ref.rs:17:5
|
17 | drop(&&owned1);
| ^^^^^^^^^^^^^^
|
= note: #[warn(drop_copy)] on by default
note: argument has type &&SomeStruct
--> $DIR/drop_forget_ref.rs:17:10
|
17 | drop(&&owned1);
| ^^^^^^^^
error: call to `std::mem::drop` with a reference argument. Dropping a reference does nothing
error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
--> $DIR/drop_forget_ref.rs:18:5
|
18 | drop(&mut owned1);
@ -120,7 +68,7 @@ note: argument has type &mut SomeStruct
18 | drop(&mut owned1);
| ^^^^^^^^^^^
error: call to `std::mem::forget` with a reference argument. Forgetting a reference does nothing
error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
--> $DIR/drop_forget_ref.rs:21:5
|
21 | forget(&owned2);
@ -132,20 +80,7 @@ note: argument has type &SomeStruct
21 | forget(&owned2);
| ^^^^^^^
warning: call to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
--> $DIR/drop_forget_ref.rs:21:5
|
21 | forget(&owned2);
| ^^^^^^^^^^^^^^^
|
= note: #[warn(forget_copy)] on by default
note: argument has type &SomeStruct
--> $DIR/drop_forget_ref.rs:21:12
|
21 | forget(&owned2);
| ^^^^^^^
error: call to `std::mem::forget` with a reference argument. Forgetting a reference does nothing
error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
--> $DIR/drop_forget_ref.rs:22:5
|
22 | forget(&&owned2);
@ -157,20 +92,7 @@ note: argument has type &&SomeStruct
22 | forget(&&owned2);
| ^^^^^^^^
warning: call to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
--> $DIR/drop_forget_ref.rs:22:5
|
22 | forget(&&owned2);
| ^^^^^^^^^^^^^^^^
|
= note: #[warn(forget_copy)] on by default
note: argument has type &&SomeStruct
--> $DIR/drop_forget_ref.rs:22:12
|
22 | forget(&&owned2);
| ^^^^^^^^
error: call to `std::mem::forget` with a reference argument. Forgetting a reference does nothing
error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
--> $DIR/drop_forget_ref.rs:23:5
|
23 | forget(&mut owned2);
@ -182,7 +104,7 @@ note: argument has type &mut SomeStruct
23 | forget(&mut owned2);
| ^^^^^^^^^^^
error: call to `std::mem::drop` with a reference argument. Dropping a reference does nothing
error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
--> $DIR/drop_forget_ref.rs:27:5
|
27 | drop(reference1);
@ -194,20 +116,7 @@ note: argument has type &SomeStruct
27 | drop(reference1);
| ^^^^^^^^^^
warning: call to `std::mem::drop` with a value that implements Copy. Dropping a copy leaves the original intact.
--> $DIR/drop_forget_ref.rs:27:5
|
27 | drop(reference1);
| ^^^^^^^^^^^^^^^^
|
= note: #[warn(drop_copy)] on by default
note: argument has type &SomeStruct
--> $DIR/drop_forget_ref.rs:27:10
|
27 | drop(reference1);
| ^^^^^^^^^^
error: call to `std::mem::forget` with a reference argument. Forgetting a reference does nothing
error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
--> $DIR/drop_forget_ref.rs:28:5
|
28 | forget(&*reference1);
@ -219,20 +128,7 @@ note: argument has type &SomeStruct
28 | forget(&*reference1);
| ^^^^^^^^^^^^
warning: call to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
--> $DIR/drop_forget_ref.rs:28:5
|
28 | forget(&*reference1);
| ^^^^^^^^^^^^^^^^^^^^
|
= note: #[warn(forget_copy)] on by default
note: argument has type &SomeStruct
--> $DIR/drop_forget_ref.rs:28:12
|
28 | forget(&*reference1);
| ^^^^^^^^^^^^
error: call to `std::mem::drop` with a reference argument. Dropping a reference does nothing
error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
--> $DIR/drop_forget_ref.rs:31:5
|
31 | drop(reference2);
@ -244,7 +140,7 @@ note: argument has type &mut SomeStruct
31 | drop(reference2);
| ^^^^^^^^^^
error: call to `std::mem::forget` with a reference argument. Forgetting a reference does nothing
error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
--> $DIR/drop_forget_ref.rs:33:5
|
33 | forget(reference3);
@ -256,7 +152,7 @@ note: argument has type &mut SomeStruct
33 | forget(reference3);
| ^^^^^^^^^^
error: call to `std::mem::drop` with a reference argument. Dropping a reference does nothing
error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
--> $DIR/drop_forget_ref.rs:36:5
|
36 | drop(reference4);
@ -268,20 +164,7 @@ note: argument has type &SomeStruct
36 | drop(reference4);
| ^^^^^^^^^^
warning: call to `std::mem::drop` with a value that implements Copy. Dropping a copy leaves the original intact.
--> $DIR/drop_forget_ref.rs:36:5
|
36 | drop(reference4);
| ^^^^^^^^^^^^^^^^
|
= note: #[warn(drop_copy)] on by default
note: argument has type &SomeStruct
--> $DIR/drop_forget_ref.rs:36:10
|
36 | drop(reference4);
| ^^^^^^^^^^
error: call to `std::mem::forget` with a reference argument. Forgetting a reference does nothing
error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
--> $DIR/drop_forget_ref.rs:37:5
|
37 | forget(reference4);
@ -293,20 +176,7 @@ note: argument has type &SomeStruct
37 | forget(reference4);
| ^^^^^^^^^^
warning: call to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
--> $DIR/drop_forget_ref.rs:37:5
|
37 | forget(reference4);
| ^^^^^^^^^^^^^^^^^^
|
= note: #[warn(forget_copy)] on by default
note: argument has type &SomeStruct
--> $DIR/drop_forget_ref.rs:37:12
|
37 | forget(reference4);
| ^^^^^^^^^^
error: call to `std::mem::drop` with a reference argument. Dropping a reference does nothing
error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
--> $DIR/drop_forget_ref.rs:42:5
|
42 | drop(&val);
@ -318,20 +188,7 @@ note: argument has type &T
42 | drop(&val);
| ^^^^
warning: call to `std::mem::drop` with a value that implements Copy. Dropping a copy leaves the original intact.
--> $DIR/drop_forget_ref.rs:42:5
|
42 | drop(&val);
| ^^^^^^^^^^
|
= note: #[warn(drop_copy)] on by default
note: argument has type &T
--> $DIR/drop_forget_ref.rs:42:10
|
42 | drop(&val);
| ^^^^
error: call to `std::mem::forget` with a reference argument. Forgetting a reference does nothing
error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
--> $DIR/drop_forget_ref.rs:48:5
|
48 | forget(&val);
@ -343,20 +200,7 @@ note: argument has type &T
48 | forget(&val);
| ^^^^
warning: call to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
--> $DIR/drop_forget_ref.rs:48:5
|
48 | forget(&val);
| ^^^^^^^^^^^^
|
= note: #[warn(forget_copy)] on by default
note: argument has type &T
--> $DIR/drop_forget_ref.rs:48:12
|
48 | forget(&val);
| ^^^^
error: call to `std::mem::drop` with a reference argument. Dropping a reference does nothing
error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
--> $DIR/drop_forget_ref.rs:56:5
|
56 | std::mem::drop(&SomeStruct);
@ -368,20 +212,7 @@ note: argument has type &SomeStruct
56 | std::mem::drop(&SomeStruct);
| ^^^^^^^^^^^
warning: call to `std::mem::drop` with a value that implements Copy. Dropping a copy leaves the original intact.
--> $DIR/drop_forget_ref.rs:56:5
|
56 | std::mem::drop(&SomeStruct);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: #[warn(drop_copy)] on by default
note: argument has type &SomeStruct
--> $DIR/drop_forget_ref.rs:56:20
|
56 | std::mem::drop(&SomeStruct);
| ^^^^^^^^^^^
error: call to `std::mem::forget` with a reference argument. Forgetting a reference does nothing
error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
--> $DIR/drop_forget_ref.rs:59:5
|
59 | std::mem::forget(&SomeStruct);
@ -393,18 +224,5 @@ note: argument has type &SomeStruct
59 | std::mem::forget(&SomeStruct);
| ^^^^^^^^^^^
warning: call to `std::mem::forget` with a value that implements Copy. Forgetting a copy leaves the original intact.
--> $DIR/drop_forget_ref.rs:59:5
|
59 | std::mem::forget(&SomeStruct);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: #[warn(forget_copy)] on by default
note: argument has type &SomeStruct
--> $DIR/drop_forget_ref.rs:59:22
|
59 | std::mem::forget(&SomeStruct);
| ^^^^^^^^^^^
error: aborting due to 18 previous errors