@@ -7,7 +7,7 @@ use syntax::ast::{self, DUMMY_NODE_ID, Ident, Attribute, AttrKind, AttrStyle, An
77use syntax:: ast:: { ItemKind , ImplItem , ImplItemKind , TraitItem , TraitItemKind , UseTree , UseTreeKind } ;
88use syntax:: ast:: { PathSegment , IsAuto , Constness , IsAsync , Unsafety , Defaultness , Extern , StrLit } ;
99use 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 } ;
1111use syntax:: ast:: { Mac , MacDelimiter , Block , BindingMode , FnDecl , FnSig , SelfKind , Param } ;
1212use syntax:: print:: pprust;
1313use syntax:: ptr:: P ;
@@ -1329,85 +1329,65 @@ impl<'a> Parser<'a> {
13291329 let id = self . parse_ident ( ) ?;
13301330 let mut generics = self . parse_generics ( ) ?;
13311331 generics. where_clause = self . parse_where_clause ( ) ?;
1332- self . expect ( & token:: OpenDelim ( token:: Brace ) ) ?;
13331332
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| {
13351337 self . recover_stmt ( ) ;
1336- self . eat ( & token:: CloseDelim ( token:: Brace ) ) ;
13371338 e
13381339 } ) ?;
1340+
1341+ let enum_definition = EnumDef {
1342+ variants : variants. into_iter ( ) . filter_map ( |v| v) . collect ( ) ,
1343+ } ;
13391344 Ok ( ( id, ItemKind :: Enum ( enum_definition, generics) , None ) )
13401345 }
13411346
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 ;
13571350
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 ( ) ?;
13701356
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+ } ;
13791369
1380- let vr = ast:: Variant {
1381- ident,
1382- vis,
1370+ let disr_expr = if self . eat ( & token:: Eq ) {
1371+ Some ( AnonConst {
13831372 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+ } ;
13911378
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+ } ;
14091389
1410- Ok ( ast :: EnumDef { variants } )
1390+ Ok ( Some ( vr ) )
14111391 }
14121392
14131393 /// Parses `struct Foo { ... }`.
@@ -1764,7 +1744,6 @@ impl<'a> Parser<'a> {
17641744 let kw_token = self . token . clone ( ) ;
17651745 let kw_str = pprust:: token_to_string ( & kw_token) ;
17661746 let item = self . parse_item ( ) ?;
1767- self . eat ( & token:: Comma ) ;
17681747
17691748 self . struct_span_err (
17701749 kw_token. span ,
0 commit comments