Auto merge of #106537 - fmease:recover-where-clause-before-tuple-stru…

…ct-body, r=estebank

Recover from where clauses placed before tuple struct bodies

Open to any suggestions regarding the phrasing of the diagnostic.

Fixes #100790.
`@rustbot` label A-diagnostics
r? diagnostics

compiler/rustc_error_messages/locales/en-US/parse.ftl

@@ -372,3 +372,9 @@ parse_maybe_fn_typo_with_impl = you might have meant to write `impl` instead of
 
 parse_expected_fn_path_found_fn_keyword = expected identifier, found keyword `fn`
     .suggestion = use `Fn` to refer to the trait
+
+parse_where_clause_before_tuple_struct_body = where clauses are not allowed before tuple struct bodies
+    .label = unexpected where clause
+    .name_label = while parsing this tuple struct
+    .body_label = the struct body
+    .suggestion = move the body before the where clause

compiler/rustc_parse/src/errors.rs

@@ -1255,3 +1255,27 @@ pub(crate) struct ExpectedFnPathFoundFnKeyword {
     #[suggestion(applicability = "machine-applicable", code = "Fn", style = "verbose")]
     pub fn_token_span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(parse_where_clause_before_tuple_struct_body)]
+pub(crate) struct WhereClauseBeforeTupleStructBody {
+    #[primary_span]
+    #[label]
+    pub span: Span,
+    #[label(name_label)]
+    pub name: Span,
+    #[label(body_label)]
+    pub body: Span,
+    #[subdiagnostic]
+    pub sugg: Option<WhereClauseBeforeTupleStructBodySugg>,
+}
+
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(suggestion, applicability = "machine-applicable")]
+pub(crate) struct WhereClauseBeforeTupleStructBodySugg {
+    #[suggestion_part(code = "{snippet}")]
+    pub left: Span,
+    pub snippet: String,
+    #[suggestion_part(code = "")]
+    pub right: Span,
+}

compiler/rustc_parse/src/parser/generics.rs

@@ -1,11 +1,20 @@
+use crate::errors::{WhereClauseBeforeTupleStructBody, WhereClauseBeforeTupleStructBodySugg};
+
 use super::{ForceCollect, Parser, TrailingToken};
 
+use ast::token::Delimiter;
 use rustc_ast::token;
 use rustc_ast::{
     self as ast, AttrVec, GenericBounds, GenericParam, GenericParamKind, TyKind, WhereClause,
 };
 use rustc_errors::{Applicability, PResult};
-use rustc_span::symbol::kw;
+use rustc_span::symbol::{kw, Ident};
+use rustc_span::Span;
+
+enum PredicateOrStructBody {
+    Predicate(ast::WherePredicate),
+    StructBody(Vec<ast::FieldDef>),
+}
 
 impl<'a> Parser<'a> {
     /// Parses bounds of a lifetime parameter `BOUND + BOUND + BOUND`, possibly with trailing `+`.
@@ -240,23 +249,39 @@ impl<'a> Parser<'a> {
         })
     }
 
-    /// Parses an optional where-clause and places it in `generics`.
+    /// Parses an optional where-clause.
     ///
     /// ```ignore (only-for-syntax-highlight)
     /// where T : Trait<U, V> + 'b, 'a : 'b
     /// ```
     pub(super) fn parse_where_clause(&mut self) -> PResult<'a, WhereClause> {
+        self.parse_where_clause_common(None).map(|(clause, _)| clause)
+    }
+
+    pub(super) fn parse_struct_where_clause(
+        &mut self,
+        struct_name: Ident,
+        body_insertion_point: Span,
+    ) -> PResult<'a, (WhereClause, Option<Vec<ast::FieldDef>>)> {
+        self.parse_where_clause_common(Some((struct_name, body_insertion_point)))
+    }
+
+    fn parse_where_clause_common(
+        &mut self,
+        struct_: Option<(Ident, Span)>,
+    ) -> PResult<'a, (WhereClause, Option<Vec<ast::FieldDef>>)> {
         let mut where_clause = WhereClause {
             has_where_token: false,
             predicates: Vec::new(),
             span: self.prev_token.span.shrink_to_hi(),
         };
