Update Clippy

Author: flip1995

CONTRIBUTING.md

@@ -145,13 +145,28 @@ using that version of Rust.
 
 You can use [rustup-toolchain-install-master][rtim] to do that:
 
-```
+```bash
 cargo install rustup-toolchain-install-master
 rustup-toolchain-install-master -n master --force
 rustup override set master
 cargo test
 ```
 
+After fixing the build failure on this repository, we can submit a pull request
+to [`rust-lang/rust`] to fix the toolstate.
+
+To submit a pull request, you should follow these steps:
+
+```bash
+# Assuming you already cloned the rust-lang/rust repo and you're in the correct directory
+git submodule update --remote src/tools/clippy
+cargo update -p clippy
+git add -u
+git commit -m "Update Clippy"
+./x.py test -i --stage 1 src/tools/clippy # This is optional and should succeed anyway
+# Open a PR in rust-lang/rust
+```
+
 ## Issue and PR triage
 
 Clippy is following the [Rust triage procedure][triage] for issues and pull
@@ -211,3 +226,4 @@ or the [MIT](http://opensource.org/licenses/MIT) license.
 [homu]: https://github.com/servo/homu
 [homu_instructions]: https://buildbot2.rust-lang.org/homu/
 [homu_queue]: https://buildbot2.rust-lang.org/homu/queue/clippy
+[`rust-lang/rust`]: https://github.com/rust-lang/rust

clippy_lints/src/attrs.rs

@@ -277,7 +277,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Attributes {
                                                         line_span,
                                                         "if you just forgot a `!`, use",
                                                         sugg,
-                                                        Applicability::MachineApplicable,
+                                                        Applicability::MaybeIncorrect,
                                                     );
                                                 },
                                             );

clippy_lints/src/cognitive_complexity.rs

@@ -100,7 +100,11 @@ impl CognitiveComplexity {
                     cx,
                     COGNITIVE_COMPLEXITY,
                     span,
-                    &format!("the function has a cognitive complexity of {}", rust_cc),
+                    &format!(
+                        "the function has a cognitive complexity of ({}/{})",
+                        rust_cc,
+                        self.limit.limit()
+                    ),
                     "you could split it up into multiple smaller functions",
                 );
             }

clippy_lints/src/int_plus_one.rs

@@ -158,7 +158,7 @@ impl IntPlusOne {
             |db| {
                 db.span_suggestion(
                     block.span,
-                    "change `>= y + 1` to `> y` as shown",
+                    "change it to",
                     recommendation,
                     Applicability::MachineApplicable, // snippet
                 );

clippy_lints/src/matches.rs

@@ -624,6 +624,24 @@ fn check_match_as_ref(cx: &LateContext<'_, '_>, ex: &Expr, arms: &[Arm], expr: &
             } else {
                 "as_mut"
             };
+
+            let output_ty = cx.tables.expr_ty(expr);
+            let input_ty = cx.tables.expr_ty(ex);
+
+            let cast = if_chain! {
+                if let ty::Adt(_, substs) = input_ty.sty;
+                let input_ty = substs.type_at(0);
+                if let ty::Adt(_, substs) = output_ty.sty;
+                let output_ty = substs.type_at(0);
+                if let ty::Ref(_, output_ty, _) = output_ty.sty;
+                if input_ty != output_ty;
+                then {
+                    ".map(|x| x as _)"
+                } else {
+                    ""
+                }
+            };
+
             let mut applicability = Applicability::MachineApplicable;
             span_lint_and_sugg(
                 cx,
@@ -632,9 +650,10 @@ fn check_match_as_ref(cx: &LateContext<'_, '_>, ex: &Expr, arms: &[Arm], expr: &
                 &format!("use {}() instead", suggestion),
                 "try this",
                 format!(
-                    "{}.{}()",
+                    "{}.{}(){}",
                     snippet_with_applicability(cx, ex.span, "_", &mut applicability),
-                    suggestion
+                    suggestion,
+                    cast,
                 ),
                 applicability,
             )

clippy_lints/src/methods/mod.rs

@@ -15,7 +15,7 @@ use rustc::{declare_lint_pass, declare_tool_lint};
 use rustc_errors::Applicability;
 use syntax::ast;
 use syntax::source_map::Span;
-use syntax::symbol::LocalInternedString;
+use syntax::symbol::{sym, LocalInternedString};
 
 use crate::utils::sugg;
 use crate::utils::usage::mutated_variables;
@@ -2682,7 +2682,7 @@ fn get_error_type<'a>(cx: &LateContext<'_, '_>, ty: Ty<'a>) -> Option<Ty<'a>> {
 
 /// This checks whether a given type is known to implement Debug.
 fn has_debug_impl<'a, 'b>(ty: Ty<'a>, cx: &LateContext<'b, 'a>) -> bool {
-    match cx.tcx.lang_items().debug_trait() {
+    match cx.tcx.get_diagnostic_item(sym::debug_trait) {
         Some(debug) => implements_trait(cx, ty, debug, &[]),
         None => false,
     }

clippy_lints/src/misc.rs

@@ -407,7 +407,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MiscLints {
                                 lhs - rhs,
                                 if op == BinOpKind::Eq { '<' } else { '>' }
                             ),
-                            Applicability::MachineApplicable, // snippet
+                            Applicability::HasPlaceholders, // snippet
                         );
                         db.span_note(expr.span, "std::f32::EPSILON and std::f64::EPSILON are available.");
                     });

clippy_lints/src/missing_const_for_fn.rs

@@ -1,10 +1,11 @@
-use crate::utils::{is_entrypoint_fn, span_lint, trait_ref_of_method};
+use crate::utils::{has_drop, is_entrypoint_fn, span_lint, trait_ref_of_method};
 use rustc::hir;
 use rustc::hir::intravisit::FnKind;
-use rustc::hir::{Body, Constness, FnDecl, HirId};
+use rustc::hir::{Body, Constness, FnDecl, HirId, HirVec};
 use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintPass};
 use rustc::{declare_lint_pass, declare_tool_lint};
 use rustc_mir::transform::qualify_min_const_fn::is_min_const_fn;
+use rustc_typeck::hir_ty_to_ty;
 use syntax_pos::Span;
 
 declare_clippy_lint! {
@@ -94,7 +95,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingConstForFn {
                 }
             },
             FnKind::Method(_, sig, ..) => {
-                if trait_ref_of_method(cx, hir_id).is_some() || already_const(sig.header) {
+                if trait_ref_of_method(cx, hir_id).is_some()
+                    || already_const(sig.header)
+                    || method_accepts_dropable(cx, &sig.decl.inputs)
+                {
                     return;
                 }
             },
@@ -113,6 +117,16 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingConstForFn {
     }
 }
 
+/// Returns true if any of the method parameters is a type that implements `Drop`. The method
+/// can't be made const then, because `drop` can't be const-evaluated.
+fn method_accepts_dropable(cx: &LateContext<'_, '_>, param_tys: &HirVec<hir::Ty>) -> bool {
+    // If any of the params are dropable, return true
+    param_tys.iter().any(|hir_ty| {
+        let ty_ty = hir_ty_to_ty(cx.tcx, hir_ty);
+        has_drop(cx, ty_ty)
+    })
+}
+
 // We don't have to lint on something that's already `const`
 fn already_const(header: hir::FnHeader) -> bool {
     header.constness == Constness::Const

tests/ui/assign_ops.fixed

@@ -0,0 +1,21 @@
+// run-rustfix
+
+#[allow(dead_code, unused_assignments)]
+#[warn(clippy::assign_op_pattern)]
+fn main() {
+    let mut a = 5;
+    a += 1;
+    a += 1;
+    a -= 1;
+    a *= 99;
+    a *= 42;
+    a /= 2;
+    a %= 5;
+    a &= 1;
+    a = 1 - a;
+    a = 5 / a;
+    a = 42 % a;
+    a = 6 << a;
+    let mut s = String::new();
+    s += "bla";
+}

tests/ui/assign_ops.rs

@@ -1,3 +1,5 @@
+// run-rustfix
+
 #[allow(dead_code, unused_assignments)]
 #[warn(clippy::assign_op_pattern)]
 fn main() {