librustc: Remove common fields and nested enums from the language

11 files changed, 34 insertions, 87 deletions

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 6b788810a79..7304eb20bca 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -1078,7 +1078,6 @@ pub struct variant_arg {
 pub enum variant_kind {
     tuple_variant_kind(~[variant_arg]),
     struct_variant_kind(@struct_def),
-    enum_variant_kind(enum_def)
 }
 
 #[auto_encode]
@@ -1086,7 +1085,6 @@ pub enum variant_kind {
 #[deriving(Eq)]
 pub struct enum_def {
     variants: ~[variant],
-    common: Option<@struct_def>,
 }
 
 #[auto_encode]
diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs
index 2a112f106a8..d7e0e9aa550 100644
--- a/src/libsyntax/ext/auto_encode.rs
+++ b/src/libsyntax/ext/auto_encode.rs
@@ -990,8 +990,6 @@ fn mk_enum_ser_body(
                 ),
             ast::struct_variant_kind(*) =>
                 fail!(~"struct variants unimplemented"),
-            ast::enum_variant_kind(*) =>
-                fail!(~"enum variants unimplemented"),
         }
     };
 
@@ -1089,8 +1087,6 @@ fn mk_enum_deser_body(
             },
             ast::struct_variant_kind(*) =>
                 fail!(~"struct variants unimplemented"),
-            ast::enum_variant_kind(*) =>
-                fail!(~"enum variants unimplemented")
         };
 
         let pat = @ast::pat {
diff --git a/src/libsyntax/ext/deriving/clone.rs b/src/libsyntax/ext/deriving/clone.rs
index df4dd2735fc..6516bd85270 100644
--- a/src/libsyntax/ext/deriving/clone.rs
+++ b/src/libsyntax/ext/deriving/clone.rs
@@ -12,7 +12,7 @@ use core::prelude::*;
 
 use ast;
 use ast::{TraitTyParamBound, Ty, and, bind_by_ref, binop, deref, enum_def};
-use ast::{enum_variant_kind, expr, expr_match, ident, impure_fn, item, item_};
+use ast::{expr, expr_match, ident, impure_fn, item, item_};
 use ast::{item_enum, item_impl, item_struct, Generics};
 use ast::{m_imm, meta_item, method};
 use ast::{named_field, or, pat, pat_ident, pat_wild, public, pure_fn};
diff --git a/src/libsyntax/ext/deriving/eq.rs b/src/libsyntax/ext/deriving/eq.rs
index 531390035db..a1cb981e3bd 100644
--- a/src/libsyntax/ext/deriving/eq.rs
+++ b/src/libsyntax/ext/deriving/eq.rs
@@ -12,7 +12,7 @@ use core::prelude::*;
 
 use ast;
 use ast::{TraitTyParamBound, Ty, and, bind_by_ref, binop, deref, enum_def};
-use ast::{enum_variant_kind, expr, expr_match, ident, impure_fn, item, item_};
+use ast::{expr, expr_match, ident, impure_fn, item, item_};
 use ast::{item_enum, item_impl, item_struct, Generics};
 use ast::{m_imm, meta_item, method};
 use ast::{named_field, or, pat, pat_ident, pat_wild, public, pure_fn};
diff --git a/src/libsyntax/ext/deriving/iter_bytes.rs b/src/libsyntax/ext/deriving/iter_bytes.rs
index 528db0d1072..3be8bf6efb5 100644
--- a/src/libsyntax/ext/deriving/iter_bytes.rs
+++ b/src/libsyntax/ext/deriving/iter_bytes.rs
@@ -12,7 +12,7 @@ use core::prelude::*;
 
 use ast;
 use ast::{TraitTyParamBound, Ty, and, bind_by_ref, binop, deref, enum_def};
-use ast::{enum_variant_kind, expr, expr_match, ident, impure_fn, item, item_};
+use ast::{expr, expr_match, ident, impure_fn, item, item_};
 use ast::{item_enum, item_impl, item_struct, Generics};
 use ast::{m_imm, meta_item, method};
 use ast::{named_field, or, pat, pat_ident, pat_wild, public, pure_fn};
diff --git a/src/libsyntax/ext/deriving/mod.rs b/src/libsyntax/ext/deriving/mod.rs
index 21477d6e067..1b81380ec9b 100644
--- a/src/libsyntax/ext/deriving/mod.rs
+++ b/src/libsyntax/ext/deriving/mod.rs
@@ -15,7 +15,7 @@ use core::prelude::*;
 
 use ast;
 use ast::{TraitTyParamBound, Ty, and, bind_by_ref, binop, deref, enum_def};
-use ast::{enum_variant_kind, expr, expr_match, ident, impure_fn, item, item_};
+use ast::{expr, expr_match, ident, impure_fn, item, item_};
 use ast::{item_enum, item_impl, item_struct, Generics};
 use ast::{m_imm, meta_item, method};
 use ast::{named_field, or, pat, pat_ident, pat_wild, public, pure_fn};
@@ -283,9 +283,6 @@ pub fn create_enum_variant_pattern(cx: @ext_ctxt,
 
             build::mk_pat_struct(cx, span, matching_path, field_pats)
         }
-        enum_variant_kind(*) => {
-            cx.span_unimpl(span, ~"enum variants for `deriving`");
-        }
     }
 }
 
