fix rust-lang#105061, Fix unused_parens issue for higher ranked function pointers

Author: chenyukang

compiler/rustc_lint/src/unused.rs

@@ -1038,7 +1038,20 @@ impl EarlyLintPass for UnusedParens {
         if let ast::TyKind::Paren(r) = &ty.kind {
             match &r.kind {
                 ast::TyKind::TraitObject(..) => {}
-                ast::TyKind::BareFn(b) if b.generic_params.len() > 0 => {}
+                ast::TyKind::BareFn(b) => {
+                    let spans = if let Some(r) = r.span.find_ancestor_inside(ty.span) {
+                        Some((ty.span.with_hi(r.lo()), ty.span.with_lo(r.hi())))
+                    } else {
+                        None
+                    };
+                    let sm = cx.sess().source_map();
+                    if let Some((_, r)) = spans &&
+                        b.generic_params.len() > 0 &&
+                        sm.span_followed_by(r, ":") {
+                            return;
+                    }
+                    self.emit_unused_delims(cx, ty.span, spans, "type", (false, false));
+                }
                 ast::TyKind::ImplTrait(_, bounds) if bounds.len() > 1 => {}
                 ast::TyKind::Array(_, len) => {
                     self.check_unused_delims_expr(

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -1158,8 +1158,7 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> {
         // where a brace being opened means a block is being started. Look
         // ahead for the next text to see if `span` is followed by a `{`.
         let sm = self.r.session.source_map();
-        let sp = sm.span_look_ahead(span, None, Some(50));
-        let followed_by_brace = matches!(sm.span_to_snippet(sp), Ok(ref snippet) if snippet == "{");
+        let followed_by_brace = sm.span_followed_by(span, "{");
         // In case this could be a struct literal that needs to be surrounded
         // by parentheses, find the appropriate span.
         let closing_span = sm.span_look_ahead(span, Some("}"), Some(50));

compiler/rustc_span/src/source_map.rs

@@ -962,6 +962,14 @@ impl SourceMap {
         sp
     }
 
+    /// Check whether a `span` is followed by a specific string
+    pub fn span_followed_by(&self, span: Span, expect: &str) -> bool {
+        if let Ok(source) = self.span_to_next_source(span) {
+            return source.trim_start().starts_with(expect);
+        }
+        false
+    }
+
     /// Finds the width of the character, either before or after the end of provided span,
     /// depending on the `forwards` parameter.
     fn find_width_of_character_at_span(&self, sp: Span, forwards: bool) -> u32 {

src/test/ui/lint/unused/issue-105061.rs

@@ -0,0 +1,17 @@
+#![warn(unused)]
+#![deny(warnings)]
+
+struct Inv<'a>(&'a mut &'a ());
+
+trait Trait {}
+impl Trait for (for<'a> fn(Inv<'a>),) {}
+
+
+fn with_bound()
+where
+    ((for<'a> fn(Inv<'a>)),): Trait, //~ ERROR unnecessary parentheses around type
+{}
+
+fn main() {
+    with_bound();
+}

src/test/ui/lint/unused/issue-105061.stderr

@@ -0,0 +1,20 @@
+error: unnecessary parentheses around type
+  --> $DIR/issue-105061.rs:12:6
+   |
+LL |     ((for<'a> fn(Inv<'a>)),): Trait,
+   |      ^                   ^
+   |
+note: the lint level is defined here
+  --> $DIR/issue-105061.rs:2:9
+   |
+LL | #![deny(warnings)]
+   |         ^^^^^^^^
+   = note: `#[deny(unused_parens)]` implied by `#[deny(warnings)]`
+help: remove these parentheses
+   |
+LL -     ((for<'a> fn(Inv<'a>)),): Trait,
+LL +     (for<'a> fn(Inv<'a>),): Trait,
+   |
+
+error: aborting due to previous error
+