+        let mut tuple_struct_body = None;
 
         if !self.eat_keyword(kw::Where) {
-            return Ok(where_clause);
+            return Ok((where_clause, None));
         }
         where_clause.has_where_token = true;
-        let lo = self.prev_token.span;
+        let where_lo = self.prev_token.span;
 
         // We are considering adding generics to the `where` keyword as an alternative higher-rank
         // parameter syntax (as in `where<'a>` or `where<T>`. To avoid that being a breaking
@@ -272,21 +297,30 @@ impl<'a> Parser<'a> {
         }
 
         loop {
-            let lo = self.token.span;
+            let where_sp = where_lo.to(self.prev_token.span);
+            let pred_lo = self.token.span;
             if self.check_lifetime() && self.look_ahead(1, |t| !t.is_like_plus()) {
                 let lifetime = self.expect_lifetime();
                 // Bounds starting with a colon are mandatory, but possibly empty.
                 self.expect(&token::Colon)?;
                 let bounds = self.parse_lt_param_bounds();
                 where_clause.predicates.push(ast::WherePredicate::RegionPredicate(
                     ast::WhereRegionPredicate {
-                        span: lo.to(self.prev_token.span),
+                        span: pred_lo.to(self.prev_token.span),
                         lifetime,
                         bounds,
                     },
                 ));
             } else if self.check_type() {
-                where_clause.predicates.push(self.parse_ty_where_predicate()?);
+                match self.parse_ty_where_predicate_or_recover_tuple_struct_body(
+                    struct_, pred_lo, where_sp,
+                )? {
+                    PredicateOrStructBody::Predicate(pred) => where_clause.predicates.push(pred),
+                    PredicateOrStructBody::StructBody(body) => {
+                        tuple_struct_body = Some(body);
+                        break;
+                    }
+                }
             } else {
                 break;
             }
@@ -297,7 +331,7 @@ impl<'a> Parser<'a> {
             if self.eat_keyword_noexpect(kw::Where) {
                 let msg = "cannot define duplicate `where` clauses on an item";
                 let mut err = self.struct_span_err(self.token.span, msg);
-                err.span_label(lo, "previous `where` clause starts here");
+                err.span_label(pred_lo, "previous `where` clause starts here");
                 err.span_suggestion_verbose(
                     prev_token.shrink_to_hi().to(self.prev_token.span),
                     "consider joining the two `where` clauses into one",
@@ -310,8 +344,72 @@ impl<'a> Parser<'a> {
             }
         }
 
-        where_clause.span = lo.to(self.prev_token.span);
-        Ok(where_clause)
+        where_clause.span = where_lo.to(self.prev_token.span);
+        Ok((where_clause, tuple_struct_body))
+    }
+
+    fn parse_ty_where_predicate_or_recover_tuple_struct_body(
+        &mut self,
+        struct_: Option<(Ident, Span)>,
+        pred_lo: Span,
+        where_sp: Span,
+    ) -> PResult<'a, PredicateOrStructBody> {
+        let mut snapshot = None;
+
+        if let Some(struct_) = struct_
+            && self.may_recover()
+            && self.token.kind == token::OpenDelim(Delimiter::Parenthesis)
+        {
+            snapshot = Some((struct_, self.create_snapshot_for_diagnostic()));
+        };
+
+        match self.parse_ty_where_predicate() {
+            Ok(pred) => Ok(PredicateOrStructBody::Predicate(pred)),
+            Err(type_err) => {
+                let Some(((struct_name, body_insertion_point), mut snapshot)) = snapshot else {
+                    return Err(type_err);
+                };
+
+                // Check if we might have encountered an out of place tuple struct body.
+                match snapshot.parse_tuple_struct_body() {
+                    // Since we don't know the exact reason why we failed to parse the
+                    // predicate (we might have stumbled upon something bogus like `(T): ?`),
+                    // employ a simple heuristic to weed out some pathological cases:
+                    // Look for a semicolon (strong indicator) or anything that might mark
+                    // the end of the item (weak indicator) following the body.
+                    Ok(body)
+                        if matches!(snapshot.token.kind, token::Semi | token::Eof)
+                            || snapshot.token.can_begin_item() =>
+                    {
+                        type_err.cancel();
+
+                        let body_sp = pred_lo.to(snapshot.prev_token.span);
+                        let map = self.sess.source_map();
+
+                        self.sess.emit_err(WhereClauseBeforeTupleStructBody {
+                            span: where_sp,
+                            name: struct_name.span,
+                            body: body_sp,
+                            sugg: map.span_to_snippet(body_sp).ok().map(|body| {
+                                WhereClauseBeforeTupleStructBodySugg {
+                                    left: body_insertion_point.shrink_to_hi(),
+                                    snippet: body,
+                                    right: map.end_point(where_sp).to(body_sp),
+                                }
+                            }),
+                        });
+
+                        self.restore_snapshot(snapshot);
+                        Ok(PredicateOrStructBody::StructBody(body))
+                    }
+                    Ok(_) => Err(type_err),
+                    Err(body_err) => {
+                        body_err.cancel();
+                        Err(type_err)
+                    }
+                }
+            }
+        }
     }
 
     fn parse_ty_where_predicate(&mut self) -> PResult<'a, ast::WherePredicate> {

compiler/rustc_parse/src/parser/item.rs

@@ -1454,8 +1454,16 @@ impl<'a> Parser<'a> {
         // struct.
 
         let vdata = if self.token.is_keyword(kw::Where) {
-            generics.where_clause = self.parse_where_clause()?;
-            if self.eat(&token::Semi) {
+            let tuple_struct_body;
+            (generics.where_clause, tuple_struct_body) =
+                self.parse_struct_where_clause(class_name, generics.span)?;
+
+            if let Some(body) = tuple_struct_body {
+                // If we see a misplaced tuple struct body: `struct Foo<T> where T: Copy, (T);`
+                let body = VariantData::Tuple(body, DUMMY_NODE_ID);
+                self.expect_semi()?;
+                body
+            } else if self.eat(&token::Semi) {
                 // If we see a: `struct Foo<T> where T: Copy;` style decl.
                 VariantData::Unit(DUMMY_NODE_ID)
             } else {
@@ -1575,7 +1583,7 @@ impl<'a> Parser<'a> {
         Ok((fields, recovered))
     }
 
-    fn parse_tuple_struct_body(&mut self) -> PResult<'a, Vec<FieldDef>> {
+    pub(super) fn parse_tuple_struct_body(&mut self) -> PResult<'a, Vec<FieldDef>> {
         // This is the case where we find `struct Foo<T>(T) where T: Copy;`
         // Unit like structs are handled in parse_item_struct function
         self.parse_paren_comma_seq(|p| {

tests/ui/parser/issues/issue-17904.rs

@@ -1,6 +1,8 @@
+// compile-flags: -Zparse-only
+
 struct Baz<U> where U: Eq(U); //This is parsed as the new Fn* style parenthesis syntax.
 struct Baz<U> where U: Eq(U) -> R; // Notice this parses as well.
 struct Baz<U>(U) where U: Eq; // This rightfully signals no error as well.
-struct Foo<T> where T: Copy, (T); //~ ERROR expected one of `:`, `==`, or `=`, found `;`
+struct Foo<T> where T: Copy, (T); //~ ERROR where clauses are not allowed before tuple struct bodies
 
 fn main() {}

tests/ui/parser/issues/issue-17904.stderr

@@ -1,8 +1,17 @@
-error: expected one of `:`, `==`, or `=`, found `;`
-  --> $DIR/issue-17904.rs:4:33
+error: where clauses are not allowed before tuple struct bodies
+  --> $DIR/issue-17904.rs:6:15
    |
 LL | struct Foo<T> where T: Copy, (T);
-   |                                 ^ expected one of `:`, `==`, or `=`
+   |        ---    ^^^^^^^^^^^^^^ --- the struct body
+   |        |      |
+   |        |      unexpected where clause
+   |        while parsing this tuple struct
+   |
+help: move the body before the where clause
+   |
+LL - struct Foo<T> where T: Copy, (T);
+LL + struct Foo<T>(T) where T: Copy;
+   |
 
 error: aborting due to previous error
 

tests/ui/parser/recover-where-clause-before-tuple-struct-body-0.fixed

@@ -0,0 +1,15 @@
+// Regression test for issues #100790 and #106439.
+// run-rustfix
+
+pub struct Example(usize)
+where
+    (): Sized;
+//~^^^ ERROR where clauses are not allowed before tuple struct bodies
+
+struct _Demo(pub usize, usize)
+where
+    (): Sized,
+    String: Clone;
+//~^^^^ ERROR where clauses are not allowed before tuple struct bodies
+
+fn main() {}

tests/ui/parser/recover-where-clause-before-tuple-struct-body-0.rs

@@ -0,0 +1,17 @@
+// Regression test for issues #100790 and #106439.
+// run-rustfix
+
+pub struct Example
+where
+    (): Sized,
+(usize);
+//~^^^ ERROR where clauses are not allowed before tuple struct bodies
+
+struct _Demo
+where
+    (): Sized,
+    String: Clone,
+(pub usize, usize);
+//~^^^^ ERROR where clauses are not allowed before tuple struct bodies
+
+fn main() {}

tests/ui/parser/recover-where-clause-before-tuple-struct-body-0.stderr

@@ -0,0 +1,40 @@
+error: where clauses are not allowed before tuple struct bodies
+  --> $DIR/recover-where-clause-before-tuple-struct-body-0.rs:5:1
+   |
+LL |   pub struct Example
+   |              ------- while parsing this tuple struct
+LL | / where
+LL | |     (): Sized,
+   | |______________^ unexpected where clause
+LL |   (usize);
+   |   ------- the struct body
+   |
+help: move the body before the where clause
+   |
+LL ~ pub struct Example(usize)
+LL | where
+LL ~     (): Sized;
+   |
+
+error: where clauses are not allowed before tuple struct bodies
+  --> $DIR/recover-where-clause-before-tuple-struct-body-0.rs:11:1
+   |
+LL |   struct _Demo
+   |          ----- while parsing this tuple struct
+LL | / where
+LL | |     (): Sized,
+LL | |     String: Clone,
+   | |__________________^ unexpected where clause
+LL |   (pub usize, usize);
+   |   ------------------ the struct body
+   |
+help: move the body before the where clause
+   |
+LL ~ struct _Demo(pub usize, usize)
+LL | where
+LL |     (): Sized,
+LL ~     String: Clone;
+   |
+
+error: aborting due to 2 previous errors
+

tests/ui/parser/recover-where-clause-before-tuple-struct-body-1.rs

@@ -0,0 +1,7 @@
+// Regression test for issues #100790 and #106439.
+
+// Make sure that we still show a helpful error message even if the trailing semicolon is missing.
+
+struct Foo<T> where T: MyTrait, (T)
+//~^ ERROR where clauses are not allowed before tuple struct bodies
+//~| ERROR expected `;`, found `<eof>`

tests/ui/parser/recover-where-clause-before-tuple-struct-body-1.stderr

@@ -0,0 +1,23 @@
+error: where clauses are not allowed before tuple struct bodies
+  --> $DIR/recover-where-clause-before-tuple-struct-body-1.rs:5:15
+   |
+LL | struct Foo<T> where T: MyTrait, (T)
+   |        ---    ^^^^^^^^^^^^^^^^^ --- the struct body
+   |        |      |
+   |        |      unexpected where clause
+   |        while parsing this tuple struct
+   |
+help: move the body before the where clause
+   |
+LL - struct Foo<T> where T: MyTrait, (T)
+LL + struct Foo<T>(T) where T: MyTrait
+   |
+
+error: expected `;`, found `<eof>`
+  --> $DIR/recover-where-clause-before-tuple-struct-body-1.rs:5:35
+   |
+LL | struct Foo<T> where T: MyTrait, (T)
+   |                                   ^ expected `;`
+
+error: aborting due to 2 previous errors
+