@@ -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 ;
@@ -1329,85 +1329,65 @@ impl<'a> Parser<'a> {
1329
1329
let id = self . parse_ident ( ) ?;
1330
1330
let mut generics = self . parse_generics ( ) ?;
1331
1331
generics. where_clause = self . parse_where_clause ( ) ?;
1332
- self . expect ( & token:: OpenDelim ( token:: Brace ) ) ?;
1333
1332
1334
- let enum_definition = self . parse_enum_def ( & generics) . map_err ( |e| {
1333
+ let ( variants, _) = self . parse_delim_comma_seq (
1334
+ token:: Brace ,
1335
+ |p| p. parse_enum_item ( ) ,
1336
+ ) . map_err ( |e| {
1335
1337
self . recover_stmt ( ) ;
1336
- self . eat ( & token:: CloseDelim ( token:: Brace ) ) ;
1337
1338
e
1338
1339
} ) ?;
1340
+
1341
+ let enum_definition = EnumDef {
1342
+ variants : variants. into_iter ( ) . filter_map ( |v| v) . collect ( ) ,
1343
+ } ;
1339
1344
Ok ( ( id, ItemKind :: Enum ( enum_definition, generics) , None ) )
1340
1345
}
1341
1346
1342
- /// Parses the part of an enum declaration following the `{`.
1343
- fn parse_enum_def ( & mut self , _generics : & Generics ) -> PResult < ' a , EnumDef > {
1344
- let mut variants = Vec :: new ( ) ;
1345
- // FIXME: Consider using `parse_delim_comma_seq`.
1346
- // We could then remove eating comma in `recover_nested_adt_item`.
1347
- while self . token != token:: CloseDelim ( token:: Brace ) {
1348
- let variant_attrs = self . parse_outer_attributes ( ) ?;
1349
- let vlo = self . token . span ;
1350
-
1351
- let vis = self . parse_visibility ( FollowedByType :: No ) ?;
1352
- if !self . recover_nested_adt_item ( kw:: Enum ) ? {
1353
- // Item already parsed, we need to skip this variant.
1354
- continue
1355
- }
1356
- let ident = self . parse_ident ( ) ?;
1347
+ fn parse_enum_item ( & mut self ) -> PResult < ' a , Option < Variant > > {
1348
+ let variant_attrs = self . parse_outer_attributes ( ) ?;
1349
+ let vlo = self . token . span ;
1357
1350
1358
- let struct_def = if self . check ( & token:: OpenDelim ( token:: Brace ) ) {
1359
- // Parse a struct variant.
1360
- let ( fields, recovered) = self . parse_record_struct_body ( ) ?;
1361
- VariantData :: Struct ( fields, recovered)
1362
- } else if self . check ( & token:: OpenDelim ( token:: Paren ) ) {
1363
- VariantData :: Tuple (
1364
- self . parse_tuple_struct_body ( ) ?,
1365
- DUMMY_NODE_ID ,
1366
- )
1367
- } else {
1368
- VariantData :: Unit ( DUMMY_NODE_ID )
1369
- } ;
1351
+ let vis = self . parse_visibility ( FollowedByType :: No ) ?;
1352
+ if !self . recover_nested_adt_item ( kw:: Enum ) ? {
1353
+ return Ok ( None )
1354
+ }
1355
+ let ident = self . parse_ident ( ) ?;
1370
1356
1371
- let disr_expr = if self . eat ( & token:: Eq ) {
1372
- Some ( AnonConst {
1373
- id : DUMMY_NODE_ID ,
1374
- value : self . parse_expr ( ) ?,
1375
- } )
1376
- } else {
1377
- None
1378
- } ;
1357
+ let struct_def = if self . check ( & token:: OpenDelim ( token:: Brace ) ) {
1358
+ // Parse a struct variant.
1359
+ let ( fields, recovered) = self . parse_record_struct_body ( ) ?;
1360
+ VariantData :: Struct ( fields, recovered)
1361
+ } else if self . check ( & token:: OpenDelim ( token:: Paren ) ) {
1362
+ VariantData :: Tuple (
1363
+ self . parse_tuple_struct_body ( ) ?,
1364
+ DUMMY_NODE_ID ,
1365
+ )
1366
+ } else {
1367
+ VariantData :: Unit ( DUMMY_NODE_ID )
1368
+ } ;
1379
1369
1380
- let vr = ast:: Variant {
1381
- ident,
1382
- vis,
1370
+ let disr_expr = if self . eat ( & token:: Eq ) {
1371
+ Some ( AnonConst {
1383
1372
id : DUMMY_NODE_ID ,
1384
- attrs : variant_attrs,
1385
- data : struct_def,
1386
- disr_expr,
1387
- span : vlo. to ( self . prev_span ) ,
1388
- is_placeholder : false ,
1389
- } ;
1390
- variants. push ( vr) ;
1373
+ value : self . parse_expr ( ) ?,
1374
+ } )
1375
+ } else {
1376
+ None
1377
+ } ;
1391
1378
1392
- if !self . eat ( & token:: Comma ) {
1393
- if self . token . is_ident ( ) && !self . token . is_reserved_ident ( ) {
1394
- let sp = self . sess . source_map ( ) . next_point ( self . prev_span ) ;
1395
- self . struct_span_err ( sp, "missing comma" )
1396
- . span_suggestion_short (
1397
- sp,
1398
- "missing comma" ,
1399
- "," . to_owned ( ) ,
1400
- Applicability :: MaybeIncorrect ,
1401
- )
1402
- . emit ( ) ;
1403
- } else {
1404
- break ;
1405
- }
1406
- }
1407
- }
1408
- self . expect ( & token:: CloseDelim ( token:: Brace ) ) ?;
1379
+ let vr = ast:: Variant {
1380
+ ident,
1381
+ vis,
1382
+ id : DUMMY_NODE_ID ,
1383
+ attrs : variant_attrs,
1384
+ data : struct_def,
1385
+ disr_expr,
1386
+ span : vlo. to ( self . prev_span ) ,
1387
+ is_placeholder : false ,
1388
+ } ;
1409
1389
1410
- Ok ( ast :: EnumDef { variants } )
1390
+ Ok ( Some ( vr ) )
1411
1391
}
1412
1392
1413
1393
/// Parses `struct Foo { ... }`.
@@ -1764,7 +1744,6 @@ impl<'a> Parser<'a> {
1764
1744
let kw_token = self . token . clone ( ) ;
1765
1745
let kw_str = pprust:: token_to_string ( & kw_token) ;
1766
1746
let item = self . parse_item ( ) ?;
1767
- self . eat ( & token:: Comma ) ;
1768
1747
1769
1748
self . struct_span_err (
1770
1749
kw_token. span ,
0 commit comments