WIP: Add Applicability to suggestion lints

clippy_lints/src/bytecount.rs

@@ -3,6 +3,7 @@ use rustc::lint::*;
 use rustc::{declare_lint, lint_array};
 use if_chain::if_chain;
 use rustc::ty;
+use rustc_errors::Applicability;
 use syntax::ast::{Name, UintTy};
 use crate::utils::{contains_name, get_pat_name, match_type, paths, single_segment_path, snippet, span_lint_and_sugg,
             walk_ptrs_ty};
@@ -86,7 +87,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ByteCount {
                                            "Consider using the bytecount crate",
                                            format!("bytecount::count({}, {})",
                                                     snippet(cx, haystack.span, ".."),
-                                                    snippet(cx, needle.span, "..")));
+                                                    snippet(cx, needle.span, "..")),
+                                           Applicability::HasPlaceholders);
                     }
                 };
             }

clippy_lints/src/collapsible_if.rs

@@ -14,6 +14,7 @@
 
 use rustc::lint::*;
 use rustc::{declare_lint, lint_array};
+use rustc_errors::Applicability;
 use if_chain::if_chain;
 use syntax::ast;
 
@@ -114,7 +115,9 @@ fn check_collapsible_maybe_if_let(cx: &EarlyContext<'_>, else_: &ast::Expr) {
                                        block.span,
                                        "this `else { if .. }` block can be collapsed",
                                        "try",
-                                       snippet_block(cx, else_.span, "..").into_owned());
+                                       snippet_block(cx, else_.span, "..").into_owned(),
+                                       Applicability::HasPlaceholders,
+                    );
                 }
                 _ => (),
             }

clippy_lints/src/default_trait_access.rs

@@ -3,6 +3,7 @@ use rustc::lint::*;
 use rustc::{declare_lint, lint_array};
 use if_chain::if_chain;
 use rustc::ty::TypeVariants;
+use rustc_errors::Applicability;
 
 use crate::utils::{any_parent_is_automatically_derived, match_def_path, opt_def_id, paths, span_lint_and_sugg};
 
@@ -59,7 +60,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for DefaultTraitAccess {
                                 expr.span,
                                 &format!("Calling {} is more clear than this expression", replacement),
                                 "try",
-                                replacement);
+                                replacement,
+                                Applicability::MaybeIncorrect);
                          }
                     },
                     QPath::TypeRelative(..) => {},

clippy_lints/src/double_comparison.rs

@@ -3,6 +3,7 @@
 use rustc::hir::*;
 use rustc::lint::*;
 use rustc::{declare_lint, lint_array};
+use rustc_errors::Applicability;
 use syntax::codemap::Span;
 
 use crate::utils::{snippet, span_lint_and_sugg, SpanlessEq};
@@ -64,7 +65,7 @@ impl<'a, 'tcx> DoubleComparisonPass {
                 let sugg = format!("{} {} {}", lhs_str, stringify!($op), rhs_str);
                 span_lint_and_sugg(cx, DOUBLE_COMPARISONS, span,
                                    "This binary expression can be simplified",
-                                   "try", sugg);
+                                   "try", sugg, Applicability::HasPlaceholders);
             }}
         }
         match (op, lkind, rkind) {

clippy_lints/src/duration_subsec.rs

@@ -1,6 +1,7 @@
 use rustc::hir::*;
 use rustc::lint::*;
 use rustc::{declare_lint, lint_array};
+use rustc_errors::Applicability;
 use if_chain::if_chain;
 use syntax::codemap::Spanned;
 
@@ -58,6 +59,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for DurationSubsec {
                     &format!("Calling `{}()` is more concise than this calculation", suggested_fn),
                     "try",
                     format!("{}.{}()", snippet(cx, args[0].span, "_"), suggested_fn),
+                    Applicability::HasPlaceholders,
                 );
             }
         }

clippy_lints/src/else_if_without_else.rs

@@ -4,7 +4,7 @@ use rustc::lint::*;
 use rustc::{declare_lint, lint_array};
 use syntax::ast::*;
 
-use crate::utils::span_lint_and_sugg;
+use crate::utils::span_help_and_lint;
 
 /// **What it does:** Checks for usage of if expressions with an `else if` branch,
 /// but without a final `else` branch.
