Add @rustbot reroll to pick a new reviewer

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>

Author: xizheyin

parser/src/command/assign.rs

@@ -22,6 +22,8 @@ pub enum AssignCommand {
     AssignUser { username: String },
     /// Corresponds to `r? [@]user`.
     RequestReview { name: String },
+    /// Corresponds to `@bot reroll`.
+    Reroll,
 }
 
 #[derive(PartialEq, Eq, Debug)]
@@ -55,6 +57,15 @@ impl AssignCommand {
             } else {
                 return Err(toks.error(ParseError::ExpectedEnd));
             }
+        } else if let Some(Token::Word("reroll")) = toks.peek_token()? {
+            toks.next_token()?;
+            if let Some(Token::Dot) | Some(Token::EndOfLine) = toks.peek_token()? {
+                toks.next_token()?;
+                *input = toks;
+                return Ok(Some(AssignCommand::Reroll));
+            } else {
+                return Err(toks.error(ParseError::ExpectedEnd));
+            }
         } else if let Some(Token::Word("assign")) = toks.peek_token()? {
             toks.next_token()?;
             if let Some(Token::Word(user)) = toks.next_token()? {
@@ -181,4 +192,10 @@ mod tests {
             )
         }
     }
+
+    #[test]
+    fn test_reroll() {
+        assert_eq!(parse("reroll."), Ok(Some(AssignCommand::Reroll)),);
+        assert_eq!(parse("reroll"), Ok(Some(AssignCommand::Reroll)),);
+    }
 }

src/handlers.rs

@@ -306,7 +306,7 @@ macro_rules! command_handlers {
                     // case, just ignore it.
                     if commands
                         .iter()
-                        .all(|cmd| matches!(cmd, Command::Assign(Ok(AssignCommand::RequestReview { .. }))))
+                        .all(|cmd| matches!(cmd, Command::Assign(Ok(AssignCommand::RequestReview { .. })) | Command::Assign(Ok(AssignCommand::Reroll))))
                     {
                         return;
                     }

src/handlers/assign.rs

@@ -5,6 +5,7 @@
 //! * `@rustbot assign @gh-user`: Assigns to the given user.
 //! * `@rustbot claim`: Assigns to the comment author.
 //! * `@rustbot release-assignment`: Removes the commenter's assignment.
+//! * `@rustbot reroll`: Assigns a new reviewer, excluding the current assignee.
 //! * `r? @user`: Assigns to the given user (PRs only).
 //!
 //! Note: this module does not handle review assignments issued from the
@@ -134,7 +135,7 @@ pub(super) async fn handle_input(
 
     // Don't auto-assign or welcome if the user manually set the assignee when opening.
     if event.issue.assignees.is_empty() {
-        let (assignee, from_comment) = determine_assignee(ctx, event, config, &diff).await?;
+        let (assignee, from_comment) = determine_assignee(ctx, event, config, &diff, &[]).await?;
         if assignee.as_deref() == Some(GHOST_ACCOUNT) {
             // "ghost" is GitHub's placeholder account for deleted accounts.
             // It is used here as a convenient way to prevent assignment. This
@@ -202,6 +203,7 @@ fn find_assign_command(ctx: &Context, event: &IssuesEvent) -> Option<String> {
     let mut input = Input::new(&event.issue.body, vec![&ctx.username]);
     input.find_map(|command| match command {
         Command::Assign(Ok(AssignCommand::RequestReview { name })) => Some(name),
+        Command::Assign(Ok(AssignCommand::Reroll)) => None,
         _ => None,
     })
 }
@@ -260,6 +262,7 @@ async fn determine_assignee(
     event: &IssuesEvent,
     config: &AssignConfig,
     diff: &[FileDiff],
+    exclude_assignees: &[String],
 ) -> anyhow::Result<(Option<String>, bool)> {
     let db_client = ctx.db.get().await;
     let teams = crate::team_data::teams(&ctx.github).await?;
@@ -279,8 +282,18 @@ async fn determine_assignee(
     // Errors fall-through to try fallback group.
     match find_reviewers_from_diff(config, diff) {
         Ok(candidates) if !candidates.is_empty() => {
-            match find_reviewer_from_names(&db_client, &teams, config, &event.issue, &candidates)
-                .await
+            let filtered_candidates = candidates
+                .into_iter()
+                .filter(|candidate| !exclude_assignees.contains(candidate))
+                .collect::<Vec<_>>();
+            match find_reviewer_from_names(
+                &db_client,
+                &teams,
+                config,
+                &event.issue,
+                &filtered_candidates,
+            )
+            .await
             {
                 Ok(assignee) => return Ok((Some(assignee), false)),
                 Err(FindReviewerError::TeamNotFound(team)) => log::warn!(
@@ -450,6 +463,44 @@ pub(super) async fn handle_command(
         let assignee = match cmd {
             AssignCommand::Claim => event.user().login.clone(),
             AssignCommand::AssignUser { username } => username,
+            AssignCommand::Reroll => {
+                // Get the current assignees and make sure we don't select them again
+                let current_assignees: Vec<String> =
+                    issue.assignees.iter().map(|a| a.login.clone()).collect();
+
+                if current_assignees.is_empty() {
+                    issue
+                        .post_comment(
+                            &ctx.github,
+                            "Cannot reroll because there is no current assignee.",
+                        )
+                        .await?;
+                    return Ok(());
+                }
+
+                // Get PR diff to find candidates
+                let Some(diff) = issue.diff(&ctx.github).await? else {
+                    log::error!("Failed to get PR diff for reroll.");
+                    return Ok(());
+                };
+
+                let Event::Issue(issue_event) = event else {
+                    log::error!("Failed to get IssuesEvent for reroll.");
+                    return Ok(());
+                };
+
+                let (Some(new_assignee), _) =
+                    determine_assignee(ctx, &issue_event, config, diff, &current_assignees).await?
+                else {
+                    issue.post_comment(
+                        &ctx.github,
+                        "Failed to determine new assignee for reroll. Please try r? @author to pick a new reviewer.",
+                    ).await?;
+                    return Ok(());
+                };
+
+                new_assignee
+            }
             AssignCommand::ReleaseAssignment => {
                 log::trace!(
                     "ignoring release on PR {:?}, must always have assignee",
@@ -542,6 +593,7 @@ pub(super) async fn handle_command(
                 };
             }
             AssignCommand::RequestReview { .. } => bail!("r? is only allowed on PRs."),
+            AssignCommand::Reroll => bail!("Reroll is only allowed on PRs."),
         };
         // Don't re-assign if aleady assigned, e.g. on comment edit
         if issue.contain_assignee(&to_assign) {