Run Clippy

github-graphql/src/lib.rs

@@ -323,17 +323,11 @@ pub mod project_items {
 
     impl ProjectV2Item {
         pub fn status(&self) -> Option<&str> {
-            let Some(ref status) = self.status else {
-                return None;
-            };
-            status.as_str()
+            self.status.as_ref()?.as_str()
         }
 
         pub fn date(&self) -> Option<Date> {
-            let Some(ref date) = self.date else {
-                return None;
-            };
-            date.as_date()
+            self.date.as_ref()?.as_date()
         }
     }
 

parser/Cargo.toml

@@ -2,7 +2,7 @@
 name = "parser"
 version = "0.1.0"
 authors = ["Mark Rousskov <[email protected]>"]
-edition = "2021"
+edition = "2024"
 
 [dependencies]
 pulldown-cmark = "0.12.0"

parser/src/command.rs

@@ -64,7 +64,7 @@ impl<'a> Input<'a> {
     pub fn new(input: &'a str, bot: Vec<&'a str>) -> Input<'a> {
         let bots: Vec<_> = bot.iter().map(|bot| format!(r"(?:@{bot}\b)")).collect();
         let bot_re = Regex::new(&format!(
-            r#"(?i)(?P<review>\br\?)|{bots}"#,
+            r"(?i)(?P<review>\br\?)|{bots}",
             bots = bots.join("|")
         ))
         .unwrap();
@@ -140,13 +140,12 @@ impl<'a> Input<'a> {
             &original_tokenizer,
         ));
 
-        if success.len() > 1 {
-            panic!(
-                "succeeded parsing {:?} to multiple commands: {:?}",
-                &self.all[self.parsed..],
-                success
-            );
-        }
+        assert!(
+            success.len() <= 1,
+            "succeeded parsing {:?} to multiple commands: {:?}",
+            &self.all[self.parsed..],
+            success
+        );
 
         let (mut tok, c) = success.pop()?;
         // if we errored out while parsing the command do not move the input forwards
@@ -201,7 +200,7 @@ impl<'a> Iterator for Input<'a> {
     }
 }
 
