Add applicability to span_lint_and_sugg

Author: flip1995

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/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: &[Expr], lit
                 &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,
                 );
             }
         }
@@ -1200,6 +1204,7 @@ fn lint_iter_method(cx: &LateContext, args: &[Expr], arg: &Expr, method_name: &s
          iteration methods",
         "to write this more concisely, try",
         format!("&{}{}", muta, object),
+        Applicability::HasPlaceholders,
     )
 }
 
@@ -1238,6 +1243,7 @@ fn check_for_loop_arg(cx: &LateContext, pat: &Pat, arg: &Expr, expr: &Expr) {
                          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) {