Don't trim non-parenthesis spans in unused_parens for bounds

`poly_trait_ref.parens` only records that the parser saw parentheses
around a trait-object/impl-trait bound; it does not guarantee that the
bound's span actually points at those parentheses in the source. A
proc-macro can synthesize the parentheses while reusing an unrelated span
from its input, so the span may not be wrapped in parentheses at all.

Previously the lint unconditionally trimmed the first and last byte of the
span to build the "remove these parentheses" suggestion. On such reused
spans this produced an invalid suggestion (e.g. rewriting a field
`val: u8` to `al: u`) and could even ICE when the span started or ended on
a multibyte character.

Only emit the lint when the source text at the span really is wrapped in
parentheses.

Author: sanidhyasin

compiler/rustc_lint/src/unused.rs

@@ -937,21 +937,33 @@ impl EarlyLintPass for UnusedParens {
                             && !dyn2015_exception
                         {
                             let s = poly_trait_ref.span;
-                            let spans = (!s.from_expansion()).then(|| {
-                                (
+                            // `poly_trait_ref.parens` only records that the parser saw
+                            // parentheses around this bound; it does not guarantee that `s`
+                            // points at them in the source. A proc-macro can synthesize the
+                            // parentheses while reusing an unrelated span from its input (see
+                            // issue #144378), in which case trimming the first and last byte
+                            // of `s` would corrupt the suggestion and could even ICE on a
+                            // multibyte character. Only lint when the source really is
+                            // wrapped in parentheses.
+                            if !s.from_expansion()
+                                && let Ok(snippet) = cx.sess().source_map().span_to_snippet(s)
+                                && snippet.starts_with('(')
+                                && snippet.ends_with(')')
+                            {
+                                let spans = Some((
                                     s.with_hi(s.lo() + rustc_span::BytePos(1)),
                                     s.with_lo(s.hi() - rustc_span::BytePos(1)),
-                                )
-                            });
-
-                            self.emit_unused_delims(
-                                cx,
-                                poly_trait_ref.span,
-                                spans,
-                                "type",
-                                (false, false),
-                                false,
-                            );
+                                ));
+
+                                self.emit_unused_delims(
+                                    cx,
+                                    poly_trait_ref.span,
+                                    spans,
+                                    "type",
+                                    (false, false),
+                                    false,
+                                );
+                            }
                         }
                     }
                 }

tests/ui/lint/unused/auxiliary/unused-parens-bound-proc-macro.rs

@@ -0,0 +1,32 @@
+extern crate proc_macro;
+
+use proc_macro::{Group, Span, TokenStream, TokenTree};
+
+// Recursively overwrite the span of every token (including group delimiters)
+// with `span`.
+fn respan(span: Span, stream: TokenStream) -> TokenStream {
+    stream
+        .into_iter()
+        .map(|tt| match tt {
+            TokenTree::Group(group) => {
+                let mut group = Group::new(group.delimiter(), respan(span, group.stream()));
+                group.set_span(span);
+                TokenTree::Group(group)
+            }
+            mut tt => {
+                tt.set_span(span);
+                tt
+            }
+        })
+        .collect()
+}
+
+/// Emits `const _: &dyn (Send) = &();` with every token carrying the span of the
+/// macro's first input token. The parenthesized trait-object bound is therefore
+/// reported at a span that does not actually contain parentheses in the source.
+#[proc_macro]
+pub fn emit_parenthesized_bound(input: TokenStream) -> TokenStream {
+    let span = input.into_iter().next().unwrap().span();
+    let code: TokenStream = "const _: &dyn (Send) = &();".parse().unwrap();
+    respan(span, code)
+}

tests/ui/lint/unused/unused-parens-trait-obj-proc-macro-144378.rs

@@ -0,0 +1,24 @@
+//@ check-pass
+//@ edition: 2021
+//@ proc-macro: unused-parens-bound-proc-macro.rs
+
+// Regression test for #144378.
+//
+// A proc-macro can synthesize parentheses around a trait-object bound while
+// reusing a span from its input. That span does not actually point at the
+// parentheses (or at anything resembling them), so the `unused_parens` lint
+// must not blindly trim its first and last byte: doing so produced an invalid
+// suggestion (e.g. turning a field `val: u8` into `al: u`) and could ICE when
+// the reused span started or ended on a multibyte character.
+
+#![deny(unused_parens)]
+#![allow(uncommon_codepoints)]
+
+extern crate unused_parens_bound_proc_macro;
+
+// The generated `&dyn (Send)` reuses the span of the multibyte identifier
+// `naïve`. Before the fix this ICEd; now the lint is silently skipped because
+// the source span is not wrapped in parentheses.
+unused_parens_bound_proc_macro::emit_parenthesized_bound!(naïve);
+
+fn main() {}