Add an Option<Span> argument to span_lint_and_help.

Author: xiongmao86

clippy_lints/src/as_conversions.rs

@@ -50,6 +50,7 @@ impl EarlyLintPass for AsConversions {
                 AS_CONVERSIONS,
                 expr.span,
                 "using a potentially dangerous silent `as` conversion",
+                None,
                 "consider using a safe wrapper for this conversion",
             );
         }

clippy_lints/src/assertions_on_constants.rs

@@ -41,6 +41,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssertionsOnConstants {
                 } else {
                     "`assert!(true)` will be optimized out by the compiler"
                 },
+                None,
                 "remove it",
             );
         };
@@ -50,6 +51,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssertionsOnConstants {
                 ASSERTIONS_ON_CONSTANTS,
                 e.span,
                 "`assert!(false)` should probably be replaced",
+                None,
                 "use `panic!()` or `unreachable!()`",
             );
         };
@@ -59,6 +61,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssertionsOnConstants {
                 ASSERTIONS_ON_CONSTANTS,
                 e.span,
                 &format!("`assert!(false, {})` should probably be replaced", panic_message),
+                None,
                 &format!("use `panic!({})` or `unreachable!({})`", panic_message, panic_message),
             )
         };

clippy_lints/src/atomic_ordering.rs

@@ -85,6 +85,7 @@ fn check_atomic_load_store(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
                     INVALID_ATOMIC_ORDERING,
                     ordering_arg.span,
                     "atomic loads cannot have `Release` and `AcqRel` ordering",
+                    None,
                     "consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`"
                 );
             } else if method == "store" &&
@@ -94,6 +95,7 @@ fn check_atomic_load_store(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
                     INVALID_ATOMIC_ORDERING,
                     ordering_arg.span,
                     "atomic stores cannot have `Acquire` and `AcqRel` ordering",
+                    None,
                     "consider using ordering modes `Release`, `SeqCst` or `Relaxed`"
                 );
             }
@@ -118,6 +120,7 @@ fn check_memory_fence(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
                 INVALID_ATOMIC_ORDERING,
                 args[0].span,
                 "memory fences cannot have `Relaxed` ordering",
+                None,
                 "consider using ordering modes `Acquire`, `Release`, `AcqRel` or `SeqCst`"
             );
         }

clippy_lints/src/cognitive_complexity.rs

@@ -105,6 +105,7 @@ impl CognitiveComplexity {
                     rust_cc,
                     self.limit.limit()
                 ),
+                None,
                 "you could split it up into multiple smaller functions",
             );
         }

clippy_lints/src/comparison_chain.rs

@@ -104,6 +104,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ComparisonChain {
             COMPARISON_CHAIN,
             expr.span,
             "`if` chain can be rewritten with `match`",
+            None,
             "Consider rewriting the `if` chain to use `cmp` and `match`.",
         )
     }

clippy_lints/src/dbg_macro.rs

@@ -48,6 +48,7 @@ impl EarlyLintPass for DbgMacro {
                     DBG_MACRO,
                     mac.span(),
                     "`dbg!` macro is intended as a debugging tool",
+                    None,
                     "ensure to avoid having uses of it in version control",
                 );
             }

clippy_lints/src/else_if_without_else.rs

@@ -61,6 +61,7 @@ impl EarlyLintPass for ElseIfWithoutElse {
                     ELSE_IF_WITHOUT_ELSE,
                     els.span,
                     "`if` expression with an `else if`, but without a final `else`",
+                    None,
                     "add an `else` block here",
                 );
             }

clippy_lints/src/empty_enum.rs

