fix: Remove unnecessary explicit lifetimes (#488)

DataTriny · web-flow · commit d2bcd6d3048d · 2024-12-08T06:20:47.000-06:00
diff --git a/consumer/src/iterators.rs b/consumer/src/iterators.rs
@@ -48,7 +48,7 @@ impl<'a> FollowingSiblings<'a> {
     }
 }
 
-impl<'a> Iterator for FollowingSiblings<'a> {
+impl Iterator for FollowingSiblings<'_> {
     type Item = NodeId;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -76,7 +76,7 @@ impl<'a> Iterator for FollowingSiblings<'a> {
     }
 }
 
-impl<'a> DoubleEndedIterator for FollowingSiblings<'a> {
+impl DoubleEndedIterator for FollowingSiblings<'_> {
     fn next_back(&mut self) -> Option<Self::Item> {
         if self.done {
             None
@@ -94,9 +94,9 @@ impl<'a> DoubleEndedIterator for FollowingSiblings<'a> {
     }
 }
 
-impl<'a> ExactSizeIterator for FollowingSiblings<'a> {}
+impl ExactSizeIterator for FollowingSiblings<'_> {}
 
-impl<'a> FusedIterator for FollowingSiblings<'a> {}
+impl FusedIterator for FollowingSiblings<'_> {}
 
 /// An iterator that yields preceding siblings of a node.
 ///
@@ -126,7 +126,7 @@ impl<'a> PrecedingSiblings<'a> {
     }
 }
 
-impl<'a> Iterator for PrecedingSiblings<'a> {
+impl Iterator for PrecedingSiblings<'_> {
     type Item = NodeId;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -156,7 +156,7 @@ impl<'a> Iterator for PrecedingSiblings<'a> {
     }
 }
 
-impl<'a> DoubleEndedIterator for PrecedingSiblings<'a> {
+impl DoubleEndedIterator for PrecedingSiblings<'_> {
     fn next_back(&mut self) -> Option<Self::Item> {
         if self.done {
             None
@@ -174,9 +174,9 @@ impl<'a> DoubleEndedIterator for PrecedingSiblings<'a> {
     }
 }
 
-impl<'a> ExactSizeIterator for PrecedingSiblings<'a> {}
+impl ExactSizeIterator for PrecedingSiblings<'_> {}
 
-impl<'a> FusedIterator for PrecedingSiblings<'a> {}
+impl FusedIterator for PrecedingSiblings<'_> {}
 
 fn next_filtered_sibling<'a>(
     node: Option<Node<'a>>,
@@ -297,8 +297,8 @@ impl<'a, Filter: Fn(&Node) -> FilterResult> Iterator for FollowingFilteredSiblin
     }
 }
 
-impl<'a, Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator
-    for FollowingFilteredSiblings<'a, Filter>
+impl<Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator
+    for FollowingFilteredSiblings<'_, Filter>
 {
     fn next_back(&mut self) -> Option<Self::Item> {
         if self.done {
@@ -312,10 +312,7 @@ impl<'a, Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator
     }
 }
 
-impl<'a, Filter: Fn(&Node) -> FilterResult> FusedIterator
-    for FollowingFilteredSiblings<'a, Filter>
-{
-}
+impl<Filter: Fn(&Node) -> FilterResult> FusedIterator for FollowingFilteredSiblings<'_, Filter> {}
 
 /// An iterator that yields preceding siblings of a node according to the
 /// specified filter.
@@ -358,8 +355,8 @@ impl<'a, Filter: Fn(&Node) -> FilterResult> Iterator for PrecedingFilteredSiblin
     }
 }
 
-impl<'a, Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator
-    for PrecedingFilteredSiblings<'a, Filter>
+impl<Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator
+    for PrecedingFilteredSiblings<'_, Filter>
 {
     fn next_back(&mut self) -> Option<Self::Item> {
         if self.done {
@@ -373,10 +370,7 @@ impl<'a, Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator
     }
 }
 
-impl<'a, Filter: Fn(&Node) -> FilterResult> FusedIterator
-    for PrecedingFilteredSiblings<'a, Filter>
-{
-}
+impl<Filter: Fn(&Node) -> FilterResult> FusedIterator for PrecedingFilteredSiblings<'_, Filter> {}
 
 /// An iterator that yields children of a node according to the specified
 /// filter.
@@ -417,7 +411,7 @@ impl<'a, Filter: Fn(&Node) -> FilterResult> Iterator for FilteredChildren<'a, Fi
     }
 }
 
