@@ -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