Suggest removing parenss around leading lifetime "bound" in "trait object type"

Author: fmease

compiler/rustc_lint/src/unused.rs

@@ -1254,6 +1254,7 @@ impl EarlyLintPass for UnusedParens {
             }
             ast::TyKind::Paren(r) => {
                 match &r.kind {
+                    ast::TyKind::Err(_) => { /* we don't know anything about the shape */ }
                     ast::TyKind::TraitObject(..) => {}
                     ast::TyKind::BareFn(b)
                         if self.with_self_ty_parens && b.generic_params.len() > 0 => {}

compiler/rustc_parse/messages.ftl

@@ -718,6 +718,8 @@ parse_recover_import_as_use = expected item, found {$token_name}
 parse_remove_let = expected pattern, found `let`
     .suggestion = remove the unnecessary `let` keyword
 
+parse_remove_paren = remove these parentheses
+
 parse_repeated_mut_in_pattern = `mut` on a binding may not be repeated
     .suggestion = remove the additional `mut`s
 

compiler/rustc_parse/src/errors.rs

@@ -56,6 +56,13 @@ pub(crate) enum BadTypePlusSub {
         #[primary_span]
         span: Span,
     },
+    #[multipart_suggestion(parse_remove_paren, applicability = "machine-applicable")]
+    RemoveParen {
+        #[suggestion_part(code = "")]
+        lo: Span,
+        #[suggestion_part(code = "")]
+        hi: Span,
+    },
     #[label(parse_expect_path)]
     ExpectPath {
         #[primary_span]

compiler/rustc_parse/src/parser/diagnostics.rs

@@ -1628,22 +1628,36 @@ impl<'a> Parser<'a> {
         Ok(())
     }
 
-    pub(super) fn maybe_recover_from_bad_type_plus(&mut self, ty: &Ty) -> PResult<'a, ()> {
+    pub(super) fn maybe_recover_from_bad_type_plus(
+        &mut self,
+        paren_ty_plus: bool,
+        ty: &Ty,
+    ) -> PResult<'a, ()> {
         // Do not add `+` to expected tokens.
         if !self.token.is_like_plus() {
             return Ok(());
         }
 
         self.bump(); // `+`
         let _bounds = self.parse_generic_bounds()?;
+        let sum_span = ty.span.to(self.prev_token.span);
+
         let sub = match &ty.kind {
             TyKind::Ref(_lifetime, mut_ty) => {
                 let lo = mut_ty.ty.span.shrink_to_lo();
                 let hi = self.prev_token.span.shrink_to_hi();
                 BadTypePlusSub::AddParen { suggestion: AddParen { lo, hi } }
             }
-            TyKind::Ptr(..) | TyKind::BareFn(..) => {
-                BadTypePlusSub::ForgotParen { span: ty.span.to(self.prev_token.span) }
+            TyKind::Ptr(..) | TyKind::BareFn(..) => BadTypePlusSub::ForgotParen { span: sum_span },
+            TyKind::Paren(inner_ty)
+                if let TyKind::TraitObject(bounds, ast::TraitObjectSyntax::None) = &inner_ty.kind
+                    && let [ast::GenericBound::Outlives(_)] = bounds.as_slice()
+                    && !paren_ty_plus /* no trailing `+` */ =>
+            {
+                BadTypePlusSub::RemoveParen {
+                    lo: ty.span.shrink_to_lo().to(inner_ty.span.shrink_to_lo()),
+                    hi: inner_ty.span.shrink_to_hi().to(ty.span.shrink_to_hi()),
+                }
             }
             _ => BadTypePlusSub::ExpectPath { span: ty.span },
         };

compiler/rustc_parse/src/parser/ty.rs

@@ -256,10 +256,12 @@ impl<'a> Parser<'a> {
             return Ok(ty);
         }
 
-        let lo = self.token.span;
         let mut impl_dyn_multi = false;
+        let mut paren_ty_plus = false;
+
+        let lo = self.token.span;
         let kind = if self.check(exp!(OpenParen)) {
-            self.parse_ty_tuple_or_parens(lo, allow_plus)?
+            self.parse_ty_tuple_or_parens(lo, allow_plus, &mut paren_ty_plus)?
         } else if self.eat(exp!(Bang)) {
             // Never type `!`
             TyKind::Never
@@ -370,7 +372,7 @@ impl<'a> Parser<'a> {
 
         // Try to recover from use of `+` with incorrect priority.
         match allow_plus {
-            AllowPlus::Yes => self.maybe_recover_from_bad_type_plus(&ty)?,
+            AllowPlus::Yes => self.maybe_recover_from_bad_type_plus(paren_ty_plus, &ty)?,
             AllowPlus::No => self.maybe_report_ambiguous_plus(impl_dyn_multi, &ty),
         }
         if let RecoverQuestionMark::Yes = recover_question_mark {
@@ -395,7 +397,12 @@ impl<'a> Parser<'a> {
     /// Parses either:
     /// - `(TYPE)`, a parenthesized type.
     /// - `(TYPE,)`, a tuple with a single field of type TYPE.
-    fn parse_ty_tuple_or_parens(&mut self, lo: Span, allow_plus: AllowPlus) -> PResult<'a, TyKind> {
+    fn parse_ty_tuple_or_parens(
+        &mut self,
+        lo: Span,
+        allow_plus: AllowPlus,
+        paren_ty_plus: &mut bool,
+    ) -> PResult<'a, TyKind> {
         let mut trailing_plus = false;
         let (ts, trailing) = self.parse_paren_comma_seq(|p| {
             let ty = p.parse_ty()?;
@@ -404,20 +411,14 @@ impl<'a> Parser<'a> {
         })?;
 
         if ts.len() == 1 && matches!(trailing, Trailing::No) {
+            *paren_ty_plus = trailing_plus;
             let ty = ts.into_iter().next().unwrap().into_inner();
-            let maybe_bounds = allow_plus == AllowPlus::Yes && self.token.is_like_plus();
             match ty.kind {
                 // `(TY_BOUND_NOPAREN) + BOUND + ...`.
-                TyKind::Path(None, path) if maybe_bounds => {
-                    self.parse_remaining_bounds_path(ThinVec::new(), path, lo, true)
-                }
-                // For `('a) + …`, we know that `'a` in type position already lead to an error being
-                // emitted. To reduce output, let's indirectly suppress E0178 (bad `+` in type) and
-                // other irrelevant consequential errors.
-                TyKind::TraitObject(bounds, TraitObjectSyntax::None)
-                    if maybe_bounds && bounds.len() == 1 && !trailing_plus =>
+                TyKind::Path(None, path)
+                    if allow_plus == AllowPlus::Yes && self.token.is_like_plus() =>
                 {
-                    self.parse_remaining_bounds(bounds, true)
+                    self.parse_remaining_bounds_path(ThinVec::new(), path, lo, true)
                 }
                 // `(TYPE)`
                 _ => Ok(TyKind::Paren(P(ty))),

tests/ui/parser/trait-object-lifetime-parens.e201.stderr

@@ -0,0 +1,71 @@
+error: parenthesized lifetime bounds are not supported
+  --> $DIR/trait-object-lifetime-parens.rs:9:21
+   |
+LL | fn f<'a, T: Trait + ('a)>() {}
+   |                     ^^^^
+   |
+help: remove the parentheses
+   |
+LL - fn f<'a, T: Trait + ('a)>() {}
+LL + fn f<'a, T: Trait + 'a>() {}
+   |
+
+error: parenthesized lifetime bounds are not supported
+  --> $DIR/trait-object-lifetime-parens.rs:12:24
+   |
+LL |     let _: Box<Trait + ('a)>;
+   |                        ^^^^
+   |
+help: remove the parentheses
+   |
+LL -     let _: Box<Trait + ('a)>;
+LL +     let _: Box<Trait + 'a>;
+   |
+
+error: lifetimes must be followed by `+` to form a trait object type
+  --> $DIR/trait-object-lifetime-parens.rs:16:17
+   |
+LL |     let _: Box<('a) + Trait>;
+   |                 ^^
+   |
+help: consider adding a trait bound after the potential lifetime bound
+   |
+LL |     let _: Box<('a + /* Trait */) + Trait>;
+   |                    +++++++++++++
+
+error[E0178]: expected a path on the left-hand side of `+`
+  --> $DIR/trait-object-lifetime-parens.rs:16:16
+   |
+LL |     let _: Box<('a) + Trait>;
+   |                ^^^^
+   |
+help: remove these parentheses
+   |
+LL -     let _: Box<('a) + Trait>;
+LL +     let _: Box<'a + Trait>;
+   |
+
+warning: trait objects without an explicit `dyn` are deprecated
+  --> $DIR/trait-object-lifetime-parens.rs:12:16
+   |
+LL |     let _: Box<Trait + ('a)>;
+   |                ^^^^^^^^^^^^
+   |
+   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
+   = note: `#[warn(bare_trait_objects)]` on by default
+help: if this is a dyn-compatible trait, use `dyn`
+   |
+LL |     let _: Box<dyn Trait + ('a)>;
+   |                +++
+
+error[E0224]: at least one trait is required for an object type
+  --> $DIR/trait-object-lifetime-parens.rs:16:17
+   |
+LL |     let _: Box<('a) + Trait>;
+   |                 ^^
+
+error: aborting due to 5 previous errors; 1 warning emitted
+
+Some errors have detailed explanations: E0178, E0224.
+For more information about an error, try `rustc --explain E0178`.

tests/ui/parser/trait-object-lifetime-parens.e2015.stderr

@@ -33,5 +33,25 @@ help: consider adding a trait bound after the potential lifetime bound
 LL |     let _: Box<('a + /* Trait */) + Trait>;
    |                    +++++++++++++
 
-error: aborting due to 3 previous errors
+error[E0178]: expected a path on the left-hand side of `+`
+  --> $DIR/trait-object-lifetime-parens.rs:16:16
+   |
+LL |     let _: Box<('a) + Trait>;
+   |                ^^^^
+   |
+help: remove these parentheses
+   |
+LL -     let _: Box<('a) + Trait>;
+LL +     let _: Box<'a + Trait>;
+   |
+
+error[E0224]: at least one trait is required for an object type
+  --> $DIR/trait-object-lifetime-parens.rs:16:17
+   |
+LL |     let _: Box<('a) + Trait>;
+   |                 ^^
+
+error: aborting due to 5 previous errors
 
+Some errors have detailed explanations: E0178, E0224.
+For more information about an error, try `rustc --explain E0178`.

tests/ui/parser/trait-object-lifetime-parens.rs

@@ -11,11 +11,12 @@ fn f<'a, T: Trait + ('a)>() {} //~ ERROR parenthesized lifetime bounds are not s
 fn check<'a>() {
     let _: Box<Trait + ('a)>; //~ ERROR parenthesized lifetime bounds are not supported
     //[e2021]~^ ERROR expected a type, found a trait
-    // FIXME: It'd be great if we could suggest removing the parentheses here too.
-    //[e2015]~v ERROR lifetimes must be followed by `+` to form a trait object type
+
+    //~v ERROR expected a path on the left-hand side of `+`
     let _: Box<('a) + Trait>;
-    //[e2021]~^ ERROR expected type, found lifetime
-    //[e2021]~| ERROR expected a path on the left-hand side of `+`
+    //[e2015]~^ ERROR lifetimes must be followed by `+` to form a trait object type
+    //[e2015]~| ERROR at least one trait is required for an object type
+    //[e2021]~^^^ ERROR expected type, found lifetime
 }
 
 fn main() {}