[rustc.git] / src / tools / clippy / clippy_lints / src / mem_replace.rs

use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
use clippy_utils::source::{snippet, snippet_with_applicability};
use clippy_utils::ty::is_non_aggregate_primitive_type;
use clippy_utils::{is_default_equivalent, is_lang_ctor, match_def_path, meets_msrv, msrvs, paths};
use if_chain::if_chain;
use rustc_errors::Applicability;
use rustc_hir::LangItem::OptionNone;
use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, QPath};
use rustc_lint::{LateContext, LateLintPass};
use rustc_middle::lint::in_external_macro;
use rustc_semver::RustcVersion;
use rustc_session::{declare_tool_lint, impl_lint_pass};
use rustc_span::source_map::Span;
use rustc_span::symbol::sym;

declare_clippy_lint! {
    /// ### What it does
    /// Checks for `mem::replace()` on an `Option` with
    /// `None`.
    ///
    /// ### Why is this bad?
    /// `Option` already has the method `take()` for
    /// taking its current value (Some(..) or None) and replacing it with
    /// `None`.
    ///
    /// ### Example
    /// ```rust
    /// use std::mem;
    ///
    /// let mut an_option = Some(0);
    /// let replaced = mem::replace(&mut an_option, None);
    /// ```
    /// Is better expressed with:
    /// ```rust
    /// let mut an_option = Some(0);
    /// let taken = an_option.take();
    /// ```
    #[clippy::version = "1.31.0"]
    pub MEM_REPLACE_OPTION_WITH_NONE,
    style,
    "replacing an `Option` with `None` instead of `take()`"
}

declare_clippy_lint! {
    /// ### What it does
    /// Checks for `mem::replace(&mut _, mem::uninitialized())`
    /// and `mem::replace(&mut _, mem::zeroed())`.
    ///
    /// ### Why is this bad?
    /// This will lead to undefined behavior even if the
    /// value is overwritten later, because the uninitialized value may be
    /// observed in the case of a panic.
    ///
    /// ### Example
    /// ```
    /// use std::mem;
    ///# fn may_panic(v: Vec<i32>) -> Vec<i32> { v }
    ///
    /// #[allow(deprecated, invalid_value)]
    /// fn myfunc (v: &mut Vec<i32>) {
    ///     let taken_v = unsafe { mem::replace(v, mem::uninitialized()) };
    ///     let new_v = may_panic(taken_v); // undefined behavior on panic
    ///     mem::forget(mem::replace(v, new_v));
    /// }
    /// ```
    ///
    /// The [take_mut](https://docs.rs/take_mut) crate offers a sound solution,
    /// at the cost of either lazily creating a replacement value or aborting
    /// on panic, to ensure that the uninitialized value cannot be observed.
    #[clippy::version = "1.39.0"]
    pub MEM_REPLACE_WITH_UNINIT,
    correctness,
    "`mem::replace(&mut _, mem::uninitialized())` or `mem::replace(&mut _, mem::zeroed())`"
}

declare_clippy_lint! {
    /// ### What it does
    /// Checks for `std::mem::replace` on a value of type
    /// `T` with `T::default()`.
    ///
    /// ### Why is this bad?
    /// `std::mem` module already has the method `take` to
    /// take the current value and replace it with the default value of that type.
    ///
    /// ### Example
    /// ```rust
    /// let mut text = String::from("foo");
    /// let replaced = std::mem::replace(&mut text, String::default());
    /// ```
    /// Is better expressed with:
    /// ```rust
    /// let mut text = String::from("foo");
    /// let taken = std::mem::take(&mut text);
    /// ```
    #[clippy::version = "1.42.0"]
    pub MEM_REPLACE_WITH_DEFAULT,
    style,
    "replacing a value of type `T` with `T::default()` instead of using `std::mem::take`"
}

impl_lint_pass!(MemReplace =>
    [MEM_REPLACE_OPTION_WITH_NONE, MEM_REPLACE_WITH_UNINIT, MEM_REPLACE_WITH_DEFAULT]);