-impl<'a> Command<'a> {
+impl Command<'_> {
     pub fn is_ok(&self) -> bool {
         match self {
             Command::Relabel(r) => r.is_ok(),

parser/src/command/assign.rs

@@ -48,12 +48,12 @@ impl AssignCommand {
         let mut toks = input.clone();
         if let Some(Token::Word("claim")) = toks.peek_token()? {
             toks.next_token()?;
-            if let Some(Token::Dot) | Some(Token::EndOfLine) = toks.peek_token()? {
+            if let Some(Token::Dot | Token::EndOfLine) = toks.peek_token()? {
                 toks.next_token()?;
                 *input = toks;
-                return Ok(Some(AssignCommand::Claim));
+                Ok(Some(AssignCommand::Claim))
             } else {
-                return Err(toks.error(ParseError::ExpectedEnd));
+                Err(toks.error(ParseError::ExpectedEnd))
             }
         } else if let Some(Token::Word("assign")) = toks.peek_token()? {
             toks.next_token()?;
@@ -63,22 +63,22 @@ impl AssignCommand {
                         username: user[1..].to_owned(),
                     }))
                 } else {
-                    return Err(toks.error(ParseError::MentionUser));
+                    Err(toks.error(ParseError::MentionUser))
                 }
             } else {
-                return Err(toks.error(ParseError::NoUser));
+                Err(toks.error(ParseError::NoUser))
             }
         } else if let Some(Token::Word("release-assignment" | "unclaim")) = toks.peek_token()? {
             toks.next_token()?;
-            if let Some(Token::Dot) | Some(Token::EndOfLine) = toks.peek_token()? {
+            if let Some(Token::Dot | Token::EndOfLine) = toks.peek_token()? {
                 toks.next_token()?;
                 *input = toks;
-                return Ok(Some(AssignCommand::ReleaseAssignment));
+                Ok(Some(AssignCommand::ReleaseAssignment))
             } else {
-                return Err(toks.error(ParseError::ExpectedEnd));
+                Err(toks.error(ParseError::ExpectedEnd))
             }
         } else {
-            return Ok(None);
+            Ok(None)
         }
     }
 

parser/src/command/concern.rs

@@ -28,11 +28,11 @@ impl ConcernCommand {
         if let Some(Token::Word(mut action @ ("concern" | "resolve"))) = toks.peek_token()? {
             toks.next_token()?;
 
-            if action == "concern" {
-                if let Some(Token::Word(sub_action @ "resolve")) = toks.peek_token()? {
-                    toks.next_token()?;
-                    action = sub_action;
-                }
+            if action == "concern"
+                && let Some(Token::Word(sub_action @ "resolve")) = toks.peek_token()?
+            {
+                toks.next_token()?;
+                action = sub_action;
             }
 
             let title = toks.take_line()?.trim().to_string();

parser/src/command/nominate.rs

@@ -55,26 +55,23 @@ impl NominateCommand {
         let style = match toks.peek_token()? {
             Some(Token::Word("beta-nominate")) => Style::Beta,
             Some(Token::Word("nominate")) => Style::Decision,
-            Some(Token::Word("beta-accept")) => Style::BetaApprove,
-            Some(Token::Word("beta-approve")) => Style::BetaApprove,
+            Some(Token::Word("beta-accept" | "beta-approve")) => Style::BetaApprove,
             None | Some(_) => return Ok(None),
         };
         toks.next_token()?;
-        let team = if style != Style::BetaApprove {
-            if let Some(Token::Word(team)) = toks.next_token()? {
-                team.to_owned()
-            } else {
-                return Err(toks.error(ParseError::NoTeam));
-            }
-        } else {
+        let team = if style == Style::BetaApprove {
             String::new()
+        } else if let Some(Token::Word(team)) = toks.next_token()? {
+            team.to_owned()
+        } else {
+            return Err(toks.error(ParseError::NoTeam));
         };
-        if let Some(Token::Dot) | Some(Token::EndOfLine) = toks.peek_token()? {
+        if let Some(Token::Dot | Token::EndOfLine) = toks.peek_token()? {
             toks.next_token()?;
             *input = toks;
-            return Ok(Some(NominateCommand { team, style }));
+            Ok(Some(NominateCommand { team, style }))
         } else {
-            return Err(toks.error(ParseError::ExpectedEnd));
+            Err(toks.error(ParseError::ExpectedEnd))
         }
     }
 }

parser/src/command/ping.rs

@@ -44,15 +44,15 @@ impl PingCommand {
             } else {
                 return Err(toks.error(ParseError::NoTeam));
             };
-            if let Some(Token::Dot) | Some(Token::EndOfLine) = toks.peek_token()? {
+            if let Some(Token::Dot | Token::EndOfLine) = toks.peek_token()? {
                 toks.next_token()?;
                 *input = toks;
-                return Ok(Some(PingCommand { team }));
+                Ok(Some(PingCommand { team }))
             } else {
-                return Err(toks.error(ParseError::ExpectedEnd));
+                Err(toks.error(ParseError::ExpectedEnd))
             }
         } else {
-            return Ok(None);
+            Ok(None)
         }
     }
 }

parser/src/command/relabel.rs

@@ -51,9 +51,9 @@ impl Label {
 }
 
 impl std::ops::Deref for Label {
-    type Target = String;
-    fn deref(&self) -> &String {
-        &self.0
+    type Target = str;
+    fn deref(&self) -> &str {
+        self.0.as_str()
     }
 }
 
@@ -68,13 +68,13 @@ impl LabelDelta {
                 return Err(input.error(ParseError::ExpectedLabelDelta));
             }
         };
-        if delta.starts_with('+') {
+        if let Some(label) = delta.strip_prefix('+') {
             Ok(LabelDelta::Add(
-                Label::parse(&delta[1..]).map_err(|e| input.error(e))?,
+                Label::parse(label).map_err(|e| input.error(e))?,
             ))
-        } else if delta.starts_with('-') {
+        } else if let Some(label) = delta.strip_prefix('-') {
             Ok(LabelDelta::Remove(
-                Label::parse(&delta[1..]).map_err(|e| input.error(e))?,
+                Label::parse(label).map_err(|e| input.error(e))?,
             ))
         } else {
             Ok(LabelDelta::Add(
@@ -85,8 +85,7 @@ impl LabelDelta {
 
     pub fn label(&self) -> &Label {
         match self {
-            LabelDelta::Add(l) => l,
-            LabelDelta::Remove(l) => l,
+            LabelDelta::Add(l) | LabelDelta::Remove(l) => l,
         }
     }
 }
@@ -129,9 +128,7 @@ impl RelabelCommand {
             toks.eat_token(Token::Comma)?;
             toks.eat_token(Token::Word("and"))?;
 
-            if let Some(Token::Semi) | Some(Token::Dot) | Some(Token::EndOfLine) =
-                toks.peek_token()?
-            {
+            if let Some(Token::Semi | Token::Dot | Token::EndOfLine) = toks.peek_token()? {
                 toks.next_token()?;
                 *input = toks;
                 return Ok(Some(RelabelCommand(deltas)));

parser/src/command/shortcut.rs

@@ -33,21 +33,21 @@ impl fmt::Display for ParseError {
 
 impl ShortcutCommand {
     pub fn parse<'a>(input: &mut Tokenizer<'a>) -> Result<Option<Self>, Error<'a>> {
-        let mut shortcuts = HashMap::new();
-        shortcuts.insert("ready", ShortcutCommand::Ready);
-        shortcuts.insert("review", ShortcutCommand::Ready);
-        shortcuts.insert("reviewer", ShortcutCommand::Ready);
-        shortcuts.insert("author", ShortcutCommand::Author);
-        shortcuts.insert("blocked", ShortcutCommand::Blocked);
+        let shortcuts = HashMap::from([
+            ("ready", ShortcutCommand::Ready),
+            ("review", ShortcutCommand::Ready),
+            ("reviewer", ShortcutCommand::Ready),
+            ("author", ShortcutCommand::Author),
+            ("blocked", ShortcutCommand::Blocked),
+        ]);
 
         let mut toks = input.clone();
         if let Some(Token::Word(word)) = toks.peek_token()? {
-            if !shortcuts.contains_key(word) {
+            let Some(command) = shortcuts.get(word) else {
                 return Ok(None);
-            }
+            };
             toks.next_token()?;
             *input = toks;
-            let command = shortcuts.get(word).unwrap();
             return Ok(Some(*command));
         }
         Ok(None)
@@ -57,7 +57,7 @@ impl ShortcutCommand {
 #[cfg(test)]
 fn parse(input: &str) -> Result<Option<ShortcutCommand>, Error<'_>> {
     let mut toks = Tokenizer::new(input);
-    Ok(ShortcutCommand::parse(&mut toks)?)
+    ShortcutCommand::parse(&mut toks)
 }
 
 #[test]

parser/src/error.rs

@@ -8,25 +8,25 @@ pub struct Error<'a> {
     pub source: Box<dyn error::Error + Send>,
 }
 
-impl<'a> PartialEq for Error<'a> {
+impl PartialEq for Error<'_> {
     fn eq(&self, other: &Self) -> bool {
         self.input == other.input && self.position == other.position
     }
 }
 
-impl<'a> error::Error for Error<'a> {
+impl error::Error for Error<'_> {
     fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         Some(&*self.source)
     }
 }
 
-impl<'a> Error<'a> {
+impl Error<'_> {
     pub fn position(&self) -> usize {
         self.position
     }
 }
 
-impl<'a> fmt::Display for Error<'a> {
+impl fmt::Display for Error<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let space = 10;
         let end = std::cmp::min(self.input.len(), self.position + space);

parser/src/ignore_block.rs

@@ -15,7 +15,7 @@ impl IgnoreBlocks {
             macro_rules! ignore_till_end {
                 ($p:pat) => {
                     let start = range.start;
-                    while let Some((event, range)) = parser.next() {
+                    for (event, range) in parser.by_ref() {
                         if let Event::End($p) = event {
                             ignore.push(start..range.end);
                             break;
@@ -28,15 +28,15 @@ impl IgnoreBlocks {
                     ignore_till_end!(TagEnd::CodeBlock);
                 }
                 Event::Start(Tag::Link { .. }) => {
-                    ignore_till_end!(TagEnd::Link { .. });
+                    ignore_till_end!(TagEnd::Link);
                 }
                 Event::Start(Tag::Image { .. }) => {
-                    ignore_till_end!(TagEnd::Image { .. });
+                    ignore_till_end!(TagEnd::Image);
                 }
                 Event::Start(Tag::BlockQuote(_)) => {
                     let start = range.start;
                     let mut count = 1;
-                    while let Some((event, range)) = parser.next() {
+                    for (event, range) in parser.by_ref() {
                         if let Event::Start(Tag::BlockQuote(_)) = event {
                             count += 1;
                         } else if let Event::End(TagEnd::BlockQuote(_)) = event {

parser/src/mentions.rs

@@ -10,15 +10,13 @@ pub fn get_mentions(input: &str) -> Vec<&str> {
 
     let mut mentions = Vec::new();
     for (idx, _) in input.match_indices('@') {
-        if let Some(previous) = input[..idx].chars().next_back() {
-            // A github username must stand apart from other text.
-            //
-            // Oddly enough, english letters do not work, but letters outside
-            // ASCII do work as separators; for now just go with this limited
-            // list.
-            if let 'a'..='z' | 'A'..='Z' | '0'..='9' = previous {
-                continue;
-            }
+        // A github username must stand apart from other text.
+        //
+        // Oddly enough, english letters do not work, but letters outside
+        // ASCII do work as separators; for now just go with this limited
+        // list.
+        if let Some('a'..='z' | 'A'..='Z' | '0'..='9') = input[..idx].chars().next_back() {
+            continue;
         }
         let mut saw_slash = false;
         let username_end = input