Handle proc-macro spans pointing at attribute in suggestions

Hide invalid proc-macro suggestions and track spans coming from proc-macros pointing at attribute. Effectively, unless the proc-macro keeps user spans, suggestions will not be produced for the code they produce. Account for desugaring when checking if a span can be used for suggestions Fix #106720.
rust-lang · matthiaskrgr · Mar 12, 2023 · Mar 14, 2023 · Mar 15, 2023 · Mar 15, 2023
commit d9ac2be215fe381dd9301b78c988fdb2680f66b0
diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs
@@ -286,10 +286,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             segment_ident_span.find_ancestor_inside(path_span).unwrap_or(path_span)
         } else if generic_args.is_empty() {
             // If there are brackets, but not generic arguments, then use the opening bracket
-            generic_args.span.with_hi(generic_args.span.lo() + BytePos(1))
+            self.tcx.adjust_span(generic_args.span).with_hi(generic_args.span.lo() + BytePos(1))
         } else {
             // Else use an empty span right after the opening bracket.
-            generic_args.span.with_lo(generic_args.span.lo() + BytePos(1)).shrink_to_lo()
+            self.tcx
+                .adjust_span(generic_args.span)
+                .with_lo(generic_args.span.lo() + BytePos(1))
+                .shrink_to_lo()
         };
 
         generic_args.args.insert_many(

diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -2073,12 +2073,12 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
             Ok(string) => {
                 if string.starts_with("async ") {
                     let pos = args_span.lo() + BytePos(6);
-                    (args_span.with_lo(pos).with_hi(pos), "move ")
+                    (self.infcx.tcx.adjust_span(args_span).with_lo(pos).with_hi(pos), "move ")
                 } else if string.starts_with("async|") {
                     let pos = args_span.lo() + BytePos(5);
-                    (args_span.with_lo(pos).with_hi(pos), " move")
+                    (self.infcx.tcx.adjust_span(args_span).with_lo(pos).with_hi(pos), " move")
                 } else {
-                    (args_span.shrink_to_lo(), "move ")
+                    (self.infcx.tcx.adjust_span(args_span).shrink_to_lo(), "move ")
                 }
             }
             Err(_) => (args_span, "move |<args>| <body>"),

diff --git a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
@@ -457,15 +457,15 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
         match self.infcx.tcx.sess.source_map().span_to_snippet(span) {
             Ok(snippet) if snippet.starts_with('*') => {
                 err.span_suggestion_verbose(
-                    span.with_hi(span.lo() + BytePos(1)),
+                    self.infcx.tcx.adjust_span(span).with_hi(span.lo() + BytePos(1)),
                     "consider removing the dereference here",
                     String::new(),
                     Applicability::MaybeIncorrect,
                 );
             }
             _ => {
                 err.span_suggestion_verbose(
-                    span.shrink_to_lo(),
+                    self.infcx.tcx.adjust_span(span).shrink_to_lo(),
                     "consider borrowing here",
                     '&',
                     Applicability::MaybeIncorrect,

diff --git a/compiler/rustc_builtin_macros/src/alloc_error_handler.rs b/compiler/rustc_builtin_macros/src/alloc_error_handler.rs
@@ -10,7 +10,7 @@ use thin_vec::{thin_vec, ThinVec};
 
 pub fn expand(
     ecx: &mut ExtCtxt<'_>,
-    _span: Span,
+    span: Span,
     meta_item: &ast::MetaItem,
     item: Annotatable,
 ) -> Vec<Annotatable> {
@@ -36,7 +36,7 @@ pub fn expand(
         };
 
     // Generate a bunch of new items using the AllocFnFactory
-    let span = ecx.with_def_site_ctxt(item.span);
+    let span = ecx.with_def_site_ctxt(span);
 
     // Generate item statements for the allocator methods.
     let stmts = thin_vec![generate_handler(ecx, item.ident, span, sig_span)];

diff --git a/compiler/rustc_builtin_macros/src/derive.rs b/compiler/rustc_builtin_macros/src/derive.rs
@@ -138,7 +138,7 @@ fn report_unexpected_meta_item_lit(sess: &Session, lit: &ast::MetaItemLit) {
         }
         _ => "for example, write `#[derive(Debug)]` for `Debug`".to_string(),
     };
-    struct_span_err!(sess, lit.span, E0777, "expected path to a trait, found literal",)
+    struct_span_err!(sess, lit.span, E0777, "expected path to a trait, found literal")
         .span_label(lit.span, "not a trait")
         .help(&help_msg)
         .emit();

diff --git a/compiler/rustc_const_eval/src/transform/check_consts/ops.rs b/compiler/rustc_const_eval/src/transform/check_consts/ops.rs
@@ -256,11 +256,15 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
                                     {
                                         let rhs_pos =
                                             span.lo() + BytePos::from_usize(eq_idx + 2 + rhs_idx);
-                                        let rhs_span = span.with_lo(rhs_pos).with_hi(rhs_pos);
+                                        let rhs_span =
+                                            tcx.adjust_span(span).with_lo(rhs_pos).with_hi(rhs_pos);
                                         err.multipart_suggestion(
                                             "consider dereferencing here",
                                             vec![
-                                                (span.shrink_to_lo(), deref.clone()),
+                                                (
+                                                    tcx.adjust_span(span).shrink_to_lo(),
+                                                    deref.clone(),
+                                                ),
                                                 (rhs_span, deref),
                                             ],
                                             Applicability::MachineApplicable,

diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs
@@ -621,6 +621,10 @@ impl Diagnostic {
             .map(|(span, snippet)| SubstitutionPart { snippet, span })
             .collect::<Vec<_>>();
 
+        if !parts.iter().all(|sub| sub.span.can_be_used_for_suggestions()) {
+            return self;
+        }
+
         parts.sort_unstable_by_key(|part| part.span);
 
         assert!(!parts.is_empty());
@@ -711,6 +715,9 @@ impl Diagnostic {
             !(sp.is_empty() && suggestion.to_string().is_empty()),
             "Span must not be empty and have no suggestion"
         );
+        if !sp.can_be_used_for_suggestions() {
+            return self;
+        }
         self.push_suggestion(CodeSuggestion {
             substitutions: vec![Substitution {
                 parts: vec![SubstitutionPart { snippet: suggestion.to_string(), span: sp }],
@@ -774,6 +781,9 @@ impl Diagnostic {
             !(sp.is_empty() && suggestions.iter().any(|suggestion| suggestion.is_empty())),
             "Span must not be empty and have no suggestion"
         );
+        if !sp.can_be_used_for_suggestions() {
+            return self;
+        }
 
         let substitutions = suggestions
             .into_iter()
@@ -799,12 +809,16 @@ impl Diagnostic {
     ) -> &mut Self {
         let substitutions = suggestions
             .into_iter()
-            .map(|sugg| {
+            .filter_map(|sugg| {
                 let mut parts = sugg
                     .into_iter()
                     .map(|(span, snippet)| SubstitutionPart { snippet, span })
                     .collect::<Vec<_>>();
 
+                if !parts.iter().all(|sub| sub.span.can_be_used_for_suggestions()) {
+                    return None;
+                }
+
                 parts.sort_unstable_by_key(|part| part.span);
 
                 assert!(!parts.is_empty());
@@ -819,7 +833,7 @@ impl Diagnostic {
                     "suggestion must not have overlapping parts",
                 );
 
-                Substitution { parts }
+                Some(Substitution { parts })
             })
             .collect();
 

diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -1351,7 +1351,7 @@ fn compare_number_of_method_arguments<'tcx>(
                     if pos == 0 {
                         arg.span
                     } else {
-                        arg.span.with_lo(trait_m_sig.decl.inputs[0].span.lo())
+                        tcx.adjust_span(arg.span).with_lo(trait_m_sig.decl.inputs[0].span.lo())
                     }
                 })
             })
@@ -1367,7 +1367,7 @@ fn compare_number_of_method_arguments<'tcx>(
                 if pos == 0 {
                     arg.span
                 } else {
-                    arg.span.with_lo(impl_m_sig.decl.inputs[0].span.lo())
+                    tcx.adjust_span(arg.span).with_lo(impl_m_sig.decl.inputs[0].span.lo())
                 }
             })
             .unwrap_or_else(|| tcx.def_span(impl_m.def_id));
@@ -1464,7 +1464,8 @@ fn compare_synthetic_generics<'tcx>(
 
                         // in case there are no generics, take the spot between the function name
                         // and the opening paren of the argument list
-                        let new_generics_span = tcx.def_ident_span(impl_def_id)?.shrink_to_hi();
+                        let new_generics_span =
+                            tcx.adjust_span(tcx.def_ident_span(impl_def_id)?).shrink_to_hi();
                         // in case there are generics, just replace them
                         let generics_span =
                             impl_m.generics.span.substitute_dummy(new_generics_span);

diff --git a/compiler/rustc_hir_analysis/src/check/mod.rs b/compiler/rustc_hir_analysis/src/check/mod.rs
@@ -220,7 +220,7 @@ fn missing_items_err(
     let hi = full_impl_span.hi() - BytePos(1);
     // Point at the place right before the closing brace of the relevant `impl` to suggest
     // adding the associated item at the end of its body.
-    let sugg_sp = full_impl_span.with_lo(hi).with_hi(hi);
+    let sugg_sp = tcx.adjust_span(full_impl_span).with_lo(hi).with_hi(hi);
     // Obtain the level of indentation ending in `sugg_sp`.
     let padding =
         tcx.sess.source_map().indentation_before(sugg_sp).unwrap_or_else(|| String::new());

diff --git a/compiler/rustc_hir_analysis/src/structured_errors/wrong_number_of_generic_args.rs b/compiler/rustc_hir_analysis/src/structured_errors/wrong_number_of_generic_args.rs
@@ -610,10 +610,10 @@ impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
 
             AngleBrackets::Available => {
                 let (sugg_span, is_first) = if self.num_provided_lifetime_args() == 0 {
-                    (self.gen_args.span().unwrap().shrink_to_lo(), true)
+                    (self.tcx.adjust_span(self.gen_args.span().unwrap()).shrink_to_lo(), true)
                 } else {
                     let last_lt = &self.gen_args.args[self.num_provided_lifetime_args() - 1];
-                    (last_lt.span().shrink_to_hi(), false)
+                    (self.tcx.adjust_span(last_lt.span()).shrink_to_hi(), false)
                 };
                 let has_non_lt_args = self.num_provided_type_or_const_args() != 0;
                 let has_bindings = !self.gen_args.bindings.is_empty();
@@ -658,14 +658,14 @@ impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
                 );
             }
             AngleBrackets::Available => {
-                let gen_args_span = self.gen_args.span().unwrap();
+                let gen_args_span = self.tcx.adjust_span(self.gen_args.span().unwrap());
                 let sugg_offset =
                     self.get_lifetime_args_offset() + self.num_provided_type_or_const_args();
 
                 let (sugg_span, is_first) = if sugg_offset == 0 {
-                    (gen_args_span.shrink_to_lo(), true)
+                    (self.tcx.adjust_span(gen_args_span).shrink_to_lo(), true)
                 } else {
-                    let arg_span = self.gen_args.args[sugg_offset - 1].span();
+                    let arg_span = self.tcx.adjust_span(self.gen_args.args[sugg_offset - 1].span());
                     // If we came here then inferred lifetime's spans can only point
                     // to either the opening bracket or to the space right after.
                     // Both of these spans have an `hi` lower than or equal to the span
@@ -770,7 +770,7 @@ impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
                 && let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
                     let sugg = vec![
                         (self.path_segment.ident.span, format!("{}::{}", snippet, self.path_segment.ident)),
-                        (span.with_lo(self.path_segment.ident.span.hi()), "".to_owned())
+                        (self.tcx.adjust_span(span).with_lo(self.path_segment.ident.span.hi()), "".to_owned())
                     ];
 
                     err.multipart_suggestion(
@@ -953,11 +953,8 @@ impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
             }
         } else if remove_entire_generics {
             let span = self
-                .path_segment
-                .args
-                .unwrap()
-                .span_ext()
-                .unwrap()
+                .tcx
+                .adjust_span(self.path_segment.args.unwrap().span_ext().unwrap())
                 .with_lo(self.path_segment.ident.span.hi());
 
             let msg = format!(