Make some clippy checks stricter (#129)

* fix some issues

* fix some issues

* Fix clippy match_same_arms warnings by merging identical match arms

Merged match arms with identical bodies across multiple files:
- src/loop/mod.rs: Merged PlaceUsageType equality checks and PlaceContext arms
- src/owned_pcg/impl/local/join.rs: Merged JoinExpandedPlaceResult actions
- src/pcg/engine.rs: Merged Assert and Drop terminator edge handling
- src/pcg/capabilities.rs: Consolidated partial ordering comparisons and minimum function
- src/pcg/obtain/mod.rs: Merged ObtainType variants returning true
- src/pcg/place_capabilities.rs: Consolidated BlockType capability returns
- src/pcg/triple.rs: Merged SetDiscriminant and Retag, removed redundant PlaceMention
- src/pcg/visitor/function_call.rs: Removed redundant FnPtr arm
- src/utils/display.rs: Merged ConstantIndex and Subslice projections
- src/utils/html.rs: Merged Text and Subscript variants
- src/utils/initialized.rs: Merged LookupResult variants
- src/utils/liveness.rs: Merged NonUse and Drop contexts
- src/utils/place/mod.rs: Consolidated TyKind arms
- src/utils/place_snapshot.rs: Merged SnapshotLocation variants
- src/utils/visitor.rs: Consolidated statement and rvalue handling
- src/visualization/mir_graph.rs: Merged binary ops and terminator kinds
- src/visualization/mod.rs: Consolidated GraphEdge validity_conditions

* rustfmt

* rustfmt

* more clippy checks

* more clippy checks

Author: zgrannan

src/action.rs

@@ -58,7 +58,7 @@ impl<'a, 'tcx: 'a, Ctxt: HasBorrowCheckerCtxt<'a, 'tcx>> DebugRepr<Ctxt> for App
 
 pub(crate) type AppliedActions<'tcx> = PcgActions<'tcx, AppliedAction<'tcx>>;
 
-impl<'tcx> Default for AppliedActions<'tcx> {
+impl Default for AppliedActions<'_> {
     fn default() -> Self {
         Self {
             actions: vec![],

src/borrow_pcg/action/mod.rs

@@ -225,7 +225,7 @@ pub struct LabelPlaceAction<'tcx, P = Place<'tcx>> {
     _marker: PhantomData<&'tcx ()>,
 }
 
-impl<'tcx, P> LabelPlaceAction<'tcx, P> {
+impl<P> LabelPlaceAction<'_, P> {
     pub(crate) fn new(place: P, location: SnapshotLocation, reason: LabelPlaceReason) -> Self {
         Self {
             place,
@@ -398,11 +398,11 @@ impl<'a, 'tcx: 'a, Ctxt: HasBorrowCheckerCtxt<'a, 'tcx>, EdgeKind: DisplayWithCt
             BorrowPcgActionKind::LabelPlace(action) => action.display_output(ctxt, mode),
             BorrowPcgActionKind::RemoveEdge(edge) => DisplayOutput::join(
                 vec!["Remove Edge".into(), edge.display_output(ctxt, mode)],
-                DisplayOutput::SPACE,
+                &DisplayOutput::SPACE,
             ),
             BorrowPcgActionKind::AddEdge { edge } => DisplayOutput::join(
                 vec!["Add Edge".into(), edge.display_output(ctxt, mode)],
-                DisplayOutput::SPACE,
+                &DisplayOutput::SPACE,
             ),
         }
     }

src/borrow_pcg/borrow_pcg_edge.rs

@@ -47,16 +47,16 @@ pub struct BorrowPcgEdgeRef<
     _marker: PhantomData<&'tcx ()>,
 }
 
-impl<'a, 'tcx: 'a, 'graph, Ctxt: HasCompilerCtxt<'a, 'tcx>, EdgeKind: DisplayWithCtxt<Ctxt>>
-    DisplayWithCtxt<Ctxt> for BorrowPcgEdgeRef<'tcx, 'graph, EdgeKind>
+impl<'a, 'tcx: 'a, Ctxt: HasCompilerCtxt<'a, 'tcx>, EdgeKind: DisplayWithCtxt<Ctxt>>
+    DisplayWithCtxt<Ctxt> for BorrowPcgEdgeRef<'tcx, '_, EdgeKind>
 {
     fn display_output(&self, ctxt: Ctxt, mode: OutputMode) -> DisplayOutput {
         let kind = self.kind.display_output(ctxt, mode);
         self.conditions.conditional_string(kind, ctxt)
     }
 }
 
-impl<'tcx, 'graph, EdgeKind, VC> BorrowPcgEdgeRef<'tcx, 'graph, EdgeKind, VC> {
+impl<'graph, EdgeKind, VC> BorrowPcgEdgeRef<'_, 'graph, EdgeKind, VC> {
     pub(crate) fn new(kind: &'graph EdgeKind, conditions: &'graph VC) -> Self {
         Self {
             kind,
@@ -66,15 +66,15 @@ impl<'tcx, 'graph, EdgeKind, VC> BorrowPcgEdgeRef<'tcx, 'graph, EdgeKind, VC> {
     }
 }
 
-impl<'tcx, 'graph, EdgeKind, VC> BorrowPcgEdgeRef<'tcx, 'graph, EdgeKind, VC> {
+impl<EdgeKind, VC> BorrowPcgEdgeRef<'_, '_, EdgeKind, VC> {
     pub fn kind(&self) -> &EdgeKind {
         self.kind
     }
 }
 
-impl<'tcx, 'graph, EdgeKind> Copy for BorrowPcgEdgeRef<'tcx, 'graph, EdgeKind> {}
+impl<EdgeKind> Copy for BorrowPcgEdgeRef<'_, '_, EdgeKind> {}
 
-impl<'tcx, 'graph, EdgeKind> Clone for BorrowPcgEdgeRef<'tcx, 'graph, EdgeKind> {
+impl<EdgeKind> Clone for BorrowPcgEdgeRef<'_, '_, EdgeKind> {
     fn clone(&self) -> Self {
         *self
     }
@@ -287,7 +287,7 @@ impl<'tcx> From<LifetimeProjection<'tcx, Place<'tcx>>> for LocalNode<'tcx> {
 /// by definition)
 pub type BlockingNode<'tcx> = LocalNode<'tcx>;
 
-impl<'a, 'tcx> HasValidityCheck<CompilerCtxt<'a, 'tcx>> for MaybeRemotePlace<'tcx> {
+impl<'tcx> HasValidityCheck<CompilerCtxt<'_, 'tcx>> for MaybeRemotePlace<'tcx> {
     fn check_validity(&self, _ctxt: CompilerCtxt<'_, 'tcx>) -> Result<(), String> {
         Ok(())
     }
@@ -302,7 +302,7 @@ impl<T: std::fmt::Display> std::fmt::Display for PcgNode<'_, T> {
     }
 }
 
-impl<'tcx, P: PcgNodeComponent> LocalNode<'tcx, P> {
+impl<P: PcgNodeComponent> LocalNode<'_, P> {
     pub fn as_current_place(self) -> Option<P> {
         match self {
             LocalNode::Place(MaybeLabelledPlace::Current(place)) => Some(place),
@@ -339,7 +339,7 @@ impl<'tcx, P: Copy> PcgNodeWithPlace<'tcx, P> {
     }
 }
 
-impl<'tcx, T: Copy, U> PcgNode<'tcx, T, U> {
+impl<T: Copy, U> PcgNode<'_, T, U> {
     pub(crate) fn as_place(&self) -> Option<T> {
         match self {
             PcgNode::Place(p) => Some(*p),

src/borrow_pcg/borrow_pcg_expansion.rs

@@ -250,7 +250,7 @@ impl<'tcx, P: PcgNodeComponent> BorrowPcgExpansion<'tcx, P> {
 impl<'tcx> BorrowPcgExpansion<'tcx> {
     pub(crate) fn new_lifetime_projection_expansion<'a>(
         base: LifetimeProjection<'tcx, Place<'tcx>>,
-        expansion: PlaceExpansion<'tcx>,
+        expansion: &PlaceExpansion<'tcx>,
         ctxt: impl HasBorrowCheckerCtxt<'a, 'tcx>,
     ) -> Result<Self, PcgError>
     where
@@ -266,7 +266,7 @@ impl<'tcx> BorrowPcgExpansion<'tcx> {
     }
     pub(crate) fn new_place_expansion<'a>(
         base: Place<'tcx>,
-        expansion: PlaceExpansion<'tcx>,
+        expansion: &PlaceExpansion<'tcx>,
         ctxt: impl HasBorrowCheckerCtxt<'a, 'tcx>,
     ) -> Result<Self, PcgError>
     where
@@ -513,7 +513,7 @@ impl<'tcx, Node: PcgNodeComponent> BorrowPcgExpansionData<Node> {
 
     pub(crate) fn new<Ctxt: DebugCtxt + Copy, P: PlaceLike<'tcx, Ctxt> + DisplayWithCtxt<Ctxt>>(
         base: Node,
-        expansion: PlaceExpansion<'tcx>,
+        expansion: &PlaceExpansion<'tcx>,
         ctxt: Ctxt,
     ) -> Result<Self, PcgError>
     where
@@ -524,7 +524,7 @@ impl<'tcx, Node: PcgNodeComponent> BorrowPcgExpansionData<Node> {
             return Err(PcgUnsupportedError::DerefUnsafePtr.into());
         }
         pcg_validity_assert!(
-            !(base.is_place() && base.place().is_ref(ctxt) && expansion == PlaceExpansion::Deref),
+            !(base.is_place() && base.place().is_ref(ctxt) && expansion == &PlaceExpansion::Deref),
             [ctxt],
             "Deref expansion of {} should be a Deref edge, not an expansion",
             base.place().display_string(ctxt)

src/borrow_pcg/edge/abstraction/function.rs

@@ -87,7 +87,7 @@ impl<'tcx> FunctionDataShapeDataSource<'tcx> {
 }
 
 impl<'tcx> FunctionData<'tcx> {
-    pub(crate) fn identity_fn_sig(&self, tcx: ty::TyCtxt<'tcx>) -> ty::FnSig<'tcx> {
+    pub(crate) fn identity_fn_sig(self, tcx: ty::TyCtxt<'tcx>) -> ty::FnSig<'tcx> {
         let fn_sig = tcx.fn_sig(self.def_id).instantiate_identity();
         tcx.liberate_late_bound_regions(self.def_id, fn_sig)
     }
@@ -207,8 +207,8 @@ pub struct AbstractionBlockEdgeWithMetadata<Metadata, Edge> {
     pub(crate) edge: Edge,
 }
 
-impl<'tcx, Metadata, Input: Copy, Output: Copy>
-    AbstractionBlockEdgeWithMetadata<Metadata, AbstractionBlockEdge<'tcx, Input, Output>>
+impl<Metadata, Input: Copy, Output: Copy>
+    AbstractionBlockEdgeWithMetadata<Metadata, AbstractionBlockEdge<'_, Input, Output>>
 {
     pub(crate) fn into_singleton_coupled_edge(self) -> CoupledEdgeKind<Metadata, Input, Output> {
         CoupledEdgeKind::new(self.metadata, self.edge.to_singleton_hyper_edge())

src/borrow_pcg/edge/abstraction/mod.rs

@@ -91,8 +91,8 @@ impl<'tcx> AbstractionEdge<'tcx> {
     }
 }
 
-impl<'tcx, Input: std::fmt::Display, Output: std::fmt::Display> std::fmt::Display
-    for AbstractionBlockEdge<'tcx, Input, Output>
+impl<Input: std::fmt::Display, Output: std::fmt::Display> std::fmt::Display
+    for AbstractionBlockEdge<'_, Input, Output>
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{} -> {}", self.input, self.output)
@@ -107,7 +107,7 @@ pub struct AbstractionBlockEdge<'tcx, Input, Output> {
     pub(crate) output: Output,
 }
 
-impl<'tcx, Input: Copy, Output: Copy> AbstractionBlockEdge<'tcx, Input, Output> {
+impl<Input: Copy, Output: Copy> AbstractionBlockEdge<'_, Input, Output> {
     pub(crate) fn new(input: Input, output: Output) -> Self {
         Self {
             _phantom: PhantomData,
@@ -271,8 +271,8 @@ impl<
     }
 }
 
-impl<'tcx, Ctxt: Copy, Input: DisplayWithCtxt<Ctxt>, Output: DisplayWithCtxt<Ctxt>>
-    DisplayWithCtxt<Ctxt> for AbstractionBlockEdge<'tcx, Input, Output>
+impl<Ctxt: Copy, Input: DisplayWithCtxt<Ctxt>, Output: DisplayWithCtxt<Ctxt>> DisplayWithCtxt<Ctxt>
+    for AbstractionBlockEdge<'_, Input, Output>
 {
     fn display_output(&self, ctxt: Ctxt, _mode: OutputMode) -> DisplayOutput {
         DisplayOutput::Text(
@@ -287,11 +287,10 @@ impl<'tcx, Ctxt: Copy, Input: DisplayWithCtxt<Ctxt>, Output: DisplayWithCtxt<Ctx
 }
 
 impl<
-    'tcx,
     Ctxt: DebugCtxt + Copy,
     Input: HasValidityCheck<Ctxt> + DisplayWithCtxt<Ctxt>,
     Output: HasValidityCheck<Ctxt> + DisplayWithCtxt<Ctxt>,
-> HasValidityCheck<Ctxt> for AbstractionBlockEdge<'tcx, Input, Output>
+> HasValidityCheck<Ctxt> for AbstractionBlockEdge<'_, Input, Output>
 {
     fn check_validity(&self, ctxt: Ctxt) -> Result<(), String> {
         self.input.check_validity(ctxt)?;
@@ -306,7 +305,7 @@ impl<
     }
 }
 
-impl<'tcx, Input, Output> AbstractionBlockEdge<'tcx, Input, Output> {
+impl<Input, Output> AbstractionBlockEdge<'_, Input, Output> {
     pub(crate) fn new_checked<Ctxt: DebugCtxt + Copy>(
         input: Input,
         output: Output,

src/borrow_pcg/edge/borrow_flow.rs

@@ -37,7 +37,7 @@ pub struct BorrowFlowEdge<'tcx, P = Place<'tcx>> {
     pub(crate) kind: BorrowFlowEdgeKind<'tcx>,
 }
 
-impl<'tcx, P> BorrowFlowEdge<'tcx, P> {
+impl<P> BorrowFlowEdge<'_, P> {
     pub(crate) fn future_edge_kind(self) -> Option<private::FutureEdgeKind> {
         if let BorrowFlowEdgeKind::Future(future_edge_kind) = self.kind {
             Some(future_edge_kind)
@@ -239,7 +239,7 @@ impl<'tcx, P: Copy> BorrowFlowEdge<'tcx, P> {
     }
 }
 
-impl<'tcx, Ty: serde::Serialize> serde::Serialize for CastData<'tcx, Ty> {
+impl<Ty: serde::Serialize> serde::Serialize for CastData<'_, Ty> {
     fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
@@ -255,7 +255,7 @@ pub struct CastData<'tcx, Ty = ty::Ty<'tcx>> {
     _phantom: PhantomData<&'tcx Ty>,
 }
 
-impl<'tcx, Ty> CastData<'tcx, Ty> {
+impl<Ty> CastData<'_, Ty> {
     pub(crate) fn new(kind: mir::CastKind, ty: Ty) -> Self {
         Self {
             kind,
@@ -383,7 +383,7 @@ impl<'tcx, Ctxt> DebugRepr<Ctxt> for BorrowFlowEdgeKind<'tcx> {
     }
 }
 
-impl<'tcx, Ty: std::fmt::Debug> std::fmt::Display for BorrowFlowEdgeKind<'tcx, Ty> {
+impl<Ty: std::fmt::Debug> std::fmt::Display for BorrowFlowEdgeKind<'_, Ty> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             BorrowFlowEdgeKind::Aggregate {

src/borrow_pcg/edge_data.rs

@@ -144,7 +144,7 @@ where
     }
 }
 
-impl<'graph, 'tcx, Ctxt: Copy> EdgeData<'tcx, Ctxt> for BorrowPcgEdgeRef<'tcx, 'graph>
+impl<'tcx, Ctxt: Copy> EdgeData<'tcx, Ctxt> for BorrowPcgEdgeRef<'tcx, '_>
 where
     BorrowPcgEdgeKind<'tcx>: EdgeData<'tcx, Ctxt>,
 {
@@ -196,7 +196,7 @@ pub enum LabelNodePredicate<'tcx, P = Place<'tcx>> {
     InTargetNodes,
 }
 
-impl<'tcx, P: Copy> LabelNodePredicate<'tcx, P> {
+impl<P: Copy> LabelNodePredicate<'_, P> {
     /// Creates a predicate that matches all future lifetime projections whose base
     /// is a postfix of the given place (and the base is current, not labelled).
     pub(crate) fn all_future_postfixes(place: P) -> Self {
@@ -272,15 +272,15 @@ impl<'a, 'tcx: 'a, Ctxt: HasBorrowCheckerCtxt<'a, 'tcx> + OverrideRegionDebugStr
                 "(".into(),
                 DisplayOutput::join(
                     predicates.iter().map(|p| p.display_output(ctxt, mode)),
-                    " && ".into(),
+                    &" && ".into(),
                 ),
                 ")".into(),
             ]),
             LabelNodePredicate::Or(predicates) => DisplayOutput::Seq(vec![
                 "(".into(),
                 DisplayOutput::join(
                     predicates.iter().map(|p| p.display_output(ctxt, mode)),
-                    " || ".into(),
+                    &" || ".into(),
                 ),
                 ")".into(),
             ]),
@@ -402,7 +402,7 @@ where
         .collect();
     DisplayOutput::Seq(vec![
         "Labelled nodes: [".into(),
-        DisplayOutput::join(items, ", ".into()),
+        DisplayOutput::join(items, &", ".into()),
         "]".into(),
     ])
 }

src/borrow_pcg/graph/aliases.rs

@@ -76,14 +76,10 @@ impl<'tcx> BorrowsGraph<'tcx> {
                 if !alias.exact_alias {
                     continue;
                 }
-                let local_node = if let Some(local_node) = alias.node.try_to_local_node(ctxt) {
-                    local_node
-                } else {
+                let Some(local_node) = alias.node.try_to_local_node(ctxt) else {
                     continue;
                 };
-                let local_node = if let Ok(n) = local_node.project_deeper(proj, ctxt) {
-                    n
-                } else {
+                let Ok(local_node) = local_node.project_deeper(proj, ctxt) else {
                     continue;
                 };
                 results.extend(self.direct_aliases(

src/borrow_pcg/graph/frozen.rs

@@ -49,9 +49,7 @@ pub struct FrozenGraphRef<
     roots_cache: RefCell<Option<FxHashSet<PcgNode<'tcx>>>>,
 }
 
-impl<'graph, 'tcx, P: PcgNodeComponent, VC>
-    FrozenGraphRef<'graph, 'tcx, P, BorrowPcgEdgeKind<'tcx, P>, VC>
-{
+impl<'tcx, P: PcgNodeComponent, VC> FrozenGraphRef<'_, 'tcx, P, BorrowPcgEdgeKind<'tcx, P>, VC> {
     pub(crate) fn is_leaf<'slf, Ctxt: Copy + DebugCtxt>(
         &'slf self,
         node: LocalNode<'tcx, P>,