mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge VariantData and VariantData_

Browse Source
This commit is contained in:
Vadim Petrochenkov 2015-10-10 03:28:40 +03:00
parent a5225cbe92
commit 46750d0409
28 changed files with 141 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/librustc/front/map/collector.rs
View File

@ -134,7 +134,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
ItemEnum(ref enum_definition, _) => {
for v in &enum_definition.variants {
let variant_def_index =
self.insert_def(v.node.data.id,
self.insert_def(v.node.data.id(),
NodeVariant(&**v),
DefPathData::EnumVariant(v.node.name));
@ -151,7 +151,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
ItemStruct(ref struct_def, _) => {
// If this is a tuple-like struct, register the constructor.
if !struct_def.is_struct() {
self.insert_def(struct_def.id,
self.insert_def(struct_def.id(),
NodeStructCtor(&**struct_def),
DefPathData::StructCtor);
}

8
src/librustc/metadata/encoder.rs
View File

@ -382,7 +382,7 @@ fn each_auxiliary_node_id<F>(item: &hir::Item, callback: F) -> bool where
hir::ItemStruct(ref struct_def, _) => {
// If this is a newtype struct, return the constructor.
if struct_def.is_tuple() {
continue_ = callback(struct_def.id);
continue_ = callback(struct_def.id());
}
}
_ => {}
@ -1019,7 +1019,7 @@ fn encode_info_for_item<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
encode_attributes(rbml_w, &item.attrs);
encode_repr_attrs(rbml_w, ecx, &item.attrs);
for v in &enum_definition.variants {
encode_variant_id(rbml_w, ecx.tcx.map.local_def_id(v.node.data.id));
encode_variant_id(rbml_w, ecx.tcx.map.local_def_id(v.node.data.id()));
}
encode_inlined_item(ecx, rbml_w, InlinedItemRef::Item(item));
encode_path(rbml_w, path);
@ -1069,7 +1069,7 @@ fn encode_info_for_item<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
encode_inherent_implementations(ecx, rbml_w, def_id);
if !struct_def.is_struct() {
let ctor_did = ecx.tcx.map.local_def_id(struct_def.id);
let ctor_did = ecx.tcx.map.local_def_id(struct_def.id());
rbml_w.wr_tagged_u64(tag_items_data_item_struct_ctor,
def_to_u64(ctor_did));
}
@ -1082,7 +1082,7 @@ fn encode_info_for_item<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
// If this is a tuple-like struct, encode the type of the constructor.
if !struct_def.is_struct() {
encode_info_for_struct_ctor(ecx, rbml_w, item.name, struct_def.id, index, item.id);
encode_info_for_struct_ctor(ecx, rbml_w, item.name, struct_def.id(), index, item.id);
}
}
hir::ItemDefaultImpl(unsafety, _) => {

8
src/librustc/middle/astencode.rs
View File

@ -1315,8 +1315,8 @@ fn copy_item_types(dcx: &DecodeContext, ii: &InlinedItem, orig_did: DefId) {
def.variants.iter().zip(orig_def.variants.iter())
{
debug!("astencode: copying variant {:?} => {:?}",
orig_variant.did, i_variant.node.data.id);
copy_item_type(dcx, i_variant.node.data.id, orig_variant.did);
orig_variant.did, i_variant.node.data.id());
copy_item_type(dcx, i_variant.node.data.id(), orig_variant.did);
}
}
hir::ItemStruct(ref def, _) => {
@ -1324,8 +1324,8 @@ fn copy_item_types(dcx: &DecodeContext, ii: &InlinedItem, orig_did: DefId) {
let ctor_did = dcx.tcx.lookup_adt_def(orig_did)
.struct_variant().did;
debug!("astencode: copying ctor {:?} => {:?}", ctor_did,
def.id);
copy_item_type(dcx, def.id, ctor_did);
def.id());
copy_item_type(dcx, def.id(), ctor_did);
}
}
_ => {}

6
src/librustc/middle/check_static_recursion.rs
View File

@ -168,7 +168,7 @@ impl<'a, 'ast: 'a> CheckItemRecursionVisitor<'a, 'ast> {
let mut discriminant_map = self.discriminant_map.borrow_mut();
match enum_definition.variants.first() {
None => { return; }
Some(variant) if discriminant_map.contains_key(&variant.node.data.id) => {
Some(variant) if discriminant_map.contains_key(&variant.node.data.id()) => {
return;
}
_ => {}
@ -177,7 +177,7 @@ impl<'a, 'ast: 'a> CheckItemRecursionVisitor<'a, 'ast> {
// Go through all the variants.
let mut variant_stack: Vec<ast::NodeId> = Vec::new();
for variant in enum_definition.variants.iter().rev() {
variant_stack.push(variant.node.data.id);
variant_stack.push(variant.node.data.id());
// When we find an expression, every variant currently on the stack
// is affected by that expression.
if let Some(ref expr) = variant.node.disr_expr {
@ -208,7 +208,7 @@ impl<'a, 'ast: 'a> Visitor<'ast> for CheckItemRecursionVisitor<'a, 'ast> {
fn visit_variant(&mut self, variant: &'ast hir::Variant,
_: &'ast hir::Generics, _: ast::NodeId) {
let variant_id = variant.node.data.id;
let variant_id = variant.node.data.id();
let maybe_expr;
if let Some(get_expr) = self.discriminant_map.borrow().get(&variant_id) {
// This is necessary because we need to let the `discriminant_map`

2
src/librustc/middle/const_eval.rs
View File

@ -63,7 +63,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt,
fn variant_expr<'a>(variants: &'a [P<hir::Variant>], id: ast::NodeId)
-> Option<&'a Expr> {
for variant in variants {
if variant.node.data.id == id {
if variant.node.data.id() == id {
return variant.node.disr_expr.as_ref().map(|e| &**e);
}
}

9
src/librustc/middle/dead.rs
View File

@ -339,7 +339,8 @@ impl<'v> Visitor<'v> for LifeSeeder {
}
match item.node {
hir::ItemEnum(ref enum_def, _) if allow_dead_code => {
self.worklist.extend(enum_def.variants.iter().map(|variant| variant.node.data.id));
self.worklist.extend(enum_def.variants.iter()
.map(|variant| variant.node.data.id()));
}
hir::ItemTrait(_, _, _, ref trait_items) => {
for trait_item in trait_items {
@ -427,7 +428,7 @@ fn find_live(tcx: &ty::ctxt,
fn get_struct_ctor_id(item: &hir::Item) -> Option<ast::NodeId> {
match item.node {
hir::ItemStruct(ref struct_def, _) if !struct_def.is_struct() => {
Some(struct_def.id)
Some(struct_def.id())
}
_ => None
}
@ -466,7 +467,7 @@ impl<'a, 'tcx> DeadVisitor<'a, 'tcx> {
}
fn should_warn_about_variant(&mut self, variant: &hir::Variant_) -> bool {
!self.symbol_is_live(variant.data.id, None)
!self.symbol_is_live(variant.data.id(), None)
&& !has_allow_dead_code_or_lang_attr(&variant.attrs)
}
@ -542,7 +543,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for DeadVisitor<'a, 'tcx> {
hir::ItemEnum(ref enum_def, _) => {
for variant in &enum_def.variants {
if self.should_warn_about_variant(&variant.node) {
self.warn_dead_code(variant.node.data.id, variant.span,
self.warn_dead_code(variant.node.data.id(), variant.span,
variant.node.name, "variant");
}
}

4
src/librustc/middle/stability.rs
View File

@ -186,7 +186,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Annotator<'a, 'tcx> {
if let hir::ItemStruct(ref sd, _) = i.node {
if !sd.is_struct() {
self.annotate(sd.id, true, &i.attrs, i.span, |_| {}, true)
self.annotate(sd.id(), true, &i.attrs, i.span, |_| {}, true)
}
}
}
@ -208,7 +208,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Annotator<'a, 'tcx> {
}
fn visit_variant(&mut self, var: &Variant, g: &'v Generics, item_id: NodeId) {
self.annotate(var.node.data.id, true, &var.node.attrs, var.span,
self.annotate(var.node.data.id(), true, &var.node.attrs, var.span,
|v| visit::walk_variant(v, var, g, item_id), true)
}

21
src/librustc_front/fold.rs
View File

@ -694,18 +694,15 @@ pub fn noop_fold_where_predicate<T: Folder>(pred: WherePredicate, fld: &mut T) -
}
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_ {
VariantData_::Struct(fields) => {
VariantData_::Struct(fields.move_map(|f| fld.fold_struct_field(f)))
}
VariantData_::Tuple(fields) => {
VariantData_::Tuple(fields.move_map(|f| fld.fold_struct_field(f)))
}
VariantData_::Unit => VariantData_::Unit
},
id: fld.new_id(id),
struct_def.map(|vdata| {
match vdata {
VariantData::Struct(fields, id) => {
VariantData::Struct(fields.move_map(|f| fld.fold_struct_field(f)), fld.new_id(id))
}
VariantData::Tuple(fields, id) => {
VariantData::Tuple(fields.move_map(|f| fld.fold_struct_field(f)), fld.new_id(id))
}
VariantData::Unit(id) => VariantData::Unit(fld.new_id(id))
}
})
}

31
src/librustc_front/hir.rs
View File

@ -1162,18 +1162,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>>,
@ -1183,19 +1175,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 }
}
}

21
src/librustc_front/lowering.rs
View File

@ -499,19 +499,16 @@ pub fn lower_where_predicate(_lctx: &LoweringContext,
}
pub fn lower_struct_def(_lctx: &LoweringContext, sd: &VariantData) -> P<hir::VariantData> {
P(hir::VariantData {
id: sd.id,
data_: match sd.data_ {
VariantData_::Struct(ref fields) => {
hir::VariantData_::Struct(fields.iter()
.map(|f| lower_struct_field(_lctx, f)).collect())
}
VariantData_::Tuple(ref fields) => {
hir::VariantData_::Tuple(fields.iter()
.map(|f| lower_struct_field(_lctx, f)).collect())
}
VariantData_::Unit => hir::VariantData_::Unit
P(match *sd {
VariantData::Struct(ref fields, id) => {
hir::VariantData::Struct(fields.iter()
.map(|f| lower_struct_field(_lctx, f)).collect(), id)
}
VariantData::Tuple(ref fields, id) => {
hir::VariantData::Tuple(fields.iter()
.map(|f| lower_struct_field(_lctx, f)).collect(), id)
}
VariantData::Unit(id) => hir::VariantData::Unit(id)
})
}

2
src/librustc_front/util.rs
View File

@ -287,7 +287,7 @@ impl<'a, 'v, O: ast_util::IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O>
_: &hir::Generics,
_: NodeId,
_: Span) {
self.operation.visit_id(struct_def.id);
self.operation.visit_id(struct_def.id());
visit::walk_struct_def(self, struct_def);
}

3
src/librustc_lint/builtin.rs
View File

@ -527,7 +527,8 @@ impl LateLintPass for MissingDoc {
}
fn check_variant(&mut self, cx: &LateContext, v: &hir::Variant, _: &hir::Generics) {
self.check_missing_docs_attrs(cx, Some(v.node.data.id), &v.node.attrs, v.span, "a variant");
self.check_missing_docs_attrs(cx, Some(v.node.data.id()),
&v.node.attrs, v.span, "a variant");
assert!(!self.in_variant);
self.in_variant = true;
}

12
src/librustc_privacy/lib.rs
View File

@ -82,7 +82,7 @@ impl<'v> Visitor<'v> for ParentVisitor {
// The parent is considered the enclosing enum because the
// enum will dictate the privacy visibility of this variant
// instead.
self.parents.insert(variant.node.data.id, item.id);
self.parents.insert(variant.node.data.id(), item.id);
}
}
@ -133,7 +133,7 @@ impl<'v> Visitor<'v> for ParentVisitor {
// Struct constructors are parented to their struct definitions because
// they essentially are the struct definitions.
if !s.is_struct() {
self.parents.insert(s.id, item_id);
self.parents.insert(s.id(), item_id);
}
// While we have the id of the struct definition, go ahead and parent
@ -233,8 +233,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> {
// public all variants are public unless they're explicitly priv
hir::ItemEnum(ref def, _) if public_first => {
for variant in &def.variants {
self.exported_items.insert(variant.node.data.id);
self.public_items.insert(variant.node.data.id);
self.exported_items.insert(variant.node.data.id());
self.public_items.insert(variant.node.data.id());
}
}
@ -320,7 +320,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> {
// Struct constructors are public if the struct is all public.
hir::ItemStruct(ref def, _) if public_first => {
if !def.is_struct() {
self.exported_items.insert(def.id);
self.exported_items.insert(def.id());
}
// fields can be public or private, so lets check
for field in def.fields() {
@ -1431,7 +1431,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> {
}
fn visit_variant(&mut self, v: &hir::Variant, g: &hir::Generics, item_id: ast::NodeId) {
if self.exported_items.contains(&v.node.data.id) {
if self.exported_items.contains(&v.node.data.id()) {
self.in_variant = true;
visit::walk_variant(self, v, g, item_id);
self.in_variant = false;

10
src/librustc_resolve/build_reduced_graph.rs
View File

@ -495,7 +495,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
let (forbid, ctor_id) = if struct_def.is_struct() {
(ForbidDuplicateTypesAndModules, None)
} else {
(ForbidDuplicateTypesAndValues, Some(struct_def.id))
(ForbidDuplicateTypesAndValues, Some(struct_def.id()))
};
let name_bindings = self.add_child(name, parent, forbid, sp);
@ -590,7 +590,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
let name = variant.node.name;
let is_exported = if variant.node.data.is_struct() {
// Not adding fields for variants as they are not accessed with a self receiver
let variant_def_id = self.ast_map.local_def_id(variant.node.data.id);
let variant_def_id = self.ast_map.local_def_id(variant.node.data.id());
self.structs.insert(variant_def_id, Vec::new());
true
} else {
@ -603,10 +603,12 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
// variants are always treated as importable to allow them to be glob
// used
child.define_value(DefVariant(item_id,
self.ast_map.local_def_id(variant.node.data.id), is_exported),
self.ast_map.local_def_id(variant.node.data.id()),
is_exported),
variant.span, DefModifiers::PUBLIC | DefModifiers::IMPORTABLE);
child.define_type(DefVariant(item_id,
self.ast_map.local_def_id(variant.node.data.id), is_exported),
self.ast_map.local_def_id(variant.node.data.id()),
is_exported),
variant.span, DefModifiers::PUBLIC | DefModifiers::IMPORTABLE);
}

8
src/librustc_trans/save/dump_csv.rs
View File

@ -467,7 +467,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
self.fmt.struct_str(item.span,
sub_span,
item.id,
def.id,
def.id(),
&qualname,
self.cur_scope,
&val);
@ -503,15 +503,15 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
self.fmt.struct_variant_str(variant.span,
self.span.span_for_first_ident(variant.span),
variant.node.data.id,
variant.node.data.id,
variant.node.data.id(),
variant.node.data.id(),
&qualname,
&enum_data.qualname,
&val,
enum_data.id);
for field in variant.node.data.fields() {
self.process_struct_field_def(field, variant.node.data.id);
self.process_struct_field_def(field, variant.node.data.id());
self.visit_ty(&*field.node.ty);
}
}

2
src/librustc_trans/trans/base.rs
View File

@ -2458,7 +2458,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
ccx.sess().bug("attempt to register a constructor of \
a non-tuple-like struct")
} else {
struct_def.id
struct_def.id()
};
let parent = ccx.tcx().map.get_parent(id);
let struct_item = ccx.tcx().map.expect_item(parent);

8
src/librustc_trans/trans/inline.rs
View File

@ -110,8 +110,8 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: DefId)
let ty_vs = &ccx.tcx().lookup_adt_def(parent_id).variants;
assert_eq!(ast_vs.len(), ty_vs.len());
for (ast_v, ty_v) in ast_vs.iter().zip(ty_vs.iter()) {
if ty_v.did == fn_id { my_id = ast_v.node.data.id; }
ccx.external().borrow_mut().insert(ty_v.did, Some(ast_v.node.data.id));
if ty_v.did == fn_id { my_id = ast_v.node.data.id(); }
ccx.external().borrow_mut().insert(ty_v.did, Some(ast_v.node.data.id()));
}
}
hir::ItemStruct(ref struct_def, _) => {
@ -119,8 +119,8 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: DefId)
ccx.sess().bug("instantiate_inline: called on a \
non-tuple struct")
} else {
ccx.external().borrow_mut().insert(fn_id, Some(struct_def.id));
my_id = struct_def.id;
ccx.external().borrow_mut().insert(fn_id, Some(struct_def.id()));
my_id = struct_def.id();
}
}
_ => ccx.sess().bug("instantiate_inline: item has a \

2
src/librustc_trans/trans/monomorphize.rs
View File

@ -250,7 +250,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
panic!("ast-mapped struct didn't have a ctor id")
}
base::trans_tuple_struct(ccx,
struct_def.id,
struct_def.id(),
psubsts,
d);
d

8
src/librustc_typeck/collect.rs
View File

@ -1015,7 +1015,7 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) {
}
if !struct_def.is_struct() {
convert_variant_ctor(tcx, struct_def.id, variant, scheme, predicates);
convert_variant_ctor(tcx, struct_def.id(), variant, scheme, predicates);
}
},
hir::ItemTy(_, ref generics) => {
@ -1075,7 +1075,7 @@ fn convert_enum_variant_types<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
// an item.
convert_variant_ctor(
ccx.tcx,
variant.node.data.id,
variant.node.data.id(),
ty_variant,
scheme.clone(),
predicates.clone()
@ -1126,7 +1126,7 @@ fn convert_struct_def<'tcx>(tcx: &ty::ctxt<'tcx>,
let did = tcx.map.local_def_id(it.id);
let ctor_id = if !def.is_struct() {
tcx.map.local_def_id(def.id)
tcx.map.local_def_id(def.id())
} else {
did
};
@ -1209,7 +1209,7 @@ fn convert_enum_def<'tcx>(tcx: &ty::ctxt<'tcx>,
disr: ty::Disr)
-> ty::VariantDefData<'tcx, 'tcx>
{
let did = tcx.map.local_def_id(v.node.data.id);
let did = tcx.map.local_def_id(v.node.data.id());
let name = v.node.name;
convert_struct_variant(tcx, did, name, disr, &v.node.data)
}

2
src/librustdoc/clean/mod.rs
View File

@ -1853,7 +1853,7 @@ impl Clean<Item> for doctree::Variant {
source: self.whence.clean(cx),
visibility: None,
stability: self.stab.clean(cx),
def_id: cx.map.local_def_id(self.def.id),
def_id: cx.map.local_def_id(self.def.id()),
inner: VariantItem(Variant {
kind: struct_def_to_variant_kind(&self.def, cx),
}),

2
src/librustdoc/visit_ast.rs
View File

@ -111,7 +111,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
variants: def.variants.iter().map(|v| Variant {
name: v.node.name,
attrs: v.node.attrs.clone(),
stab: self.stability(v.node.data.id),
stab: self.stability(v.node.data.id()),
def: v.node.data.clone(),
whence: v.span,
}).collect(),

31
src/libsyntax/ast.rs
View File

@ -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 }
}
}

2
src/libsyntax/ast_util.rs
View File

@ -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);
}

29
src/libsyntax/config.rs
View File

@ -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)
}
})
}

9
src/libsyntax/ext/build.rs
View File

@ -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,
})
}

19
src/libsyntax/fold.rs
View File

@ -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))
}
})
}

36
src/libsyntax/parse/parser.rs
View File

@ -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_ {

3
src/libsyntax/print/pprust.rs
View File

@ -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,
});