-impl<'a, Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator for FilteredChildren<'a, Filter> {
+impl<Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator for FilteredChildren<'_, Filter> {
     fn next_back(&mut self) -> Option<Self::Item> {
         if self.done {
             None
@@ -430,7 +424,7 @@ impl<'a, Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator for FilteredChil
     }
 }
 
-impl<'a, Filter: Fn(&Node) -> FilterResult> FusedIterator for FilteredChildren<'a, Filter> {}
+impl<Filter: Fn(&Node) -> FilterResult> FusedIterator for FilteredChildren<'_, Filter> {}
 
 pub(crate) enum LabelledBy<'a, Filter: Fn(&Node) -> FilterResult> {
     FromDescendants(FilteredChildren<'a, Filter>),
@@ -460,7 +454,7 @@ impl<'a, Filter: Fn(&Node) -> FilterResult> Iterator for LabelledBy<'a, Filter>
     }
 }
 
-impl<'a, Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator for LabelledBy<'a, Filter> {
+impl<Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator for LabelledBy<'_, Filter> {
     fn next_back(&mut self) -> Option<Self::Item> {
         match self {
             Self::FromDescendants(iter) => iter.next_back(),
@@ -471,7 +465,7 @@ impl<'a, Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator for LabelledBy<'
     }
 }
 
-impl<'a, Filter: Fn(&Node) -> FilterResult> FusedIterator for LabelledBy<'a, Filter> {}
+impl<Filter: Fn(&Node) -> FilterResult> FusedIterator for LabelledBy<'_, Filter> {}
 
 #[cfg(test)]
 mod tests {
diff --git a/consumer/src/text.rs b/consumer/src/text.rs
@@ -177,13 +177,13 @@ impl<'a> InnerPosition<'a> {
     }
 }
 
-impl<'a> PartialEq for InnerPosition<'a> {
+impl PartialEq for InnerPosition<'_> {
     fn eq(&self, other: &Self) -> bool {
         self.node.id() == other.node.id() && self.character_index == other.character_index
     }
 }
 
-impl<'a> Eq for InnerPosition<'a> {}
+impl Eq for InnerPosition<'_> {}
 
 #[derive(Clone, Copy)]
 pub struct Position<'a> {
@@ -455,15 +455,15 @@ impl<'a> Position<'a> {
     }
 }
 
-impl<'a> PartialEq for Position<'a> {
+impl PartialEq for Position<'_> {
     fn eq(&self, other: &Self) -> bool {
         self.root_node.id() == other.root_node.id() && self.inner == other.inner
     }
 }
 
-impl<'a> Eq for Position<'a> {}
+impl Eq for Position<'_> {}
 
-impl<'a> PartialOrd for Position<'a> {
+impl PartialOrd for Position<'_> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         if self.root_node.id() != other.root_node.id() {
             return None;
@@ -742,13 +742,13 @@ impl<'a> Range<'a> {
     }
 }
 
-impl<'a> PartialEq for Range<'a> {
+impl PartialEq for Range<'_> {
     fn eq(&self, other: &Self) -> bool {
         self.node.id() == other.node.id() && self.start == other.start && self.end == other.end
     }
 }
 
