@@ -7,7 +7,7 @@ use syntax::ast::{self, DUMMY_NODE_ID, Ident, Attribute, AttrKind, AttrStyle, An
7
7
use syntax:: ast:: { ItemKind , ImplItem , ImplItemKind , TraitItem , TraitItemKind , UseTree , UseTreeKind } ;
8
8
use syntax:: ast:: { PathSegment , IsAuto , Constness , IsAsync , Unsafety , Defaultness , Extern , StrLit } ;
9
9
use syntax:: ast:: { Visibility , VisibilityKind , Mutability , FnHeader , ForeignItem , ForeignItemKind } ;
10
- use syntax:: ast:: { Ty , TyKind , Generics , TraitRef , EnumDef , VariantData , StructField } ;
10
+ use syntax:: ast:: { Ty , TyKind , Generics , TraitRef , EnumDef , Variant , VariantData , StructField } ;
11
11
use syntax:: ast:: { Mac , MacDelimiter , Block , BindingMode , FnDecl , FnSig , SelfKind , Param } ;
12
12
use syntax:: print:: pprust;
13
13
use syntax:: ptr:: P ;
@@ -1324,85 +1324,65 @@ impl<'a> Parser<'a> {
1324
1324
let id = self . parse_ident ( ) ?;
1325
1325
let mut generics = self . parse_generics ( ) ?;
1326
1326
generics. where_clause = self . parse_where_clause ( ) ?;
1327
- self . expect ( & token:: OpenDelim ( token:: Brace ) ) ?;
1328
1327
1329
- let enum_definition = self . parse_enum_def ( & generics) . map_err ( |e| {
1328
+ let ( variants, _) = self . parse_delim_comma_seq (
1329
+ token:: Brace ,
1330
+ |p| p. parse_enum_item ( ) ,
1331
+ ) . map_err ( |e| {
1330
1332
self . recover_stmt ( ) ;
1331
- self . eat ( & token:: CloseDelim ( token:: Brace ) ) ;
1332
1333
e
1333
1334
} ) ?;
1335
+
1336
+ let enum_definition = EnumDef {
1337
+ variants : variants. into_iter ( ) . filter_map ( |v| v) . collect ( ) ,
1338
+ } ;
1334
1339
Ok ( ( id, ItemKind :: Enum ( enum_definition, generics) , None ) )
1335
1340
}
1336
1341
1337
- /// Parses the part of an enum declaration following the `{`.
1338
- fn parse_enum_def ( & mut self , _generics : & Generics ) -> PResult < ' a , EnumDef > {
1339
- let mut variants = Vec :: new ( ) ;
1340
- // FIXME: Consider using `parse_delim_comma_seq`.
1341
- // We could then remove eating comma in `recover_nested_adt_item`.
1342
- while self . token != token:: CloseDelim ( token:: Brace ) {
1343
- let variant_attrs = self . parse_outer_attributes ( ) ?;
1344
- let vlo = self . token . span ;
1345
-
1346
- let vis = self . parse_visibility ( FollowedByType :: No ) ?;
1347
- if !self . recover_nested_adt_item ( kw:: Enum ) ? {
1348
- // Item already parsed, we need to skip this variant.
1349
- continue
1350
- }
1351
- let ident = self . parse_ident ( ) ?;
1342
+ fn parse_enum_item ( & mut self ) -> PResult < ' a , Option < Variant > > {
1343
+ let variant_attrs = self . parse_outer_attributes ( ) ?;
1344
+ let vlo = self . token . span ;
1352
1345
1353
- let struct_def = if self . check ( & token:: OpenDelim ( token:: Brace ) ) {
1354
- // Parse a struct variant.
1355
- let ( fields, recovered) = self . parse_record_struct_body ( ) ?;
1356
- VariantData :: Struct ( fields, recovered)
1357
- } else if self . check ( & token:: OpenDelim ( token:: Paren ) ) {
1358
- VariantData :: Tuple (
1359
- self . parse_tuple_struct_body ( ) ?,
1360
- DUMMY_NODE_ID ,
1361
- )
1362
- } else {
1363
- VariantData :: Unit ( DUMMY_NODE_ID )
1364
- } ;
1346
+ let vis = self . parse_visibility ( FollowedByType :: No ) ?;
1347
+ if !self . recover_nested_adt_item ( kw:: Enum ) ? {
1348
+ return Ok ( None )
1349
+ }
1350
+ let ident = self . parse_ident ( ) ?;
1365
1351
1366
- let disr_expr = if self . eat ( & token:: Eq ) {
1367
- Some ( AnonConst {
1368
- id : DUMMY_NODE_ID ,
1369
- value : self . parse_expr ( ) ?,
1370
- } )
1371
- } else {
1372
- None
1373
- } ;
1352
+ let struct_def = if self . check ( & token:: OpenDelim ( token:: Brace ) ) {
1353
+ // Parse a struct variant.
1354
+ let ( fields, recovered) = self . parse_record_struct_body ( ) ?;
1355
+ VariantData :: Struct ( fields, recovered)
1356
+ } else if self . check ( & token:: OpenDelim ( token:: Paren ) ) {
1357
+ VariantData :: Tuple (
1358
+ self . parse_tuple_struct_body ( ) ?,
1359
+ DUMMY_NODE_ID ,
1360
+ )
1361
+ } else {
1362
+ VariantData :: Unit ( DUMMY_NODE_ID )
1363
+ } ;
1374
1364
1375
- let vr = ast:: Variant {
1376
- ident,
1377
- vis,
1365
+ let disr_expr = if self . eat ( & token:: Eq ) {
1366
+ Some ( AnonConst {
1378
1367
id : DUMMY_NODE_ID ,
1379
- attrs : variant_attrs,
1380
- data : struct_def,
1381
- disr_expr,
1382
- span : vlo. to ( self . prev_span ) ,
1383
- is_placeholder : false ,
1384
- } ;
1385
- variants. push ( vr) ;
1368
+ value : self . parse_expr ( ) ?,
1369
+ } )
1370
+ } else {
1371
+ None
1372
+ } ;
1386
1373
1387
- if !self . eat ( & token:: Comma ) {
1388
- if self . token . is_ident ( ) && !self . token . is_reserved_ident ( ) {
1389
- let sp = self . sess . source_map ( ) . next_point ( self . prev_span ) ;
1390
- self . struct_span_err ( sp, "missing comma" )
1391
- . span_suggestion_short (
1392
- sp,
1393
- "missing comma" ,
1394
- "," . to_owned ( ) ,
1395
- Applicability :: MaybeIncorrect ,
1396
- )
1397
- . emit ( ) ;
1398
- } else {
1399
- break ;
1400
- }
1401
- }
1402
- }
1403
- self . expect ( & token:: CloseDelim ( token:: Brace ) ) ?;
1374
+ let vr = ast:: Variant {
1375
+ ident,
1376
+ vis,
1377
+ id : DUMMY_NODE_ID ,
1378
+ attrs : variant_attrs,
1379
+ data : struct_def,
1380
+ disr_expr,
1381
+ span : vlo. to ( self . prev_span ) ,
1382
+ is_placeholder : false ,
1383
+ } ;
1404
1384
1405
- Ok ( ast :: EnumDef { variants } )
1385
+ Ok ( Some ( vr ) )
1406
1386
}
1407
1387
1408
1388
/// Parses `struct Foo { ... }`.
@@ -1759,7 +1739,6 @@ impl<'a> Parser<'a> {
1759
1739
let kw_token = self . token . clone ( ) ;
1760
1740
let kw_str = pprust:: token_to_string ( & kw_token) ;
1761
1741
let item = self . parse_item ( ) ?;
1762
- self . eat ( & token:: Comma ) ;
1763
1742
1764
1743
self . struct_span_err (
1765
1744
kw_token. span ,
0 commit comments