refactor: centralize range rewriting in src/range.rs

Move the range rewrite logic from `src/exrp.rs` to `src/range.rs`. There are a
few different places where we rewrite ranges so centralizing the logic in a
single location is ideal.

Author: ytmimi

src/expr.rs

@@ -23,6 +23,7 @@ use crate::macros::{MacroPosition, rewrite_macro};
 use crate::matches::rewrite_match;
 use crate::overflow::{self, IntoOverflowableItem, OverflowableItem};
 use crate::pairs::{PairParts, rewrite_all_pairs, rewrite_pair};
+use crate::range::rewrite_range;
 use crate::rewrite::{Rewrite, RewriteContext, RewriteError, RewriteErrorExt, RewriteResult};
 use crate::shape::{Indent, Shape};
 use crate::source_map::{LineRangeUtils, SpanUtils};
@@ -315,78 +316,13 @@ pub(crate) fn format_expr(
             shape,
             SeparatorPlace::Back,
         ),
-        ast::ExprKind::Range(ref lhs, ref rhs, limits) => {
-            let delim = match limits {
-                ast::RangeLimits::HalfOpen => "..",
-                ast::RangeLimits::Closed => "..=",
-            };
-
-            fn needs_space_before_range(context: &RewriteContext<'_>, lhs: &ast::Expr) -> bool {
-                match lhs.kind {
-                    ast::ExprKind::Lit(token_lit) => lit_ends_in_dot(&token_lit, context),
-                    ast::ExprKind::Unary(_, ref expr) => needs_space_before_range(context, expr),
-                    ast::ExprKind::Binary(_, _, ref rhs_expr) => {
-                        needs_space_before_range(context, rhs_expr)
-                    }
-                    _ => false,
-                }
-            }
-
-            fn needs_space_after_range(rhs: &ast::Expr) -> bool {
-                // Don't format `.. ..` into `....`, which is invalid.
-                //
-                // This check is unnecessary for `lhs`, because a range
-                // starting from another range needs parentheses as `(x ..) ..`
-                // (`x .. ..` is a range from `x` to `..`).
-                matches!(rhs.kind, ast::ExprKind::Range(None, _, _))
-            }
-
-            let default_sp_delim = |lhs: Option<&ast::Expr>, rhs: Option<&ast::Expr>| {
-                let space_if = |b: bool| if b { " " } else { "" };
-
-                format!(
-                    "{}{}{}",
-                    lhs.map_or("", |lhs| space_if(needs_space_before_range(context, lhs))),
-                    delim,
-                    rhs.map_or("", |rhs| space_if(needs_space_after_range(rhs))),
-                )
-            };
-
-            match (lhs.as_ref().map(|x| &**x), rhs.as_ref().map(|x| &**x)) {
-                (Some(lhs), Some(rhs)) => {
-                    let sp_delim = if context.config.spaces_around_ranges() {
-                        format!(" {delim} ")
-                    } else {
-                        default_sp_delim(Some(lhs), Some(rhs))
-                    };
-                    rewrite_pair(
-                        &*lhs,
-                        &*rhs,
-                        PairParts::infix(&sp_delim),
-                        context,
-                        shape,
-                        context.config.binop_separator(),
-                    )
-                }
-                (None, Some(rhs)) => {
-                    let sp_delim = if context.config.spaces_around_ranges() {
-                        format!("{delim} ")
-                    } else {
-                        default_sp_delim(None, Some(rhs))
-                    };
-                    rewrite_unary_prefix(context, &sp_delim, &*rhs, shape)
-                }
-                (Some(lhs), None) => {
-                    let sp_delim = if context.config.spaces_around_ranges() {
-                        format!(" {delim}")
-                    } else {
-                        default_sp_delim(Some(lhs), None)
-                    };
-                    rewrite_unary_suffix(context, &sp_delim, &*lhs, shape)
-                }
-                (None, None) => Ok(delim.to_owned()),
-            }
-        }
+        ast::ExprKind::Range(ref lhs, ref rhs, limits) => rewrite_range(
+            context,
+            shape,
+            lhs.as_deref(),
+            rhs.as_deref(),
+            limits.as_str(),
+        ),
         // We do not format these expressions yet, but they should still
         // satisfy our width restrictions.
         // Style Guide RFC for InlineAsm variant pending