@@ -45,13 +45,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EmptyEnum {
             let ty = cx.tcx.type_of(did);
             let adt = ty.ty_adt_def().expect("already checked whether this is an enum");
             if adt.variants.is_empty() {
-                span_lint_and_then(
+                span_lint_and_help(
                     cx,
                     EMPTY_ENUM,
                     item.span,
                     "enum with no variants",
-                    "consider using the uninhabited type `!` (never type) or a wrapper around it \
-                    to introduce a type which can't be instantiated",
+                    Some(item.span),
+                    "consider using the uninhabited type `!` (never type) or a wrapper \
+                    around it to introduce a type which can't be instantiated",
                 );
             }
         }

clippy_lints/src/enum_variants.rs

@@ -206,6 +206,7 @@ fn check_variant(
         lint,
         span,
         &format!("All variants have the same {}fix: `{}`", what, value),
+        None,
         &format!(
             "remove the {}fixes and use full paths to \
              the variants instead of glob imports",

clippy_lints/src/excessive_bools.rs

@@ -114,6 +114,7 @@ impl ExcessiveBools {
                 FN_PARAMS_EXCESSIVE_BOOLS,
                 span,
                 &format!("more than {} bools in function parameters", self.max_fn_params_bools),
+                None,
                 "consider refactoring bools into two-variant enums",
             );
         }
@@ -153,6 +154,7 @@ impl EarlyLintPass for ExcessiveBools {
                         STRUCT_EXCESSIVE_BOOLS,
                         item.span,
                         &format!("more than {} bools in a struct", self.max_struct_bools),
+                        None,
                         "consider using a state machine or refactoring bools into two-variant enums",
                     );
                 }

clippy_lints/src/formatting.rs

@@ -188,6 +188,7 @@ fn check_unop(cx: &EarlyContext<'_>, expr: &Expr) {
                     binop = binop_str,
                     unop = unop_str
                 ),
+                None,
                 &format!(
                     "put a space between `{binop}` and `{unop}` and remove the space after `{unop}`",
                     binop = binop_str,

clippy_lints/src/functions.rs

@@ -431,6 +431,7 @@ fn check_needless_must_use(
             DOUBLE_MUST_USE,
             fn_header_span,
             "this function has an empty `#[must_use]` attribute, but returns a type already marked as `#[must_use]`",
+            None,
             "either add some descriptive text or remove the attribute",
         );
     }

clippy_lints/src/if_not_else.rs

@@ -61,6 +61,7 @@ impl EarlyLintPass for IfNotElse {
                             IF_NOT_ELSE,
                             item.span,
                             "Unnecessary boolean `not` operation",
+                            None,
                             "remove the `!` and swap the blocks of the `if`/`else`",
                         );
                     },
@@ -70,6 +71,7 @@ impl EarlyLintPass for IfNotElse {
                             IF_NOT_ELSE,
                             item.span,
                             "Unnecessary `!=` operation",
+                            None,
                             "change to `==` and swap the blocks of the `if`/`else`",
                         );
                     },

clippy_lints/src/indexing_slicing.rs

@@ -138,7 +138,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IndexingSlicing {
                     (None, None) => return, // [..] is ok.
                 };
 
-                span_lint_and_help(cx, INDEXING_SLICING, expr.span, "slicing may panic.", help_msg);
+                span_lint_and_help(cx, INDEXING_SLICING, expr.span, "slicing may panic.", None, help_msg);
             } else {
                 // Catchall non-range index, i.e., [n] or [n << m]
                 if let ty::Array(..) = ty.kind {
@@ -154,6 +154,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IndexingSlicing {
                     INDEXING_SLICING,
                     expr.span,
                     "indexing may panic.",
+                    None,
                     "Consider using `.get(n)` or `.get_mut(n)` instead",
                 );
             }

clippy_lints/src/inherent_to_string.rs

@@ -137,6 +137,7 @@ fn show_lint(cx: &LateContext<'_, '_>, item: &ImplItem<'_>) {
                 "type `{}` implements inherent method `to_string(&self) -> String` which shadows the implementation of `Display`",
                 self_type.to_string()
             ),
+            None,
             &format!("remove the inherent method from type `{}`", self_type.to_string())
         );
     } else {
@@ -148,6 +149,7 @@ fn show_lint(cx: &LateContext<'_, '_>, item: &ImplItem<'_>) {
                 "implementation of inherent method `to_string(&self) -> String` for type `{}`",
                 self_type.to_string()
             ),
+            None,
             &format!("implement trait `Display` for type `{}` instead", self_type.to_string()),
         );
     }

clippy_lints/src/integer_division.rs

@@ -35,6 +35,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IntegerDivision {
                 INTEGER_DIVISION,
                 expr.span,
                 "integer division",
+                None,
                 "division of integers may cause loss of precision. consider using floats.",
             );
         }