@@ -293,9 +290,6 @@ pub fn variant_arg_count(cx: @ext_ctxt, span: span, variant: &variant) -> uint {
     match variant.node.kind {
         tuple_variant_kind(ref args) => args.len(),
         struct_variant_kind(ref struct_def) => struct_def.fields.len(),
-        enum_variant_kind(*) => {
-            cx.span_bug(span, ~"variant_arg_count: enum variants deprecated")
-        }
     }
 }
 
diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs
index a7725eab695..99033b3b3cc 100644
--- a/src/libsyntax/ext/pipes/pipec.rs
+++ b/src/libsyntax/ext/pipes/pipec.rs
@@ -238,7 +238,7 @@ impl to_type_decls for state {
             cx.item_enum_poly(
                 name,
                 self.span,
-                ast::enum_def { variants: items_msg, common: None },
+                ast::enum_def { variants: items_msg },
                 cx.strip_bounds(&self.generics)
             )
         ]
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 279d57a291e..f0885afa580 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -257,9 +257,6 @@ pub fn noop_fold_item_underscore(i: &item_, fld: @ast_fold) -> item_ {
                     variants: do enum_definition.variants.map |x| {
                         fld.fold_variant(x)
                     },
-                    common: do enum_definition.common.map |x| {
-                        fold_struct_def(*x, fld)
-                    }
                 },
                 fold_generics(generics, fld))
         }
@@ -682,17 +679,6 @@ fn noop_fold_variant(v: &variant_, fld: @ast_fold) -> variant_ {
                 ctor_id: struct_def.ctor_id.map(|c| fld.new_id(*c))
             })
         }
-        enum_variant_kind(ref enum_definition) => {
-            let variants = do (*enum_definition).variants.map |x| {
-                fld.fold_variant(x)
-            };
-            let common = do (*enum_definition).common.map |x| {
-                fold_struct_def(*x, fld)
-            };
-            kind = enum_variant_kind(
-                ast::enum_def { variants: variants, common: common }
-            );
-        }
     }
 
     let fold_attribute = |x| fold_attribute_(x, fld);
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 6fe003b2eba..51a7f7fbd1c 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -19,7 +19,7 @@ use ast::{_mod, add, arg, arm, attribute, bind_by_ref, bind_infer};
 use ast::{bind_by_copy, bitand, bitor, bitxor, blk};
 use ast::{blk_check_mode, box, by_copy, by_ref};
 use ast::{crate, crate_cfg, decl, decl_item};
-use ast::{decl_local, default_blk, deref, div, enum_def, enum_variant_kind};
+use ast::{decl_local, default_blk, deref, div, enum_def};
 use ast::{expl, expr, expr_, expr_addr_of, expr_match, expr_again};
 use ast::{expr_assign, expr_assign_op, expr_binary, expr_block};
 use ast::{expr_break, expr_call, expr_cast, expr_copy, expr_do_body};