@@ -56,13 +56,12 @@ impl EarlyLintPass for ElseIfWithoutElse {
 
         while let ExprKind::If(_, _, Some(ref els)) = item.node {
             if let ExprKind::If(_, _, None) = els.node {
-                span_lint_and_sugg(
+                span_help_and_lint(
                     cx,
                     ELSE_IF_WITHOUT_ELSE,
                     els.span,
                     "if expression with an `else if`, but without a final `else`",
                     "add an `else` block here",
-                    "".to_string()
                 );
             }
 

clippy_lints/src/eq_op.rs

@@ -1,6 +1,7 @@
 use rustc::hir::*;
 use rustc::lint::*;
 use rustc::{declare_lint, lint_array};
+use rustc_errors::Applicability;
 use crate::utils::{in_macro, implements_trait, is_copy, multispan_sugg, snippet, span_lint, span_lint_and_then, SpanlessEq};
 
 /// **What it does:** Checks for equal operands to comparison, logical and
@@ -107,6 +108,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp {
                                         db,
                                         "use the values directly".to_string(),
                                         vec![(left.span, lsnip), (right.span, rsnip)],
+                                        Applicability::HasPlaceholders,
                                     );
                                 },
                             )

clippy_lints/src/excessive_precision.rs

@@ -3,6 +3,7 @@ use rustc::lint::*;
 use rustc::{declare_lint, lint_array};
 use if_chain::if_chain;
 use rustc::ty::TypeVariants;
+use rustc_errors::Applicability;
 use std::f32;
 use std::f64;
 use std::fmt;
@@ -58,6 +59,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ExcessivePrecision {
                     "float has excessive precision",
                     "consider changing the type or truncating it to",
                     sugg,
+                    Applicability::MachineApplicable,
                 );
             }
         }

clippy_lints/src/infallible_destructuring_match.rs

@@ -2,6 +2,7 @@ use super::utils::{get_arg_name, match_var, remove_blocks, snippet, span_lint_an
 use rustc::hir::*;
 use rustc::lint::*;
 use rustc::{declare_lint, lint_array};
+use rustc_errors::Applicability;
 use if_chain::if_chain;
 
 /// **What it does:** Checks for matches being used to destructure a single-variant enum
@@ -74,6 +75,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                         snippet(cx, local.pat.span, ".."),
                         snippet(cx, target.span, ".."),
                     ),
+                    Applicability::HasPlaceholders,
                 );
             }
         }

clippy_lints/src/len_zero.rs

@@ -3,6 +3,7 @@ use rustc::hir::*;
 use rustc::lint::*;
 use rustc::{declare_lint, lint_array};
 use rustc::ty;
+use rustc_errors::Applicability;
 use std::collections::HashSet;
 use syntax::ast::{Lit, LitKind, Name};
 use syntax::codemap::{Span, Spanned};
@@ -226,6 +227,7 @@ fn check_len(cx: &LateContext<'_, '_>, span: Span, method_name: Name, args: &[Ex
                 &format!("length comparison to {}", if compare_to == 0 { "zero" } else { "one" }),
                 "using `is_empty` is more concise",
                 format!("{}{}.is_empty()", op, snippet(cx, args[0].span, "_")),
+                Applicability::HasPlaceholders,
             );
         }
     }

clippy_lints/src/literal_representation.rs

@@ -3,6 +3,7 @@
 
 use rustc::lint::*;
 use rustc::{declare_lint, lint_array};
+use rustc_errors::Applicability;
 use if_chain::if_chain;
 use syntax::ast::*;
 use syntax_pos;
@@ -238,6 +239,7 @@ impl WarningType {
                 "long literal lacking separators",
                 "consider",
                 grouping_hint.to_owned(),
+                Applicability::MachineApplicable,
             ),
             WarningType::LargeDigitGroups => span_lint_and_sugg(
                 cx,
@@ -246,6 +248,7 @@ impl WarningType {
                 "digit groups should be smaller",
                 "consider",
                 grouping_hint.to_owned(),
+                Applicability::MachineApplicable,
             ),
             WarningType::InconsistentDigitGrouping => span_lint_and_sugg(
                 cx,
@@ -254,6 +257,7 @@ impl WarningType {
                 "digits grouped inconsistently by underscores",
                 "consider",
                 grouping_hint.to_owned(),
+                Applicability::MachineApplicable,
             ),
             WarningType::DecimalRepresentation => span_lint_and_sugg(
                 cx,
@@ -262,6 +266,7 @@ impl WarningType {
                 "integer literal has a better hexadecimal representation",
                 "consider",
                 grouping_hint.to_owned(),
+                Applicability::MachineApplicable,
             ),
         };
     }

clippy_lints/src/loops.rs

@@ -15,6 +15,7 @@ use rustc::middle::mem_categorization::Categorization;
 use rustc::middle::mem_categorization::cmt_;
 use rustc::ty::{self, Ty};
 use rustc::ty::subst::Subst;
+use rustc_errors::Applicability;
 use std::collections::{HashMap, HashSet};
 use std::iter::{once, Iterator};
 use syntax::ast;
@@ -470,6 +471,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                                         snippet(cx, arms[0].pats[0].span, ".."),
                                         snippet(cx, matchexpr.span, "..")
                                     ),
