Tweak wording and spans

Author: estebank

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -21,6 +21,7 @@ use rustc_middle::ty::{
     self, subst::Subst, suggest_constraining_type_params, EarlyBinder, PredicateKind, Ty,
 };
 use rustc_mir_dataflow::move_paths::{InitKind, MoveOutIndex, MovePathIndex};
+use rustc_span::hygiene::DesugaringKind;
 use rustc_span::symbol::sym;
 use rustc_span::{BytePos, Span};
 use rustc_trait_selection::infer::InferCtxtExt;
@@ -331,7 +332,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
             spans.push(span);
         }
 
-        let (item_msg, name, desc) =
+        let (binding, name, desc) =
             match self.describe_place_with_options(used_place, IncludingDowncast(true)) {
                 Some(name) => (format!("`{name}`"), format!("`{name}`"), format!("`{name}` ")),
                 None => ("value".to_string(), "the variable".to_string(), String::new()),
@@ -351,20 +352,21 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
         } else {
             "initialized in all conditions"
         };
-        let mut err = struct_span_err!(self, span, E0381, "binding {desc}isn't {initialized}");
+        let used = desired_action.as_general_verb_in_past_tense();
+        let mut err =
+            struct_span_err!(self, span, E0381, "{used} binding {desc}isn't {initialized}");
         use_spans.var_span_label_path_only(
             &mut err,
             format!("{} occurs due to use{}", desired_action.as_noun(), use_spans.describe()),
         );
 
         if let InitializationRequiringAction::PartialAssignment = desired_action {
             err.help(
-                "partial initialization isn't supported, fully initialize the binding with \
-                a default value and mutate, or use `std::mem::MaybeUninit`",
+                "partial initialization isn't supported, fully initialize the binding with a \
+                 default value and mutate it, or use `std::mem::MaybeUninit`",
             );
         }
-        let verb = desired_action.as_verb_in_past_tense();
-        err.span_label(span, format!("{item_msg} {verb} here but it isn't {initialized}",));
+        err.span_label(span, format!("{binding} {used} here but it isn't {initialized}"));
 
         // We use the statements were the binding was initialized, and inspect the HIR to look
         // for the branching codepaths that aren't covered, to point at them.
@@ -400,7 +402,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                 err.span_label(sp, &label);
             }
         }
-        err.span_label(decl_span, "variable declared here");
+        err.span_label(decl_span, "binding declared here but left uninitialized");
         err
     }
 
