submodules: update clippy from fc24fce to f7bdf50

Fixes clippy toolstate

Changes:
````
Match on ast/hir::ExprKind::Err
Update *.stderr files
Use -Zui-testing flag
Mention S-inactive-closed PRs in the CONTRIBUTING.md
tests: fix formatting and update test output
base tests: make sure to fail CI if tests need formatting
base tests: switch to nightly toolchain before checking formatting of tests with rustfmt
rustup rust-lang/rust#57069
Rustfmt.
fix breakage from rust-lang/rust#57088
fix a couple of ftrivial typos (NFC).
update CARGO_CLIPPY_HELP string to suggest tool lints.
rustc_tools_util: add readme
rustc_tool_utils: expand Cargo.toml with a few keywords in preparation for crates.io release
Fix macro detection in `empty_loop`.
Changed `macro_backtrace()` to `in_macro()`.
Fix lint detection on macro expansion.
````

Author: matthiaskrgr

CONTRIBUTING.md

@@ -42,6 +42,13 @@ Some issues are easier than others. The [`good first issue`](https://github.com/
 label can be used to find the easy issues. If you want to work on an issue, please leave a comment
 so that we can assign it to you!
 
+There are also some abandoned PRs, marked with
+[`S-inactive-closed`](https://github.com/rust-lang/rust-clippy/pulls?q=is%3Aclosed+label%3AS-inactive-closed).
+Pretty often these PRs are nearly completed and just need some extra steps
+(formatting, addressing review comments, ...) to be merged. If you want to
+complete such a PR, please leave a comment in the PR and open a new one based
+on it.
+
 Issues marked [`T-AST`](https://github.com/rust-lang/rust-clippy/labels/T-AST) involve simple
 matching of the syntax tree structure, and are generally easier than
 [`T-middle`](https://github.com/rust-lang/rust-clippy/labels/T-middle) issues, which involve types

ci/base-tests.sh

@@ -35,19 +35,29 @@ cd ..
 ./util/dev update_lints --check
 cargo +nightly fmt --all -- --check
 
-
-#avoid loop spam
-set +x
 # make sure tests are formatted
 
 # some lints are sensitive to formatting, exclude some files
-needs_formatting=false
+tests_need_reformatting="false"
+# switch to nightly
+rustup default nightly
+# avoid loop spam and allow cmds with exit status != 0
+set +ex
+
 for file in `find tests -not -path "tests/ui/methods.rs" -not -path "tests/ui/format.rs" -not -path "tests/ui/formatting.rs" -not -path "tests/ui/empty_line_after_outer_attribute.rs" -not -path "tests/ui/double_parens.rs" -not -path "tests/ui/doc.rs" -not -path "tests/ui/unused_unit.rs" | grep "\.rs$"` ; do
-rustfmt ${file} --check  || echo "${file} needs reformatting!" ; needs_formatting=true
+  rustfmt ${file} --check
+  if [ $? -ne 0 ]; then
+    echo "${file} needs reformatting!"
+    tests_need_reformatting="true"
+  fi
 done
 
-if [ "${needs_reformatting}" = true ] ; then
+set -ex # reset
+
+if [ "${tests_need_reformatting}" == "true" ] ; then
     echo "Tests need reformatting!"
     exit 2
 fi
-set -x
+
+# switch back to master
+rustup default master

clippy_dev/src/lib.rs

@@ -432,7 +432,7 @@ fn test_gen_deprecated() {
             "should_assert_eq",
             "group1",
             "abc",
-            Some("has been superseeded by should_assert_eq2"),
+            Some("has been superseded by should_assert_eq2"),
             "module_name",
         ),
         Lint::new(
@@ -447,7 +447,7 @@ fn test_gen_deprecated() {
     let expected: Vec<String> = vec![
         "    store.register_removed(",
         "        \"should_assert_eq\",",
-        "        \"has been superseeded by should_assert_eq2\",",
+        "        \"has been superseded by should_assert_eq2\",",
         "    );",
         "    store.register_removed(",
         "        \"another_deprecated\",",

clippy_lints/src/double_comparison.rs

@@ -17,7 +17,7 @@ use crate::syntax::source_map::Span;
 
 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.
+/// **What it does:** Checks for double comparions that could be simplified to a single expression.
 ///
 ///
 /// **Why is this bad?** Readability.

clippy_lints/src/implicit_return.rs

@@ -12,7 +12,7 @@ use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use crate::rustc::{declare_tool_lint, lint_array};
 use crate::rustc_errors::Applicability;
 use crate::syntax::{ast::NodeId, source_map::Span};
-use crate::utils::{snippet_opt, span_lint_and_then};
+use crate::utils::{in_macro, snippet_opt, span_lint_and_then};
 
 /// **What it does:** Checks for missing return statements at the end of a block.
 ///
@@ -116,14 +116,15 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
         _: FnKind<'tcx>,
         _: &'tcx FnDecl,
         body: &'tcx Body,
-        _: Span,
+        span: Span,
         _: NodeId,
     ) {
         let def_id = cx.tcx.hir().body_owner_def_id(body.id());
         let mir = cx.tcx.optimized_mir(def_id);
 
         // checking return type through MIR, HIR is not able to determine inferred closure return types
-        if !mir.return_ty().is_unit() {
+        // make sure it's not a macro
+        if !mir.return_ty().is_unit() && !in_macro(span) {
             Self::expr_match(cx, &body.value);
         }
     }

clippy_lints/src/loops.rs

@@ -478,6 +478,11 @@ impl LintPass for Pass {
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
+        // we don't want to check expanded macros
+        if in_macro(expr.span) {
+            return;
+        }
+
         if let Some((pat, arg, body)) = higher::for_loop(expr) {
             check_for_loop(cx, pat, arg, body, expr);
         }
@@ -751,7 +756,8 @@ fn never_loop_expr(expr: &Expr, main_loop_id: NodeId) -> NeverLoopResult {
         | ExprKind::Closure(_, _, _, _, _)
         | ExprKind::InlineAsm(_, _, _)
         | ExprKind::Path(_)
-        | ExprKind::Lit(_) => NeverLoopResult::Otherwise,
+        | ExprKind::Lit(_)
+        | ExprKind::Err => NeverLoopResult::Otherwise,
     }
 }
 

clippy_lints/src/utils/author.rs

@@ -504,6 +504,9 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 self.current = value_pat;
                 self.visit_expr(value);
             },
+            ExprKind::Err => {
+                println!("Err = {}", current);
+            },
         }
     }
 

clippy_lints/src/utils/hir_utils.rs

@@ -615,6 +615,7 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> {
                     self.hash_name(l.ident.name);
                 }
             },
+            ExprKind::Err => {},
         }
     }
 

clippy_lints/src/utils/inspector.rs

@@ -347,6 +347,9 @@ fn print_expr(cx: &LateContext<'_, '_>, expr: &hir::Expr, indent: usize) {
             println!("{}repeat count:", ind);
             print_expr(cx, &cx.tcx.hir().body(anon_const.body).value, indent + 1);
         },
+        hir::ExprKind::Err => {
+            println!("{}Err", ind);
+        },
     }
 }
 