clippy_lints/src/large_stack_arrays.rs

@@ -57,6 +57,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LargeStackArrays {
                         "allocating a local array larger than {} bytes",
                         self.maximum_allowed_size
                     ),
+                    None,
                     &format!(
                         "consider allocating on the heap with `vec!{}.into_boxed_slice()`",
                         snippet(cx, expr.span, "[...]")

clippy_lints/src/let_underscore.rs

@@ -90,6 +90,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetUnderscore {
                         LET_UNDERSCORE_LOCK,
                         local.span,
                         "non-binding let on a synchronization lock",
+                        None,
                         "consider using an underscore-prefixed named \
                             binding or dropping explicitly with `std::mem::drop`"
                     )
@@ -99,6 +100,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetUnderscore {
                         LET_UNDERSCORE_MUST_USE,
                         local.span,
                         "non-binding let on an expression with `#[must_use]` type",
+                        None,
                         "consider explicitly using expression value"
                     )
                 } else if is_must_use_func_call(cx, init) {
@@ -107,6 +109,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetUnderscore {
                         LET_UNDERSCORE_MUST_USE,
                         local.span,
                         "non-binding let on a result of a `#[must_use]` function",
+                        None,
                         "consider explicitly using function result"
                     )
                 }

clippy_lints/src/loops.rs

@@ -1402,6 +1402,7 @@ fn check_arg_type(cx: &LateContext<'_, '_>, pat: &Pat<'_>, arg: &Expr<'_>) {
                  `if let` statement.",
                 snippet(cx, arg.span, "_")
             ),
+            None,
             &format!(
                 "consider replacing `for {0} in {1}` with `if let Some({0}) = {1}`",
                 snippet(cx, pat.span, "_"),
@@ -1418,6 +1419,7 @@ fn check_arg_type(cx: &LateContext<'_, '_>, pat: &Pat<'_>, arg: &Expr<'_>) {
                  `if let` statement.",
                 snippet(cx, arg.span, "_")
             ),
+            None,
             &format!(
                 "consider replacing `for {0} in {1}` with `if let Ok({0}) = {1}`",
                 snippet(cx, pat.span, "_"),

clippy_lints/src/main_recursion.rs

@@ -53,6 +53,7 @@ impl LateLintPass<'_, '_> for MainRecursion {
                     MAIN_RECURSION,
                     func.span,
                     &format!("recursing into entrypoint `{}`", snippet(cx, func.span, "main")),
+                    None,
                     "consider using another function for this recursion"
                 )
             }

clippy_lints/src/matches.rs

@@ -441,6 +441,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Matches {
                     REST_PAT_IN_FULLY_BOUND_STRUCTS,
                     pat.span,
                     "unnecessary use of `..` pattern in struct binding. All fields were already bound",
+                    None,
                     "consider removing `..` from this binding",
                 );
             }
@@ -887,6 +888,7 @@ fn check_wild_in_or_pats(cx: &LateContext<'_, '_>, arms: &[Arm<'_>]) {
                     WILDCARD_IN_OR_PATTERNS,
                     arm.pat.span,
                     "wildcard pattern covers any other pattern as it will match anyway.",
+                    None,
                     "Consider handling `_` separately.",
                 );
             }

clippy_lints/src/mem_replace.rs

@@ -148,6 +148,7 @@ fn check_replace_with_uninit(cx: &LateContext<'_, '_>, src: &Expr<'_>, expr_span
                         MEM_REPLACE_WITH_UNINIT,
                         expr_span,
                         "replacing with `mem::uninitialized()`",
+                        None,
                         "consider using the `take_mut` crate instead",
                     );
                 } else if cx.tcx.is_diagnostic_item(sym::mem_zeroed, repl_def_id) &&
@@ -157,6 +158,7 @@ fn check_replace_with_uninit(cx: &LateContext<'_, '_>, src: &Expr<'_>, expr_span
                         MEM_REPLACE_WITH_UNINIT,
                         expr_span,
                         "replacing with `mem::zeroed()`",
+                        None,
                         "consider using a default value or the `take_mut` crate instead",
                     );
                 }