use Result type

Author: J-ZhengLi

clippy_lints/src/loops/infinite_loop.rs

@@ -1,3 +1,5 @@
+use std::ops::ControlFlow;
+
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{fn_def_id, is_from_proc_macro, is_lint_allowed};
 use hir::intravisit::{walk_expr, Visitor};
@@ -153,35 +155,39 @@ impl<'hir> RetTy<'hir> {
         /// given `ty` is not an `OpaqueDef`.
         fn inner_<'tcx>(cx: &LateContext<'tcx>, ty: &Ty<'tcx>) -> Option<Ty<'tcx>> {
             /// Visitor to find the type binding.
-            struct BindingVisitor<'tcx> {
-                res: Option<Ty<'tcx>>,
-            }
-            impl<'tcx> Visitor<'tcx> for BindingVisitor<'tcx> {
-                fn visit_assoc_type_binding(&mut self, type_binding: &'tcx hir::TypeBinding<'tcx>) {
-                    if self.res.is_some() {
-                        return;
-                    }
-                    if let hir::TypeBindingKind::Equality {
+            struct BindingVisitor;
+
+            impl<'tcx> Visitor<'tcx> for BindingVisitor {
+                type Result = ControlFlow<Ty<'tcx>>;
+
+                fn visit_assoc_item_constraint(
+                    &mut self,
+                    constraint: &'tcx hir::AssocItemConstraint<'tcx>,
+                ) -> Self::Result {
+                    if let hir::AssocItemConstraintKind::Equality {
                         term: hir::Term::Ty(ty),
-                    } = type_binding.kind
+                    } = constraint.kind
                     {
-                        self.res = Some(*ty);
+                        ControlFlow::Break(*ty)
+                    } else {
+                        ControlFlow::Continue(())
                     }
                 }
             }
 
-            let TyKind::OpaqueDef(item_id, ..) = ty.kind else {
-                return None;
-            };
-            let opaque_ty_item = cx.tcx.hir().item(item_id);
-
-            // Sinces the `item_id` is from a `TyKind::OpaqueDef`,
-            // therefore the `Item` related to it should always be `OpaqueTy`.
-            assert!(matches!(opaque_ty_item.kind, ItemKind::OpaqueTy(_)));
-
-            let mut vis = BindingVisitor { res: None };
-            vis.visit_item(opaque_ty_item);
-            vis.res
+            if let TyKind::OpaqueDef(item_id, ..) = ty.kind
+                && let opaque_ty_item = cx.tcx.hir().item(item_id)
+                && let ItemKind::OpaqueTy(_) = opaque_ty_item.kind
+            {
+                let mut vis = BindingVisitor;
+                // Use `vis.break_value()` once it's stablized.
+                match vis.visit_item(opaque_ty_item) {
+                    ControlFlow::Break(res) => Some(res),
+                    ControlFlow::Continue(()) => None,
+                }
+            } else {
+                None
+            }
         }
 
         match fn_ret_ty {
@@ -198,7 +204,12 @@ impl<'hir> RetTy<'hir> {
         }
     }
     fn is_never(&self) -> bool {
-        let Self::Return(ty) = self else { return false };
-        matches!(ty.kind, TyKind::Never)
+        matches!(
+            self,
+            RetTy::Return(Ty {
+                kind: TyKind::Never,
+                ..
+            })
+        )
     }
 }