From e8ddbba2ed356df4f5ef8f0742b810a4ecf82a50 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sun, 25 Oct 2015 18:33:51 +0300 Subject: syntax/rustc_front: Simplify VariantData::fields And use VariantData instead of P in Item_ and Variant_ --- src/libsyntax/ast.rs | 18 ++++++------------ src/libsyntax/config.rs | 28 +++++++++++++--------------- src/libsyntax/ext/build.rs | 4 ++-- src/libsyntax/ext/deriving/generic/mod.rs | 8 ++++---- src/libsyntax/feature_gate.rs | 2 +- src/libsyntax/fold.rs | 28 +++++++++++++--------------- src/libsyntax/parse/parser.rs | 14 ++++++-------- src/libsyntax/print/pprust.rs | 18 ++---------------- 8 files changed, 47 insertions(+), 73 deletions(-) (limited to 'src/libsyntax') 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, - pub data: P, + pub data: VariantData, /// Explicit discriminant, eg `Foo = 1` pub disr_expr: Option>, } @@ -1757,17 +1756,12 @@ pub enum VariantData { Unit(NodeId), } -pub type FieldIter<'a> = iter::FlatMap>, - slice::Iter<'a, StructField>, - fn(&Vec) -> slice::Iter>; - impl VariantData { - pub fn fields(&self) -> FieldIter { - fn vec_iter(v: &Vec) -> slice::Iter { 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 {C, D}` ItemEnum(EnumDef, Generics), /// A struct definition, e.g. `struct Foo {x: A}` - ItemStruct(P, 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(cx: &mut Context, item: ast::Item_) -> ast::Item_ fold::noop_fold_item_underscore(item, cx) } -fn fold_struct(cx: &mut Context, def: P) -> P where +fn fold_struct(cx: &mut Context, 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(cx: &mut Context, 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 { - 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 { - let field_tys: Vec> = struct_def.fields() + let field_tys: Vec> = 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, Vec<(Span, Option, P, &'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) -> P { - 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) -> Vec { @@ -814,20 +814,18 @@ pub fn noop_fold_where_predicate( } } -pub fn noop_fold_struct_def(struct_def: P, fld: &mut T) -> P { - 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(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(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> { @@ -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> { + fn parse_struct_def(&mut self) -> PResult { let mut fields: Vec = 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, - { - 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 { 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, }); -- cgit 1.4.1-3-g733a5