From 7f3744f07f0d32f9673af1563d70b22985b1c2cf Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sat, 2 Apr 2016 16:47:53 +0300 Subject: [PATCH 1/2] Get rid of ast::StructFieldKind --- src/librustc_front/lowering.rs | 5 +-- src/librustc_save_analysis/lib.rs | 33 +++++++------- src/libsyntax/ast.rs | 35 +-------------- src/libsyntax/ast_util.rs | 6 --- src/libsyntax/ext/build.rs | 3 +- src/libsyntax/fold.rs | 12 ++--- src/libsyntax/parse/parser.rs | 8 ++-- src/libsyntax/print/pprust.rs | 32 +++++-------- src/libsyntax/visit.rs | 2 +- src/libsyntax_ext/deriving/generic/mod.rs | 55 +++++------------------ 10 files changed, 55 insertions(+), 136 deletions(-) diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs index 66b9e217bd387..4ca30a041a541 100644 --- a/src/librustc_front/lowering.rs +++ b/src/librustc_front/lowering.rs @@ -622,9 +622,8 @@ pub fn lower_struct_field(lctx: &LoweringContext, hir::StructField { span: f.span, id: f.node.id, - name: f.node.ident().map(|ident| ident.name) - .unwrap_or(token::intern(&index.to_string())), - vis: lower_visibility(lctx, f.node.kind.visibility()), + name: f.node.ident.map(|ident| ident.name).unwrap_or(token::intern(&index.to_string())), + vis: lower_visibility(lctx, f.node.vis), ty: lower_ty(lctx, &f.node.ty), attrs: lower_attrs(lctx, &f.node.attrs), } diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs index 36b94731e45ab..550628741c209 100644 --- a/src/librustc_save_analysis/lib.rs +++ b/src/librustc_save_analysis/lib.rs @@ -246,23 +246,22 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { pub fn get_field_data(&self, field: &ast::StructField, scope: NodeId) -> Option { - match field.node.kind { - ast::NamedField(ident, _) => { - let qualname = format!("::{}::{}", self.tcx.map.path_to_string(scope), ident); - let typ = self.tcx.node_types().get(&field.node.id).unwrap().to_string(); - let sub_span = self.span_utils.sub_span_before_token(field.span, token::Colon); - filter!(self.span_utils, sub_span, field.span, None); - Some(VariableData { - id: field.node.id, - name: ident.to_string(), - qualname: qualname, - span: sub_span.unwrap(), - scope: scope, - value: "".to_owned(), - type_value: typ, - }) - } - _ => None, + if let Some(ident) = field.node.ident { + let qualname = format!("::{}::{}", self.tcx.map.path_to_string(scope), ident); + let typ = self.tcx.node_types().get(&field.node.id).unwrap().to_string(); + let sub_span = self.span_utils.sub_span_before_token(field.span, token::Colon); + filter!(self.span_utils, sub_span, field.span, None); + Some(VariableData { + id: field.node.id, + name: ident.to_string(), + qualname: qualname, + span: sub_span.unwrap(), + scope: scope, + value: "".to_owned(), + type_value: typ, + }) + } else { + None } } diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index a441f2990cd1a..fb6ae8b88bed2 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -10,7 +10,6 @@ // The Rust abstract syntax tree. -pub use self::StructFieldKind::*; pub use self::TyParamBound::*; pub use self::UnsafeSource::*; pub use self::ViewPath_::*; @@ -1878,45 +1877,15 @@ pub enum Visibility { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct StructField_ { - pub kind: StructFieldKind, + pub ident: Option, + pub vis: Visibility, pub id: NodeId, pub ty: P, pub attrs: Vec, } -impl StructField_ { - pub fn ident(&self) -> Option { - match self.kind { - NamedField(ref ident, _) => Some(ident.clone()), - UnnamedField(_) => None - } - } -} - pub type StructField = Spanned; -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] -pub enum StructFieldKind { - NamedField(Ident, Visibility), - /// Element of a tuple-like struct - UnnamedField(Visibility), -} - -impl StructFieldKind { - pub fn is_unnamed(&self) -> bool { - match *self { - UnnamedField(..) => true, - NamedField(..) => false, - } - } - - pub fn visibility(&self) -> &Visibility { - match *self { - NamedField(_, ref vis) | UnnamedField(ref vis) => vis - } - } -} - /// Fields and Ids of enum variants and structs /// /// For enum variants: `NodeId` represents both an Id of the variant itself (relevant for all diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 852b153044fea..671ba3b0996af 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -95,12 +95,6 @@ pub fn impl_pretty_name(trait_ref: &Option, ty: Option<&Ty>) -> Ident token::gensym_ident(&pretty[..]) } -pub fn struct_field_visibility(field: ast::StructField) -> Visibility { - match field.node.kind { - ast::NamedField(_, v) | ast::UnnamedField(v) => v - } -} - // ______________________________________________________________________ // Enumerating the IDs which appear in an AST diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index 0eb42f17f68b4..a62832b928d60 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -1009,7 +1009,8 @@ impl<'a> AstBuilder for ExtCtxt<'a> { let fields: Vec<_> = tys.into_iter().map(|ty| { Spanned { span: ty.span, node: ast::StructField_ { ty: ty, - kind: ast::UnnamedField(ast::Visibility::Inherited), + ident: None, + vis: ast::Visibility::Inherited, attrs: Vec::new(), id: ast::DUMMY_NODE_ID, }} diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 46bcb8067a3b0..eb35d3fd9d35b 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -847,15 +847,15 @@ pub fn noop_fold_poly_trait_ref(p: PolyTraitRef, fld: &mut T) -> Poly } pub fn noop_fold_struct_field(f: StructField, fld: &mut T) -> StructField { - let StructField {node: StructField_ {id, kind, ty, attrs}, span} = f; Spanned { node: StructField_ { - id: fld.new_id(id), - kind: kind, - ty: fld.fold_ty(ty), - attrs: fold_attrs(attrs, fld), + id: fld.new_id(f.node.id), + ident: f.node.ident.map(|ident| fld.fold_ident(ident)), + vis: f.node.vis, + ty: fld.fold_ty(f.node.ty), + attrs: fold_attrs(f.node.attrs, fld), }, - span: fld.new_span(span) + span: fld.new_span(f.span) } } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 89a504e1ebd60..00d60630eaceb 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -29,7 +29,6 @@ use ast::Local; use ast::MacStmtStyle; use ast::Mac_; use ast::{MutTy, Mutability}; -use ast::NamedField; use ast::{Pat, PatKind}; use ast::{PolyTraitRef, QSelf}; use ast::{Stmt, StmtKind}; @@ -38,7 +37,6 @@ use ast::StrStyle; use ast::SelfKind; use ast::{Delimited, SequenceRepetition, TokenTree, TraitItem, TraitRef}; use ast::{Ty, TyKind, TypeBinding, TyParam, TyParamBounds}; -use ast::UnnamedField; use ast::{ViewPath, ViewPathGlob, ViewPathList, ViewPathSimple}; use ast::{Visibility, WhereClause}; use attr::{ThinAttributes, ThinAttributesExt, AttributesExt}; @@ -3848,7 +3846,8 @@ impl<'a> Parser<'a> { self.expect(&token::Colon)?; let ty = self.parse_ty_sum()?; Ok(spanned(lo, self.last_span.hi, ast::StructField_ { - kind: NamedField(name, pr), + ident: Some(name), + vis: pr, id: ast::DUMMY_NODE_ID, ty: ty, attrs: attrs, @@ -5247,7 +5246,8 @@ impl<'a> Parser<'a> { let attrs = p.parse_outer_attributes()?; let lo = p.span.lo; let struct_field_ = ast::StructField_ { - kind: UnnamedField(p.parse_visibility()?), + vis: p.parse_visibility()?, + ident: None, id: ast::DUMMY_NODE_ID, ty: p.parse_ty_sum()?, attrs: attrs, diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index a8f28ed3d9e0d..c7a755aeeac56 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1407,14 +1407,9 @@ impl<'a> State<'a> { self.commasep( Inconsistent, struct_def.fields(), |s, field| { - match field.node.kind { - ast::NamedField(..) => panic!("unexpected named field"), - ast::UnnamedField(ref vis) => { - s.print_visibility(vis)?; - s.maybe_print_comment(field.span.lo)?; - s.print_type(&field.node.ty) - } - } + s.print_visibility(field.node.vis)?; + s.maybe_print_comment(field.span.lo)?; + s.print_type(&field.node.ty) } )?; self.pclose()?; @@ -1432,19 +1427,14 @@ impl<'a> State<'a> { self.hardbreak_if_not_bol()?; for field in struct_def.fields() { - match field.node.kind { - ast::UnnamedField(..) => panic!("unexpected unnamed field"), - ast::NamedField(ident, ref visibility) => { - self.hardbreak_if_not_bol()?; - self.maybe_print_comment(field.span.lo)?; - self.print_outer_attributes(&field.node.attrs)?; - self.print_visibility(visibility)?; - self.print_ident(ident)?; - self.word_nbsp(":")?; - self.print_type(&field.node.ty)?; - word(&mut self.s, ",")?; - } - } + self.hardbreak_if_not_bol()?; + self.maybe_print_comment(field.span.lo)?; + self.print_outer_attributes(&field.node.attrs)?; + self.print_visibility(field.node.vis)?; + self.print_ident(field.node.ident.unwrap())?; + self.word_nbsp(":")?; + self.print_type(&field.node.ty)?; + word(&mut self.s, ",")?; } self.bclose(span) diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 1251f9bfe1350..d97e2db626514 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -619,7 +619,7 @@ pub fn walk_struct_def<'v, V: Visitor<'v>>(visitor: &mut V, pub fn walk_struct_field<'v, V: Visitor<'v>>(visitor: &mut V, struct_field: &'v StructField) { - walk_opt_ident(visitor, struct_field.span, struct_field.node.ident()); + walk_opt_ident(visitor, struct_field.span, struct_field.node.ident); visitor.visit_ty(&struct_field.node.ty); walk_list!(visitor, visit_attribute, &struct_field.node.attrs); } diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs index 7d452b14dae84..12a7270d5214b 100644 --- a/src/libsyntax_ext/deriving/generic/mod.rs +++ b/src/libsyntax_ext/deriving/generic/mod.rs @@ -186,7 +186,6 @@ pub use self::StaticFields::*; pub use self::SubstructureFields::*; -use self::StructType::*; use std::cell::RefCell; use std::collections::HashSet; @@ -1409,11 +1408,6 @@ impl<'a> MethodDef<'a> { } } -#[derive(PartialEq)] // dogfooding! -enum StructType { - Unknown, Record, Tuple -} - // general helper methods. impl<'a> TraitDef<'a> { fn set_expn_info(&self, @@ -1441,9 +1435,9 @@ impl<'a> TraitDef<'a> { let mut just_spans = Vec::new(); for field in struct_def.fields(){ let sp = self.set_expn_info(cx, field.span); - match field.node.kind { - ast::NamedField(ident, _) => named_idents.push((ident, sp)), - ast::UnnamedField(..) => just_spans.push(sp), + match field.node.ident { + Some(ident) => named_idents.push((ident, sp)), + _ => just_spans.push(sp), } } @@ -1479,53 +1473,26 @@ impl<'a> TraitDef<'a> { -> (P, Vec<(Span, Option, P, &'a [ast::Attribute])>) { - if struct_def.fields().is_empty() { - if struct_def.is_struct() { - return (cx.pat_struct(self.span, struct_path, vec![]), vec![]); - } else { - return (cx.pat_enum(self.span, struct_path, vec![]), vec![]); - } - } - let mut paths = Vec::new(); - let mut ident_expr = Vec::new(); - let mut struct_type = Unknown; - + let mut ident_exprs = Vec::new(); 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 || - struct_type == Record) => { - struct_type = Record; - Some(ident) - } - ast::UnnamedField(..) if (struct_type == Unknown || - struct_type == Tuple) => { - struct_type = Tuple; - None - } - _ => { - cx.span_bug(sp, "a struct with named and unnamed fields in `derive`"); - } - }; let ident = cx.ident_of(&format!("{}_{}", prefix, i)); paths.push(codemap::Spanned{span: sp, node: ident}); let val = cx.expr_deref(sp, cx.expr_path(cx.path_ident(sp,ident))); let val = cx.expr(sp, ast::ExprKind::Paren(val)); - ident_expr.push((sp, opt_id, val, &struct_field.node.attrs[..])); + ident_exprs.push((sp, struct_field.node.ident, val, &struct_field.node.attrs[..])); } let subpats = self.create_subpatterns(cx, paths, mutbl); - - // struct_type is definitely not Unknown, since struct_def.fields - // must be nonempty to reach here let pattern = if struct_def.is_struct() { - let field_pats = subpats.into_iter().zip(&ident_expr) - .map(|(pat, &(_, id, _, _))| { - // id is guaranteed to be Some + let field_pats = subpats.into_iter().zip(&ident_exprs).map(|(pat, &(sp, ident, _, _))| { + if ident.is_none() { + cx.span_bug(sp, "a braced struct with unnamed fields in `derive`"); + } codemap::Spanned { span: pat.span, - node: ast::FieldPat { ident: id.unwrap(), pat: pat, is_shorthand: false }, + node: ast::FieldPat { ident: ident.unwrap(), pat: pat, is_shorthand: false }, } }).collect(); cx.pat_struct(self.span, struct_path, field_pats) @@ -1533,7 +1500,7 @@ impl<'a> TraitDef<'a> { cx.pat_enum(self.span, struct_path, subpats) }; - (pattern, ident_expr) + (pattern, ident_exprs) } fn create_enum_variant_pattern(&self, From 8fe4290f1cf87bf7b0a0661e6bbe84f3319e614d Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Wed, 6 Apr 2016 11:19:10 +0300 Subject: [PATCH 2/2] Move span into `StructField` --- src/librustc/lint/context.rs | 2 +- src/librustc_front/lowering.rs | 10 +++++----- src/librustc_save_analysis/dump_visitor.rs | 4 ++-- src/librustc_save_analysis/lib.rs | 6 +++--- src/libsyntax/ast.rs | 5 ++--- src/libsyntax/ast_util.rs | 2 +- src/libsyntax/config.rs | 6 +++--- src/libsyntax/ext/build.rs | 5 +++-- src/libsyntax/fold.rs | 16 +++++++--------- src/libsyntax/parse/parser.rs | 17 ++++++++++------- src/libsyntax/print/pprust.rs | 12 ++++++------ src/libsyntax/visit.rs | 6 +++--- src/libsyntax_ext/deriving/generic/mod.rs | 8 ++++---- 13 files changed, 50 insertions(+), 49 deletions(-) diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index e78ff513ac473..46ac384670685 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -978,7 +978,7 @@ impl<'a, 'v> ast_visit::Visitor<'v> for EarlyContext<'a> { } fn visit_struct_field(&mut self, s: &ast::StructField) { - self.with_lint_attrs(&s.node.attrs, |cx| { + self.with_lint_attrs(&s.attrs, |cx| { run_lints!(cx, check_struct_field, early_passes, s); ast_visit::walk_struct_field(cx, s); }) diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs index 4ca30a041a541..738a04dea585d 100644 --- a/src/librustc_front/lowering.rs +++ b/src/librustc_front/lowering.rs @@ -621,11 +621,11 @@ pub fn lower_struct_field(lctx: &LoweringContext, -> hir::StructField { hir::StructField { span: f.span, - id: f.node.id, - name: f.node.ident.map(|ident| ident.name).unwrap_or(token::intern(&index.to_string())), - vis: lower_visibility(lctx, f.node.vis), - ty: lower_ty(lctx, &f.node.ty), - attrs: lower_attrs(lctx, &f.node.attrs), + id: f.id, + name: f.ident.map(|ident| ident.name).unwrap_or(token::intern(&index.to_string())), + vis: lower_visibility(lctx, &f.vis), + ty: lower_ty(lctx, &f.ty), + attrs: lower_attrs(lctx, &f.attrs), } } diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs index 35ca2a9b0149a..e9cfd24d41047 100644 --- a/src/librustc_save_analysis/dump_visitor.rs +++ b/src/librustc_save_analysis/dump_visitor.rs @@ -563,7 +563,7 @@ where D: Dump // fields for field in def.fields() { self.process_struct_field_def(field, item.id); - self.visit_ty(&field.node.ty); + self.visit_ty(&field.ty); } self.process_generic_params(ty_params, item.span, &qualname, item.id); @@ -624,7 +624,7 @@ where D: Dump for field in variant.node.data.fields() { self.process_struct_field_def(field, variant.node.data.id()); - self.visit_ty(&field.node.ty); + self.visit_ty(&field.ty); } } self.process_generic_params(ty_params, item.span, &enum_data.qualname, enum_data.id); diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs index 550628741c209..95339c7937161 100644 --- a/src/librustc_save_analysis/lib.rs +++ b/src/librustc_save_analysis/lib.rs @@ -246,13 +246,13 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { pub fn get_field_data(&self, field: &ast::StructField, scope: NodeId) -> Option { - if let Some(ident) = field.node.ident { + if let Some(ident) = field.ident { let qualname = format!("::{}::{}", self.tcx.map.path_to_string(scope), ident); - let typ = self.tcx.node_types().get(&field.node.id).unwrap().to_string(); + let typ = self.tcx.node_types().get(&field.id).unwrap().to_string(); let sub_span = self.span_utils.sub_span_before_token(field.span, token::Colon); filter!(self.span_utils, sub_span, field.span, None); Some(VariableData { - id: field.node.id, + id: field.id, name: ident.to_string(), qualname: qualname, span: sub_span.unwrap(), diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index fb6ae8b88bed2..dbe7b078498ea 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -1876,7 +1876,8 @@ pub enum Visibility { } #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] -pub struct StructField_ { +pub struct StructField { + pub span: Span, pub ident: Option, pub vis: Visibility, pub id: NodeId, @@ -1884,8 +1885,6 @@ pub struct StructField_ { pub attrs: Vec, } -pub type StructField = Spanned; - /// Fields and Ids of enum variants and structs /// /// For enum variants: `NodeId` represents both an Id of the variant itself (relevant for all diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 671ba3b0996af..ffba9e824d4ad 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -263,7 +263,7 @@ impl<'a, 'v, O: IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> { } fn visit_struct_field(&mut self, struct_field: &StructField) { - self.operation.visit_id(struct_field.node.id); + self.operation.visit_id(struct_field.id); visit::walk_struct_field(self, struct_field) } diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs index 9acb1805cdde8..4554a280e5f19 100644 --- a/src/libsyntax/config.rs +++ b/src/libsyntax/config.rs @@ -180,12 +180,12 @@ fn fold_struct(cx: &mut Context, vdata: ast::VariantData) -> ast::VariantD match vdata { ast::VariantData::Struct(fields, id) => { ast::VariantData::Struct(fields.into_iter().filter(|m| { - (cx.in_cfg)(&m.node.attrs) + (cx.in_cfg)(&m.attrs) }).collect(), id) } ast::VariantData::Tuple(fields, id) => { ast::VariantData::Tuple(fields.into_iter().filter(|m| { - (cx.in_cfg)(&m.node.attrs) + (cx.in_cfg)(&m.attrs) }).collect(), id) } ast::VariantData::Unit(id) => ast::VariantData::Unit(id) @@ -434,7 +434,7 @@ impl<'v, 'a, 'b> visit::Visitor<'v> for StmtExprAttrFeatureVisitor<'a, 'b> { } fn visit_struct_field(&mut self, s: &'v ast::StructField) { - if node_survives_cfg(&s.node.attrs, self.config) { + if node_survives_cfg(&s.attrs, self.config) { visit::walk_struct_field(self, s); } } diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index a62832b928d60..a4e5b68277d69 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -1007,13 +1007,14 @@ impl<'a> AstBuilder for ExtCtxt<'a> { fn variant(&self, span: Span, name: Ident, tys: Vec> ) -> ast::Variant { let fields: Vec<_> = tys.into_iter().map(|ty| { - Spanned { span: ty.span, node: ast::StructField_ { + ast::StructField { + span: ty.span, ty: ty, ident: None, vis: ast::Visibility::Inherited, attrs: Vec::new(), id: ast::DUMMY_NODE_ID, - }} + } }).collect(); let vdata = if fields.is_empty() { diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index eb35d3fd9d35b..46191b95f81f6 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -847,15 +847,13 @@ pub fn noop_fold_poly_trait_ref(p: PolyTraitRef, fld: &mut T) -> Poly } pub fn noop_fold_struct_field(f: StructField, fld: &mut T) -> StructField { - Spanned { - node: StructField_ { - id: fld.new_id(f.node.id), - ident: f.node.ident.map(|ident| fld.fold_ident(ident)), - vis: f.node.vis, - ty: fld.fold_ty(f.node.ty), - attrs: fold_attrs(f.node.attrs, fld), - }, - span: fld.new_span(f.span) + StructField { + span: fld.new_span(f.span), + id: fld.new_id(f.id), + ident: f.ident.map(|ident| fld.fold_ident(ident)), + vis: f.vis, + ty: fld.fold_ty(f.ty), + attrs: fold_attrs(f.attrs, fld), } } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 00d60630eaceb..28e4682f66b7e 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -3845,13 +3845,14 @@ impl<'a> Parser<'a> { let name = self.parse_ident()?; self.expect(&token::Colon)?; let ty = self.parse_ty_sum()?; - Ok(spanned(lo, self.last_span.hi, ast::StructField_ { + Ok(StructField { + span: mk_sp(lo, self.last_span.hi), ident: Some(name), vis: pr, id: ast::DUMMY_NODE_ID, ty: ty, attrs: attrs, - })) + }) } /// Emit an expected item after attributes error. @@ -5245,14 +5246,16 @@ impl<'a> Parser<'a> { |p| { let attrs = p.parse_outer_attributes()?; let lo = p.span.lo; - let struct_field_ = ast::StructField_ { - vis: p.parse_visibility()?, + let vis = p.parse_visibility()?; + let ty = p.parse_ty_sum()?; + Ok(StructField { + span: mk_sp(lo, p.span.hi), + vis: vis, ident: None, id: ast::DUMMY_NODE_ID, - ty: p.parse_ty_sum()?, + ty: ty, attrs: attrs, - }; - Ok(spanned(lo, p.span.hi, struct_field_)) + }) })?; Ok(fields) diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index c7a755aeeac56..e2b1d2f5e7abe 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1407,9 +1407,9 @@ impl<'a> State<'a> { self.commasep( Inconsistent, struct_def.fields(), |s, field| { - s.print_visibility(field.node.vis)?; + s.print_visibility(&field.vis)?; s.maybe_print_comment(field.span.lo)?; - s.print_type(&field.node.ty) + s.print_type(&field.ty) } )?; self.pclose()?; @@ -1429,11 +1429,11 @@ impl<'a> State<'a> { for field in struct_def.fields() { self.hardbreak_if_not_bol()?; self.maybe_print_comment(field.span.lo)?; - self.print_outer_attributes(&field.node.attrs)?; - self.print_visibility(field.node.vis)?; - self.print_ident(field.node.ident.unwrap())?; + self.print_outer_attributes(&field.attrs)?; + self.print_visibility(&field.vis)?; + self.print_ident(field.ident.unwrap())?; self.word_nbsp(":")?; - self.print_type(&field.node.ty)?; + self.print_type(&field.ty)?; word(&mut self.s, ",")?; } diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index d97e2db626514..839bbf4805df2 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -619,9 +619,9 @@ pub fn walk_struct_def<'v, V: Visitor<'v>>(visitor: &mut V, pub fn walk_struct_field<'v, V: Visitor<'v>>(visitor: &mut V, struct_field: &'v StructField) { - walk_opt_ident(visitor, struct_field.span, struct_field.node.ident); - visitor.visit_ty(&struct_field.node.ty); - walk_list!(visitor, visit_attribute, &struct_field.node.attrs); + walk_opt_ident(visitor, struct_field.span, struct_field.ident); + visitor.visit_ty(&struct_field.ty); + walk_list!(visitor, visit_attribute, &struct_field.attrs); } pub fn walk_block<'v, V: Visitor<'v>>(visitor: &mut V, block: &'v Block) { diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs index 12a7270d5214b..a389165f71534 100644 --- a/src/libsyntax_ext/deriving/generic/mod.rs +++ b/src/libsyntax_ext/deriving/generic/mod.rs @@ -653,7 +653,7 @@ impl<'a> TraitDef<'a> { type_ident: Ident, generics: &Generics) -> P { let field_tys: Vec> = struct_def.fields().iter() - .map(|field| field.node.ty.clone()) + .map(|field| field.ty.clone()) .collect(); let methods = self.methods.iter().map(|method_def| { @@ -701,7 +701,7 @@ impl<'a> TraitDef<'a> { for variant in &enum_def.variants { field_tys.extend(variant.node.data.fields().iter() - .map(|field| field.node.ty.clone())); + .map(|field| field.ty.clone())); } let methods = self.methods.iter().map(|method_def| { @@ -1435,7 +1435,7 @@ impl<'a> TraitDef<'a> { let mut just_spans = Vec::new(); for field in struct_def.fields(){ let sp = self.set_expn_info(cx, field.span); - match field.node.ident { + match field.ident { Some(ident) => named_idents.push((ident, sp)), _ => just_spans.push(sp), } @@ -1481,7 +1481,7 @@ impl<'a> TraitDef<'a> { paths.push(codemap::Spanned{span: sp, node: ident}); let val = cx.expr_deref(sp, cx.expr_path(cx.path_ident(sp,ident))); let val = cx.expr(sp, ast::ExprKind::Paren(val)); - ident_exprs.push((sp, struct_field.node.ident, val, &struct_field.node.attrs[..])); + ident_exprs.push((sp, struct_field.ident, val, &struct_field.attrs[..])); } let subpats = self.create_subpatterns(cx, paths, mutbl);