Elide unnecessary lifetimes in impl

https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes

Author: thomaskrause

capi/src/cerror.rs

@@ -20,7 +20,7 @@ struct CauseIterator<'a> {
     current: Option<&'a dyn StdError>,
 }
 
-impl<'a> std::iter::Iterator for CauseIterator<'a> {
+impl std::iter::Iterator for CauseIterator<'_> {
     type Item = Error;
 
     fn next(&mut self) -> std::option::Option<Error> {

core/src/dfs.rs

@@ -121,7 +121,7 @@ impl<'a> CycleSafeDFS<'a> {
     }
 }
 
-impl<'a> Iterator for CycleSafeDFS<'a> {
+impl Iterator for CycleSafeDFS<'_> {
     type Item = Result<DFSStep>;
 
     fn next(&mut self) -> Option<Self::Item> {

core/src/graph/storage/union.rs

@@ -15,7 +15,7 @@ impl<'a> UnionEdgeContainer<'a> {
     }
 }
 
-impl<'a> EdgeContainer for UnionEdgeContainer<'a> {
+impl EdgeContainer for UnionEdgeContainer<'_> {
     fn get_outgoing_edges<'b>(
         &'b self,
         node: NodeID,

core/src/util/disk_collections.rs

@@ -471,7 +471,7 @@ where
     }
 }
 
-impl<'a, K, V> Iterator for CombinedRange<'a, K, V>
+impl<K, V> Iterator for CombinedRange<'_, K, V>
 where
     K: Ord,
     for<'de> K: 'static + Clone + KeySerializer + Send,
@@ -556,7 +556,7 @@ where
     }
 }
 
-impl<'a, K, V> FusedIterator for CombinedRange<'a, K, V>
+impl<K, V> FusedIterator for CombinedRange<'_, K, V>
 where
     K: 'static + Ord + Clone + KeySerializer + Serialize + DeserializeOwned + Send,
     for<'de> V: 'static + Clone + Serialize + Deserialize<'de> + Send,

graphannis/src/annis/db/aql/operators/equal_value.rs

@@ -65,7 +65,7 @@ pub struct EqualValue<'a> {
     negated: bool,
 }
 
