2020-08-28 14:10:16 +00:00
|
|
|
use crate::rustc_target::abi::LayoutOf;
|
2021-06-03 06:41:37 +00:00
|
|
|
use clippy_utils::consts::{constant, Constant};
|
2021-03-25 18:29:11 +00:00
|
|
|
use clippy_utils::diagnostics::span_lint_and_sugg;
|
|
|
|
use clippy_utils::higher;
|
|
|
|
use clippy_utils::source::snippet_with_applicability;
|
|
|
|
use clippy_utils::ty::is_copy;
|
2018-11-20 13:06:29 +00:00
|
|
|
use if_chain::if_chain;
|
2018-12-29 15:04:45 +00:00
|
|
|
use rustc_errors::Applicability;
|
2021-04-08 15:50:13 +00:00
|
|
|
use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability};
|
2020-01-12 06:08:41 +00:00
|
|
|
use rustc_lint::{LateContext, LateLintPass};
|
2020-03-30 09:02:14 +00:00
|
|
|
use rustc_middle::ty::{self, Ty};
|
2020-08-28 14:10:16 +00:00
|
|
|
use rustc_session::{declare_tool_lint, impl_lint_pass};
|
2020-01-04 10:00:00 +00:00
|
|
|
use rustc_span::source_map::Span;
|
2016-01-29 00:54:10 +00:00
|
|
|
|
2020-08-28 14:10:16 +00:00
|
|
|
#[allow(clippy::module_name_repetitions)]
|
|
|
|
#[derive(Copy, Clone)]
|
|
|
|
pub struct UselessVec {
|
|
|
|
pub too_large_for_stack: u64,
|
|
|
|
}
|
|
|
|
|
2018-03-28 13:24:26 +00:00
|
|
|
declare_clippy_lint! {
|
2021-07-29 10:16:06 +00:00
|
|
|
/// ### What it does
|
|
|
|
/// Checks for usage of `&vec![..]` when using `&[..]` would
|
2019-03-05 16:50:33 +00:00
|
|
|
/// be possible.
|
|
|
|
///
|
2021-07-29 10:16:06 +00:00
|
|
|
/// ### Why is this bad?
|
|
|
|
/// This is less efficient.
|
2019-03-05 16:50:33 +00:00
|
|
|
///
|
2021-07-29 10:16:06 +00:00
|
|
|
/// ### Example
|
2020-06-09 14:36:01 +00:00
|
|
|
/// ```rust
|
|
|
|
/// # fn foo(my_vec: &[u8]) {}
|
|
|
|
///
|
|
|
|
/// // Bad
|
|
|
|
/// foo(&vec![1, 2]);
|
|
|
|
///
|
|
|
|
/// // Good
|
|
|
|
/// foo(&[1, 2]);
|
2019-03-05 16:50:33 +00:00
|
|
|
/// ```
|
2016-01-29 00:54:10 +00:00
|
|
|
pub USELESS_VEC,
|
2018-03-28 13:24:26 +00:00
|
|
|
perf,
|
2016-01-29 00:54:10 +00:00
|
|
|
"useless `vec!`"
|
|
|
|
}
|
|
|
|
|
2020-08-28 14:10:16 +00:00
|
|
|
impl_lint_pass!(UselessVec => [USELESS_VEC]);
|
2016-01-29 00:54:10 +00:00
|
|
|
|
2020-06-25 20:41:36 +00:00
|
|
|
impl<'tcx> LateLintPass<'tcx> for UselessVec {
|
|
|
|
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
|
2016-03-03 19:09:31 +00:00
|
|
|
// search for `&vec![_]` expressions where the adjusted type is `&[_]`
|
2017-10-23 19:18:02 +00:00
|
|
|
if_chain! {
|
2020-08-03 22:18:29 +00:00
|
|
|
if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty_adjusted(expr).kind();
|
|
|
|
if let ty::Slice(..) = ty.kind();
|
2021-08-08 14:49:13 +00:00
|
|
|
if let ExprKind::AddrOf(BorrowKind::Ref, mutability, ref addressee) = expr.kind;
|
|
|
|
if let Some(vec_args) = higher::VecArgs::hir(cx, addressee);
|
2017-10-23 19:18:02 +00:00
|
|
|
then {
|
2021-04-08 15:50:13 +00:00
|
|
|
self.check_vec_macro(cx, &vec_args, mutability, expr.span);
|
2017-10-23 19:18:02 +00:00
|
|
|
}
|
|
|
|
}
|
2016-03-28 21:32:55 +00:00
|
|
|
|
|
|
|
// search for `for _ in vec![…]`
|
2017-10-23 19:18:02 +00:00
|
|
|
if_chain! {
|
2021-08-08 14:49:13 +00:00
|
|
|
if let Some(higher::ForLoop { arg, .. }) = higher::ForLoop::hir(expr);
|
|
|
|
if let Some(vec_args) = higher::VecArgs::hir(cx, arg);
|
2020-07-17 08:47:04 +00:00
|
|
|
if is_copy(cx, vec_type(cx.typeck_results().expr_ty_adjusted(arg)));
|
2017-10-23 19:18:02 +00:00
|
|
|
then {
|
|
|
|
// report the error around the `vec!` not inside `<std macros>:`
|
2017-11-04 19:56:05 +00:00
|
|
|
let span = arg.span
|
2019-03-26 09:55:03 +00:00
|
|
|
.ctxt()
|
2019-08-16 16:29:30 +00:00
|
|
|
.outer_expn_data()
|
|
|
|
.call_site
|
2017-11-04 19:56:05 +00:00
|
|
|
.ctxt()
|
2019-08-16 16:29:30 +00:00
|
|
|
.outer_expn_data()
|
|
|
|
.call_site;
|
2021-04-08 15:50:13 +00:00
|
|
|
self.check_vec_macro(cx, &vec_args, Mutability::Not, span);
|
2017-10-23 19:18:02 +00:00
|
|
|
}
|
|
|
|
}
|
2016-03-28 21:32:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-28 14:10:16 +00:00
|
|
|
impl UselessVec {
|
2021-04-08 15:50:13 +00:00
|
|
|
fn check_vec_macro<'tcx>(
|
|
|
|
self,
|
|
|
|
cx: &LateContext<'tcx>,
|
|
|
|
vec_args: &higher::VecArgs<'tcx>,
|
|
|
|
mutability: Mutability,
|
|
|
|
span: Span,
|
|
|
|
) {
|
2020-08-28 14:10:16 +00:00
|
|
|
let mut applicability = Applicability::MachineApplicable;
|
|
|
|
let snippet = match *vec_args {
|
|
|
|
higher::VecArgs::Repeat(elem, len) => {
|
|
|
|
if let Some((Constant::Int(len_constant), _)) = constant(cx, cx.typeck_results(), len) {
|
|
|
|
#[allow(clippy::cast_possible_truncation)]
|
|
|
|
if len_constant as u64 * size_of(cx, elem) > self.too_large_for_stack {
|
|
|
|
return;
|
|
|
|
}
|
2016-01-29 00:54:10 +00:00
|
|
|
|
2021-04-08 15:50:13 +00:00
|
|
|
match mutability {
|
|
|
|
Mutability::Mut => {
|
|
|
|
format!(
|
|
|
|
"&mut [{}; {}]",
|
|
|
|
snippet_with_applicability(cx, elem.span, "elem", &mut applicability),
|
|
|
|
snippet_with_applicability(cx, len.span, "len", &mut applicability)
|
|
|
|
)
|
|
|
|
},
|
|
|
|
Mutability::Not => {
|
|
|
|
format!(
|
|
|
|
"&[{}; {}]",
|
|
|
|
snippet_with_applicability(cx, elem.span, "elem", &mut applicability),
|
|
|
|
snippet_with_applicability(cx, len.span, "len", &mut applicability)
|
|
|
|
)
|
|
|
|
},
|
|
|
|
}
|
2020-08-28 14:10:16 +00:00
|
|
|
} else {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
},
|
|
|
|
higher::VecArgs::Vec(args) => {
|
|
|
|
if let Some(last) = args.iter().last() {
|
|
|
|
#[allow(clippy::cast_possible_truncation)]
|
|
|
|
if args.len() as u64 * size_of(cx, last) > self.too_large_for_stack {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
let span = args[0].span.to(last.span);
|
|
|
|
|
2021-04-08 15:50:13 +00:00
|
|
|
match mutability {
|
|
|
|
Mutability::Mut => {
|
|
|
|
format!(
|
|
|
|
"&mut [{}]",
|
|
|
|
snippet_with_applicability(cx, span, "..", &mut applicability)
|
|
|
|
)
|
|
|
|
},
|
|
|
|
Mutability::Not => {
|
|
|
|
format!("&[{}]", snippet_with_applicability(cx, span, "..", &mut applicability))
|
|
|
|
},
|
|
|
|
}
|
2020-08-28 14:10:16 +00:00
|
|
|
} else {
|
2021-04-08 15:50:13 +00:00
|
|
|
match mutability {
|
|
|
|
Mutability::Mut => "&mut []".into(),
|
|
|
|
Mutability::Not => "&[]".into(),
|
|
|
|
}
|
2020-08-28 14:10:16 +00:00
|
|
|
}
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
span_lint_and_sugg(
|
|
|
|
cx,
|
|
|
|
USELESS_VEC,
|
|
|
|
span,
|
|
|
|
"useless use of `vec!`",
|
|
|
|
"you can use a slice directly",
|
|
|
|
snippet,
|
|
|
|
applicability,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
2016-01-29 00:54:10 +00:00
|
|
|
|
2020-08-28 14:10:16 +00:00
|
|
|
fn size_of(cx: &LateContext<'_>, expr: &Expr<'_>) -> u64 {
|
|
|
|
let ty = cx.typeck_results().expr_ty_adjusted(expr);
|
|
|
|
cx.layout_of(ty).map_or(0, |l| l.size.bytes())
|
2016-01-29 00:54:10 +00:00
|
|
|
}
|
|
|
|
|
2019-01-31 01:15:29 +00:00
|
|
|
/// Returns the item type of the vector (i.e., the `T` in `Vec<T>`).
|
2018-07-23 11:01:12 +00:00
|
|
|
fn vec_type(ty: Ty<'_>) -> Ty<'_> {
|
2020-08-03 22:18:29 +00:00
|
|
|
if let ty::Adt(_, substs) = ty.kind() {
|
2016-08-28 15:25:41 +00:00
|
|
|
substs.type_at(0)
|
2016-07-14 17:31:17 +00:00
|
|
|
} else {
|
|
|
|
panic!("The type of `vec!` is a not a struct?");
|
|
|
|
}
|
|
|
|
}
|