src/lib.rs

@@ -84,6 +84,7 @@ mod overflow;
 mod pairs;
 mod parse;
 mod patterns;
+mod range;
 mod release_channel;
 mod reorder;
 mod rewrite;

src/range.rs

@@ -0,0 +1,78 @@
+use crate::expr::{lit_ends_in_dot, rewrite_unary_prefix, rewrite_unary_suffix};
+use crate::pairs::{PairParts, rewrite_pair};
+use crate::rewrite::{RewriteContext, RewriteResult};
+use crate::shape::Shape;
+
+use rustc_ast::ast;
+
+fn needs_space_before_range(context: &RewriteContext<'_>, lhs: &ast::Expr) -> bool {
+    match lhs.kind {
+        ast::ExprKind::Lit(token_lit) => lit_ends_in_dot(&token_lit, context),
+        ast::ExprKind::Unary(_, ref expr) => needs_space_before_range(context, expr),
+        ast::ExprKind::Binary(_, _, ref rhs_expr) => needs_space_before_range(context, rhs_expr),
+        _ => false,
+    }
+}
+
+fn needs_space_after_range(rhs: &ast::Expr) -> bool {
+    // Don't format `.. ..` into `....`, which is invalid.
+    //
+    // This check is unnecessary for `lhs`, because a range
+    // starting from another range needs parentheses as `(x ..) ..`
+    // (`x .. ..` is a range from `x` to `..`).
+    matches!(rhs.kind, ast::ExprKind::Range(None, _, _))
+}
+
+pub(crate) fn rewrite_range(
+    context: &RewriteContext<'_>,
+    shape: Shape,
+    lhs: Option<&ast::Expr>,
+    rhs: Option<&ast::Expr>,
+    delim: &str,
+) -> RewriteResult {
+    let default_sp_delim = |lhs: Option<&ast::Expr>, rhs: Option<&ast::Expr>| {
+        let space_if = |b: bool| if b { " " } else { "" };
+
+        format!(
+            "{}{}{}",
+            lhs.map_or("", |lhs| space_if(needs_space_before_range(context, lhs))),
+            delim,
+            rhs.map_or("", |rhs| space_if(needs_space_after_range(rhs))),
+        )
+    };
+
+    match (lhs.as_ref().map(|x| &**x), rhs.as_ref().map(|x| &**x)) {
+        (Some(lhs), Some(rhs)) => {
+            let sp_delim = if context.config.spaces_around_ranges() {
+                format!(" {delim} ")
+            } else {
+                default_sp_delim(Some(lhs), Some(rhs))
+            };
+            rewrite_pair(
+                &*lhs,
+                &*rhs,
+                PairParts::infix(&sp_delim),
+                context,
+                shape,
+                context.config.binop_separator(),
+            )
+        }
+        (None, Some(rhs)) => {
+            let sp_delim = if context.config.spaces_around_ranges() {
+                format!("{delim} ")
+            } else {
+                default_sp_delim(None, Some(rhs))
+            };
+            rewrite_unary_prefix(context, &sp_delim, &*rhs, shape)
+        }
+        (Some(lhs), None) => {
+            let sp_delim = if context.config.spaces_around_ranges() {
+                format!(" {delim}")
+            } else {
+                default_sp_delim(Some(lhs), None)
+            };
+            rewrite_unary_suffix(context, &sp_delim, &*lhs, shape)
+        }
+        (None, None) => Ok(delim.to_owned()),
+    }
+}