fn check_replace_option_with_none(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
    if let ExprKind::Path(ref replacement_qpath) = src.kind {
        // Check that second argument is `Option::None`
        if is_lang_ctor(cx, replacement_qpath, OptionNone) {
            // Since this is a late pass (already type-checked),
            // and we already know that the second argument is an
            // `Option`, we do not need to check the first
            // argument's type. All that's left is to get
            // replacee's path.
            let replaced_path = match dest.kind {
                ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, replaced) => {
                    if let ExprKind::Path(QPath::Resolved(None, replaced_path)) = replaced.kind {
                        replaced_path
                    } else {
                        return;
                    }
                },
                ExprKind::Path(QPath::Resolved(None, replaced_path)) => replaced_path,
                _ => return,
            };

            let mut applicability = Applicability::MachineApplicable;
            span_lint_and_sugg(
                cx,
                MEM_REPLACE_OPTION_WITH_NONE,
                expr_span,
                "replacing an `Option` with `None`",
                "consider `Option::take()` instead",
                format!(
                    "{}.take()",
                    snippet_with_applicability(cx, replaced_path.span, "", &mut applicability)
                ),
                applicability,
            );
        }
    }
}

fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
    if_chain! {
        // check if replacement is mem::MaybeUninit::uninit().assume_init()
        if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(src.hir_id);
        if cx.tcx.is_diagnostic_item(sym::assume_init, method_def_id);
        then {
            let mut applicability = Applicability::MachineApplicable;
            span_lint_and_sugg(
                cx,
                MEM_REPLACE_WITH_UNINIT,
                expr_span,
                "replacing with `mem::MaybeUninit::uninit().assume_init()`",
                "consider using",
                format!(
                    "std::ptr::read({})",
                    snippet_with_applicability(cx, dest.span, "", &mut applicability)
                ),
                applicability,
            );
            return;
        }
    }

    if_chain! {
        if let ExprKind::Call(repl_func, repl_args) = src.kind;
        if repl_args.is_empty();
        if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
        if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
        then {
            if cx.tcx.is_diagnostic_item(sym::mem_uninitialized, repl_def_id) {
                let mut applicability = Applicability::MachineApplicable;
                span_lint_and_sugg(
                    cx,
                    MEM_REPLACE_WITH_UNINIT,
                    expr_span,
                    "replacing with `mem::uninitialized()`",
                    "consider using",
                    format!(
                        "std::ptr::read({})",
                        snippet_with_applicability(cx, dest.span, "", &mut applicability)
                    ),
                    applicability,
                );
            } else if cx.tcx.is_diagnostic_item(sym::mem_zeroed, repl_def_id) &&
                    !cx.typeck_results().expr_ty(src).is_primitive() {
                span_lint_and_help(
                    cx,
                    MEM_REPLACE_WITH_UNINIT,
                    expr_span,
                    "replacing with `mem::zeroed()`",
                    None,
                    "consider using a default value or the `take_mut` crate instead",
                );
            }
        }
    }
}

fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
    // disable lint for primitives
    let expr_type = cx.typeck_results().expr_ty_adjusted(src);
    if is_non_aggregate_primitive_type(expr_type) {
        return;
    }
    // disable lint for Option since it is covered in another lint
    if let ExprKind::Path(q) = &src.kind {
        if is_lang_ctor(cx, q, OptionNone) {
            return;
        }
    }
    if is_default_equivalent(cx, src) && !in_external_macro(cx.tcx.sess, expr_span) {
        span_lint_and_then(
            cx,
            MEM_REPLACE_WITH_DEFAULT,
            expr_span,
            "replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`",
            |diag| {
                if !expr_span.from_expansion() {
                    let suggestion = format!("std::mem::take({})", snippet(cx, dest.span, ""));

                    diag.span_suggestion(
                        expr_span,
                        "consider using",
                        suggestion,
                        Applicability::MachineApplicable,
                    );
                }
            },
        );
    }
}

pub struct MemReplace {
    msrv: Option<RustcVersion>,
}

impl MemReplace {
    #[must_use]
    pub fn new(msrv: Option<RustcVersion>) -> Self {
        Self { msrv }
    }
}

