Add a helper for extending a span to include any trailing whitespace

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -346,7 +346,7 @@ impl<'a> AstValidator<'a> {
             in_impl: matches!(parent, TraitOrTraitImpl::TraitImpl { .. }),
             const_context_label: parent_constness,
             remove_const_sugg: (
-                self.session.source_map().span_extend_while(span, |c| c == ' ').unwrap_or(span),
+                self.session.source_map().span_extend_while_whitespace(span),
                 match parent_constness {
                     Some(_) => rustc_errors::Applicability::MachineApplicable,
                     None => rustc_errors::Applicability::MaybeIncorrect,

compiler/rustc_hir_typeck/src/expr.rs

@@ -2023,8 +2023,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 .tcx
                 .sess
                 .source_map()
-                .span_extend_while(range_start.span, |c| c.is_whitespace())
+                .span_extend_while_whitespace(range_start.span)
-                .unwrap_or(range_start.span)
                 .shrink_to_hi()
                 .to(range_end.span);
 

compiler/rustc_infer/src/infer/error_reporting/suggest.rs

@@ -766,8 +766,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
             self.tcx
                 .sess
                 .source_map()
-                .span_extend_while(last_expr.span, |c| c.is_whitespace())
+                .span_extend_while_whitespace(last_expr.span)
-                .ok()?
                 .shrink_to_hi()
                 .with_hi(last_stmt.span.hi())
         };
@@ -874,10 +873,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                         format!(" {ident} ")
                     };
                     let left_span = sm.span_through_char(blk.span, '{').shrink_to_hi();
-                    (
+                    (sm.span_extend_while_whitespace(left_span), sugg)
-                        sm.span_extend_while(left_span, |c| c.is_whitespace()).unwrap_or(left_span),
-                        sugg,
-                    )
                 };
                 Some(SuggestRemoveSemiOrReturnBinding::Add { sp: span, code: sugg, ident: *ident })
             }

compiler/rustc_lint/src/context/diagnostics.rs

@@ -215,10 +215,7 @@ pub(super) fn builtin(sess: &Session, diagnostic: BuiltinLintDiag, diag: &mut Di
             if let Some(deletion_span) = deletion_span {
                 let msg = "elide the single-use lifetime";
                 let (use_span, replace_lt) = if elide {
-                    let use_span = sess
+                    let use_span = sess.source_map().span_extend_while_whitespace(use_span);
-                        .source_map()
-                        .span_extend_while(use_span, char::is_whitespace)
-                        .unwrap_or(use_span);
                     (use_span, String::new())
                 } else {
                     (use_span, "'_".to_owned())

compiler/rustc_span/src/source_map.rs

@@ -654,6 +654,12 @@ impl SourceMap {
         })
     }
 
+    /// Extends the span to include any trailing whitespace, or returns the original
+    /// span if a `SpanSnippetError` was encountered.
+    pub fn span_extend_while_whitespace(&self, span: Span) -> Span {
+        self.span_extend_while(span, char::is_whitespace).unwrap_or(span)
+    }
+
     /// Extends the given `Span` to previous character while the previous character matches the predicate
     pub fn span_extend_prev_while(
         &self,
@@ -1034,12 +1040,9 @@ impl SourceMap {
     /// // ^^^^^^ input
     /// ```
     pub fn mac_call_stmt_semi_span(&self, mac_call: Span) -> Option<Span> {
-        let span = self.span_extend_while(mac_call, char::is_whitespace).ok()?;
+        let span = self.span_extend_while_whitespace(mac_call);
-        let span = span.shrink_to_hi().with_hi(BytePos(span.hi().0.checked_add(1)?));
+        let span = self.next_point(span);
-        if self.span_to_snippet(span).as_deref() != Ok(";") {
+        if self.span_to_snippet(span).as_deref() == Ok(";") { Some(span) } else { None }
-            return None;
-        }
-        Some(span)
     }
 }
 

compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs

@@ -1592,8 +1592,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                     .tcx
                     .sess
                     .source_map()
-                    .span_extend_while(expr_span, char::is_whitespace)
+                    .span_extend_while_whitespace(expr_span)
-                    .unwrap_or(expr_span)
                     .shrink_to_hi()
                     .to(await_expr.span.shrink_to_hi());
                 err.span_suggestion(
@@ -4851,10 +4850,7 @@ pub fn suggest_desugaring_async_fn_to_impl_future_in_trait<'tcx>(
     let hir::IsAsync::Async(async_span) = sig.header.asyncness else {
         return None;
     };
-    let Ok(async_span) = tcx.sess.source_map().span_extend_while(async_span, |c| c.is_whitespace())
+    let async_span = tcx.sess.source_map().span_extend_while_whitespace(async_span);
-    else {
-        return None;
-    };
 
     let future = tcx.hir_node_by_def_id(opaque_def_id).expect_item().expect_opaque_ty();
     let [hir::GenericBound::Trait(trait_ref, _)] = future.bounds else {

src/tools/clippy/clippy_lints/src/lifetimes.rs

@@ -294,8 +294,7 @@ fn elision_suggestions(
                         let span = cx
                             .sess()
                             .source_map()
-                            .span_extend_while(usage.ident.span, |ch| ch.is_ascii_whitespace())
+                            .span_extend_while_whitespace(usage.ident.span);
-                            .unwrap_or(usage.ident.span);
 
                         (span, String::new())
                     },