@@ -2950,38 +2950,49 @@ class parser {
2950
2950
}
2951
2951
2952
2952
let vis = self . parse_visibility ( ) ;
2953
- let ident = self . parse_value_ident ( ) ;
2953
+
2954
+ // Is this a nested enum declaration?
2955
+ let ident, needs_comma, kind;
2954
2956
let mut args = ~[ ] , disr_expr = none;
2955
- let kind;
2956
- if self . eat ( token:: LBRACE ) {
2957
- // Parse a struct variant.
2958
- all_nullary = false ;
2959
- let path = self . ident_to_path_tys ( ident, ty_params) ;
2960
- kind = struct_variant_kind ( self . parse_struct_def ( path) ) ;
2961
- } else if self . token == token:: LPAREN {
2962
- all_nullary = false ;
2963
- let arg_tys = self . parse_unspanned_seq (
2964
- token:: LPAREN , token:: RPAREN ,
2965
- seq_sep_trailing_disallowed ( token:: COMMA ) ,
2966
- |p| p. parse_ty ( false ) ) ;
2967
- for arg_tys. each |ty| {
2968
- vec:: push( args, { ty: ty, id: self . get_id( ) } ) ;
2969
- }
2970
- kind = tuple_variant_kind ( args) ;
2971
- } else if self . eat ( token:: EQ ) {
2972
- have_disr = true ;
2973
- disr_expr = some ( self . parse_expr ( ) ) ;
2974
- kind = tuple_variant_kind ( args) ;
2957
+ if self . eat_keyword ( ~"enum ") {
2958
+ ident = self . parse_ident ( ) ;
2959
+ self . expect ( token:: LBRACE ) ;
2960
+ let nested_enum_def = self . parse_enum_def ( ident, ty_params) ;
2961
+ kind = enum_variant_kind ( move nested_enum_def) ;
2962
+ needs_comma = false ;
2975
2963
} else {
2976
- kind = tuple_variant_kind ( ~[ ] ) ;
2964
+ ident = self . parse_value_ident ( ) ;
2965
+ if self . eat ( token:: LBRACE ) {
2966
+ // Parse a struct variant.
2967
+ all_nullary = false ;
2968
+ let path = self . ident_to_path_tys ( ident, ty_params) ;
2969
+ kind = struct_variant_kind ( self . parse_struct_def ( path) ) ;
2970
+ } else if self . token == token:: LPAREN {
2971
+ all_nullary = false ;
2972
+ let arg_tys = self . parse_unspanned_seq (
2973
+ token:: LPAREN , token:: RPAREN ,
2974
+ seq_sep_trailing_disallowed ( token:: COMMA ) ,
2975
+ |p| p. parse_ty ( false ) ) ;
2976
+ for arg_tys. each |ty| {
2977
+ vec:: push( args, { ty: ty, id: self . get_id( ) } ) ;
2978
+ }
2979
+ kind = tuple_variant_kind ( args) ;
2980
+ } else if self . eat ( token:: EQ ) {
2981
+ have_disr = true ;
2982
+ disr_expr = some ( self . parse_expr ( ) ) ;
2983
+ kind = tuple_variant_kind ( args) ;
2984
+ } else {
2985
+ kind = tuple_variant_kind ( ~[ ] ) ;
2986
+ }
2987
+ needs_comma = true ;
2977
2988
}
2978
2989
2979
2990
let vr = { name: ident, attrs: variant_attrs,
2980
2991
kind: kind, id: self . get_id ( ) ,
2981
2992
disr_expr: disr_expr, vis: vis} ;
2982
2993
vec:: push ( variants, spanned ( vlo, self . last_span . hi , vr) ) ;
2983
2994
2984
- if !self . eat ( token:: COMMA ) { break ; }
2995
+ if needs_comma && !self . eat ( token:: COMMA ) { break ; }
2985
2996
}
2986
2997
self . expect ( token:: RBRACE ) ;
2987
2998
if ( have_disr && !all_nullary) {
0 commit comments