impl<'tcx> LateLintPass<'tcx> for MemReplace {
    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
        if_chain! {
            // Check that `expr` is a call to `mem::replace()`
            if let ExprKind::Call(func, func_args) = expr.kind;
            if let ExprKind::Path(ref func_qpath) = func.kind;
            if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
            if match_def_path(cx, def_id, &paths::MEM_REPLACE);
            if let [dest, src] = func_args;
            then {
                check_replace_option_with_none(cx, src, dest, expr.span);
                check_replace_with_uninit(cx, src, dest, expr.span);
                if meets_msrv(self.msrv.as_ref(), &msrvs::MEM_TAKE) {
                    check_replace_with_default(cx, src, dest, expr.span);
                }
            }
        }
    }
    extract_msrv_attr!(LateContext);
}
Commit	Line	Data
cdc7bbd5 XL	1	use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
cdc7bbd5 XL	2	use clippy_utils::source::{snippet, snippet_with_applicability};
c295e0f8	3	use clippy_utils::ty::is_non_aggregate_primitive_type;
a2a8927a	4	use clippy_utils::{is_default_equivalent, is_lang_ctor, match_def_path, meets_msrv, msrvs, paths};
f20569fa XL	5	use if_chain::if_chain;
f20569fa XL	6	use rustc_errors::Applicability;
cdc7bbd5	7	use rustc_hir::LangItem::OptionNone;
f20569fa	8	use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, QPath};
5099ac24	9	use rustc_lint::{LateContext, LateLintPass};
f20569fa XL	10	use rustc_middle::lint::in_external_macro;
	11	use rustc_semver::RustcVersion;
	12	use rustc_session::{declare_tool_lint, impl_lint_pass};
	13	use rustc_span::source_map::Span;
	14	use rustc_span::symbol::sym;
	15
	16	declare_clippy_lint! {
94222f64 XL	17	/// ### What it does
94222f64 XL	18	/// Checks for `mem::replace()` on an `Option` with
f20569fa XL	19	/// `None`.
f20569fa XL	20	///
94222f64 XL	21	/// ### Why is this bad?
94222f64 XL	22	/// `Option` already has the method `take()` for
f20569fa XL	23	/// taking its current value (Some(..) or None) and replacing it with
	24	/// `None`.
	25	///
94222f64	26	/// ### Example
f20569fa XL	27	/// ```rust
	28	/// use std::mem;
	29	///
	30	/// let mut an_option = Some(0);
	31	/// let replaced = mem::replace(&mut an_option, None);
	32	/// ```
	33	/// Is better expressed with:
	34	/// ```rust
	35	/// let mut an_option = Some(0);
	36	/// let taken = an_option.take();
	37	/// ```
a2a8927a	38	#[clippy::version = "1.31.0"]
f20569fa XL	39	pub MEM_REPLACE_OPTION_WITH_NONE,
	40	style,
	41	"replacing an `Option` with `None` instead of `take()`"
	42	}
	43
	44	declare_clippy_lint! {
94222f64 XL	45	/// ### What it does
94222f64 XL	46	/// Checks for `mem::replace(&mut _, mem::uninitialized())`
f20569fa XL	47	/// and `mem::replace(&mut _, mem::zeroed())`.
f20569fa XL	48	///
94222f64 XL	49	/// ### Why is this bad?
94222f64 XL	50	/// This will lead to undefined behavior even if the
f20569fa XL	51	/// value is overwritten later, because the uninitialized value may be
	52	/// observed in the case of a panic.
	53	///
94222f64	54	/// ### Example
f20569fa XL	55	/// ```
	56	/// use std::mem;
	57	///# fn may_panic(v: Vec<i32>) -> Vec<i32> { v }
	58	///
	59	/// #[allow(deprecated, invalid_value)]
	60	/// fn myfunc (v: &mut Vec<i32>) {
	61	/// let taken_v = unsafe { mem::replace(v, mem::uninitialized()) };
	62	/// let new_v = may_panic(taken_v); // undefined behavior on panic
	63	/// mem::forget(mem::replace(v, new_v));
	64	/// }
	65	/// ```
	66	///
	67	/// The [take_mut](https://docs.rs/take_mut) crate offers a sound solution,
	68	/// at the cost of either lazily creating a replacement value or aborting
	69	/// on panic, to ensure that the uninitialized value cannot be observed.
a2a8927a	70	#[clippy::version = "1.39.0"]
f20569fa XL	71	pub MEM_REPLACE_WITH_UNINIT,
	72	correctness,
	73	"`mem::replace(&mut _, mem::uninitialized())` or `mem::replace(&mut _, mem::zeroed())`"
	74	}
	75
	76	declare_clippy_lint! {
94222f64 XL	77	/// ### What it does
94222f64 XL	78	/// Checks for `std::mem::replace` on a value of type
f20569fa XL	79	/// `T` with `T::default()`.
f20569fa XL	80	///
94222f64 XL	81	/// ### Why is this bad?
94222f64 XL	82	/// `std::mem` module already has the method `take` to
f20569fa XL	83	/// take the current value and replace it with the default value of that type.
f20569fa XL	84	///
94222f64	85	/// ### Example
f20569fa XL	86	/// ```rust
	87	/// let mut text = String::from("foo");
	88	/// let replaced = std::mem::replace(&mut text, String::default());
	89	/// ```
	90	/// Is better expressed with:
	91	/// ```rust
	92	/// let mut text = String::from("foo");
	93	/// let taken = std::mem::take(&mut text);
	94	/// ```
a2a8927a	95	#[clippy::version = "1.42.0"]
f20569fa XL	96	pub MEM_REPLACE_WITH_DEFAULT,
	97	style,
	98	"replacing a value of type `T` with `T::default()` instead of using `std::mem::take`"
	99	}
	100
	101	impl_lint_pass!(MemReplace =>
	102	[MEM_REPLACE_OPTION_WITH_NONE, MEM_REPLACE_WITH_UNINIT, MEM_REPLACE_WITH_DEFAULT]);
	103
	104	fn check_replace_option_with_none(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
	105	if let ExprKind::Path(ref replacement_qpath) = src.kind {
	106	// Check that second argument is `Option::None`
cdc7bbd5	107	if is_lang_ctor(cx, replacement_qpath, OptionNone) {
f20569fa XL	108	// Since this is a late pass (already type-checked),
	109	// and we already know that the second argument is an
	110	// `Option`, we do not need to check the first
	111	// argument's type. All that's left is to get
	112	// replacee's path.
	113	let replaced_path = match dest.kind {
cdc7bbd5 XL	114	ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, replaced) => {
cdc7bbd5 XL	115	if let ExprKind::Path(QPath::Resolved(None, replaced_path)) = replaced.kind {
f20569fa XL	116	replaced_path
	117	} else {
	118	return;
	119	}
	120	},
cdc7bbd5	121	ExprKind::Path(QPath::Resolved(None, replaced_path)) => replaced_path,
f20569fa XL	122	_ => return,
	123	};
	124
	125	let mut applicability = Applicability::MachineApplicable;
	126	span_lint_and_sugg(
	127	cx,
	128	MEM_REPLACE_OPTION_WITH_NONE,
	129	expr_span,
	130	"replacing an `Option` with `None`",
	131	"consider `Option::take()` instead",
	132	format!(
	133	"{}.take()",
	134	snippet_with_applicability(cx, replaced_path.span, "", &mut applicability)
	135	),
	136	applicability,
	137	);
	138	}
	139	}
	140	}
	141
	142	fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
	143	if_chain! {
	144	// check if replacement is mem::MaybeUninit::uninit().assume_init()
	145	if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(src.hir_id);
	146	if cx.tcx.is_diagnostic_item(sym::assume_init, method_def_id);
	147	then {
	148	let mut applicability = Applicability::MachineApplicable;
	149	span_lint_and_sugg(
	150	cx,
	151	MEM_REPLACE_WITH_UNINIT,
	152	expr_span,
	153	"replacing with `mem::MaybeUninit::uninit().assume_init()`",
	154	"consider using",
	155	format!(
	156	"std::ptr::read({})",
	157	snippet_with_applicability(cx, dest.span, "", &mut applicability)
	158	),
	159	applicability,
	160	);
	161	return;
	162	}
	163	}
	164
	165	if_chain! {
cdc7bbd5	166	if let ExprKind::Call(repl_func, repl_args) = src.kind;
f20569fa XL	167	if repl_args.is_empty();
	168	if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
	169	if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
	170	then {
	171	if cx.tcx.is_diagnostic_item(sym::mem_uninitialized, repl_def_id) {
	172	let mut applicability = Applicability::MachineApplicable;
	173	span_lint_and_sugg(
	174	cx,
	175	MEM_REPLACE_WITH_UNINIT,
	176	expr_span,
	177	"replacing with `mem::uninitialized()`",
	178	"consider using",
	179	format!(
	180	"std::ptr::read({})",
	181	snippet_with_applicability(cx, dest.span, "", &mut applicability)
	182	),
	183	applicability,
	184	);
	185	} else if cx.tcx.is_diagnostic_item(sym::mem_zeroed, repl_def_id) &&
	186	!cx.typeck_results().expr_ty(src).is_primitive() {
	187	span_lint_and_help(
	188	cx,
	189	MEM_REPLACE_WITH_UNINIT,
	190	expr_span,
	191	"replacing with `mem::zeroed()`",
	192	None,
	193	"consider using a default value or the `take_mut` crate instead",
	194	);
	195	}
	196	}
	197	}
	198	}
	199
