Fix clippy lints.

emilio · emilio · commit bb071313db0d · 2024-11-07T18:34:00.000+01:00
diff --git a/src/cow_rc_str.rs b/src/cow_rc_str.rs
@@ -51,7 +51,7 @@ impl<'a> From<&'a str> for CowRcStr<'a> {
     }
 }
 
-impl<'a> From<String> for CowRcStr<'a> {
+impl From<String> for CowRcStr<'_> {
     #[inline]
     fn from(s: String) -> Self {
         CowRcStr::from_rc(Rc::new(s))
@@ -84,7 +84,7 @@ impl<'a> CowRcStr<'a> {
     }
 }
 
-impl<'a> Clone for CowRcStr<'a> {
+impl Clone for CowRcStr<'_> {
     #[inline]
     fn clone(&self) -> Self {
         match self.unpack() {
@@ -99,7 +99,7 @@ impl<'a> Clone for CowRcStr<'a> {
     }
 }
 
-impl<'a> Drop for CowRcStr<'a> {
+impl Drop for CowRcStr<'_> {
     #[inline]
     fn drop(&mut self) {
         if let Err(ptr) = self.unpack() {
@@ -108,7 +108,7 @@ impl<'a> Drop for CowRcStr<'a> {
     }
 }
 
-impl<'a> ops::Deref for CowRcStr<'a> {
+impl ops::Deref for CowRcStr<'_> {
     type Target = str;
 
     #[inline]
@@ -119,65 +119,65 @@ impl<'a> ops::Deref for CowRcStr<'a> {
 
 // Boilerplate / trivial impls below.
 
-impl<'a> AsRef<str> for CowRcStr<'a> {
+impl AsRef<str> for CowRcStr<'_> {
     #[inline]
     fn as_ref(&self) -> &str {
         self
     }
 }
 
-impl<'a> Borrow<str> for CowRcStr<'a> {
+impl Borrow<str> for CowRcStr<'_> {
     #[inline]
     fn borrow(&self) -> &str {
         self
     }
 }
 
-impl<'a> Default for CowRcStr<'a> {
+impl Default for CowRcStr<'_> {
     #[inline]
     fn default() -> Self {
         Self::from("")
     }
 }
 
-impl<'a> hash::Hash for CowRcStr<'a> {
+impl hash::Hash for CowRcStr<'_> {
     #[inline]
     fn hash<H: hash::Hasher>(&self, hasher: &mut H) {
         str::hash(self, hasher)
     }
 }
 
-impl<'a, T: AsRef<str>> PartialEq<T> for CowRcStr<'a> {
+impl<T: AsRef<str>> PartialEq<T> for CowRcStr<'_> {
     #[inline]
     fn eq(&self, other: &T) -> bool {
         str::eq(self, other.as_ref())
     }
 }
 
-impl<'a, T: AsRef<str>> PartialOrd<T> for CowRcStr<'a> {
+impl<T: AsRef<str>> PartialOrd<T> for CowRcStr<'_> {
     #[inline]
     fn partial_cmp(&self, other: &T) -> Option<cmp::Ordering> {
         str::partial_cmp(self, other.as_ref())
     }
 }
 
-impl<'a> Eq for CowRcStr<'a> {}
+impl Eq for CowRcStr<'_> {}
 
-impl<'a> Ord for CowRcStr<'a> {
+impl Ord for CowRcStr<'_> {
     #[inline]
     fn cmp(&self, other: &Self) -> cmp::Ordering {
         str::cmp(self, other)
     }
 }
 
-impl<'a> fmt::Display for CowRcStr<'a> {
+impl fmt::Display for CowRcStr<'_> {
     #[inline]
     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         str::fmt(self, formatter)
     }
 }
 
-impl<'a> fmt::Debug for CowRcStr<'a> {
+impl fmt::Debug for CowRcStr<'_> {
     #[inline]
     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         str::fmt(self, formatter)
diff --git a/src/parser.rs b/src/parser.rs
@@ -76,7 +76,7 @@ pub enum BasicParseErrorKind<'i> {
     QualifiedRuleInvalid,
 }
 
-impl<'i> fmt::Display for BasicParseErrorKind<'i> {
+impl fmt::Display for BasicParseErrorKind<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             BasicParseErrorKind::UnexpectedToken(token) => {
@@ -176,7 +176,7 @@ impl<'i, T> ParseErrorKind<'i, T> {
     }
 }
 
-impl<'i, E: fmt::Display> fmt::Display for ParseErrorKind<'i, E> {
+impl<E: fmt::Display> fmt::Display for ParseErrorKind<'_, E> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             ParseErrorKind::Basic(ref basic) => basic.fmt(f),
@@ -218,13 +218,13 @@ impl<'i, T> ParseError<'i, T> {
     }
 }
 
-impl<'i, E: fmt::Display> fmt::Display for ParseError<'i, E> {
+impl<E: fmt::Display> fmt::Display for ParseError<'_, E> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         self.kind.fmt(f)
     }
 }
 
-impl<'i, E: fmt::Display + fmt::Debug> std::error::Error for ParseError<'i, E> {}
+impl<E: fmt::Display + fmt::Debug> std::error::Error for ParseError<'_, E> {}
 
 /// The owned input for a parser.
 pub struct ParserInput<'i> {
diff --git a/src/rules_and_declarations.rs b/src/rules_and_declarations.rs
@@ -241,7 +241,7 @@ impl<'i, 't, 'a, P, I, E> RuleBodyParser<'i, 't, 'a, P, I, E> {
 }
 
 /// https://drafts.csswg.org/css-syntax/#consume-a-blocks-contents
-impl<'i, 't, 'a, I, P, E: 'i> Iterator for RuleBodyParser<'i, 't, 'a, P, I, E>
+impl<'i, I, P, E: 'i> Iterator for RuleBodyParser<'i, '_, '_, P, I, E>
 where
     P: RuleBodyItemParser<'i, I, E>,
 {
@@ -349,7 +349,7 @@ where
 }
 
 /// `RuleListParser` is an iterator that yields `Ok(_)` for a rule or an `Err(..)` for an invalid one.
-impl<'i, 't, 'a, R, P, E: 'i> Iterator for StyleSheetParser<'i, 't, 'a, P>
+impl<'i, R, P, E: 'i> Iterator for StyleSheetParser<'i, '_, '_, P>
 where
     P: QualifiedRuleParser<'i, QualifiedRule = R, Error = E>
         + AtRuleParser<'i, AtRule = R, Error = E>,
diff --git a/src/serializer.rs b/src/serializer.rs
@@ -55,7 +55,7 @@ where
     Ok(())
 }
 
-impl<'a> ToCss for Token<'a> {
+impl ToCss for Token<'_> {
     fn to_css<W>(&self, dest: &mut W) -> fmt::Result
     where
         W: fmt::Write,
@@ -311,7 +311,7 @@ where
     }
 }
 
-impl<'a, W> fmt::Write for CssStringWriter<'a, W>
+impl<W> fmt::Write for CssStringWriter<'_, W>
 where
     W: fmt::Write,
 {
@@ -539,7 +539,7 @@ impl TokenSerializationType {
     }
 }
 
-impl<'a> Token<'a> {
+impl Token<'_> {
     /// Categorize a token into a type that determines when `/**/` needs to be inserted
     /// between two tokens when serialized next to each other without whitespace in between.
     ///
diff --git a/src/tests.rs b/src/tests.rs
@@ -773,7 +773,7 @@ where
     }
 }
 
-impl<'a> ToJson for CowRcStr<'a> {
+impl ToJson for CowRcStr<'_> {
     fn to_json(&self) -> Value {
         let s: &str = self;
         s.to_json()
@@ -946,7 +946,7 @@ impl<'i> QualifiedRuleParser<'i> for JsonParser {
     }
 }
 
-impl<'i> RuleBodyItemParser<'i, Value, ()> for JsonParser {
+impl RuleBodyItemParser<'_, Value, ()> for JsonParser {
     fn parse_qualified(&self) -> bool {
         true
     }
diff --git a/src/tokenizer.rs b/src/tokenizer.rs
@@ -190,7 +190,7 @@ pub enum Token<'a> {
     CloseCurlyBracket,
 }
 
-impl<'a> Token<'a> {
+impl Token<'_> {
     /// Return whether this token represents a parse error.
     ///
     /// `BadUrl` and `BadString` are tokenizer-level parse errors.
@@ -324,11 +324,11 @@ impl<'a> Tokenizer<'a> {
         let current = self.position();
         let start = self
             .slice(SourcePosition(0)..current)
-            .rfind(|c| matches!(c, '\r' | '\n' | '\x0C'))
+            .rfind(['\r', '\n', '\x0C'])
             .map_or(0, |start| start + 1);
         let end = self
             .slice(current..SourcePosition(self.input.len()))
-            .find(|c| matches!(c, '\r' | '\n' | '\x0C'))
+            .find(['\r', '\n', '\x0C'])
             .map_or(self.input.len(), |end| current.0 + end);
         self.slice(SourcePosition(start)..SourcePosition(end))
     }
@@ -720,9 +720,7 @@ fn check_for_source_map<'a>(tokenizer: &mut Tokenizer<'a>, contents: &'a str) {
     // If there is a source map directive, extract the URL.
     if contents.starts_with(directive) || contents.starts_with(directive_old) {
         let contents = &contents[directive.len()..];
-        tokenizer.source_map_url = contents
-            .split(|c| c == ' ' || c == '\t' || c == '\x0C' || c == '\r' || c == '\n')
-            .next()
+        tokenizer.source_map_url = contents.split([' ', '\t', '\x0C', '\r', '\n']).next();
     }
 
     let directive = "# sourceURL=";
@@ -731,9 +729,7 @@ fn check_for_source_map<'a>(tokenizer: &mut Tokenizer<'a>, contents: &'a str) {
     // If there is a source map directive, extract the URL.
     if contents.starts_with(directive) || contents.starts_with(directive_old) {
         let contents = &contents[directive.len()..];
-        tokenizer.source_url = contents
-            .split(|c| c == ' ' || c == '\t' || c == '\x0C' || c == '\r' || c == '\n')
-            .next()
+        tokenizer.source_url = contents.split([' ', '\t', '\x0C', '\r', '\n']).next()
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ impl<'a> From<&'a str> for CowRcStr<'a> {`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
`54`		`-impl<'a> From<String> for CowRcStr<'a> {`
	`54`	`+impl From<String> for CowRcStr<'_> {`
`55`	`55`	`#[inline]`
`56`	`56`	`fn from(s: String) -> Self {`
`57`	`57`	`CowRcStr::from_rc(Rc::new(s))`
`@@ -84,7 +84,7 @@ impl<'a> CowRcStr<'a> {`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`
`87`		`-impl<'a> Clone for CowRcStr<'a> {`
	`87`	`+impl Clone for CowRcStr<'_> {`
`88`	`88`	`#[inline]`
`89`	`89`	`fn clone(&self) -> Self {`
`90`	`90`	`match self.unpack() {`
`@@ -99,7 +99,7 @@ impl<'a> Clone for CowRcStr<'a> {`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
`102`		`-impl<'a> Drop for CowRcStr<'a> {`
	`102`	`+impl Drop for CowRcStr<'_> {`
`103`	`103`	`#[inline]`
`104`	`104`	`fn drop(&mut self) {`
`105`	`105`	`if let Err(ptr) = self.unpack() {`
`@@ -108,7 +108,7 @@ impl<'a> Drop for CowRcStr<'a> {`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`111`		`-impl<'a> ops::Deref for CowRcStr<'a> {`
	`111`	`+impl ops::Deref for CowRcStr<'_> {`
`112`	`112`	`type Target = str;`
`113`	`113`
`114`	`114`	`#[inline]`
`@@ -119,65 +119,65 @@ impl<'a> ops::Deref for CowRcStr<'a> {`
`119`	`119`
`120`	`120`	`// Boilerplate / trivial impls below.`
`121`	`121`
`122`		`-impl<'a> AsRef<str> for CowRcStr<'a> {`
	`122`	`+impl AsRef<str> for CowRcStr<'_> {`
`123`	`123`	`#[inline]`
`124`	`124`	`fn as_ref(&self) -> &str {`
`125`	`125`	`self`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
`129`		`-impl<'a> Borrow<str> for CowRcStr<'a> {`
	`129`	`+impl Borrow<str> for CowRcStr<'_> {`
`130`	`130`	`#[inline]`
`131`	`131`	`fn borrow(&self) -> &str {`
`132`	`132`	`self`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`
`136`		`-impl<'a> Default for CowRcStr<'a> {`
	`136`	`+impl Default for CowRcStr<'_> {`
`137`	`137`	`#[inline]`
`138`	`138`	`fn default() -> Self {`
`139`	`139`	`Self::from("")`
`140`	`140`	`}`
`141`	`141`	`}`
`142`	`142`
`143`		`-impl<'a> hash::Hash for CowRcStr<'a> {`
	`143`	`+impl hash::Hash for CowRcStr<'_> {`
`144`	`144`	`#[inline]`
`145`	`145`	`fn hash<H: hash::Hasher>(&self, hasher: &mut H) {`
`146`	`146`	`str::hash(self, hasher)`
`147`	`147`	`}`
`148`	`148`	`}`
`149`	`149`
`150`		`-impl<'a, T: AsRef<str>> PartialEq<T> for CowRcStr<'a> {`
	`150`	`+impl<T: AsRef<str>> PartialEq<T> for CowRcStr<'_> {`
`151`	`151`	`#[inline]`
`152`	`152`	`fn eq(&self, other: &T) -> bool {`
`153`	`153`	`str::eq(self, other.as_ref())`
`154`	`154`	`}`
`155`	`155`	`}`
`156`	`156`
`157`		`-impl<'a, T: AsRef<str>> PartialOrd<T> for CowRcStr<'a> {`
	`157`	`+impl<T: AsRef<str>> PartialOrd<T> for CowRcStr<'_> {`
`158`	`158`	`#[inline]`
`159`	`159`	`fn partial_cmp(&self, other: &T) -> Option<cmp::Ordering> {`
`160`	`160`	`str::partial_cmp(self, other.as_ref())`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`
`164`		`-impl<'a> Eq for CowRcStr<'a> {}`
	`164`	`+impl Eq for CowRcStr<'_> {}`
`165`	`165`
`166`		`-impl<'a> Ord for CowRcStr<'a> {`
	`166`	`+impl Ord for CowRcStr<'_> {`
`167`	`167`	`#[inline]`
`168`	`168`	`fn cmp(&self, other: &Self) -> cmp::Ordering {`
`169`	`169`	`str::cmp(self, other)`
`170`	`170`	`}`
`171`	`171`	`}`
`172`	`172`
`173`		`-impl<'a> fmt::Display for CowRcStr<'a> {`
	`173`	`+impl fmt::Display for CowRcStr<'_> {`
`174`	`174`	`#[inline]`
`175`	`175`	`fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {`
`176`	`176`	`str::fmt(self, formatter)`
`177`	`177`	`}`
`178`	`178`	`}`
`179`	`179`
`180`		`-impl<'a> fmt::Debug for CowRcStr<'a> {`
	`180`	`+impl fmt::Debug for CowRcStr<'_> {`
`181`	`181`	`#[inline]`
`182`	`182`	`fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {`
`183`	`183`	`str::fmt(self, formatter)`
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ pub enum BasicParseErrorKind<'i> {`
`76`	`76`	`QualifiedRuleInvalid,`
`77`	`77`	`}`
`78`	`78`
`79`		`-impl<'i> fmt::Display for BasicParseErrorKind<'i> {`
	`79`	`+impl fmt::Display for BasicParseErrorKind<'_> {`
`80`	`80`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`81`	`81`	`match self {`
`82`	`82`	`BasicParseErrorKind::UnexpectedToken(token) => {`
`@@ -176,7 +176,7 @@ impl<'i, T> ParseErrorKind<'i, T> {`
`176`	`176`	`}`
`177`	`177`	`}`
`178`	`178`
`179`		`-impl<'i, E: fmt::Display> fmt::Display for ParseErrorKind<'i, E> {`
	`179`	`+impl<E: fmt::Display> fmt::Display for ParseErrorKind<'_, E> {`
`180`	`180`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`181`	`181`	`match self {`
`182`	`182`	`ParseErrorKind::Basic(ref basic) => basic.fmt(f),`
`@@ -218,13 +218,13 @@ impl<'i, T> ParseError<'i, T> {`
`218`	`218`	`}`
`219`	`219`	`}`
`220`	`220`
`221`		`-impl<'i, E: fmt::Display> fmt::Display for ParseError<'i, E> {`
	`221`	`+impl<E: fmt::Display> fmt::Display for ParseError<'_, E> {`
`222`	`222`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`223`	`223`	`self.kind.fmt(f)`
`224`	`224`	`}`
`225`	`225`	`}`
`226`	`226`
`227`		`-impl<'i, E: fmt::Display + fmt::Debug> std::error::Error for ParseError<'i, E> {}`
	`227`	`+impl<E: fmt::Display + fmt::Debug> std::error::Error for ParseError<'_, E> {}`
`228`	`228`
`229`	`229`	`/// The owned input for a parser.`
`230`	`230`	`pub struct ParserInput<'i> {`
Original file line number	Diff line number	Diff line change
`@@ -241,7 +241,7 @@ impl<'i, 't, 'a, P, I, E> RuleBodyParser<'i, 't, 'a, P, I, E> {`
`241`	`241`	`}`
`242`	`242`
`243`	`243`	`/// https://drafts.csswg.org/css-syntax/#consume-a-blocks-contents`
`244`		`-impl<'i, 't, 'a, I, P, E: 'i> Iterator for RuleBodyParser<'i, 't, 'a, P, I, E>`
	`244`	`+impl<'i, I, P, E: 'i> Iterator for RuleBodyParser<'i, '_, '_, P, I, E>`
`245`	`245`	`where`
`246`	`246`	`P: RuleBodyItemParser<'i, I, E>,`
`247`	`247`	`{`
`@@ -349,7 +349,7 @@ where`
`349`	`349`	`}`
`350`	`350`
`351`	`351`	/// `RuleListParser` is an iterator that yields `Ok(_)` for a rule or an `Err(..)` for an invalid one.
`352`		`-impl<'i, 't, 'a, R, P, E: 'i> Iterator for StyleSheetParser<'i, 't, 'a, P>`
	`352`	`+impl<'i, R, P, E: 'i> Iterator for StyleSheetParser<'i, '_, '_, P>`
`353`	`353`	`where`
`354`	`354`	`P: QualifiedRuleParser<'i, QualifiedRule = R, Error = E>`
`355`	`355`	`+ AtRuleParser<'i, AtRule = R, Error = E>,`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ where`
`55`	`55`	`Ok(())`
`56`	`56`	`}`
`57`	`57`
`58`		`-impl<'a> ToCss for Token<'a> {`
	`58`	`+impl ToCss for Token<'_> {`
`59`	`59`	`fn to_css<W>(&self, dest: &mut W) -> fmt::Result`
`60`	`60`	`where`
`61`	`61`	`W: fmt::Write,`
`@@ -311,7 +311,7 @@ where`
`311`	`311`	`}`
`312`	`312`	`}`
`313`	`313`
`314`		`-impl<'a, W> fmt::Write for CssStringWriter<'a, W>`
	`314`	`+impl<W> fmt::Write for CssStringWriter<'_, W>`
`315`	`315`	`where`
`316`	`316`	`W: fmt::Write,`
`317`	`317`	`{`
`@@ -539,7 +539,7 @@ impl TokenSerializationType {`
`539`	`539`	`}`
`540`	`540`	`}`
`541`	`541`
`542`		`-impl<'a> Token<'a> {`
	`542`	`+impl Token<'_> {`
`543`	`543`	/// Categorize a token into a type that determines when `/**/` needs to be inserted
`544`	`544`	`/// between two tokens when serialized next to each other without whitespace in between.`
`545`	`545`	`///`
Original file line number	Diff line number	Diff line change
`@@ -773,7 +773,7 @@ where`
`773`	`773`	`}`
`774`	`774`	`}`
`775`	`775`
`776`		`-impl<'a> ToJson for CowRcStr<'a> {`
	`776`	`+impl ToJson for CowRcStr<'_> {`
`777`	`777`	`fn to_json(&self) -> Value {`
`778`	`778`	`let s: &str = self;`
`779`	`779`	`s.to_json()`
`@@ -946,7 +946,7 @@ impl<'i> QualifiedRuleParser<'i> for JsonParser {`
`946`	`946`	`}`
`947`	`947`	`}`
`948`	`948`
`949`		`-impl<'i> RuleBodyItemParser<'i, Value, ()> for JsonParser {`
	`949`	`+impl RuleBodyItemParser<'_, Value, ()> for JsonParser {`
`950`	`950`	`fn parse_qualified(&self) -> bool {`
`951`	`951`	`true`
`952`	`952`	`}`