about summary refs log tree commit diff
path: root/src/libsyntax
diff options
context:
space:
mode:
Diffstat (limited to 'src/libsyntax')
-rw-r--r--src/libsyntax/ast.rs18
-rw-r--r--src/libsyntax/config.rs28
-rw-r--r--src/libsyntax/ext/build.rs4
-rw-r--r--src/libsyntax/ext/deriving/generic/mod.rs8
-rw-r--r--src/libsyntax/feature_gate.rs2
-rw-r--r--src/libsyntax/fold.rs28
-rw-r--r--src/libsyntax/parse/parser.rs14
-rw-r--r--src/libsyntax/print/pprust.rs18
8 files changed, 47 insertions, 73 deletions
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index a45f5c9048c..7b3c33d53a3 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -65,7 +65,6 @@ use std::fmt;
 use std::rc::Rc;
 use std::borrow::Cow;
 use std::hash::{Hash, Hasher};
-use std::{iter, option, slice};
 use serialize::{Encodable, Decodable, Encoder, Decoder};
 
 /// A name is a part of an identifier, representing a string or gensym. It's
@@ -1578,7 +1577,7 @@ pub struct EnumDef {
 pub struct Variant_ {
     pub name: Ident,
     pub attrs: Vec<Attribute>,
-    pub data: P<VariantData>,
+    pub data: VariantData,
     /// Explicit discriminant, eg `Foo = 1`
     pub disr_expr: Option<P<Expr>>,
 }
@@ -1757,17 +1756,12 @@ pub enum VariantData {
     Unit(NodeId),
 }
 
-pub type FieldIter<'a> = iter::FlatMap<option::IntoIter<&'a Vec<StructField>>,
-                                       slice::Iter<'a, StructField>,
-                                       fn(&Vec<StructField>) -> slice::Iter<StructField>>;
-
 impl VariantData {
-    pub fn fields(&self) -> FieldIter {
-        fn vec_iter<T>(v: &Vec<T>) -> slice::Iter<T> { v.iter() }
+    pub fn fields(&self) -> &[StructField] {
         match *self {
-            VariantData::Struct(ref fields, _) | VariantData::Tuple(ref fields, _) => Some(fields),
-            _ => None,
-        }.into_iter().flat_map(vec_iter)
+            VariantData::Struct(ref fields, _) | VariantData::Tuple(ref fields, _) => fields,
+            _ => &[],
+        }
     }
     pub fn id(&self) -> NodeId {
         match *self {
@@ -1826,7 +1820,7 @@ pub enum Item_ {
     /// An enum definition, e.g. `enum Foo<A, B> {C<A>, D<B>}`
     ItemEnum(EnumDef, Generics),
     /// A struct definition, e.g. `struct Foo<A> {x: A}`
-    ItemStruct(P<VariantData>, Generics),
+    ItemStruct(VariantData, Generics),
     /// Represents a Trait Declaration
     ItemTrait(Unsafety,
               Generics,
diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs
index 0ca110c5b1e..aa674bdbcf3 100644
--- a/src/libsyntax/config.rs
+++ b/src/libsyntax/config.rs
@@ -164,24 +164,22 @@ fn fold_item_underscore<F>(cx: &mut Context<F>, item: ast::Item_) -> ast::Item_
     fold::noop_fold_item_underscore(item, cx)
 }
 
-fn fold_struct<F>(cx: &mut Context<F>, def: P<ast::VariantData>) -> P<ast::VariantData> where
+fn fold_struct<F>(cx: &mut Context<F>, vdata: ast::VariantData) -> ast::VariantData where
     F: FnMut(&[ast::Attribute]) -> bool
 {
-    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)
+    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)
+    }
 }
 
 fn retain_stmt<F>(cx: &mut Context<F>, stmt: &ast::Stmt) -> bool where
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 9b06fbd0a0b..16a5eb05c4b 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -1012,7 +1012,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
                ast::Variant_ {
                    name: name,
                    attrs: Vec::new(),
-                   data: P(vdata),
+                   data: vdata,
                    disr_expr: None,
                })
     }