clippy_lints/src/utils/sugg.rs

@@ -79,7 +79,8 @@ impl<'a> Sugg<'a> {
                 | hir::ExprKind::Ret(..)
                 | hir::ExprKind::Struct(..)
                 | hir::ExprKind::Tup(..)
-                | hir::ExprKind::While(..) => Sugg::NonParen(snippet),
+                | hir::ExprKind::While(..)
+                | hir::ExprKind::Err => Sugg::NonParen(snippet),
                 hir::ExprKind::Assign(..) => Sugg::BinOp(AssocOp::Assign, snippet),
                 hir::ExprKind::AssignOp(op, ..) => Sugg::BinOp(hirbinop2assignop(op), snippet),
                 hir::ExprKind::Binary(op, ..) => Sugg::BinOp(AssocOp::from_ast_binop(higher::binop(op.node)), snippet),
@@ -158,7 +159,8 @@ impl<'a> Sugg<'a> {
             | ast::ExprKind::Tup(..)
             | ast::ExprKind::Array(..)
             | ast::ExprKind::While(..)
-            | ast::ExprKind::WhileLet(..) => Sugg::NonParen(snippet),
+            | ast::ExprKind::WhileLet(..)
+            | ast::ExprKind::Err => Sugg::NonParen(snippet),
             ast::ExprKind::Range(.., RangeLimits::HalfOpen) => Sugg::BinOp(AssocOp::DotDot, snippet),
             ast::ExprKind::Range(.., RangeLimits::Closed) => Sugg::BinOp(AssocOp::DotDotEq, snippet),
             ast::ExprKind::Assign(..) => Sugg::BinOp(AssocOp::Assign, snippet),

clippy_lints/src/write.rs

@@ -257,7 +257,7 @@ impl EarlyLintPass for Pass {
 }
 
 /// Checks the arguments of `print[ln]!` and `write[ln]!` calls. It will return a tuple of two
-/// options. The first part of the tuple is `format_str` of the macros. The secund part of the tuple
+/// options. The first part of the tuple is `format_str` of the macros. The second part of the tuple
 /// is in the `write[ln]!` case the expression the `format_str` should be written to.
 ///
 /// Example:
@@ -292,7 +292,7 @@ fn check_tts<'a>(cx: &EarlyContext<'a>, tts: &ThinTokenStream, is_write: bool) -
     };
     let tmp = fmtstr.clone();
     let mut args = vec![];