c295e0f8 XL	200	fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
	201	// disable lint for primitives
	202	let expr_type = cx.typeck_results().expr_ty_adjusted(src);
	203	if is_non_aggregate_primitive_type(expr_type) {
	204	return;
	205	}
	206	// disable lint for Option since it is covered in another lint
	207	if let ExprKind::Path(q) = &src.kind {
	208	if is_lang_ctor(cx, q, OptionNone) {
	209	return;
f20569fa XL	210	}
f20569fa XL	211	}
c295e0f8 XL	212	if is_default_equivalent(cx, src) && !in_external_macro(cx.tcx.sess, expr_span) {
	213	span_lint_and_then(
	214	cx,
	215	MEM_REPLACE_WITH_DEFAULT,
	216	expr_span,
	217	"replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`",
	218	\|diag\| {
a2a8927a	219	if !expr_span.from_expansion() {
c295e0f8	220	let suggestion = format!("std::mem::take({})", snippet(cx, dest.span, ""));
f20569fa	221
c295e0f8 XL	222	diag.span_suggestion(
	223	expr_span,
	224	"consider using",
	225	suggestion,
	226	Applicability::MachineApplicable,
	227	);
cdc7bbd5	228	}
c295e0f8 XL	229	},
c295e0f8 XL	230	);
cdc7bbd5 XL	231	}
cdc7bbd5 XL	232	}
f20569fa XL	233
	234	pub struct MemReplace {
	235	msrv: Option<RustcVersion>,
	236	}
	237
	238	impl MemReplace {
	239	#[must_use]
	240	pub fn new(msrv: Option<RustcVersion>) -> Self {
	241	Self { msrv }
	242	}
	243	}
	244
	245	impl<'tcx> LateLintPass<'tcx> for MemReplace {
	246	fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
	247	if_chain! {
	248	// Check that `expr` is a call to `mem::replace()`
cdc7bbd5	249	if let ExprKind::Call(func, func_args) = expr.kind;
f20569fa XL	250	if let ExprKind::Path(ref func_qpath) = func.kind;
	251	if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
	252	if match_def_path(cx, def_id, &paths::MEM_REPLACE);
cdc7bbd5	253	if let [dest, src] = func_args;
f20569fa XL	254	then {
	255	check_replace_option_with_none(cx, src, dest, expr.span);
	256	check_replace_with_uninit(cx, src, dest, expr.span);
cdc7bbd5	257	if meets_msrv(self.msrv.as_ref(), &msrvs::MEM_TAKE) {
f20569fa XL	258	check_replace_with_default(cx, src, dest, expr.span);
	259	}
	260	}
	261	}
	262	}
	263	extract_msrv_attr!(LateContext);
	264	}