update clippy

Author: RalfJung

.github/PULL_REQUEST_TEMPLATE

@@ -16,9 +16,11 @@ checked during review or continuous integration.
 - [ ] Followed [lint naming conventions][lint_naming]
 - [ ] Added passing UI tests (including committed `.stderr` file)
 - [ ] `cargo test` passes locally
-- [ ] Executed `util/dev update_lints`
+- [ ] Executed `./util/dev update_lints`
 - [ ] Added lint documentation
-- [ ] Run `cargo fmt`
+- [ ] Run `./util/dev fmt`
+
+[lint_naming]: https://rust-lang.github.io/rfcs/0344-conventions-galore.html#lints
 
 Note that you can skip the above if you are just opening a WIP PR in
 order to get feedback.

CHANGELOG.md

@@ -982,7 +982,6 @@ Released 2018-09-13
 [`integer_division`]: https://rust-lang.github.io/rust-clippy/master/index.html#integer_division
 [`into_iter_on_array`]: https://rust-lang.github.io/rust-clippy/master/index.html#into_iter_on_array
 [`into_iter_on_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#into_iter_on_ref
-[`invalid_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_ref
 [`invalid_regex`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_regex
 [`invalid_upcast_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_upcast_comparisons
 [`items_after_statements`]: https://rust-lang.github.io/rust-clippy/master/index.html#items_after_statements

README.md

@@ -6,7 +6,7 @@
 
 A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code.
 
-[There are 310 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are 309 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:
 
@@ -36,6 +36,7 @@ Table of contents:
 
 *   [Usage instructions](#usage)
 *   [Configuration](#configuration)
+*   [Contributing](#contributing)
 *   [License](#license)
 
 ## Usage
@@ -52,7 +53,7 @@ subcommand.
 
 #### Step 1: Install rustup
 
-You can install [rustup](http://rustup.rs/) on supported platforms. This will help
+You can install [rustup](https://rustup.rs/) on supported platforms. This will help
 us install Clippy and its dependencies.
 
 If you already have rustup installed, update to ensure you have the latest
@@ -79,6 +80,15 @@ Now you can run Clippy by invoking the following command:
 cargo clippy
 ```
 
+#### Automatically applying Clippy suggestions
+
+Some Clippy lint suggestions can be automatically applied by `cargo fix`.
+Note that this is still experimental and only supported on the nightly channel:
+
+```terminal
+cargo fix -Z unstable-options --clippy
+```
+
 ### Running Clippy from the command line without installing it
 
 To have cargo compile your crate with Clippy without Clippy installation
@@ -88,8 +98,7 @@ in your code, you can use:
 cargo run --bin cargo-clippy --manifest-path=path_to_clippys_Cargo.toml
 ```
 
-*[Note](https://github.com/rust-lang/rust-clippy/wiki#a-word-of-warning):*
-Be sure that Clippy was compiled with the same version of rustc that cargo invokes here!
+*Note:* Be sure that Clippy was compiled with the same version of rustc that cargo invokes here!
 
 ### Travis CI
 
@@ -113,20 +122,20 @@ script:
 ```
 
 If you are on nightly, 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.
+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 --toolchain=nightly || cargo install --git https://github.com/rust-lang/rust-clippy/ --force clippy
-   # etc
+   # etc.
 ```
 
 Note that adding `-D warnings` will cause your build to fail if **any** warnings are found in your code.
 That includes warnings found by rustc (e.g. `dead_code`, etc.). If you want to avoid this and only cause
-an error for clippy warnings, use `#![deny(clippy::all)]` in your code or `-D clippy::all` on the command
+an error for Clippy warnings, use `#![deny(clippy::all)]` in your code or `-D clippy::all` on the command
 line. (You can swap `clippy::all` with the specific lint category you are targeting.)
 
 ## Configuration
@@ -154,9 +163,9 @@ You can add options to your code to `allow`/`warn`/`deny` Clippy lints:
     `#![deny(clippy::pedantic)]`). Note that `clippy::pedantic` contains some very aggressive
     lints prone to false positives.
 
-*   only some lints (`#![deny(clippy::single_match, clippy::box_vec)]`, etc)
+*   only some lints (`#![deny(clippy::single_match, clippy::box_vec)]`, etc.)
 
-*   `allow`/`warn`/`deny` can be limited to a single function or module using `#[allow(...)]`, etc
+*   `allow`/`warn`/`deny` can be limited to a single function or module using `#[allow(...)]`, etc.
 
 Note: `deny` produces errors instead of warnings.
 
@@ -171,7 +180,7 @@ If you want to contribute to Clippy, you can find more information in [CONTRIBUT
 Copyright 2014-2019 The Rust Project Developers
 
 Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-[http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)> or the MIT license
-<LICENSE-MIT or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT)>, at your
+[https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)> or the MIT license
+<LICENSE-MIT or [https://opensource.org/licenses/MIT](https://opensource.org/licenses/MIT)>, at your
 option. All files in the project carrying such notice may not be
 copied, modified, or distributed except according to those terms.

clippy_lints/src/deprecated_lints.rs

@@ -113,3 +113,12 @@ declare_deprecated_lint! {
     pub UNSAFE_VECTOR_INITIALIZATION,
     "the replacement suggested by this lint had substantially different behavior"
 }
+
+/// **What it does:** Nothing. This lint has been deprecated.
+///
+/// **Deprecation reason:** This lint has been superseded by the warn-by-default
+/// `invalid_value` rustc lint.
+declare_clippy_lint! {
+    pub INVALID_REF,
+    "superseded by rustc lint `invalid_value`"
+}

clippy_lints/src/enum_variants.rs

@@ -160,6 +160,7 @@ fn check_variant(
         let name = var2str(var);
         if partial_match(item_name, &name) == item_name_chars
             && name.chars().nth(item_name_chars).map_or(false, |c| !c.is_lowercase())
+            && name.chars().nth(item_name_chars + 1).map_or(false, |c| !c.is_numeric())
         {
             span_lint(cx, lint, var.span, "Variant name starts with the enum's name");
         }
@@ -178,6 +179,9 @@ fn check_variant(
         let pre_camel = camel_case::until(pre);
         pre = &pre[..pre_camel];
         while let Some((next, last)) = name[pre.len()..].chars().zip(pre.chars().rev()).next() {
+            if next.is_numeric() {
+                return;
+            }
             if next.is_lowercase() {
                 let last = pre.len() - last.len_utf8();
                 let last_camel = camel_case::until(&pre[..last]);

clippy_lints/src/implicit_return.rs

@@ -46,8 +46,8 @@ static LINT_BREAK: &str = "change `break` to `return` as shown";
 static LINT_RETURN: &str = "add `return` as shown";
 
 fn lint(cx: &LateContext<'_, '_>, outer_span: Span, inner_span: Span, msg: &str) {
-    let outer_span = span_to_outer_expn(outer_span);
-    let inner_span = span_to_outer_expn(inner_span);
+    let outer_span = outer_span.source_callsite();
+    let inner_span = inner_span.source_callsite();
 
     span_lint_and_then(cx, IMPLICIT_RETURN, outer_span, "missing return statement", |db| {
         if let Some(snippet) = snippet_opt(cx, inner_span) {
@@ -61,14 +61,6 @@ fn lint(cx: &LateContext<'_, '_>, outer_span: Span, inner_span: Span, msg: &str)
     });
 }
 
-fn span_to_outer_expn(span: Span) -> Span {
-    if let Some(expr) = span.ctxt().outer_expn_info() {
-        span_to_outer_expn(expr.call_site)
-    } else {
-        span
-    }
-}
-
 fn expr_match(cx: &LateContext<'_, '_>, expr: &Expr) {
     match &expr.node {
         // loops could be using `break` instead of `return`

clippy_lints/src/invalid_ref.rs

@@ -200,7 +200,6 @@ pub mod inherent_to_string;
 pub mod inline_fn_without_body;
 pub mod int_plus_one;
 pub mod integer_division;
-pub mod invalid_ref;
 pub mod items_after_statements;
 pub mod large_enum_variant;
 pub mod len_zero;
@@ -558,7 +557,6 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry<'_>, conf: &Conf) {
     reg.register_late_lint_pass(box bytecount::ByteCount);
     reg.register_late_lint_pass(box infinite_iter::InfiniteIter);
     reg.register_late_lint_pass(box inline_fn_without_body::InlineFnWithoutBody);
-    reg.register_late_lint_pass(box invalid_ref::InvalidRef);
     reg.register_late_lint_pass(box identity_conversion::IdentityConversion::default());
     reg.register_late_lint_pass(box types::ImplicitHasher);
     reg.register_early_lint_pass(box redundant_static_lifetimes::RedundantStaticLifetimes);
@@ -736,7 +734,6 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry<'_>, conf: &Conf) {
         inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY,
         inline_fn_without_body::INLINE_FN_WITHOUT_BODY,
         int_plus_one::INT_PLUS_ONE,
-        invalid_ref::INVALID_REF,
         large_enum_variant::LARGE_ENUM_VARIANT,
         len_zero::LEN_WITHOUT_IS_EMPTY,
         len_zero::LEN_ZERO,
@@ -1094,7 +1091,6 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry<'_>, conf: &Conf) {
         infinite_iter::INFINITE_ITER,
         inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY,
         inline_fn_without_body::INLINE_FN_WITHOUT_BODY,
-        invalid_ref::INVALID_REF,
         literal_representation::MISTYPED_LITERAL_SUFFIXES,
         loops::FOR_LOOP_OVER_OPTION,
         loops::FOR_LOOP_OVER_RESULT,

clippy_lints/src/lib.rs

@@ -937,7 +937,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Methods {
             ["is_some", "position"] => lint_search_is_some(cx, expr, "position", arg_lists[1], arg_lists[0]),
             ["is_some", "rposition"] => lint_search_is_some(cx, expr, "rposition", arg_lists[1], arg_lists[0]),
             ["extend", ..] => lint_extend(cx, expr, arg_lists[0]),
-            ["as_ptr", "unwrap"] => lint_cstring_as_ptr(cx, expr, &arg_lists[1][0], &arg_lists[0][0]),
+            ["as_ptr", "unwrap"] | ["as_ptr", "expect"] => {
+                lint_cstring_as_ptr(cx, expr, &arg_lists[1][0], &arg_lists[0][0])
+            },
             ["nth", "iter"] => lint_iter_nth(cx, expr, arg_lists[1], false),
             ["nth", "iter_mut"] => lint_iter_nth(cx, expr, arg_lists[1], true),
             ["next", "skip"] => lint_iter_skip_next(cx, expr),
@@ -2329,13 +2331,20 @@ fn lint_chars_last_cmp_with_unwrap<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, info: &
 fn lint_single_char_pattern<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, _expr: &'tcx hir::Expr, arg: &'tcx hir::Expr) {
     if_chain! {
         if let hir::ExprKind::Lit(lit) = &arg.node;
-        if let ast::LitKind::Str(r, _) = lit.node;
+        if let ast::LitKind::Str(r, style) = lit.node;
         if r.as_str().len() == 1;
         then {
             let mut applicability = Applicability::MachineApplicable;
             let snip = snippet_with_applicability(cx, arg.span, "..", &mut applicability);
-            let c = &snip[1..snip.len() - 1];
-            let hint = format!("'{}'", if c == "'" { "\\'" } else { c });
+            let ch = if let ast::StrStyle::Raw(nhash) = style {
+                let nhash = nhash as usize;
+                // for raw string: r##"a"##
+                &snip[(nhash + 2)..(snip.len() - 1 - nhash)]
+            } else {
+                // for regular string: "a"
+                &snip[1..(snip.len() - 1)]
+            };
+            let hint = format!("'{}'", if ch == "'" { "\\'" } else { ch });
             span_lint_and_sugg(
                 cx,
                 SINGLE_CHAR_PATTERN,

clippy_lints/src/methods/mod.rs

@@ -1,4 +1,4 @@
-use crate::utils::{match_qpath, paths, snippet, span_lint_and_sugg};
+use crate::utils::{in_macro_or_desugar, match_qpath, paths, snippet, snippet_with_macro_callsite, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
@@ -67,10 +67,15 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TryErr {
 
             then {
                 let err_type = cx.tables.expr_ty(err_arg);
+                let origin_snippet = if in_macro_or_desugar(err_arg.span) {
+                    snippet_with_macro_callsite(cx, err_arg.span, "_")
+                } else {
+                    snippet(cx, err_arg.span, "_")
+                };
                 let suggestion = if err_type == return_type {
-                    format!("return Err({})", snippet(cx, err_arg.span, "_"))
+                    format!("return Err({})", origin_snippet)
                 } else {
-                    format!("return Err({}.into())", snippet(cx, err_arg.span, "_"))
+                    format!("return Err({}.into())", origin_snippet)
                 };
 
                 span_lint_and_sugg(