-impl<'a> std::fmt::Display for EqualValue<'a> {
+impl std::fmt::Display for EqualValue<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         if self.negated {
             write!(f, "!=")
@@ -75,7 +75,7 @@ impl<'a> std::fmt::Display for EqualValue<'a> {
     }
 }
 
-impl<'a> EqualValue<'a> {
+impl EqualValue<'_> {
     fn value_for_match(&self, m: &Match, spec: &NodeSearchSpec) -> Result<Option<Cow<str>>> {
         match spec {
             NodeSearchSpec::ExactValue { .. }
@@ -119,7 +119,7 @@ impl<'a> EqualValue<'a> {
     }
 }
 
-impl<'a> BinaryOperatorBase for EqualValue<'a> {
+impl BinaryOperatorBase for EqualValue<'_> {
     fn filter_match(&self, lhs: &Match, rhs: &Match) -> Result<bool> {
         let lhs_val = self.value_for_match(lhs, &self.spec_left)?;
         let rhs_val = self.value_for_match(rhs, &self.spec_right)?;
@@ -177,7 +177,7 @@ impl<'a> BinaryOperatorBase for EqualValue<'a> {
     }
 }
 
-impl<'a> BinaryOperatorIndex for EqualValue<'a> {
+impl BinaryOperatorIndex for EqualValue<'_> {
     fn retrieve_matches<'b>(&'b self, lhs: &Match) -> Box<dyn Iterator<Item = Result<Match>> + 'b> {
         let lhs = lhs.clone();
         let lhs_val = try_as_boxed_iter!(self.value_for_match(&lhs, &self.spec_left));

graphannis/src/annis/db/aql/operators/identical_cov.rs

@@ -98,13 +98,13 @@ impl<'a> IdenticalCoverage<'a> {
     }
 }
 
-impl<'a> std::fmt::Display for IdenticalCoverage<'a> {
+impl std::fmt::Display for IdenticalCoverage<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "_=_")
     }
 }
 
-impl<'a> BinaryOperatorBase for IdenticalCoverage<'a> {
+impl BinaryOperatorBase for IdenticalCoverage<'_> {
     fn filter_match(&self, lhs: &Match, rhs: &Match) -> Result<bool> {
         let start_lhs = self.tok_helper.left_token_for(lhs.node)?;
         let end_lhs = self.tok_helper.right_token_for(lhs.node)?;
@@ -155,7 +155,7 @@ impl<'a> BinaryOperatorBase for IdenticalCoverage<'a> {
     }
 }
 
-impl<'a> BinaryOperatorIndex for IdenticalCoverage<'a> {
+impl BinaryOperatorIndex for IdenticalCoverage<'_> {
     fn retrieve_matches(&self, lhs: &Match) -> Box<dyn Iterator<Item = Result<Match>>> {
         let n_left = try_as_boxed_iter!(self.tok_helper.left_token_for(lhs.node));
         let n_right = try_as_boxed_iter!(self.tok_helper.right_token_for(lhs.node));

graphannis/src/annis/db/aql/operators/inclusion.rs

@@ -86,13 +86,13 @@ impl<'a> Inclusion<'a> {
     }
 }
 
-impl<'a> std::fmt::Display for Inclusion<'a> {
+impl std::fmt::Display for Inclusion<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "_i_")
     }
 }
 
-impl<'a> BinaryOperatorBase for Inclusion<'a> {
+impl BinaryOperatorBase for Inclusion<'_> {
     fn filter_match(&self, lhs: &Match, rhs: &Match) -> Result<bool> {
         let left_right_lhs = self.tok_helper.left_right_token_for(lhs.node)?;
         let left_right_rhs = self.tok_helper.left_right_token_for(rhs.node)?;
@@ -160,7 +160,7 @@ enum NodeType {
     Other(NodeID),
 }
 
-impl<'a> BinaryOperatorIndex for Inclusion<'a> {
+impl BinaryOperatorIndex for Inclusion<'_> {
     fn retrieve_matches<'b>(&'b self, lhs: &Match) -> Box<dyn Iterator<Item = Result<Match>> + 'b> {
         let left_right_token = try_as_boxed_iter!(self.tok_helper.left_right_token_for(lhs.node));
         if let (Some(start_lhs), Some(end_lhs)) = left_right_token {

graphannis/src/annis/db/aql/operators/leftalignment.rs

@@ -56,13 +56,13 @@ impl<'a> LeftAlignment<'a> {
     }
 }
 
-impl<'a> std::fmt::Display for LeftAlignment<'a> {
+impl std::fmt::Display for LeftAlignment<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "_l_")
     }
 }
 
-impl<'a> BinaryOperatorBase for LeftAlignment<'a> {
+impl BinaryOperatorBase for LeftAlignment<'_> {
     fn filter_match(&self, lhs: &Match, rhs: &Match) -> Result<bool> {
         if let (Some(lhs_token), Some(rhs_token)) = (
             self.tok_helper.left_token_for(lhs.node)?,
@@ -101,7 +101,7 @@ impl<'a> BinaryOperatorBase for LeftAlignment<'a> {
     }
 }
 
-impl<'a> BinaryOperatorIndex for LeftAlignment<'a> {
+impl BinaryOperatorIndex for LeftAlignment<'_> {
     fn retrieve_matches(&self, lhs: &Match) -> Box<dyn Iterator<Item = Result<Match>>> {
         let mut aligned = Vec::default();
 

graphannis/src/annis/db/aql/operators/near.rs

@@ -118,13 +118,13 @@ impl<'a> Near<'a> {
     }
 }
 
-impl<'a> std::fmt::Display for Near<'a> {
+impl std::fmt::Display for Near<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "^{}", self.spec)
     }
 }
 
-impl<'a> BinaryOperatorBase for Near<'a> {
+impl BinaryOperatorBase for Near<'_> {
     fn filter_match(&self, lhs: &Match, rhs: &Match) -> Result<bool> {
         let start_end_forward = if self.spec.segmentation.is_some() {
             (lhs.node, rhs.node)
@@ -195,7 +195,7 @@ impl<'a> BinaryOperatorBase for Near<'a> {
     }
 }
 
-impl<'a> BinaryOperatorIndex for Near<'a> {
+impl BinaryOperatorIndex for Near<'_> {
     fn retrieve_matches(&self, lhs: &Match) -> Box<dyn Iterator<Item = Result<Match>>> {
         let start_forward = if self.spec.segmentation.is_some() {
             Some(lhs.node)

graphannis/src/annis/db/aql/operators/negated_op.rs

@@ -54,15 +54,15 @@ pub struct NegatedOp<'a> {
     negated_op: BinaryOperator<'a>,
 }
 
-impl<'a> Display for NegatedOp<'a> {
+impl Display for NegatedOp<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "!",)?;
         self.negated_op.fmt(f)?;
         Ok(())
     }
 }
 
-impl<'a> BinaryOperatorBase for NegatedOp<'a> {
+impl BinaryOperatorBase for NegatedOp<'_> {
     fn filter_match(&self, lhs: &Match, rhs: &Match) -> Result<bool> {
         // Invert the filtered logic by the actual operator
         let orig = self.negated_op.filter_match(lhs, rhs)?;