Merge VariantData and VariantData_

7 files changed, 57 insertions, 72 deletions

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 34181b2e097..7c82813775e 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -1742,18 +1742,10 @@ impl StructFieldKind {
 }
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum VariantData_ {
-    Struct(Vec<StructField>),
-    Tuple(Vec<StructField>),
-    Unit,
-}
-
-#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub struct VariantData {
-    pub data_: VariantData_,
-    /// ID of the constructor. This is only used for tuple- or enum-like
-    /// structs.
-    pub id: NodeId,
+pub enum VariantData {
+    Struct(Vec<StructField>, NodeId),
+    Tuple(Vec<StructField>, NodeId),
+    Unit(NodeId),
 }
 
 pub type FieldIter<'a> = iter::FlatMap<option::IntoIter<&'a Vec<StructField>>,
@@ -1763,19 +1755,24 @@ pub type FieldIter<'a> = iter::FlatMap<option::IntoIter<&'a Vec<StructField>>,
 impl VariantData {
     pub fn fields(&self) -> FieldIter {
         fn vec_iter<T>(v: &Vec<T>) -> slice::Iter<T> { v.iter() }
-        match self.data_ {
-            VariantData_::Struct(ref fields) | VariantData_::Tuple(ref fields) => Some(fields),
+        match *self {
+            VariantData::Struct(ref fields, _) | VariantData::Tuple(ref fields, _) => Some(fields),
             _ => None,
         }.into_iter().flat_map(vec_iter)
     }
+    pub fn id(&self) -> NodeId {
+        match *self {
+            VariantData::Struct(_, id) | VariantData::Tuple(_, id) | VariantData::Unit(id) => id
+        }
+    }
     pub fn is_struct(&self) -> bool {
-        if let VariantData_::Struct(..) = self.data_ { true } else { false }
+        if let VariantData::Struct(..) = *self { true } else { false }
     }
     pub fn is_tuple(&self) -> bool {
-        if let VariantData_::Tuple(..) = self.data_ { true } else { false }
+        if let VariantData::Tuple(..) = *self { true } else { false }
     }
     pub fn is_unit(&self) -> bool {
-        if let VariantData_::Unit = self.data_ { true } else { false }
+        if let VariantData::Unit(..) = *self { true } else { false }
     }
 }
 
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 42382d0459f..8c3360512d5 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -458,7 +458,7 @@ impl<'a, 'v, O: IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> {
                         _: &ast::Generics,
                         _: NodeId,
                         _: Span) {
-        self.operation.visit_id(struct_def.id);
+        self.operation.visit_id(struct_def.id());
         visit::walk_struct_def(self, struct_def);
     }
 
diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs
index 739bb36d985..0ca110c5b1e 100644
--- a/src/libsyntax/config.rs
+++ b/src/libsyntax/config.rs
@@ -167,22 +167,19 @@ fn fold_item_underscore<F>(cx: &mut Context<F>, item: ast::Item_) -> ast::Item_
 fn fold_struct<F>(cx: &mut Context<F>, def: P<ast::VariantData>) -> P<ast::VariantData> where
     F: FnMut(&[ast::Attribute]) -> bool
 {
-    def.map(|ast::VariantData { data_, id }| {
-        ast::VariantData {
-            data_: match data_ {
-                ast::VariantData_::Struct(fields) => {
-                    ast::VariantData_::Struct(fields.into_iter().filter(|m| {
-                        (cx.in_cfg)(&m.node.attrs)
-                    }).collect())
-                }
-                ast::VariantData_::Tuple(fields) => {
-                    ast::VariantData_::Tuple(fields.into_iter().filter(|m| {
-                        (cx.in_cfg)(&m.node.attrs)
-                    }).collect())
-                }
-                ast::VariantData_::Unit => ast::VariantData_::Unit
-            },
-            id: id,
+    def.map(|vdata| {
+        match vdata {
+            ast::VariantData::Struct(fields, id) => {
+                ast::VariantData::Struct(fields.into_iter().filter(|m| {
+                    (cx.in_cfg)(&m.node.attrs)
+                }).collect(), id)
+            }
+            ast::VariantData::Tuple(fields, id) => {
+                ast::VariantData::Tuple(fields.into_iter().filter(|m| {
+                    (cx.in_cfg)(&m.node.attrs)
+                }).collect(), id)
+            }
+            ast::VariantData::Unit(id) => ast::VariantData::Unit(id)
         }
     })
 }
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 25657b9c6cc..9b06fbd0a0b 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -1002,18 +1002,17 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
             }}
         }).collect();
 