+                                    Applicability::HasPlaceholders,
                                 );
                             }
                         },
@@ -501,6 +503,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                         "this loop could be written as a `for` loop",
                         "try",
                         format!("for {} in {} {{ .. }}", loop_var, iterator),
+                        Applicability::HasPlaceholders,
                     );
                 }
             }
@@ -965,6 +968,7 @@ fn detect_manual_memcpy<'a, 'tcx>(
                     "it looks like you're manually copying between slices",
                     "try replacing the loop by",
                     big_sugg,
+                    Applicability::MachineApplicable,
                 );
             }
         }
@@ -1069,6 +1073,7 @@ fn check_for_loop_range<'a, 'tcx>(
                                     (pat.span, format!("({}, <item>)", ident.name)),
                                     (arg.span, format!("{}.{}().enumerate(){}{}", indexed, method, take, skip)),
                                 ],
+                                Applicability::HasPlaceholders,
                             );
                         },
                     );
@@ -1089,6 +1094,7 @@ fn check_for_loop_range<'a, 'tcx>(
                                 db,
                                 "consider using an iterator".to_string(),
                                 vec![(pat.span, "<item>".to_string()), (arg.span, repl)],
+                                Applicability::HasPlaceholders,
                             );
                         },
                     );
@@ -1200,6 +1206,7 @@ fn lint_iter_method(cx: &LateContext<'_, '_>, args: &[Expr], arg: &Expr, method_
          iteration methods",
         "to write this more concisely, try",
         format!("&{}{}", muta, object),
+        Applicability::HasPlaceholders,
     )
 }
 
@@ -1238,6 +1245,7 @@ fn check_for_loop_arg(cx: &LateContext<'_, '_>, pat: &Pat, arg: &Expr, expr: &Ex
                          iteration methods`",
                         "to write this more concisely, try",
                         object.to_string(),
+                        Applicability::HasPlaceholders,
                     );
                 }
             } else if method_name == "next" && match_trait_method(cx, arg, &paths::ITERATOR) {
@@ -1398,6 +1406,7 @@ fn check_for_loop_over_map_kv<'a, 'tcx>(
                                 (pat_span, snippet(cx, new_pat_span, kind).into_owned()),
                                 (arg_span, format!("{}.{}s{}()", map.maybe_par(), kind, mutbl)),
                             ],
+                            Applicability::HasPlaceholders,
                         );
                     },
                 );

clippy_lints/src/matches.rs

@@ -3,6 +3,7 @@ use rustc::lint::*;
 use rustc::{declare_lint, lint_array};
 use if_chain::if_chain;
 use rustc::ty::{self, Ty};
+use rustc_errors::Applicability;
 use std::cmp::Ordering;
 use std::collections::Bound;
 use syntax::ast::LitKind;
@@ -249,6 +250,7 @@ fn report_single_match_single_pattern(cx: &LateContext<'_, '_>, ex: &Expr, arms:
             expr_block(cx, &arms[0].body, None, ".."),
             els_str
         ),
+        Applicability::HasPlaceholders,
     );
 }
 
@@ -431,7 +433,7 @@ fn check_match_ref_pats(cx: &LateContext<'_, '_>, ex: &Expr, arms: &[Arm], expr:
         }));
 
         span_lint_and_then(cx, MATCH_REF_PATS, expr.span, title, |db| {
-            multispan_sugg(db, msg.to_owned(), suggs);
+            multispan_sugg(db, msg.to_owned(), suggs, Applicability::HasPlaceholders);
         });
     }
 }
@@ -455,7 +457,8 @@ fn check_match_as_ref(cx: &LateContext<'_, '_>, ex: &Expr, arms: &[Arm], expr: &
                 expr.span,
                 &format!("use {}() instead", suggestion),
                 "try this",
-                format!("{}.{}()", snippet(cx, ex.span, "_"), suggestion)
+                format!("{}.{}()", snippet(cx, ex.span, "_"), suggestion),
+                Applicability::HasPlaceholders,
             )
         }
     }