@@ -1041,7 +1041,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
 
     fn item_struct_poly(&self, span: Span, name: Ident,
         struct_def: ast::VariantData, generics: Generics) -> P<ast::Item> {
-        self.item(span, name, Vec::new(), ast::ItemStruct(P(struct_def), generics))
+        self.item(span, name, Vec::new(), ast::ItemStruct(struct_def, generics))
     }
 
     fn item_mod(&self, span: Span, inner_span: Span, name: Ident,
diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs
index 11bf6ec24ce..5c6e2fce8ad 100644
--- a/src/libsyntax/ext/deriving/generic/mod.rs
+++ b/src/libsyntax/ext/deriving/generic/mod.rs
@@ -652,7 +652,7 @@ impl<'a> TraitDef<'a> {
                          struct_def: &'a VariantData,
                          type_ident: Ident,
                          generics: &Generics) -> P<ast::Item> {
-        let field_tys: Vec<P<ast::Ty>> = struct_def.fields()
+        let field_tys: Vec<P<ast::Ty>> = struct_def.fields().iter()
             .map(|field| field.node.ty.clone())
             .collect();
 
@@ -700,7 +700,7 @@ impl<'a> TraitDef<'a> {
         let mut field_tys = Vec::new();
 
         for variant in &enum_def.variants {
-            field_tys.extend(variant.node.data.fields()
+            field_tys.extend(variant.node.data.fields().iter()
                 .map(|field| field.node.ty.clone()));
         }
 
@@ -1483,7 +1483,7 @@ impl<'a> TraitDef<'a> {
                              -> (P<ast::Pat>, Vec<(Span, Option<Ident>,
                                                    P<Expr>,
                                                    &'a [ast::Attribute])>) {
-        if struct_def.fields().count() == 0 {
+        if struct_def.fields().is_empty() {
             return (cx.pat_enum(self.span, struct_path, vec![]), vec![]);
         }
 
@@ -1491,7 +1491,7 @@ impl<'a> TraitDef<'a> {
         let mut ident_expr = Vec::new();
         let mut struct_type = Unknown;
 
-        for (i, struct_field) in struct_def.fields().enumerate() {
+        for (i, struct_field) in struct_def.fields().iter().enumerate() {
             let sp = self.set_expn_info(cx, struct_field.span);
             let opt_id = match struct_field.node.kind {
                 ast::NamedField(ident, _) if (struct_type == Unknown ||
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
index be6ad931111..a0c089aff21 100644
--- a/src/libsyntax/feature_gate.rs
+++ b/src/libsyntax/feature_gate.rs
@@ -859,7 +859,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
 
     fn visit_variant_data(&mut self, s: &'v ast::VariantData, _: ast::Ident,
                         _: &'v ast::Generics, _: ast::NodeId, span: Span) {
-        if s.fields().count() == 0 {
+        if s.fields().is_empty() {
             if s.is_struct() {
                 self.gate_feature("braced_empty_structs", span,
                                   "empty structs and enum variants with braces are unstable");
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 219a4649339..be910285db3 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -231,8 +231,8 @@ pub trait Folder : Sized {
         noop_fold_poly_trait_ref(p, self)
     }
 
-    fn fold_variant_data(&mut self, struct_def: P<VariantData>) -> P<VariantData> {
-        noop_fold_struct_def(struct_def, self)
+    fn fold_variant_data(&mut self, vdata: VariantData) -> VariantData {
+        noop_fold_variant_data(vdata, self)
     }
 
     fn fold_lifetimes(&mut self, lts: Vec<Lifetime>) -> Vec<Lifetime> {
@@ -814,20 +814,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(|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, id) => {
-                ast::VariantData::Tuple(fields.move_map(|f| fld.fold_struct_field(f)),
-                                        fld.new_id(id))
-            }
-            ast::VariantData::Unit(id) => ast::VariantData::Unit(fld.new_id(id))
+pub fn noop_fold_variant_data<T: Folder>(vdata: VariantData, fld: &mut T) -> VariantData {
+    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, id) => {
+            ast::VariantData::Tuple(fields.move_map(|f| fld.fold_struct_field(f)),
+                                    fld.new_id(id))
+        }
+        ast::VariantData::Unit(id) => ast::VariantData::Unit(fld.new_id(id))
+    }
 }
 
 pub fn noop_fold_trait_ref<T: Folder>(p: TraitRef, fld: &mut T) -> TraitRef {
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index fcebe035961..bfd5b69cc93 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -4678,9 +4678,7 @@ impl<'a> Parser<'a> {
                                             name, found `{}`", token_str)))
         };
 
-        Ok((class_name,
-            ItemStruct(P(vdata), generics),
-            None))
+        Ok((class_name, ItemStruct(vdata, generics), None))
     }
 
     pub fn parse_record_struct_body(&mut self) -> PResult<Vec<StructField>> {
@@ -5111,14 +5109,14 @@ impl<'a> Parser<'a> {
 
     /// Parse a structure-like enum variant definition
     /// this should probably be renamed or refactored...
-    fn parse_struct_def(&mut self) -> PResult<P<VariantData>> {
+    fn parse_struct_def(&mut self) -> PResult<VariantData> {
         let mut fields: Vec<StructField> = Vec::new();
         while self.token != token::CloseDelim(token::Brace) {
             fields.push(try!(self.parse_struct_decl_field(false)));
         }
         try!(self.bump());
 
-        Ok(P(VariantData::Struct(fields, ast::DUMMY_NODE_ID)))
+        Ok(VariantData::Struct(fields, ast::DUMMY_NODE_ID))
     }
 
     /// Parse the part of an "enum" decl following the '{'
@@ -5154,13 +5152,13 @@ impl<'a> Parser<'a> {
                         id: ast::DUMMY_NODE_ID,
                     }});
                 }
-                struct_def = P(ast::VariantData::Tuple(fields, ast::DUMMY_NODE_ID));
+                struct_def = 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(ast::VariantData::Unit(ast::DUMMY_NODE_ID));
+                struct_def = ast::VariantData::Unit(ast::DUMMY_NODE_ID);
             } else {
-                struct_def = P(ast::VariantData::Unit(ast::DUMMY_NODE_ID));
+                struct_def = 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 7b5aabde231..397293f61ca 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -520,19 +520,6 @@ pub trait PrintState<'a> {
         self.end()
     }
 
-    fn commasep_iter<'it, T: 'it, F, I>(&mut self, b: Breaks, elts: I, mut op: F) -> io::Result<()>
-        where F: FnMut(&mut Self, &T) -> io::Result<()>,
-              I: Iterator<Item=&'it T>,
-    {
-        try!(self.rbox(0, b));
-        let mut first = true;
-        for elt in elts {
-            if first { first = false; } else { try!(self.word_space(",")); }
-            try!(op(self, elt));
-        }
-        self.end()
-    }
-
     fn next_lit(&mut self, pos: BytePos) -> Option<comments::Literal> {
         let mut cur_lit = self.cur_cmnt_and_lit().cur_lit;
 
@@ -1407,7 +1394,7 @@ impl<'a> State<'a> {
         if !struct_def.is_struct() {
             if struct_def.is_tuple() {
                 try!(self.popen());
-                try!(self.commasep_iter(
+                try!(self.commasep(
                     Inconsistent, struct_def.fields(),
                     |s, field| {
                         match field.node.kind {
@@ -3104,7 +3091,6 @@ mod tests {
     use ast_util;
     use codemap;
     use parse::token;
-    use ptr::P;
 
     #[test]
     fn test_fun_to_string() {
@@ -3131,7 +3117,7 @@ mod tests {
             name: ident,
             attrs: Vec::new(),
             // making this up as I go.... ?
-            data: P(ast::VariantData::Unit(ast::DUMMY_NODE_ID)),
+            data: ast::VariantData::Unit(ast::DUMMY_NODE_ID),
             disr_expr: None,
         });
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-01-15 11:45:23 +0000