@@ -3788,63 +3788,42 @@ pub impl Parser {
     fn parse_enum_def(&self, generics: &ast::Generics) -> enum_def {
         let mut variants = ~[];
         let mut all_nullary = true, have_disr = false;
-        let mut common_fields = None;
-
         while *self.token != token::RBRACE {
             let variant_attrs = self.parse_outer_attributes();
             let vlo = self.span.lo;
 
-            // Is this a common field declaration?
-            if self.eat_keyword(&~"struct") {
-                if common_fields.is_some() {
-                    self.fatal(~"duplicate declaration of shared fields");
-                }
-                self.expect(&token::LBRACE);
-                common_fields = Some(self.parse_struct_def());
-                loop;
-            }
-
             let vis = self.parse_visibility();
 
-            // Is this a nested enum declaration?
             let ident, needs_comma, kind;
             let mut args = ~[], disr_expr = None;
-            if self.eat_keyword(&~"enum") {
-                ident = self.parse_ident();
-                self.expect(&token::LBRACE);
-                let nested_enum_def = self.parse_enum_def(generics);
-                kind = enum_variant_kind(nested_enum_def);
-                needs_comma = false;
-            } else {
-                ident = self.parse_ident();
-                if self.eat(&token::LBRACE) {
-                    // Parse a struct variant.
-                    all_nullary = false;
-                    kind = struct_variant_kind(self.parse_struct_def());
-                } else if *self.token == token::LPAREN {
-                    all_nullary = false;
-                    let arg_tys = self.parse_unspanned_seq(
-                        &token::LPAREN,
-                        &token::RPAREN,
-                        seq_sep_trailing_disallowed(token::COMMA),
-                        |p| p.parse_ty(false)
-                    );
-                    for arg_tys.each |ty| {
-                        args.push(ast::variant_arg {
-                            ty: *ty,
-                            id: self.get_id(),
-                        });
-                    }
-                    kind = tuple_variant_kind(args);
-                } else if self.eat(&token::EQ) {
-                    have_disr = true;
-                    disr_expr = Some(self.parse_expr());
-                    kind = tuple_variant_kind(args);
-                } else {
-                    kind = tuple_variant_kind(~[]);
+            ident = self.parse_ident();
+            if self.eat(&token::LBRACE) {
+                // Parse a struct variant.
+                all_nullary = false;
+                kind = struct_variant_kind(self.parse_struct_def());
+            } else if *self.token == token::LPAREN {
+                all_nullary = false;
+                let arg_tys = self.parse_unspanned_seq(
+                    &token::LPAREN,
+                    &token::RPAREN,
+                    seq_sep_trailing_disallowed(token::COMMA),
+                    |p| p.parse_ty(false)
+                );
+                for arg_tys.each |ty| {
+                    args.push(ast::variant_arg {
+                        ty: *ty,
+                        id: self.get_id(),
+                    });
                 }
-                needs_comma = true;
+                kind = tuple_variant_kind(args);
+            } else if self.eat(&token::EQ) {
+                have_disr = true;
+                disr_expr = Some(self.parse_expr());
+                kind = tuple_variant_kind(args);
+            } else {
+                kind = tuple_variant_kind(~[]);
             }
+            needs_comma = true;
 
             let vr = ast::variant_ {
                 name: ident,
@@ -3864,7 +3843,7 @@ pub impl Parser {
                         enum");
         }
 
-        ast::enum_def { variants: variants, common: common_fields }
+        ast::enum_def { variants: variants }
     }
 
     fn parse_item_enum(&self) -> item_info {
@@ -3892,7 +3871,7 @@ pub impl Parser {
             return (
                 id,
                 item_enum(
-                    ast::enum_def { variants: ~[variant], common: None },
+                    ast::enum_def { variants: ~[variant] },
                     generics),
                 None
             );
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index cb142ef3f54..58fbba752f5 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -785,9 +785,6 @@ pub fn print_variant(s: @ps, v: ast::variant) {
             let generics = ast_util::empty_generics();
             print_struct(s, struct_def, &generics, v.node.name, v.span);
         }
-        ast::enum_variant_kind(ref enum_definition) => {
-            print_variants(s, (*enum_definition).variants, v.span);
-        }
     }
     match v.node.disr_expr {
       Some(d) => {
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 2bdf26fba58..33b345e2d11 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -215,9 +215,6 @@ pub fn visit_enum_def<E>(enum_definition: ast::enum_def,
                 (v.visit_struct_def)(struct_def, vr.node.name, tps,
                                    vr.node.id, e, v);
             }
-            enum_variant_kind(ref enum_definition) => {
-                visit_enum_def((*enum_definition), tps, e, v);
-            }
         }
         // Visit the disr expr if it exists
         for vr.node.disr_expr.each |ex| { (v.visit_expr)(*ex, e, v) }