Possibly finish

Author: HarrisonMc555

clippy_lints/src/use_last.rs

@@ -1,20 +1,11 @@
 //! lint on using `x.get(x.len() - 1)` instead of `x.last()`
 
-// use crate::utils::{in_macro, snippet_opt, last_path_segment, match_def_path, paths, snippet, span_lint, span_lint_and_then};
-// use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass};
+use crate::utils::{match_type, paths, span_lint};
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use rustc::{declare_tool_lint, lint_array};
-// use if_chain::if_chain;
-// use syntax::ast::*;
-use rustc::hir::{PatKind, BindingAnnotation, Expr, ExprKind};
-// use crate::utils::{opt_def_id, sugg};
-// use crate::utils::{span_lint, snippet};
-use crate::utils::span_lint;
+use rustc::hir::{Expr, ExprKind};
+use syntax::ast::{LitKind};
 use if_chain::if_chain;
-// use rustc::ty::{self, Ty};
-// use rustc_errors::Applicability;
-// use std::borrow::Cow;
-// use syntax::ast;
 
 /// **What it does:** Checks for using `x.get(x.len() - 1)` instead of `x.last()`.
 ///
@@ -54,22 +45,47 @@ impl LintPass for UseLast {
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UseLast {
-    fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
         if_chain! {
+            // Is a method call
             if let ExprKind::MethodCall(ref path, _, ref args) = expr.node;
-            // check if vector
-            // TODO: check if vector
-            // check if calling 'get' method
-            if path.ident.name.as_str() == "get";
-            // if let ExprKind::MethodCall(ref method_name, ref generics, ref args) = init.node;
-            // if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, _, None) = local.pat.node;
-            // if name.node.as_str() == "last_element";
+
+            // Method name is "get"
+            if path.ident.name == "get";
+
+            // Argument 0 (the struct we're calling the method on) is a vector
+            if let Some(struct_calling_on) = args.get(0);
+            let struct_ty = cx.tables.expr_ty(struct_calling_on);
+            if match_type(cx, struct_ty, &paths::VEC);
+
+            // Argument to "get" is a binary operation
+            if let Some(get_index_arg) = args.get(1);
+            if let rustc::hir::ExprKind::Binary(ref op, ref lhs, ref rhs) = get_index_arg.node;
+
+            // Binary operation is a subtraction
+            if op.node == rustc::hir::BinOpKind::Sub;
+
+            // LHS of subtraction is "x.len()"
+            if let ExprKind::MethodCall(ref arg_lhs_path, _, ref lhs_args) = lhs.node;
+            if arg_lhs_path.ident.name == "len";
+            if let Some(arg_lhs_struct) = lhs_args.get(0);
+            // TODO: Is this a valid way to check if they reference the same vector?
+            if arg_lhs_struct.hir_id == struct_calling_on.hir_id;
+
+            // RHS of subtraction is 1
+            if let ExprKind::Lit(ref rhs_lit) = rhs.node;
+            if let LitKind::Int(rhs_value, ..) = rhs_lit.node;
+            if rhs_value == 1;
+
+            // TODO: Figure out how to get name of variable for lint message
+            let vec_name = "x";
+
             then {
                 span_lint(cx,
                           USE_LAST,
-                          stmt.span,
-                          // Todo: fix this
-                          &format!("Use `x.last()` instead of `x.get(x.len() - 1)`"));
+                          expr.span,
+                          &format!("Use `{}.last()` instead of `{}.get({}.len() - 1)`",
+                                   vec_name, vec_name, vec_name));
             }
         }
     }