-impl<'a> Eq for Range<'a> {}
+impl Eq for Range<'_> {}
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct WeakRange {
diff --git a/platforms/atspi-common/src/node.rs b/platforms/atspi-common/src/node.rs
@@ -34,7 +34,7 @@ use crate::{
 
 pub(crate) struct NodeWrapper<'a>(pub(crate) &'a Node<'a>);
 
-impl<'a> NodeWrapper<'a> {
+impl NodeWrapper<'_> {
     pub(crate) fn name(&self) -> Option<String> {
         if self.0.label_comes_from_value() {
             self.0.value()
diff --git a/platforms/macos/src/node.rs b/platforms/macos/src/node.rs
@@ -298,7 +298,7 @@ pub(crate) enum Value {
 
 pub(crate) struct NodeWrapper<'a>(pub(crate) &'a Node<'a>);
 
-impl<'a> NodeWrapper<'a> {
+impl NodeWrapper<'_> {
     fn is_root(&self) -> bool {
         self.0.is_root()
     }
diff --git a/platforms/windows/src/node.rs b/platforms/windows/src/node.rs
@@ -43,7 +43,7 @@ fn runtime_id_from_node_id(id: NodeId) -> [i32; RUNTIME_ID_SIZE] {
 
 pub(crate) struct NodeWrapper<'a>(pub(crate) &'a Node<'a>);
 
-impl<'a> NodeWrapper<'a> {
+impl NodeWrapper<'_> {
     fn control_type(&self) -> UIA_CONTROLTYPE_ID {
         let role = self.0.role();
         // TODO: Handle special cases. (#14)

Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ impl<'a> FollowingSiblings<'a> {`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`
`51`		`-impl<'a> Iterator for FollowingSiblings<'a> {`
	`51`	`+impl Iterator for FollowingSiblings<'_> {`
`52`	`52`	`type Item = NodeId;`
`53`	`53`
`54`	`54`	`fn next(&mut self) -> Option<Self::Item> {`
`@@ -76,7 +76,7 @@ impl<'a> Iterator for FollowingSiblings<'a> {`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`
`79`		`-impl<'a> DoubleEndedIterator for FollowingSiblings<'a> {`
	`79`	`+impl DoubleEndedIterator for FollowingSiblings<'_> {`
`80`	`80`	`fn next_back(&mut self) -> Option<Self::Item> {`
`81`	`81`	`if self.done {`
`82`	`82`	`None`
`@@ -94,9 +94,9 @@ impl<'a> DoubleEndedIterator for FollowingSiblings<'a> {`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`
`97`		`-impl<'a> ExactSizeIterator for FollowingSiblings<'a> {}`
	`97`	`+impl ExactSizeIterator for FollowingSiblings<'_> {}`
`98`	`98`
`99`		`-impl<'a> FusedIterator for FollowingSiblings<'a> {}`
	`99`	`+impl FusedIterator for FollowingSiblings<'_> {}`
`100`	`100`
`101`	`101`	`/// An iterator that yields preceding siblings of a node.`
`102`	`102`	`///`
`@@ -126,7 +126,7 @@ impl<'a> PrecedingSiblings<'a> {`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
`129`		`-impl<'a> Iterator for PrecedingSiblings<'a> {`
	`129`	`+impl Iterator for PrecedingSiblings<'_> {`
`130`	`130`	`type Item = NodeId;`
`131`	`131`
`132`	`132`	`fn next(&mut self) -> Option<Self::Item> {`
`@@ -156,7 +156,7 @@ impl<'a> Iterator for PrecedingSiblings<'a> {`
`156`	`156`	`}`
`157`	`157`	`}`
`158`	`158`
`159`		`-impl<'a> DoubleEndedIterator for PrecedingSiblings<'a> {`
	`159`	`+impl DoubleEndedIterator for PrecedingSiblings<'_> {`
`160`	`160`	`fn next_back(&mut self) -> Option<Self::Item> {`
`161`	`161`	`if self.done {`
`162`	`162`	`None`
`@@ -174,9 +174,9 @@ impl<'a> DoubleEndedIterator for PrecedingSiblings<'a> {`
`174`	`174`	`}`
`175`	`175`	`}`
`176`	`176`
`177`		`-impl<'a> ExactSizeIterator for PrecedingSiblings<'a> {}`
	`177`	`+impl ExactSizeIterator for PrecedingSiblings<'_> {}`
`178`	`178`
`179`		`-impl<'a> FusedIterator for PrecedingSiblings<'a> {}`
	`179`	`+impl FusedIterator for PrecedingSiblings<'_> {}`
`180`	`180`
`181`	`181`	`fn next_filtered_sibling<'a>(`
`182`	`182`	`node: Option<Node<'a>>,`
`@@ -297,8 +297,8 @@ impl<'a, Filter: Fn(&Node) -> FilterResult> Iterator for FollowingFilteredSiblin`
`297`	`297`	`}`
`298`	`298`	`}`
`299`	`299`
`300`		`-impl<'a, Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator`
`301`		`- for FollowingFilteredSiblings<'a, Filter>`
	`300`	`+impl<Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator`
	`301`	`+ for FollowingFilteredSiblings<'_, Filter>`
`302`	`302`	`{`
`303`	`303`	`fn next_back(&mut self) -> Option<Self::Item> {`
`304`	`304`	`if self.done {`
`@@ -312,10 +312,7 @@ impl<'a, Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator`
`312`	`312`	`}`
`313`	`313`	`}`
`314`	`314`
`315`		`-impl<'a, Filter: Fn(&Node) -> FilterResult> FusedIterator`
`316`		`- for FollowingFilteredSiblings<'a, Filter>`
`317`		`-{`
`318`		`-}`
	`315`	`+impl<Filter: Fn(&Node) -> FilterResult> FusedIterator for FollowingFilteredSiblings<'_, Filter> {}`
`319`	`316`
`320`	`317`	`/// An iterator that yields preceding siblings of a node according to the`
`321`	`318`	`/// specified filter.`
`@@ -358,8 +355,8 @@ impl<'a, Filter: Fn(&Node) -> FilterResult> Iterator for PrecedingFilteredSiblin`
`358`	`355`	`}`
`359`	`356`	`}`
`360`	`357`
`361`		`-impl<'a, Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator`
`362`		`- for PrecedingFilteredSiblings<'a, Filter>`
	`358`	`+impl<Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator`
	`359`	`+ for PrecedingFilteredSiblings<'_, Filter>`
`363`	`360`	`{`
`364`	`361`	`fn next_back(&mut self) -> Option<Self::Item> {`
`365`	`362`	`if self.done {`
`@@ -373,10 +370,7 @@ impl<'a, Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator`
`373`	`370`	`}`
`374`	`371`	`}`
`375`	`372`
`376`		`-impl<'a, Filter: Fn(&Node) -> FilterResult> FusedIterator`
`377`		`- for PrecedingFilteredSiblings<'a, Filter>`
`378`		`-{`
`379`		`-}`
	`373`	`+impl<Filter: Fn(&Node) -> FilterResult> FusedIterator for PrecedingFilteredSiblings<'_, Filter> {}`
`380`	`374`
`381`	`375`	`/// An iterator that yields children of a node according to the specified`
`382`	`376`	`/// filter.`
`@@ -417,7 +411,7 @@ impl<'a, Filter: Fn(&Node) -> FilterResult> Iterator for FilteredChildren<'a, Fi`
`417`	`411`	`}`
`418`	`412`	`}`
`419`	`413`
`420`		`-impl<'a, Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator for FilteredChildren<'a, Filter> {`
	`414`	`+impl<Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator for FilteredChildren<'_, Filter> {`
`421`	`415`	`fn next_back(&mut self) -> Option<Self::Item> {`
`422`	`416`	`if self.done {`
`423`	`417`	`None`
`@@ -430,7 +424,7 @@ impl<'a, Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator for FilteredChil`
`430`	`424`	`}`
`431`	`425`	`}`
`432`	`426`
`433`		`-impl<'a, Filter: Fn(&Node) -> FilterResult> FusedIterator for FilteredChildren<'a, Filter> {}`
	`427`	`+impl<Filter: Fn(&Node) -> FilterResult> FusedIterator for FilteredChildren<'_, Filter> {}`
`434`	`428`
`435`	`429`	`pub(crate) enum LabelledBy<'a, Filter: Fn(&Node) -> FilterResult> {`
`436`	`430`	`FromDescendants(FilteredChildren<'a, Filter>),`
`@@ -460,7 +454,7 @@ impl<'a, Filter: Fn(&Node) -> FilterResult> Iterator for LabelledBy<'a, Filter>`
`460`	`454`	`}`
`461`	`455`	`}`
`462`	`456`
`463`		`-impl<'a, Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator for LabelledBy<'a, Filter> {`
	`457`	`+impl<Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator for LabelledBy<'_, Filter> {`
`464`	`458`	`fn next_back(&mut self) -> Option<Self::Item> {`
`465`	`459`	`match self {`
`466`	`460`	`Self::FromDescendants(iter) => iter.next_back(),`
`@@ -471,7 +465,7 @@ impl<'a, Filter: Fn(&Node) -> FilterResult> DoubleEndedIterator for LabelledBy<'`
`471`	`465`	`}`
`472`	`466`	`}`
`473`	`467`
`474`		`-impl<'a, Filter: Fn(&Node) -> FilterResult> FusedIterator for LabelledBy<'a, Filter> {}`
	`468`	`+impl<Filter: Fn(&Node) -> FilterResult> FusedIterator for LabelledBy<'_, Filter> {}`
`475`	`469`
`476`	`470`	`#[cfg(test)]`
`477`	`471`	`mod tests {`
Original file line number	Diff line number	Diff line change
`@@ -177,13 +177,13 @@ impl<'a> InnerPosition<'a> {`
`177`	`177`	`}`
`178`	`178`	`}`
`179`	`179`
`180`		`-impl<'a> PartialEq for InnerPosition<'a> {`
	`180`	`+impl PartialEq for InnerPosition<'_> {`
`181`	`181`	`fn eq(&self, other: &Self) -> bool {`
`182`	`182`	`self.node.id() == other.node.id() && self.character_index == other.character_index`
`183`	`183`	`}`
`184`	`184`	`}`
`185`	`185`
`186`		`-impl<'a> Eq for InnerPosition<'a> {}`
	`186`	`+impl Eq for InnerPosition<'_> {}`
`187`	`187`
`188`	`188`	`#[derive(Clone, Copy)]`
`189`	`189`	`pub struct Position<'a> {`
`@@ -455,15 +455,15 @@ impl<'a> Position<'a> {`
`455`	`455`	`}`
`456`	`456`	`}`
`457`	`457`
`458`		`-impl<'a> PartialEq for Position<'a> {`
	`458`	`+impl PartialEq for Position<'_> {`
`459`	`459`	`fn eq(&self, other: &Self) -> bool {`
`460`	`460`	`self.root_node.id() == other.root_node.id() && self.inner == other.inner`
`461`	`461`	`}`
`462`	`462`	`}`
`463`	`463`
`464`		`-impl<'a> Eq for Position<'a> {}`
	`464`	`+impl Eq for Position<'_> {}`
`465`	`465`
`466`		`-impl<'a> PartialOrd for Position<'a> {`
	`466`	`+impl PartialOrd for Position<'_> {`
`467`	`467`	`fn partial_cmp(&self, other: &Self) -> Option<Ordering> {`
`468`	`468`	`if self.root_node.id() != other.root_node.id() {`
`469`	`469`	`return None;`
`@@ -742,13 +742,13 @@ impl<'a> Range<'a> {`
`742`	`742`	`}`
`743`	`743`	`}`
`744`	`744`
`745`		`-impl<'a> PartialEq for Range<'a> {`
	`745`	`+impl PartialEq for Range<'_> {`
`746`	`746`	`fn eq(&self, other: &Self) -> bool {`
`747`	`747`	`self.node.id() == other.node.id() && self.start == other.start && self.end == other.end`
`748`	`748`	`}`
`749`	`749`	`}`
`750`	`750`
`751`		`-impl<'a> Eq for Range<'a> {}`
	`751`	`+impl Eq for Range<'_> {}`
`752`	`752`
`753`	`753`	`#[derive(Clone, Debug, PartialEq, Eq)]`
`754`	`754`	`pub struct WeakRange {`
Original file line number	Diff line number	Diff line change
`@@ -298,7 +298,7 @@ pub(crate) enum Value {`
`298`	`298`
`299`	`299`	`pub(crate) struct NodeWrapper<'a>(pub(crate) &'a Node<'a>);`
`300`	`300`
`301`		`-impl<'a> NodeWrapper<'a> {`
	`301`	`+impl NodeWrapper<'_> {`
`302`	`302`	`fn is_root(&self) -> bool {`
`303`	`303`	`self.0.is_root()`
`304`	`304`	`}`