1 //! lint on using `x.get(x.len() - 1)` instead of `x.last()`
3 use crate::utils::{is_type_diagnostic_item, snippet_with_applicability, span_lint_and_sugg, SpanlessEq};
4 use if_chain::if_chain;
5 use rustc::declare_lint_pass;
6 use rustc::hir::{BinOpKind, Expr, ExprKind};
7 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
8 use rustc_errors::Applicability;
9 use rustc_session::declare_tool_lint;
10 use syntax::ast::LitKind;
11 use syntax::source_map::Spanned;
12 use syntax::symbol::Symbol;
14 declare_clippy_lint! {
15 /// **What it does:** Checks for using `x.get(x.len() - 1)` instead of
18 /// **Why is this bad?** Using `x.last()` is easier to read and has the same
21 /// Note that using `x[x.len() - 1]` is semantically different from
22 /// `x.last()`. Indexing into the array will panic on out-of-bounds
23 /// accesses, while `x.get()` and `x.last()` will return `None`.
25 /// There is another lint (get_unwrap) that covers the case of using
26 /// `x.get(index).unwrap()` instead of `x[index]`.
28 /// **Known problems:** None.
34 /// let x = vec![2, 3, 5];
35 /// let last_element = x.get(x.len() - 1);
38 /// let x = vec![2, 3, 5];
39 /// let last_element = x.last();
41 pub GET_LAST_WITH_LEN,
43 "Using `x.get(x.len() - 1)` when `x.last()` is correct and simpler"
46 declare_lint_pass!(GetLastWithLen => [GET_LAST_WITH_LEN]);
48 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for GetLastWithLen {
49 fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
52 if let ExprKind::MethodCall(ref path, _, ref args) = expr.kind;
54 // Method name is "get"
55 if path.ident.name == Symbol::intern("get");
57 // Argument 0 (the struct we're calling the method on) is a vector
58 if let Some(struct_calling_on) = args.get(0);
59 let struct_ty = cx.tables.expr_ty(struct_calling_on);
60 if is_type_diagnostic_item(cx, struct_ty, Symbol::intern("vec_type"));
62 // Argument to "get" is a subtraction
63 if let Some(get_index_arg) = args.get(1);
64 if let ExprKind::Binary(
71 ) = &get_index_arg.kind;
73 // LHS of subtraction is "x.len()"
74 if let ExprKind::MethodCall(arg_lhs_path, _, lhs_args) = &lhs.kind;
75 if arg_lhs_path.ident.name == Symbol::intern("len");
76 if let Some(arg_lhs_struct) = lhs_args.get(0);
78 // The two vectors referenced (x in x.get(...) and in x.len())
79 if SpanlessEq::new(cx).eq_expr(struct_calling_on, arg_lhs_struct);
81 // RHS of subtraction is 1
82 if let ExprKind::Lit(rhs_lit) = &rhs.kind;
83 if let LitKind::Int(1, ..) = rhs_lit.node;
86 let mut applicability = Applicability::MachineApplicable;
87 let vec_name = snippet_with_applicability(
89 struct_calling_on.span, "vec",
97 &format!("accessing last element with `{0}.get({0}.len() - 1)`", vec_name),
99 format!("{}.last()", vec_name),