@@ -1283,12 +1283,10 @@ impl<'a> Parser<'a> {
12831283 /// Parses an enum declaration.
12841284 fn parse_item_enum ( & mut self ) -> PResult < ' a , ItemInfo > {
12851285 if self . token . is_keyword ( kw:: Struct ) {
1286- let mut err = self . struct_span_err (
1287- self . prev_token . span . to ( self . token . span ) ,
1288- "`enum` and `struct` are mutually exclusive" ,
1289- ) ;
1286+ let span = self . prev_token . span . to ( self . token . span ) ;
1287+ let mut err = self . struct_span_err ( span, "`enum` and `struct` are mutually exclusive" ) ;
12901288 err. span_suggestion (
1291- self . prev_token . span . to ( self . token . span ) ,
1289+ span,
12921290 "replace `enum struct` with" ,
12931291 "enum" ,
12941292 Applicability :: MachineApplicable ,
@@ -1307,7 +1305,8 @@ impl<'a> Parser<'a> {
13071305
13081306 let ( variants, _) = self
13091307 . parse_delim_comma_seq ( Delimiter :: Brace , |p| p. parse_enum_variant ( ) )
1310- . map_err ( |e| {
1308+ . map_err ( |mut e| {
1309+ e. span_label ( id. span , "while parsing this enum" ) ;
13111310 self . recover_stmt ( ) ;
13121311 e
13131312 } ) ?;
@@ -1332,7 +1331,8 @@ impl<'a> Parser<'a> {
13321331
13331332 let struct_def = if this. check ( & token:: OpenDelim ( Delimiter :: Brace ) ) {
13341333 // Parse a struct variant.
1335- let ( fields, recovered) = this. parse_record_struct_body ( "struct" , false ) ?;
1334+ let ( fields, recovered) =
1335+ this. parse_record_struct_body ( "struct" , ident. span , false ) ?;
13361336 VariantData :: Struct ( fields, recovered)
13371337 } else if this. check ( & token:: OpenDelim ( Delimiter :: Parenthesis ) ) {
13381338 VariantData :: Tuple ( this. parse_tuple_struct_body ( ) ?, DUMMY_NODE_ID )
@@ -1386,17 +1386,23 @@ impl<'a> Parser<'a> {
13861386 VariantData :: Unit ( DUMMY_NODE_ID )
13871387 } else {
13881388 // If we see: `struct Foo<T> where T: Copy { ... }`
1389- let ( fields, recovered) =
1390- self . parse_record_struct_body ( "struct" , generics. where_clause . has_where_token ) ?;
1389+ let ( fields, recovered) = self . parse_record_struct_body (
1390+ "struct" ,
1391+ class_name. span ,
1392+ generics. where_clause . has_where_token ,
1393+ ) ?;
13911394 VariantData :: Struct ( fields, recovered)
13921395 }
13931396 // No `where` so: `struct Foo<T>;`
13941397 } else if self . eat ( & token:: Semi ) {
13951398 VariantData :: Unit ( DUMMY_NODE_ID )
13961399 // Record-style struct definition
13971400 } else if self . token == token:: OpenDelim ( Delimiter :: Brace ) {
1398- let ( fields, recovered) =
1399- self . parse_record_struct_body ( "struct" , generics. where_clause . has_where_token ) ?;
1401+ let ( fields, recovered) = self . parse_record_struct_body (
1402+ "struct" ,
1403+ class_name. span ,
1404+ generics. where_clause . has_where_token ,
1405+ ) ?;
14001406 VariantData :: Struct ( fields, recovered)
14011407 // Tuple-style struct definition with optional where-clause.
14021408 } else if self . token == token:: OpenDelim ( Delimiter :: Parenthesis ) {
@@ -1425,12 +1431,18 @@ impl<'a> Parser<'a> {
14251431
14261432 let vdata = if self . token . is_keyword ( kw:: Where ) {
14271433 generics. where_clause = self . parse_where_clause ( ) ?;
1428- let ( fields, recovered) =
1429- self . parse_record_struct_body ( "union" , generics. where_clause . has_where_token ) ?;
1434+ let ( fields, recovered) = self . parse_record_struct_body (
1435+ "union" ,
1436+ class_name. span ,
1437+ generics. where_clause . has_where_token ,
1438+ ) ?;
14301439 VariantData :: Struct ( fields, recovered)
14311440 } else if self . token == token:: OpenDelim ( Delimiter :: Brace ) {
1432- let ( fields, recovered) =
1433- self . parse_record_struct_body ( "union" , generics. where_clause . has_where_token ) ?;
1441+ let ( fields, recovered) = self . parse_record_struct_body (
1442+ "union" ,
1443+ class_name. span ,
1444+ generics. where_clause . has_where_token ,
1445+ ) ?;
14341446 VariantData :: Struct ( fields, recovered)
14351447 } else {
14361448 let token_str = super :: token_descr ( & self . token ) ;
@@ -1446,6 +1458,7 @@ impl<'a> Parser<'a> {
14461458 fn parse_record_struct_body (
14471459 & mut self ,
14481460 adt_ty : & str ,
1461+ ident_span : Span ,
14491462 parsed_where : bool ,
14501463 ) -> PResult < ' a , ( Vec < FieldDef > , /* recovered */ bool ) > {
14511464 let mut fields = Vec :: new ( ) ;
@@ -1460,6 +1473,7 @@ impl<'a> Parser<'a> {
14601473 match field {
14611474 Ok ( field) => fields. push ( field) ,
14621475 Err ( mut err) => {
1476+ err. span_label ( ident_span, format ! ( "while parsing this {adt_ty}" ) ) ;
14631477 err. emit ( ) ;
14641478 break ;
14651479 }
0 commit comments