@@ -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 ;
@@ -1324,85 +1324,65 @@ impl<'a> Parser<'a> {
13241324 let id = self . parse_ident ( ) ?;
13251325 let mut generics = self . parse_generics ( ) ?;
13261326 generics. where_clause = self . parse_where_clause ( ) ?;
1327- self . expect ( & token:: OpenDelim ( token:: Brace ) ) ?;
13281327
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| {
13301332 self . recover_stmt ( ) ;
1331- self . eat ( & token:: CloseDelim ( token:: Brace ) ) ;
13321333 e
13331334 } ) ?;
1335+
1336+ let enum_definition = EnumDef {
1337+ variants : variants. into_iter ( ) . filter_map ( |v| v) . collect ( ) ,
1338+ } ;
13341339 Ok ( ( id, ItemKind :: Enum ( enum_definition, generics) , None ) )
13351340 }
13361341
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 ;
13521345
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 ( ) ?;
13651351
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+ } ;
13741364
1375- let vr = ast:: Variant {
1376- ident,
1377- vis,
1365+ let disr_expr = if self . eat ( & token:: Eq ) {
1366+ Some ( AnonConst {
13781367 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+ } ;
13861373
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+ } ;
14041384
1405- Ok ( ast :: EnumDef { variants } )
1385+ Ok ( Some ( vr ) )
14061386 }
14071387
14081388 /// Parses `struct Foo { ... }`.
@@ -1759,7 +1739,6 @@ impl<'a> Parser<'a> {
17591739 let kw_token = self . token . clone ( ) ;
17601740 let kw_str = pprust:: token_to_string ( & kw_token) ;
17611741 let item = self . parse_item ( ) ?;
1762- self . eat ( & token:: Comma ) ;
17631742
17641743 self . struct_span_err (
17651744 kw_token. span ,
0 commit comments