Auto merge of #59084 - estebank:diagnostic-spans, r=davidtwco

Tweak some diagnostic spans

Author: bors

src/librustc/mir/interpret/error.rs

@@ -100,6 +100,7 @@ impl<'a, 'gcx, 'tcx> ConstEvalErr<'tcx> {
         tcx: TyCtxtAt<'a, 'gcx, 'tcx>,
         message: &str,
         lint_root: hir::HirId,
+        span: Option<Span>,
     ) -> ErrorHandled {
         let lint = self.struct_generic(
             tcx,
@@ -108,6 +109,18 @@ impl<'a, 'gcx, 'tcx> ConstEvalErr<'tcx> {
         );
         match lint {
             Ok(mut lint) => {
+                if let Some(span) = span {
+                    let primary_spans = lint.span.primary_spans().to_vec();
+                    // point at the actual error as the primary span
+                    lint.replace_span_with(span);
+                    // point to the `const` statement as a secondary span
+                    // they don't have any label
+                    for sp in primary_spans {
+                        if sp != span {
+                            lint.span_label(sp, "");
+                        }
+                    }
+                }
                 lint.emit();
                 ErrorHandled::Reported
             },

src/librustc_errors/diagnostic.rs

@@ -366,7 +366,7 @@ impl Diagnostic {
                 }],
             }],
             msg: msg.to_owned(),
-            style: SuggestionStyle::HideCodeInline,
+            style: SuggestionStyle::HideCodeAlways,
             applicability,
         });
         self

src/librustc_metadata/native_libs.rs

@@ -74,9 +74,10 @@ impl<'a, 'tcx> ItemLikeVisitor<'tcx> for Collector<'a, 'tcx> {
                         "dylib" => cstore::NativeUnknown,
                         "framework" => cstore::NativeFramework,
                         k => {
-                            struct_span_err!(self.tcx.sess, m.span, E0458,
+                            struct_span_err!(self.tcx.sess, item.span(), E0458,
                                       "unknown kind: `{}`", k)
-                                .span_label(item.span(), "unknown kind").emit();
+                                .span_label(item.span(), "unknown kind")
+                                .span_label(m.span, "").emit();
                             cstore::NativeUnknown
                         }
                     };

src/librustc_mir/const_eval.rs

@@ -668,6 +668,7 @@ pub fn const_eval_raw_provider<'a, 'tcx>(
                         tcx.at(tcx.def_span(def_id)),
                         "any use of this value will cause an error",
                         hir_id,
+                        Some(err.span),
                     )
                 },
                 // promoting runtime code is only allowed to error if it references broken constants
@@ -684,6 +685,7 @@ pub fn const_eval_raw_provider<'a, 'tcx>(
                             tcx.at(span),
                             "reaching this expression at runtime will panic or abort",
                             tcx.hir().as_local_hir_id(def_id).unwrap(),
+                            Some(err.span),
                         )
                     }
                 // anything else (array lengths, enum initializers, constant patterns) are reported

src/librustc_mir/transform/const_prop.rs

@@ -237,6 +237,7 @@ impl<'a, 'mir, 'tcx> ConstPropagator<'a, 'mir, 'tcx> {
                             self.ecx.tcx,
                             "this expression will panic at runtime",
                             lint_root,
+                            None,
                         );
                     }
                 }

src/librustc_resolve/lib.rs

