Start addressing review comments

Author: smoelius

clippy_utils/src/ty/type_certainty/certainty.rs

@@ -96,18 +96,18 @@ impl Certainty {
     }
 
     pub fn clear_def_id(self) -> Certainty {
-        match self {
-            Certainty::Uncertain => Certainty::Uncertain,
-            Certainty::Certain(_) => Certainty::Certain(None),
-            Certainty::Contradiction => Certainty::Contradiction,
+        if matches!(self, Certainty::Certain(_)) {
+            Certainty::Certain(None)
+        } else {
+            self
         }
     }
 
     pub fn with_def_id(self, def_id: DefId) -> Certainty {
-        match self {
-            Certainty::Uncertain => Certainty::Uncertain,
-            Certainty::Certain(_) => Certainty::Certain(Some(def_id)),
-            Certainty::Contradiction => Certainty::Contradiction,
+        if matches!(self, Certainty::Certain(_)) {
+            Certainty::Certain(Some(def_id))
+        } else {
+            self
         }
     }
 

clippy_utils/src/ty/type_certainty/mod.rs

@@ -11,8 +11,6 @@
 //! As a heuristic, `expr_type_is_certain` may produce false negatives, but a false positive should
 //! be considered a bug.
 
-#![allow(clippy::wrong_self_convention)]
-
 use crate::def_path_res;
 use rustc_hir::def::Res;
 use rustc_hir::def_id::DefId;
@@ -130,6 +128,12 @@ impl<'cx, 'tcx> Visitor<'cx> for CertaintyVisitor<'cx, 'tcx> {
 
 fn type_certainty(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> Certainty {
     // Handle `TyKind::Path` specially so that its `DefId` can be preserved.
+    //
+    // Note that `CertaintyVisitor::new` initializes the visitor's internal certainty to
+    // `Certainty::Certain(None)`. Furthermore, if a `TyKind::Path` is encountered while traversing
+    // `ty`, the result of the call to `qpath_certainty` is combined with the visitor's internal
+    // certainty using `Certainty::meet`. Thus, if the `TyKind::Path` were not treated specially here,
+    // the resulting certainty would be `Certainty::Certain(None)`.
     if let TyKind::Path(qpath) = &ty.kind {
         qpath_certainty(cx, qpath, true)
     } else {
@@ -288,16 +292,12 @@ fn type_is_inferrable_from_arguments(cx: &LateContext<'_>, expr: &Expr<'_>) -> b
     let generics = cx.tcx.generics_of(callee_def_id);
     let fn_sig = cx.tcx.fn_sig(callee_def_id).skip_binder();
 
+    // Check that all type parameters appear in the functions input types.
     (0..(generics.parent_count + generics.params.len()) as u32).all(|index| {
-        fn_sig.inputs().iter().any(|input_ty| {
-            input_ty.skip_binder().walk().any(|arg| {
-                if let GenericArgKind::Type(ty) = arg.unpack() {
-                    ty.is_param(index)
-                } else {
-                    false
-                }
-            })
-        })
+        fn_sig
+            .inputs()
+            .iter()
+            .any(|input_ty| contains_param(*input_ty.skip_binder(), index))
     })
 }
 
@@ -308,3 +308,8 @@ fn self_ty<'tcx>(cx: &LateContext<'tcx>, method_def_id: DefId) -> Ty<'tcx> {
 fn adt_def_id(ty: Ty<'_>) -> Option<DefId> {
     ty.peel_refs().ty_adt_def().map(AdtDef::did)
 }
+
+fn contains_param(ty: Ty<'_>, index: u32) -> bool {
+    ty.walk()
+        .any(|arg| matches!(arg.unpack(), GenericArgKind::Type(ty) if ty.is_param(index)))
+}