Add MatchesMacroItem and imp Rewrite, Spanned, and IntoOverflowableItem

These traits will make it easier to implement rewriting matches! in terms
of `overflow::rewrite_with_*` methods.

Author: ytmimi

src/macros.rs

@@ -27,8 +27,10 @@ use crate::comment::{
 use crate::config::lists::*;
 use crate::expr::{rewrite_array, rewrite_assign_rhs, RhsAssignKind};
 use crate::lists::{itemize_list, write_list, ListFormatting};
+use crate::matches::rewrite_guard;
 use crate::overflow;
 use crate::parse::macros::lazy_static::parse_lazy_static;
+use crate::parse::macros::matches::MatchesMacroItem;
 use crate::parse::macros::{parse_expr, parse_macro_args, ParsedMacroArgs};
 use crate::rewrite::{Rewrite, RewriteContext};
 use crate::shape::{Indent, Shape};
@@ -1313,6 +1315,19 @@ impl MacroBranch {
     }
 }
 
+impl Rewrite for MatchesMacroItem {
+    fn rewrite(&self, context: &RewriteContext<'_>, shape: crate::shape::Shape) -> Option<String> {
+        match self {
+            Self::Expr(expr) => expr.rewrite(context, shape),
+            Self::Arm(pat, guard) => {
+                let pats_str = pat.rewrite(context, shape)?;
+                let guard_str = rewrite_guard(context, guard, shape, &pats_str)?;
+                Some(pats_str + &guard_str)
+            }
+        }
+    }
+}
+
 /// Format `lazy_static!` from <https://crates.io/crates/lazy_static>.
 ///
 /// # Expected syntax

src/overflow.rs

@@ -18,6 +18,7 @@ use crate::lists::{
     definitive_tactic, itemize_list, write_list, ListFormatting, ListItem, Separator,
 };
 use crate::macros::MacroArg;
+use crate::parse::macros::matches::MatchesMacroItem;
 use crate::patterns::{can_be_overflowed_pat, TuplePatField};
 use crate::rewrite::{Rewrite, RewriteContext};
 use crate::shape::Shape;
@@ -76,6 +77,7 @@ pub(crate) enum OverflowableItem<'a> {
     TuplePatField(&'a TuplePatField<'a>),
     Ty(&'a ast::Ty),
     Pat(&'a ast::Pat),
+    MatchesMacroItem(&'a MatchesMacroItem),
 }
 
 impl<'a> Rewrite for OverflowableItem<'a> {
@@ -116,6 +118,7 @@ impl<'a> OverflowableItem<'a> {
             OverflowableItem::TuplePatField(pat) => f(*pat),
             OverflowableItem::Ty(ty) => f(*ty),
             OverflowableItem::Pat(pat) => f(*pat),
+            OverflowableItem::MatchesMacroItem(item) => f(*item),
         }
     }
 
@@ -137,7 +140,9 @@ impl<'a> OverflowableItem<'a> {
     pub(crate) fn is_expr(&self) -> bool {
         matches!(
             self,
-            OverflowableItem::Expr(..) | OverflowableItem::MacroArg(MacroArg::Expr(..))
+            OverflowableItem::Expr(..)
+                | OverflowableItem::MacroArg(MacroArg::Expr(..))
+                | OverflowableItem::MatchesMacroItem(MatchesMacroItem::Expr(..))
         )
     }
 
@@ -153,6 +158,7 @@ impl<'a> OverflowableItem<'a> {
         match self {
             OverflowableItem::Expr(expr) => Some(expr),
             OverflowableItem::MacroArg(MacroArg::Expr(ref expr)) => Some(expr),
+            OverflowableItem::MatchesMacroItem(MatchesMacroItem::Expr(expr)) => Some(expr),
             _ => None,
         }
     }
@@ -233,7 +239,10 @@ macro_rules! impl_into_overflowable_item_for_rustfmt_types {
 }
 
 impl_into_overflowable_item_for_ast_node!(Expr, GenericParam, NestedMetaItem, FieldDef, Ty, Pat);
-impl_into_overflowable_item_for_rustfmt_types!([MacroArg], [SegmentParam, TuplePatField]);
+impl_into_overflowable_item_for_rustfmt_types!(
+    [MacroArg, MatchesMacroItem],
+    [SegmentParam, TuplePatField]
+);
 
 pub(crate) fn into_overflowable_list<'a, T>(
     iter: impl Iterator<Item = &'a T>,

src/parse/macros/matches.rs

@@ -52,3 +52,18 @@ pub(crate) fn parse_matches(context: &RewriteContext<'_>, ts: TokenStream) -> Op
     };
     Some(Matches { expr, pat, guard })
 }
+
+impl Matches {
+    pub(crate) fn items(self) -> [MatchesMacroItem; 2] {
+        [
+            MatchesMacroItem::Expr(self.expr),
+            MatchesMacroItem::Arm(self.pat, self.guard),
+        ]
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum MatchesMacroItem {
+    Expr(P<ast::Expr>),
+    Arm(P<ast::Pat>, Option<P<ast::Expr>>),
+}

src/spanned.rs

@@ -4,6 +4,7 @@ use rustc_ast::{ast, ptr};
 use rustc_span::{source_map, Span};
 
 use crate::macros::MacroArg;
+use crate::parse::macros::matches::MatchesMacroItem;
 use crate::utils::{mk_sp, outer_attributes};
 
 /// Spanned returns a span including attributes, if available.
@@ -197,3 +198,13 @@ impl Spanned for ast::NestedMetaItem {
         self.span()
     }
 }
+
+impl Spanned for MatchesMacroItem {
+    fn span(&self) -> rustc_span::Span {
+        match self {
+            Self::Expr(expr) => expr.span,
+            Self::Arm(pat, None) => pat.span,
+            Self::Arm(pat, Some(guard)) => mk_sp(pat.span.lo(), guard.span.hi()),
+        }
+    }
+}