Rename consuming chaining methods on DiagnosticBuilder.

In #119606 I added them and used a `_mv` suffix, but that wasn't great.

A `with_` prefix has three different existing uses.
- Constructors, e.g. `Vec::with_capacity`.
- Wrappers that provide an environment to execute some code, e.g.
  `with_session_globals`.
- Consuming chaining methods, e.g. `Span::with_{lo,hi,ctxt}`.

The third case is exactly what we want, so this commit changes
`DiagnosticBuilder::foo_mv` to `DiagnosticBuilder::with_foo`.

Thanks to @compiler-errors for the suggestion.

Author: nnethercote

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -23,7 +23,7 @@ macro_rules! gate {
     ($visitor:expr, $feature:ident, $span:expr, $explain:expr, $help:expr) => {{
         if !$visitor.features.$feature && !$span.allows_unstable(sym::$feature) {
             feature_err(&$visitor.sess.parse_sess, sym::$feature, $span, $explain)
-                .help_mv($help)
+                .with_help($help)
                 .emit();
         }
     }};

compiler/rustc_attr/src/session_diagnostics.rs

@@ -55,11 +55,11 @@ impl<'a, G: EmissionGuarantee> IntoDiagnostic<'a, G> for UnknownMetaItem<'_> {
     fn into_diagnostic(self, dcx: &'a DiagCtxt, level: Level) -> DiagnosticBuilder<'a, G> {
         let expected = self.expected.iter().map(|name| format!("`{name}`")).collect::<Vec<_>>();
         DiagnosticBuilder::new(dcx, level, fluent::attr_unknown_meta_item)
-            .span_mv(self.span)
-            .code_mv(error_code!(E0541))
-            .arg_mv("item", self.item)
-            .arg_mv("expected", expected.join(", "))
-            .span_label_mv(self.span, fluent::attr_label)
+            .with_span(self.span)
+            .with_code(error_code!(E0541))
+            .with_arg("item", self.item)
+            .with_arg("expected", expected.join(", "))
+            .with_span_label(self.span, fluent::attr_label)
     }
 }
 

compiler/rustc_borrowck/src/borrowck_errors.rs

@@ -38,8 +38,8 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
             "cannot use {} because it was mutably borrowed",
             desc,
         )
-        .span_label_mv(borrow_span, format!("{borrow_desc} is borrowed here"))
-        .span_label_mv(span, format!("use of borrowed {borrow_desc}"))
+        .with_span_label(borrow_span, format!("{borrow_desc} is borrowed here"))
+        .with_span_label(span, format!("use of borrowed {borrow_desc}"))
     }
 
     pub(crate) fn cannot_mutably_borrow_multiply(
@@ -243,8 +243,8 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
             "cannot assign to {} because it is borrowed",
             desc,
         )
-        .span_label_mv(borrow_span, format!("{desc} is borrowed here"))
-        .span_label_mv(span, format!("{desc} is assigned to here but it was already borrowed"))
+        .with_span_label(borrow_span, format!("{desc} is borrowed here"))
+        .with_span_label(span, format!("{desc} is assigned to here but it was already borrowed"))
     }
 
     pub(crate) fn cannot_reassign_immutable(
@@ -297,7 +297,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
             ty,
             type_name,
         )
-        .span_label_mv(move_from_span, "cannot move out of here")
+        .with_span_label(move_from_span, "cannot move out of here")
     }
 
     pub(crate) fn cannot_move_out_of_interior_of_drop(
@@ -312,7 +312,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
             "cannot move out of type `{}`, which implements the `Drop` trait",
             container_ty,
         )
-        .span_label_mv(move_from_span, "cannot move out of here")
+        .with_span_label(move_from_span, "cannot move out of here")
     }
 
     pub(crate) fn cannot_act_on_moved_value(
@@ -368,8 +368,8 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
             immutable_place,
             immutable_section,
         )
-        .span_label_mv(mutate_span, format!("cannot {action}"))
-        .span_label_mv(immutable_span, format!("value is immutable in {immutable_section}"))
+        .with_span_label(mutate_span, format!("cannot {action}"))
+        .with_span_label(immutable_span, format!("value is immutable in {immutable_section}"))
     }
 
     pub(crate) fn cannot_borrow_across_coroutine_yield(
@@ -384,7 +384,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
             E0626,
             "borrow may still be in use when {coroutine_kind:#} yields",
         )
-        .span_label_mv(yield_span, "possible yield occurs here")
+        .with_span_label(yield_span, "possible yield occurs here")
     }
 
     pub(crate) fn cannot_borrow_across_destructor(
@@ -423,7 +423,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
             REFERENCE = reference_desc,
             LOCAL = path_desc,
         )
-        .span_label_mv(
+        .with_span_label(
             span,
             format!("{return_kind}s a {reference_desc} data owned by the current function"),
         )
@@ -444,8 +444,8 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
             "{closure_kind} may outlive the current {scope}, but it borrows {borrowed_path}, \
              which is owned by the current {scope}",
         )
