Register use_last, fix bugs, and add (commented) printlns

Author: HarrisonMc555

clippy_lints/src/lib.rs

@@ -6,7 +6,8 @@
 #![feature(stmt_expr_attributes)]
 #![feature(range_contains)]
 #![allow(clippy::missing_docs_in_private_items)]
-#![recursion_limit = "256"]
+// #![recursion_limit = "256"]
+#![recursion_limit = "512"]
 #![warn(rust_2018_idioms, trivial_casts, trivial_numeric_casts)]
 #![feature(crate_visibility_modifier)]
 
@@ -551,6 +552,7 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry<'_>, conf: &Conf) {
     reg.register_late_lint_pass(box types::RefToMut);
     reg.register_late_lint_pass(box assertions_on_constants::AssertionsOnConstants);
     reg.register_late_lint_pass(box missing_const_for_fn::MissingConstForFn);
+    reg.register_late_lint_pass(box use_last::UseLast);
 
     reg.register_lint_group("clippy::restriction", Some("clippy_restriction"), vec![
         arithmetic::FLOAT_ARITHMETIC,

clippy_lints/src/use_last.rs

@@ -51,38 +51,62 @@ impl LintPass for UseLast {
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UseLast {
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
         if_chain! {
+            // let _ = println!("Starting UseLast");
             // Is a method call
             if let ExprKind::MethodCall(ref path, _, ref args) = expr.node;
+            // let _ = println!("It is a MethodCall");
 
             // Method name is "get"
             if path.ident.name == "get";
+            // let _ = println!("The name is get");
 
             // Argument 0 (the struct we're calling the method on) is a vector
             if let Some(struct_calling_on) = args.get(0);
+            // let _ = println!("It had an argument");
             let struct_ty = cx.tables.expr_ty(struct_calling_on);
             if match_type(cx, struct_ty, &paths::VEC);
+            // let _ = println!("It was a vector");
 
             // Argument to "get" is a binary operation
             if let Some(get_index_arg) = args.get(1);
+            // let _ = println!("It had an argument");
             if let rustc::hir::ExprKind::Binary(ref op, ref lhs, ref rhs) = get_index_arg.node;
+            // let _ = println!("It was a vector");
 
             // Binary operation is a subtraction
             if op.node == rustc::hir::BinOpKind::Sub;
+            // let _ = println!("It was a subtraction");
 
             // LHS of subtraction is "x.len()"
             if let ExprKind::MethodCall(ref arg_lhs_path, _, ref lhs_args) = lhs.node;
+            // let _ = println!("LHS of sub is a method call");
             if arg_lhs_path.ident.name == "len";
-            if let Some(arg_lhs_struct) = lhs_args.get(0);
+            // let _ = println!("LHS of sub was method named len");
+            // if let Some(arg_lhs_struct) = lhs_args.get(0);
+            // let _ = println!("LHS of sub method has an arg");
             // 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;
+            // if arg_lhs_struct.hir_id == struct_calling_on.hir_id;
+            // let _ = println!("The vector in .get and .len were the same");
 
             // RHS of subtraction is 1
             if let ExprKind::Lit(ref rhs_lit) = rhs.node;
+            // let _ = println!("RHS of sub was literal");
             if let LitKind::Int(rhs_value, ..) = rhs_lit.node;
+            // let _ = println!("RHS of sub was int");
             if rhs_value == 1;
+            // let _ = println!("RHS of sub was 1");
 
             // TODO: Figure out how to get name of variable for lint message
+            // Can't do this (cannot move out of borrowed content (context?))
+            // if let ExprKind::Struct(ref struct_calling_on_path, _, _) = struct_calling_on.node;
+            // let _ = println!("It was a struct");
+            // let vec_name = match struct_calling_on_path.into_inner() {
+            //     rustc::hir::QPath::Resolved(_, path) =>
+            //         path.segments.last().map(|path_seg| path_seg.ident.name.as_str().get()).unwrap_or("x"),
+            //     rustc::hir::QPath::TypeRelative(_, path_seg) => path_seg.ident.name.as_str().get(),
+            // };
             let vec_name = "x";
+            // let _ = println!("About to span_lint on \"{}\"", vec_name);
 
             then {
                 span_lint(cx,

tests/ui/use_last.rs

@@ -14,6 +14,7 @@ fn index_into_last() -> i32 {
 
 fn main() {
     let expected_value: i32 = 5;
+    println!("Working...");
     assert_eq!(dont_use_last(), Some(expected_value));
     assert_eq!(index_into_last(), expected_value);
 }

tests/ui/use_last.stderr

@@ -1 +1,10 @@
-error: there should be some output to this lint but there wasn't
+error: Use `x.last()` instead of `x.get(x.len() - 1)`
+  --> $DIR/use_last.rs:5:24
+   |
+LL |     let last_element = x.get(x.len() - 1); // ~ERROR Use _.last()
+   |                        ^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::use-last` implied by `-D warnings`
+
+error: aborting due to previous error
+