-    let mut fmt_parser = Parser::new(&tmp, None);
+    let mut fmt_parser = Parser::new(&tmp, None, Vec::new(), false);
     while let Some(piece) = fmt_parser.next() {
         if !fmt_parser.errors.is_empty() {
             return (None, expr);

rustc_tools_util/Cargo.toml

@@ -2,5 +2,11 @@
 name = "rustc_tools_util"
 version = "0.1.0"
 authors = ["Matthias Krüger <[email protected]>"]
+description = "small helper to generate version information for git packages"
+repository = "https://github.com/rust-lang/rust-clippy"
+readme = "README.md"
+license = "MIT/Apache-2.0"
+keywords = ["rustc", "tool", "git", "version", "hash"]
+categories = ["development-tools"]
 edition = "2018"
 [dependencies]

rustc_tools_util/README.md

@@ -0,0 +1,58 @@
+# rustc_tools_util
+
+A small tool to help you generate version information
+for packages installed from a git repo
+
+## Usage
+
+Add a `build.rs` file to your repo and list it in `Cargo.toml`
+````
+build = "build.rs"
+````
+
+List rustc_tools_util as regular AND build dependency.
+````
+[dependencies]
+rustc_tools_util = "0.1"
+
+[build-dependencies]
+rustc_tools_util = "0.1"
+````
+
+In `build.rs`, generate the data in your `main()`
+````rust
+fn main() {
+    println!(
+        "cargo:rustc-env=GIT_HASH={}",
+        rustc_tools_util::get_commit_hash().unwrap_or_default()
+    );
+    println!(
+        "cargo:rustc-env=COMMIT_DATE={}",
+        rustc_tools_util::get_commit_date().unwrap_or_default()
+    );
+}
+
+````
+
+Use the version information in your main.rs
+````rust
+use rustc_tools_util::*;
+
+fn show_version() {
+    let version_info = rustc_tools_util::get_version_info!();
+    println!("{}", version_info);
+}
+````
+This gives the following output in clippy:
+`clippy 0.0.212 (a416c5e 2018-12-14)`
+
+
+## License
+
+Copyright 2014-2018 The Rust Project Developers
+
+Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+<LICENSE-MIT or http://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.

src/main.rs

@@ -33,10 +33,9 @@ with:
     -D --deny OPT       Set lint denied
     -F --forbid OPT     Set lint forbidden
 
-The feature `cargo-clippy` is automatically defined for convenience. You can use
-it to allow or deny lints from the code, eg.:
+You can use tool lints to allow or deny lints from your code, eg.:
 
-    #[cfg_attr(feature = "cargo-clippy", allow(needless_lifetimes))]
+    #[allow(clippy::needless_lifetimes)]
 "#;
 
 fn show_help() {

tests/compile-test.rs

@@ -55,7 +55,10 @@ fn config(mode: &str, dir: PathBuf) -> compiletest::Config {
         config.run_lib_path = rustc_lib_path();
         config.compile_lib_path = rustc_lib_path();
     }
-    config.target_rustcflags = Some(format!("-L {0} -L {0}/deps -Dwarnings", host_libs().display()));
+    config.target_rustcflags = Some(format!(
+        "-L {0} -L {0}/deps -Dwarnings -Zui-testing",
+        host_libs().display()
+    ));
 
     config.mode = cfg_mode;
     config.build_base = if rustc_test_suite().is_some() {

tests/ui-toml/toml_blacklist/conf_french_blacklisted_name.stderr

@@ -1,45 +1,45 @@
 error: use of a blacklisted/placeholder name `toto`
   --> $DIR/conf_french_blacklisted_name.rs:15:9
    |
-15 | fn test(toto: ()) {}
+LL | fn test(toto: ()) {}
    |         ^^^^
    |
    = note: `-D clippy::blacklisted-name` implied by `-D warnings`
 
 error: use of a blacklisted/placeholder name `toto`
   --> $DIR/conf_french_blacklisted_name.rs:18:9
    |
-18 |     let toto = 42;
+LL |     let toto = 42;
    |         ^^^^
 
 error: use of a blacklisted/placeholder name `tata`
   --> $DIR/conf_french_blacklisted_name.rs:19:9
    |
-19 |     let tata = 42;
+LL |     let tata = 42;
    |         ^^^^
 
 error: use of a blacklisted/placeholder name `titi`
   --> $DIR/conf_french_blacklisted_name.rs:20:9
    |
-20 |     let titi = 42;
+LL |     let titi = 42;
    |         ^^^^
 
 error: use of a blacklisted/placeholder name `toto`
   --> $DIR/conf_french_blacklisted_name.rs:26:10
    |
-26 |         (toto, Some(tata), titi @ Some(_)) => (),
+LL |         (toto, Some(tata), titi @ Some(_)) => (),
    |          ^^^^
 
 error: use of a blacklisted/placeholder name `tata`
   --> $DIR/conf_french_blacklisted_name.rs:26:21
    |
-26 |         (toto, Some(tata), titi @ Some(_)) => (),
+LL |         (toto, Some(tata), titi @ Some(_)) => (),
    |                     ^^^^
 
 error: use of a blacklisted/placeholder name `titi`
   --> $DIR/conf_french_blacklisted_name.rs:26:28
    |
-26 |         (toto, Some(tata), titi @ Some(_)) => (),
+LL |         (toto, Some(tata), titi @ Some(_)) => (),
    |                            ^^^^
 
 error: aborting due to 7 previous errors

tests/ui-toml/toml_trivially_copy/test.stderr

@@ -1,15 +1,15 @@
 error: this argument is passed by reference, but would be more efficient if passed by value
   --> $DIR/test.rs:20:11
    |
-20 | fn bad(x: &u16, y: &Foo) {}
+LL | fn bad(x: &u16, y: &Foo) {}
    |           ^^^^ help: consider passing by value instead: `u16`
    |
    = note: `-D clippy::trivially-copy-pass-by-ref` implied by `-D warnings`
 
 error: this argument is passed by reference, but would be more efficient if passed by value
   --> $DIR/test.rs:20:20
    |
-20 | fn bad(x: &u16, y: &Foo) {}
+LL | fn bad(x: &u16, y: &Foo) {}
    |                    ^^^^ help: consider passing by value instead: `Foo`
 
 error: aborting due to 2 previous errors