@@ -4932,7 +4932,7 @@ impl<'a> Resolver<'a> {
             Some((directive, _, true)) if should_remove_import && !directive.is_glob() => {
                 // Simple case - remove the entire import. Due to the above match arm, this can
                 // only be a single use so just remove it entirely.
-                err.span_suggestion(
+                err.tool_only_span_suggestion(
                     directive.use_span_with_attributes,
                     "remove unnecessary import",
                     String::new(),
@@ -5112,7 +5112,7 @@ impl<'a> Resolver<'a> {
                         // extra for the comma.
                         span.lo().0 - (prev_comma.as_bytes().len() as u32) - 1
                     ));
-                    err.span_suggestion(
+                    err.tool_only_span_suggestion(
                         span, message, String::new(), Applicability::MaybeIncorrect,
                     );
                     return;

src/librustc_typeck/check/method/suggest.rs

@@ -69,13 +69,18 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
         error: MethodError<'tcx>,
         args: Option<&'gcx [hir::Expr]>,
     ) {
+        let orig_span = span;
+        let mut span = span;
         // Avoid suggestions when we don't know what's going on.
         if rcvr_ty.references_error() {
             return;
         }
 
-        let report_candidates = |err: &mut DiagnosticBuilder<'_>,
-                                 mut sources: Vec<CandidateSource>| {
+        let report_candidates = |
+            span: Span,
+            err: &mut DiagnosticBuilder<'_>,
+            mut sources: Vec<CandidateSource>,
+        | {
             sources.sort();
             sources.dedup();
             // Dynamic limit to avoid hiding just one candidate, which is silly.
@@ -293,9 +298,10 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                         err.emit();
                         return;
                     } else {
+                        span = item_name.span;
                         let mut err = struct_span_err!(
                             tcx.sess,
-                            item_name.span,
+                            span,
                             E0599,
                             "no {} named `{}` found for type `{}` in the current scope",
                             item_kind,
@@ -305,7 +311,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                         if let Some(suggestion) = suggestion {
                             // enum variant
                             err.span_suggestion(
-                                item_name.span,
+                                span,
                                 "did you mean",
                                 suggestion.to_string(),
                                 Applicability::MaybeIncorrect,
@@ -392,7 +398,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                     }
                 } else {
                     err.span_label(span, format!("{} not found in `{}`", item_kind, ty_str));
-                    self.tcx.sess.trait_methods_not_found.borrow_mut().insert(span);
+                    self.tcx.sess.trait_methods_not_found.borrow_mut().insert(orig_span);
                 }
 
                 if self.is_fn_ty(&rcvr_ty, span) {
@@ -434,9 +440,9 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                                           self.ty_to_string(actual), item_name));
                     }
 
-                    report_candidates(&mut err, static_sources);
+                    report_candidates(span, &mut err, static_sources);
                 } else if static_sources.len() > 1 {
-                    report_candidates(&mut err, static_sources);
+                    report_candidates(span, &mut err, static_sources);
                 }
 
                 if !unsatisfied_predicates.is_empty() {
@@ -481,7 +487,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                                                "multiple applicable items in scope");
                 err.span_label(span, format!("multiple `{}` found", item_name));
 
-                report_candidates(&mut err, sources);
+                report_candidates(span, &mut err, sources);
                 err.emit();
             }
 

src/libsyntax/parse/parser.rs

@@ -5598,8 +5598,14 @@ impl<'a> Parser<'a> {
 
         if !negative_bounds.is_empty() || was_negative {
             let plural = negative_bounds.len() > 1;
-            let mut err = self.struct_span_err(negative_bounds,
-                                               "negative trait bounds are not supported");
+            let last_span = negative_bounds.last().map(|sp| *sp);
+            let mut err = self.struct_span_err(
+                negative_bounds,
+                "negative trait bounds are not supported",
+            );
+            if let Some(sp) = last_span {
+                err.span_label(sp, "negative trait bounds are not supported");
+            }
             if let Some(bound_list) = colon_span {
                 let bound_list = bound_list.to(self.prev_span);
                 let mut new_bound_list = String::new();
@@ -5612,11 +5618,12 @@ impl<'a> Parser<'a> {
                     }
                     new_bound_list = new_bound_list.replacen(" +", ":", 1);
                 }
-                err.span_suggestion_short(bound_list,
-                                        &format!("remove the trait bound{}",
-                                                if plural { "s" } else { "" }),
-                                        new_bound_list,
-                                        Applicability::MachineApplicable);
+                err.span_suggestion_hidden(
+                    bound_list,
+                    &format!("remove the trait bound{}", if plural { "s" } else { "" }),
+                    new_bound_list,
+                    Applicability::MachineApplicable,
+                );
             }
             err.emit();
         }

src/test/ui/array_const_index-0.stderr

@@ -1,8 +1,8 @@
 error: any use of this value will cause an error
-  --> $DIR/array_const_index-0.rs:2:1
+  --> $DIR/array_const_index-0.rs:2:16
    |
 LL | const B: i32 = (&A)[1];
-   | ^^^^^^^^^^^^^^^-------^
+   | ---------------^^^^^^^-
    |                |
    |                index out of bounds: the len is 0 but the index is 1
    |

src/test/ui/array_const_index-1.stderr

@@ -1,8 +1,8 @@
 error: any use of this value will cause an error
-  --> $DIR/array_const_index-1.rs:2:1
+  --> $DIR/array_const_index-1.rs:2:16
    |
 LL | const B: i32 = A[1];
-   | ^^^^^^^^^^^^^^^----^
+   | ---------------^^^^-
    |                |
    |                index out of bounds: the len is 0 but the index is 1
    |