@@ -2559,10 +2561,10 @@ impl<'b, 'v> Visitor<'v> for ConditionVisitor<'b> {
                 v.visit_expr(body);
                 if v.1 {
                     self.errors.push((
-                        cond.span,
+                        ex.span.to(cond.span),
                         format!(
-                            "this `if` expression might be missing an `else` arm where {} is \
-                             initialized",
+                            "this `if` expression might be missing an `else` arm that initializes \
+                             {}",
                             self.name,
                         ),
                     ));
@@ -2578,10 +2580,24 @@ impl<'b, 'v> Visitor<'v> for ConditionVisitor<'b> {
                 match (a.1, b.1) {
                     (true, true) | (false, false) => {}
                     (true, false) => {
-                        self.errors.push((
-                            cond.span,
-                            format!("{} is uninitialized if this condition isn't met", self.name,),
-                        ));
+                        if other.span.is_desugaring(DesugaringKind::WhileLoop) {
+                            self.errors.push((
+                                cond.span,
+                                format!(
+                                    "{} is uninitialized if this condition isn't met and the \
+                                     `while` loop runs 0 times",
+                                    self.name
+                                ),
+                            ));
+                        } else {
+                            self.errors.push((
+                                body.span.shrink_to_hi().until(other.span),
+                                format!(
+                                    "{} is uninitialized if this `else` arm is executed",
+                                    self.name
+                                ),
+                            ));
+                        }
                     }
                     (false, true) => {
                         self.errors.push((
@@ -2591,7 +2607,7 @@ impl<'b, 'v> Visitor<'v> for ConditionVisitor<'b> {
                     }
                 }
             }
-            hir::ExprKind::Match(_, arms, _) => {
+            hir::ExprKind::Match(e, arms, loop_desugar) => {
                 // If the binding is initialized in one of the match arms, then the other match
                 // arms might be missing an initialization.
                 let results: Vec<bool> = arms
@@ -2605,22 +2621,40 @@ impl<'b, 'v> Visitor<'v> for ConditionVisitor<'b> {
                 if results.iter().any(|x| *x) && !results.iter().all(|x| *x) {
                     for (arm, seen) in arms.iter().zip(results) {
                         if !seen {
-                            self.errors.push((
-                                arm.pat.span,
-                                format!(
-                                    "{} is uninitialized if this pattern is matched",
-                                    self.name
-                                ),
-                            ));
+                            if loop_desugar == hir::MatchSource::ForLoopDesugar {
+                                self.errors.push((
+                                    e.span,
+                                    format!(
+                                        "{} is uninitialized if the `for` loop runs 0 times",
+                                        self.name
+                                    ),
+                                ));
+                            } else if let Some(guard) = &arm.guard {
+                                self.errors.push((
+                                    arm.pat.span.to(guard.body().span),
+                                    format!(
+                                        "{} is uninitialized if this pattern and condition are \
+                                         matched",
+                                        self.name
+                                    ),
+                                ));
+                            } else {
+                                self.errors.push((
+                                    arm.pat.span,
+                                    format!(
+                                        "{} is uninitialized if this pattern is matched",
+                                        self.name
+                                    ),
+                                ));
+                            }
                         }
                     }
                 }
             }
             // FIXME: should we also account for binops, particularly `&&` and `||`? `try` should
             // also be accounted for. For now it is fine, as if we don't find *any* relevant
             // branching code paths, we point at the places where the binding *is* initialized for
-            // *some* context. We should also specialize the output for `while` and `for` loops,
-            // but for now we can rely on their desugaring to provide appropriate output.
+            // *some* context.
             _ => {}
         }
         walk_expr(self, ex);

compiler/rustc_borrowck/src/lib.rs

@@ -907,6 +907,16 @@ impl InitializationRequiringAction {
             InitializationRequiringAction::PartialAssignment => "partially assigned",
         }
     }
+
+    fn as_general_verb_in_past_tense(self) -> &'static str {
+        match self {
+            InitializationRequiringAction::Borrow
+            | InitializationRequiringAction::MatchOn
+            | InitializationRequiringAction::Use => "used",
+            InitializationRequiringAction::Assignment => "assigned",
+            InitializationRequiringAction::PartialAssignment => "partially assigned",
+        }
+    }
 }
 
 impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {

src/test/ui/asm/x86_64/type-check-5.stderr

@@ -1,16 +1,16 @@
-error[E0381]: binding `x` isn't initialized
+error[E0381]: used binding `x` isn't initialized
   --> $DIR/type-check-5.rs:15:28
    |
 LL |         let x: u64;
-   |             - variable declared here
+   |             - binding declared here but left uninitialized
 LL |         asm!("{}", in(reg) x);
    |                            ^ `x` used here but it isn't initialized
 
-error[E0381]: binding `y` isn't initialized
+error[E0381]: used binding `y` isn't initialized
   --> $DIR/type-check-5.rs:18:9
    |
 LL |         let mut y: u64;
-   |             ----- variable declared here
+   |             ----- binding declared here but left uninitialized
 LL |         asm!("{}", inout(reg) y);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ `y` used here but it isn't initialized
 

src/test/ui/async-await/no-non-guaranteed-initialization.stderr

@@ -1,10 +1,10 @@
-error[E0381]: binding `y` isn't initialized in all conditions
+error[E0381]: used binding `y` isn't initialized in all conditions
   --> $DIR/no-non-guaranteed-initialization.rs:9:5
    |
 LL |     let y;
-   |         - variable declared here
+   |         - binding declared here but left uninitialized
 LL |     if x > 5 {
-   |        ----- this `if` expression might be missing an `else` arm where `y` is initialized
+   |        ----- this `if` expression might be missing an `else` arm that initializes `y`
 ...
 LL |     y
    |     ^ `y` used here but it isn't initialized in all conditions

src/test/ui/async-await/partial-initialization-across-await.stderr

@@ -1,32 +1,32 @@
-error[E0381]: binding `t` isn't fully initialized
+error[E0381]: partially assigned binding `t` isn't fully initialized
   --> $DIR/partial-initialization-across-await.rs:13:5
    |
 LL |     let mut t: (i32, i32);
-   |         ----- variable declared here
+   |         ----- binding declared here but left uninitialized
 LL |     t.0 = 42;
    |     ^^^^^^^^ `t` partially assigned here but it isn't fully initialized
    |
-   = help: partial initialization isn't supported, fully initialize the binding with a default value and mutate, or use `std::mem::MaybeUninit`
+   = help: partial initialization isn't supported, fully initialize the binding with a default value and mutate it, or use `std::mem::MaybeUninit`
 
-error[E0381]: binding `t` isn't fully initialized
+error[E0381]: partially assigned binding `t` isn't fully initialized
   --> $DIR/partial-initialization-across-await.rs:21:5
    |
 LL |     let mut t: T;
-   |         ----- variable declared here
+   |         ----- binding declared here but left uninitialized
 LL |     t.0 = 42;
    |     ^^^^^^^^ `t` partially assigned here but it isn't fully initialized
    |
-   = help: partial initialization isn't supported, fully initialize the binding with a default value and mutate, or use `std::mem::MaybeUninit`
+   = help: partial initialization isn't supported, fully initialize the binding with a default value and mutate it, or use `std::mem::MaybeUninit`
 
-error[E0381]: binding `t` isn't fully initialized
+error[E0381]: partially assigned binding `t` isn't fully initialized
   --> $DIR/partial-initialization-across-await.rs:29:5
    |
 LL |     let mut t: S;
-   |         ----- variable declared here
+   |         ----- binding declared here but left uninitialized
 LL |     t.x = 42;
    |     ^^^^^^^^ `t` partially assigned here but it isn't fully initialized
    |
-   = help: partial initialization isn't supported, fully initialize the binding with a default value and mutate, or use `std::mem::MaybeUninit`
+   = help: partial initialization isn't supported, fully initialize the binding with a default value and mutate it, or use `std::mem::MaybeUninit`
 
 error: aborting due to 3 previous errors
 

src/test/ui/borrowck/assign_mutable_fields.stderr

@@ -1,22 +1,22 @@
-error[E0381]: binding `x` isn't fully initialized
+error[E0381]: partially assigned binding `x` isn't fully initialized
   --> $DIR/assign_mutable_fields.rs:9:5
    |
 LL |     let mut x: (u32, u32);
-   |         ----- variable declared here
+   |         ----- binding declared here but left uninitialized
 LL |     x.0 = 1;
    |     ^^^^^^^ `x` partially assigned here but it isn't fully initialized
    |
-   = help: partial initialization isn't supported, fully initialize the binding with a default value and mutate, or use `std::mem::MaybeUninit`
+   = help: partial initialization isn't supported, fully initialize the binding with a default value and mutate it, or use `std::mem::MaybeUninit`
 
-error[E0381]: binding `x` isn't fully initialized
+error[E0381]: partially assigned binding `x` isn't fully initialized
   --> $DIR/assign_mutable_fields.rs:17:5
    |
 LL |     let mut x: (u32, u32);
-   |         ----- variable declared here
+   |         ----- binding declared here but left uninitialized
 LL |     x.0 = 1;
    |     ^^^^^^^ `x` partially assigned here but it isn't fully initialized
    |
-   = help: partial initialization isn't supported, fully initialize the binding with a default value and mutate, or use `std::mem::MaybeUninit`
+   = help: partial initialization isn't supported, fully initialize the binding with a default value and mutate it, or use `std::mem::MaybeUninit`
 
 error: aborting due to 2 previous errors
 

src/test/ui/borrowck/borrowck-and-init.stderr

@@ -1,13 +1,13 @@
-error[E0381]: binding `i` isn't initialized in all conditions
+error[E0381]: used binding `i` isn't initialized in all conditions
   --> $DIR/borrowck-and-init.rs:5:20
    |
 LL |     let i: isize;
-   |         - variable declared here
+   |         - binding declared here but left uninitialized
 LL |
 LL |     println!("{}", false && { i = 5; true });
    |                               ----- binding initialized here in some conditions
 LL |     println!("{}", i);
-   |                    ^ `i` borrowed here but it isn't initialized in all conditions
+   |                    ^ `i` used here but it isn't initialized in all conditions
    |
    = note: this error originates in the macro `$crate::format_args_nl` (in Nightly builds, run with -Z macro-backtrace for more info)
 

src/test/ui/borrowck/borrowck-block-unint.stderr

@@ -1,10 +1,10 @@
-error[E0381]: binding `x` isn't initialized
+error[E0381]: used binding `x` isn't initialized
   --> $DIR/borrowck-block-unint.rs:4:11
    |
 LL |     let x: isize;
-   |         - variable declared here
+   |         - binding declared here but left uninitialized
 LL |     force(|| {
-   |           ^^ `x` borrowed here but it isn't initialized
+   |           ^^ `x` used here but it isn't initialized
 LL |         println!("{}", x);
    |                        - borrow occurs due to use in closure
 

src/test/ui/borrowck/borrowck-break-uninit-2.stderr

@@ -1,11 +1,11 @@
-error[E0381]: binding `x` isn't initialized
+error[E0381]: used binding `x` isn't initialized
   --> $DIR/borrowck-break-uninit-2.rs:9:20
    |
 LL |     let x: isize;
-   |         - variable declared here
+   |         - binding declared here but left uninitialized
 ...
 LL |     println!("{}", x);
-   |                    ^ `x` borrowed here but it isn't initialized
+   |                    ^ `x` used here but it isn't initialized
    |
    = note: this error originates in the macro `$crate::format_args_nl` (in Nightly builds, run with -Z macro-backtrace for more info)
 

src/test/ui/borrowck/borrowck-break-uninit.stderr

@@ -1,11 +1,11 @@
-error[E0381]: binding `x` isn't initialized
+error[E0381]: used binding `x` isn't initialized
   --> $DIR/borrowck-break-uninit.rs:9:20
    |
 LL |     let x: isize;
-   |         - variable declared here
+   |         - binding declared here but left uninitialized
 ...
 LL |     println!("{}", x);
-   |                    ^ `x` borrowed here but it isn't initialized
+   |                    ^ `x` used here but it isn't initialized
    |
    = note: this error originates in the macro `$crate::format_args_nl` (in Nightly builds, run with -Z macro-backtrace for more info)