submodules: update clippy from 754b4c0 to b2601be

Changes:
````
Fix NAIVE_BYTECOUNT applicability
Fix dogfood error
Change Applicability of MISTYPED_LITERAL_SUFFIX
Add applicability level to (nearly) every span_lint_and_sugg function
Update stderr file
Fix bugs and improve documentation
Add Applicability::Unspecified to span_lint_and_sugg functions
Introduce snippet_with_applicability and hir_with_applicability functions
readme: tell how to install clippy on travis from git if it is not shipped with a nightly.
constants: add u128 i128 builtin types and fix outdated url
Update lints
Lint only the first statment/expression after alloc
Fix some warnings related to Self
Rename some symbols
Split lint into slow and unsafe vector initalization
Add unsafe set_len initialization
Add slow zero-filled vector initialization lint
Travis: Remove `sudo: false`
Downgrade needless_pass_by_value to allow by default
````

Author: matthiaskrgr

.travis.yml

@@ -7,8 +7,6 @@ os:
   - osx
   - windows
 
-sudo: false
-
 branches:
   # Don't build these branches
   except:

CHANGELOG.md

@@ -842,6 +842,7 @@ All notable changes to this project will be documented in this file.
 [`single_char_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_pattern
 [`single_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match
 [`single_match_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match_else
+[`slow_vector_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#slow_vector_initialization
 [`str_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#str_to_string
 [`string_add`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_add
 [`string_add_assign`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_add_assign
@@ -880,6 +881,7 @@ All notable changes to this project will be documented in this file.
 [`unneeded_field_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#unneeded_field_pattern
 [`unreadable_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal
 [`unsafe_removed_from_name`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsafe_removed_from_name
+[`unsafe_vector_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsafe_vector_initialization
 [`unseparated_literal_suffix`]: https://rust-lang.github.io/rust-clippy/master/index.html#unseparated_literal_suffix
 [`unstable_as_mut_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#unstable_as_mut_slice
 [`unstable_as_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#unstable_as_slice

README.md

@@ -9,7 +9,7 @@ We are currently in the process of discussing Clippy 1.0 via the RFC process in
 
 A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code.
 
-[There are 288 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are 290 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
 
 We have a bunch of lint categories to allow you to choose how much Clippy is supposed to ~~annoy~~ help you:
 
@@ -108,6 +108,18 @@ script:
   # etc.
 ```
 
+It might happen that clippy is not available for a certain nightly release.
+In this case you can try to conditionally install clippy from the git repo.
+
+```yaml
+language: rust
+rust:
+  - nightly
+before_script:
+   - rustup component add clippy-preview --toolchain=nightly || cargo install --git https://github.com/rust-lang/rust-clippy/ --force clippy
+   # etc
+```
+
 ## Configuration
 
 Some lints can be configured in a TOML file named `clippy.toml` or `.clippy.toml`. It contains a basic `variable = value` mapping eg.

clippy_lints/src/attrs.rs

@@ -532,6 +532,7 @@ impl EarlyLintPass for CfgAttrPass {
                     "`cfg_attr` is deprecated for rustfmt and got replaced by tool_attributes",
                     "use",
                     format!("{}rustfmt::skip]", attr_style),
+                    Applicability::MachineApplicable,
                 );
             }
         }

clippy_lints/src/bytecount.rs

@@ -10,12 +10,15 @@
 
 use crate::rustc::hir::*;
 use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
-use crate::rustc::{declare_tool_lint, lint_array};
-use if_chain::if_chain;
 use crate::rustc::ty;
+use crate::rustc::{declare_tool_lint, lint_array};
+use crate::rustc_errors::Applicability;
 use crate::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};
+use crate::utils::{
+    contains_name, get_pat_name, match_type, paths, single_segment_path, snippet_with_applicability,
+    span_lint_and_sugg, walk_ptrs_ty,
+};
+use if_chain::if_chain;
 
 /// **What it does:** Checks for naive byte counts
 ///
@@ -89,14 +92,18 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ByteCount {
                         } else {
                             &filter_args[0]
                         };
-                        span_lint_and_sugg(cx,
-                                           NAIVE_BYTECOUNT,
-                                           expr.span,
-                                           "You appear to be counting bytes the naive way",
-                                           "Consider using the bytecount crate",
-                                           format!("bytecount::count({}, {})",
-                                                    snippet(cx, haystack.span, ".."),
-                                                    snippet(cx, needle.span, "..")));
+                        let mut applicability = Applicability::MachineApplicable;
+                        span_lint_and_sugg(
+                            cx,
+                            NAIVE_BYTECOUNT,
+                            expr.span,
+                            "You appear to be counting bytes the naive way",
+                            "Consider using the bytecount crate",
+                            format!("bytecount::count({}, {})",
+                                    snippet_with_applicability(cx, haystack.span, "..", &mut applicability),
+                                    snippet_with_applicability(cx, needle.span, "..", &mut applicability)),
+                            applicability,
+                        );
                     }
                 };
             }

clippy_lints/src/collapsible_if.rs

@@ -27,7 +27,7 @@ use crate::rustc::{declare_tool_lint, lint_array};
 use if_chain::if_chain;
 use crate::syntax::ast;
 
-use crate::utils::{in_macro, snippet_block, span_lint_and_sugg, span_lint_and_then};
+use crate::utils::{in_macro, snippet_block, snippet_block_with_applicability, span_lint_and_sugg, span_lint_and_then};
 use crate::utils::sugg::Sugg;
 use crate::rustc_errors::Applicability;
 
@@ -128,12 +128,16 @@ fn check_collapsible_maybe_if_let(cx: &EarlyContext<'_>, else_: &ast::Expr) {
         then {
             match else_.node {
                 ast::ExprKind::If(..) | ast::ExprKind::IfLet(..) => {
-                    span_lint_and_sugg(cx,
-                                       COLLAPSIBLE_IF,
-                                       block.span,
-                                       "this `else { if .. }` block can be collapsed",
-                                       "try",
-                                       snippet_block(cx, else_.span, "..").into_owned());
+                    let mut applicability = Applicability::MachineApplicable;
+                    span_lint_and_sugg(
+                        cx,
+                        COLLAPSIBLE_IF,
+                        block.span,
+                        "this `else { if .. }` block can be collapsed",
+                        "try",
+                        snippet_block_with_applicability(cx, else_.span, "..", &mut applicability).into_owned(),
+                        applicability,
+                    );
                 }
                 _ => (),
             }

clippy_lints/src/default_trait_access.rs

@@ -10,9 +10,10 @@
 
 use crate::rustc::hir::*;
 use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
+use crate::rustc::ty::TyKind;
 use crate::rustc::{declare_tool_lint, lint_array};
+use crate::rustc_errors::Applicability;
 use if_chain::if_chain;
-use crate::rustc::ty::TyKind;
 
 use crate::utils::{any_parent_is_automatically_derived, match_def_path, opt_def_id, paths, span_lint_and_sugg};
 
@@ -80,7 +81,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for DefaultTraitAccess {
                                 expr.span,
                                 &format!("Calling {} is more clear than this expression", replacement),
                                 "try",
-                                replacement);
+                                replacement,
+                                Applicability::Unspecified, // First resolve the TODO above
+                            );
                          }
                     },
                     QPath::TypeRelative(..) => {},

clippy_lints/src/double_comparison.rs

@@ -13,9 +13,10 @@
 use crate::rustc::hir::*;
 use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use crate::rustc::{declare_tool_lint, lint_array};
+use crate::rustc_errors::Applicability;
 use crate::syntax::source_map::Span;
 
-use crate::utils::{snippet, span_lint_and_sugg, SpanlessEq};
+use crate::utils::{snippet_with_applicability, span_lint_and_sugg, SpanlessEq};
 
 /// **What it does:** Checks for double comparions that could be simpified to a single expression.
 ///
@@ -70,12 +71,19 @@ impl<'a, 'tcx> Pass {
         }
         macro_rules! lint_double_comparison {
             ($op:tt) => {{
-                let lhs_str = snippet(cx, llhs.span, "");
-                let rhs_str = snippet(cx, lrhs.span, "");
+                let mut applicability = Applicability::MachineApplicable;
+                let lhs_str = snippet_with_applicability(cx, llhs.span, "", &mut applicability);
+                let rhs_str = snippet_with_applicability(cx, lrhs.span, "", &mut applicability);
                 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);
+                span_lint_and_sugg(
+                    cx,
+                    DOUBLE_COMPARISONS,
+                    span,
+                    "This binary expression can be simplified",
+                    "try",
+                    sugg,
+                    applicability,
+                );
             }}
         }
         match (op, lkind, rkind) {

clippy_lints/src/duration_subsec.rs

@@ -11,12 +11,13 @@
 use crate::rustc::hir::*;
 use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use crate::rustc::{declare_tool_lint, lint_array};
-use if_chain::if_chain;
+use crate::rustc_errors::Applicability;
 use crate::syntax::source_map::Spanned;
+use if_chain::if_chain;
 
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
-use crate::utils::{match_type, snippet, span_lint_and_sugg, walk_ptrs_ty};
+use crate::utils::{match_type, snippet_with_applicability, span_lint_and_sugg, walk_ptrs_ty};
 
 /// **What it does:** Checks for calculation of subsecond microseconds or milliseconds
 /// from other `Duration` methods.
@@ -60,13 +61,15 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for DurationSubsec {
                     ("subsec_nanos", 1_000) => "subsec_micros",
                     _ => return,
                 };
+                let mut applicability = Applicability::MachineApplicable;
                 span_lint_and_sugg(
                     cx,
                     DURATION_SUBSEC,
                     expr.span,
                     &format!("Calling `{}()` is more concise than this calculation", suggested_fn),
                     "try",
-                    format!("{}.{}()", snippet(cx, args[0].span, "_"), suggested_fn),
+                    format!("{}.{}()", snippet_with_applicability(cx, args[0].span, "_", &mut applicability), suggested_fn),
+                    applicability,
                 );
             }
         }

clippy_lints/src/else_if_without_else.rs

@@ -14,7 +14,7 @@ use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass, in_ex
 use crate::rustc::{declare_tool_lint, lint_array};
 use crate::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.
@@ -66,13 +66,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",
-                    String::new()
                 );
             }