-        .span_label_mv(capture_span, format!("{borrowed_path} is borrowed here"))
-        .span_label_mv(closure_span, format!("may outlive borrowed value {borrowed_path}"))
+        .with_span_label(capture_span, format!("{borrowed_path} is borrowed here"))
+        .with_span_label(closure_span, format!("may outlive borrowed value {borrowed_path}"))
     }
 
     pub(crate) fn thread_local_value_does_not_live_long_enough(

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -2225,11 +2225,11 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
         );
 
         self.thread_local_value_does_not_live_long_enough(borrow_span)
-            .span_label_mv(
+            .with_span_label(
                 borrow_span,
                 "thread-local variables cannot be borrowed beyond the end of the function",
             )
-            .span_label_mv(drop_span, "end of enclosing function is here")
+            .with_span_label(drop_span, "end of enclosing function is here")
     }
 
     #[instrument(level = "debug", skip(self))]

compiler/rustc_borrowck/src/diagnostics/move_errors.rs

@@ -334,9 +334,9 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                         span,
                         &format!("`{}` in pattern guard", self.local_names[local].unwrap()),
                     )
-                    .note_mv(
+                    .with_note(
                         "variables bound in patterns cannot be moved from \
-                     until after the end of the pattern guard",
+                         until after the end of the pattern guard",
                     );
             } else if decl.is_ref_to_static() {
                 return self.report_cannot_move_from_static(move_place, span);
@@ -382,8 +382,8 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                 );
 
                 self.cannot_move_out_of(span, &place_description)
-                    .span_label_mv(upvar_span, "captured outer variable")
-                    .span_label_mv(
+                    .with_span_label(upvar_span, "captured outer variable")
+                    .with_span_label(
                         self.infcx.tcx.def_span(def_id),
                         format!("captured by this `{closure_kind}` closure"),
                     )

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -421,7 +421,7 @@ fn check_opaque_type_parameter_valid(
             return Err(tcx
                 .dcx()
                 .struct_span_err(span, "non-defining opaque type use in defining scope")
-                .span_note_mv(spans, format!("{descr} used multiple times"))
+                .with_span_note(spans, format!("{descr} used multiple times"))
                 .emit());
         }
     }

compiler/rustc_builtin_macros/src/asm.rs

@@ -695,8 +695,8 @@ fn expand_preparsed_asm(ecx: &mut ExtCtxt<'_>, args: AsmArgs) -> Option<ast::Inl
             let (sp, msg) = unused_operands.into_iter().next().unwrap();
             ecx.dcx()
                 .struct_span_err(sp, msg)
-                .span_label_mv(sp, msg)
-                .help_mv(format!(
+                .with_span_label(sp, msg)
+                .with_help(format!(
                     "if this argument is intentionally unused, \
                      consider using it in an asm comment: `\"/*{help_str} */\"`"
                 ))

compiler/rustc_builtin_macros/src/errors.rs

@@ -817,9 +817,9 @@ impl<'a, G: EmissionGuarantee> IntoDiagnostic<'a, G> for AsmClobberNoReg {
             level,
             crate::fluent_generated::builtin_macros_asm_clobber_no_reg,
         )
-        .span_mv(self.spans.clone())
-        .span_labels_mv(self.clobbers, &lbl1)
-        .span_labels_mv(self.spans, &lbl2)
+        .with_span(self.spans.clone())
+        .with_span_labels(self.clobbers, &lbl1)
+        .with_span_labels(self.spans, &lbl2)
     }
 }
 

compiler/rustc_builtin_macros/src/proc_macro_harness.rs

@@ -194,7 +194,7 @@ impl<'a> Visitor<'a> for CollectProcMacros<'a> {
 
                     self.dcx
                         .struct_span_err(attr.span, msg)
-                        .span_label_mv(prev_attr.span, "previous attribute here")
+                        .with_span_label(prev_attr.span, "previous attribute here")
                         .emit();
 
                     return;

compiler/rustc_builtin_macros/src/test.rs

@@ -409,8 +409,8 @@ fn not_testable_error(cx: &ExtCtxt<'_>, attr_sp: Span, item: Option<&ast::Item>)
             ),
         );
     }
-    err.span_label_mv(attr_sp, "the `#[test]` macro causes a function to be run as a test and has no effect on non-functions")
-        .span_suggestion_mv(attr_sp,
+    err.with_span_label(attr_sp, "the `#[test]` macro causes a function to be run as a test and has no effect on non-functions")
+        .with_span_suggestion(attr_sp,
             "replace with conditional compilation to make the item only exist when tests are being run",
             "#[cfg(test)]",
             Applicability::MaybeIncorrect)
@@ -480,7 +480,7 @@ fn should_panic(cx: &ExtCtxt<'_>, i: &ast::Item) -> ShouldPanic {
                                 "argument must be of the form: \
                              `expected = \"error message\"`",
                             )
-                            .note_mv(
+                            .with_note(
                                 "errors in this attribute were erroneously \
                                 allowed and will become a hard error in a \
                                 future release",