clippy_lints/src/get_last_with_len.rs

   1 //! lint on using `x.get(x.len() - 1)` instead of `x.last()`
   2
   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::hir::{BinOpKind, Expr, ExprKind};
   6 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
   7 use rustc::{declare_lint_pass, declare_tool_lint};
   8 use rustc_errors::Applicability;
   9 use syntax::ast::LitKind;
  10 use syntax::source_map::Spanned;
  11 use syntax::symbol::Symbol;
  12
  13 declare_clippy_lint! {
  14     /// **What it does:** Checks for using `x.get(x.len() - 1)` instead of
  15     /// `x.last()`.
  16     ///
  17     /// **Why is this bad?** Using `x.last()` is easier to read and has the same
  18     /// result.
  19     ///
  20     /// Note that using `x[x.len() - 1]` is semantically different from
  21     /// `x.last()`.  Indexing into the array will panic on out-of-bounds
  22     /// accesses, while `x.get()` and `x.last()` will return `None`.
  23     ///
  24     /// There is another lint (get_unwrap) that covers the case of using
  25     /// `x.get(index).unwrap()` instead of `x[index]`.
  26     ///
  27     /// **Known problems:** None.
  28     ///
  29     /// **Example:**
  30     ///
  31     /// ```rust
  32     /// // Bad
  33     /// let x = vec![2, 3, 5];
  34     /// let last_element = x.get(x.len() - 1);
  35     ///
  36     /// // Good
  37     /// let x = vec![2, 3, 5];
  38     /// let last_element = x.last();
  39     /// ```
  40     pub GET_LAST_WITH_LEN,
  41     complexity,
  42     "Using `x.get(x.len() - 1)` when `x.last()` is correct and simpler"
  43 }
  44
  45 declare_lint_pass!(GetLastWithLen => [GET_LAST_WITH_LEN]);
  46
  47 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for GetLastWithLen {
  48     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
  49         if_chain! {
  50             // Is a method call
  51             if let ExprKind::MethodCall(ref path, _, ref args) = expr.node;
  52
  53             // Method name is "get"
  54             if path.ident.name == Symbol::intern("get");
  55
  56             // Argument 0 (the struct we're calling the method on) is a vector
  57             if let Some(struct_calling_on) = args.get(0);
  58             let struct_ty = cx.tables.expr_ty(struct_calling_on);
  59             if is_type_diagnostic_item(cx, struct_ty, Symbol::intern("vec_type"));
  60
  61             // Argument to "get" is a subtraction
  62             if let Some(get_index_arg) = args.get(1);
  63             if let ExprKind::Binary(
  64                 Spanned {
  65                     node: BinOpKind::Sub,
  66                     ..
  67                 },
  68                 lhs,
  69                 rhs,
  70             ) = &get_index_arg.node;
  71
  72             // LHS of subtraction is "x.len()"
  73             if let ExprKind::MethodCall(arg_lhs_path, _, lhs_args) = &lhs.node;
  74             if arg_lhs_path.ident.name == Symbol::intern("len");
  75             if let Some(arg_lhs_struct) = lhs_args.get(0);
  76
  77             // The two vectors referenced (x in x.get(...) and in x.len())
  78             if SpanlessEq::new(cx).eq_expr(struct_calling_on, arg_lhs_struct);
  79
  80             // RHS of subtraction is 1
  81             if let ExprKind::Lit(rhs_lit) = &rhs.node;
  82             if let LitKind::Int(rhs_value, ..) = rhs_lit.node;
  83             if rhs_value == 1;
  84
  85             then {
  86                 let mut applicability = Applicability::MachineApplicable;
  87                 let vec_name = snippet_with_applicability(
  88                     cx,
  89                     struct_calling_on.span, "vec",
  90                     &mut applicability,
  91                 );
  92
  93                 span_lint_and_sugg(
  94                     cx,
  95                     GET_LAST_WITH_LEN,
  96                     expr.span,
  97                     &format!("accessing last element with `{0}.get({0}.len() - 1)`", vec_name),
  98                     "try",
  99                     format!("{}.last()", vec_name),
 100                     applicability,
 101                 );
 102             }
 103         }
 104     }
 105 }