-        let data_ = if fields.is_empty() {
-            ast::VariantData_::Unit
+        let vdata = if fields.is_empty() {
+            ast::VariantData::Unit(ast::DUMMY_NODE_ID)
         } else {
-            ast::VariantData_::Tuple(fields)
+            ast::VariantData::Tuple(fields, ast::DUMMY_NODE_ID)
         };
 
         respan(span,
                ast::Variant_ {
                    name: name,
                    attrs: Vec::new(),
-                   data: P(ast::VariantData { data_: data_,
-                                           id: ast::DUMMY_NODE_ID}),
+                   data: P(vdata),
                    disr_expr: None,
                })
     }
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 329ffb286eb..219a4649339 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -815,17 +815,18 @@ pub fn noop_fold_where_predicate<T: Folder>(
 }
 
 pub fn noop_fold_struct_def<T: Folder>(struct_def: P<VariantData>, fld: &mut T) -> P<VariantData> {
-    struct_def.map(|VariantData { data_, id }| VariantData {
-        data_: match data_ {
-            ast::VariantData_::Struct(fields) => {
-                ast::VariantData_::Struct(fields.move_map(|f| fld.fold_struct_field(f)))
+    struct_def.map(|vdata| {
+        match vdata {
+            ast::VariantData::Struct(fields, id) => {
+                ast::VariantData::Struct(fields.move_map(|f| fld.fold_struct_field(f)),
+                                         fld.new_id(id))
             }
-            ast::VariantData_::Tuple(fields) => {
-                ast::VariantData_::Tuple(fields.move_map(|f| fld.fold_struct_field(f)))
+            ast::VariantData::Tuple(fields, id) => {
+                ast::VariantData::Tuple(fields.move_map(|f| fld.fold_struct_field(f)),
+                                        fld.new_id(id))
             }
-            ast::VariantData_::Unit => ast::VariantData_::Unit
-        },
-        id: fld.new_id(id),
+            ast::VariantData::Unit(id) => ast::VariantData::Unit(fld.new_id(id))
+        }
     })
 }
 
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 2431c8cbe88..934e4472bdc 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -45,7 +45,7 @@ use ast::{PatRegion, PatStruct, PatTup, PatVec, PatWild, PatWildMulti};
 use ast::PatWildSingle;
 use ast::{PolyTraitRef, QSelf};
 use ast::{Return, BiShl, BiShr, Stmt, StmtDecl};
-use ast::{StmtExpr, StmtSemi, StmtMac, VariantData, StructField, VariantData_};
+use ast::{StmtExpr, StmtSemi, StmtMac, VariantData, StructField};
 use ast::{BiSub, StrStyle};
 use ast::{SelfExplicit, SelfRegion, SelfStatic, SelfValue};
 use ast::{Delimited, SequenceRepetition, TokenTree, TraitItem, TraitRef};
@@ -4640,24 +4640,25 @@ impl<'a> Parser<'a> {
         // Otherwise if we look ahead and see a paren we parse a tuple-style
         // struct.
 
-        let data_ = if self.token.is_keyword(keywords::Where) {
+        let vdata = if self.token.is_keyword(keywords::Where) {
             generics.where_clause = try!(self.parse_where_clause());
             if try!(self.eat(&token::Semi)) {
                 // If we see a: `struct Foo<T> where T: Copy;` style decl.
-                VariantData_::Unit
+                VariantData::Unit(ast::DUMMY_NODE_ID)
             } else {
                 // If we see: `struct Foo<T> where T: Copy { ... }`
-                VariantData_::Struct(try!(self.parse_record_struct_body()))
+                VariantData::Struct(try!(self.parse_record_struct_body()), ast::DUMMY_NODE_ID)
             }
         // No `where` so: `struct Foo<T>;`
         } else if try!(self.eat(&token::Semi) ){
-            VariantData_::Unit
+            VariantData::Unit(ast::DUMMY_NODE_ID)
         // Record-style struct definition
         } else if self.token == token::OpenDelim(token::Brace) {
-            VariantData_::Struct(try!(self.parse_record_struct_body()))
+            VariantData::Struct(try!(self.parse_record_struct_body()), ast::DUMMY_NODE_ID)
         // Tuple-style struct definition with optional where-clause.
         } else if self.token == token::OpenDelim(token::Paren) {
-            VariantData_::Tuple(try!(self.parse_tuple_struct_body(&mut generics)))
+            VariantData::Tuple(try!(self.parse_tuple_struct_body(&mut generics)),
+                               ast::DUMMY_NODE_ID)
         } else {
             let token_str = self.this_token_to_string();
             return Err(self.fatal(&format!("expected `where`, `{{`, `(`, or `;` after struct \
@@ -4665,11 +4666,8 @@ impl<'a> Parser<'a> {
         };
 
         Ok((class_name,
-         ItemStruct(P(ast::VariantData {
-             data_: data_,
-             id: ast::DUMMY_NODE_ID,
-         }), generics),
-         None))
+            ItemStruct(P(vdata), generics),
+            None))
     }
 
     pub fn parse_record_struct_body(&mut self) -> PResult<Vec<StructField>> {
@@ -5107,10 +5105,7 @@ impl<'a> Parser<'a> {
         }
         try!(self.bump());
 
-        Ok(P(VariantData {
-            data_: VariantData_::Struct(fields),
-            id: ast::DUMMY_NODE_ID,
-        }))
+        Ok(P(VariantData::Struct(fields, ast::DUMMY_NODE_ID)))
     }
 
     /// Parse the part of an "enum" decl following the '{'
@@ -5146,16 +5141,13 @@ impl<'a> Parser<'a> {
                         id: ast::DUMMY_NODE_ID,
                     }});
                 }
-                struct_def = P(VariantData { data_: ast::VariantData_::Tuple(fields),
-                                           id: ast::DUMMY_NODE_ID});
+                struct_def = P(ast::VariantData::Tuple(fields, ast::DUMMY_NODE_ID));
             } else if try!(self.eat(&token::Eq) ){
                 disr_expr = Some(try!(self.parse_expr_nopanic()));
                 any_disr = disr_expr.as_ref().map(|expr| expr.span);
-                struct_def = P(VariantData { data_: ast::VariantData_::Unit,
-                                           id: ast::DUMMY_NODE_ID});
+                struct_def = P(ast::VariantData::Unit(ast::DUMMY_NODE_ID));
             } else {
-                struct_def = P(VariantData { data_: ast::VariantData_::Unit,
-                                           id: ast::DUMMY_NODE_ID});
+                struct_def = P(ast::VariantData::Unit(ast::DUMMY_NODE_ID));
             }
 
             let vr = ast::Variant_ {
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 161f6243f85..e5a9ce216a9 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -3131,8 +3131,7 @@ mod tests {
             name: ident,
             attrs: Vec::new(),
             // making this up as I go.... ?
-            data: P(ast::VariantData { data_: ast::VariantData_::Unit,
-                                    id: ast::DUMMY_NODE_ID}),
+            data: P(ast::VariantData::Unit(ast::DUMMY_NODE_ID)),
             disr_expr: None,
         });