From ea47c2b6b349d7f252a6a734ced8204e6ef70546 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Thu, 1 Oct 2015 18:47:27 +0300 Subject: [PATCH 01/13] Unify structures and enum variants in AST --- src/librustc_front/lowering.rs | 22 +++---- src/librustc_trans/save/dump_csv.rs | 48 +++++---------- src/libsyntax/ast.rs | 2 +- src/libsyntax/config.rs | 9 +-- src/libsyntax/ext/build.rs | 11 +++- src/libsyntax/ext/deriving/generic/mod.rs | 50 ++-------------- src/libsyntax/ext/deriving/primitive.rs | 60 ++++++++----------- src/libsyntax/fold.rs | 12 +--- src/libsyntax/parse/parser.rs | 35 +++++------ src/libsyntax/print/pprust.rs | 32 ++++------ src/libsyntax/visit.rs | 15 +---- src/test/compile-fail/deriving-primitive.rs | 8 +-- .../parse-fail/struct-variant-no-fields.rs | 15 ----- 13 files changed, 95 insertions(+), 224 deletions(-) delete mode 100644 src/test/parse-fail/struct-variant-no-fields.rs diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs index 5bd188020a33c..bd5f7cf3c626e 100644 --- a/src/librustc_front/lowering.rs +++ b/src/librustc_front/lowering.rs @@ -267,14 +267,13 @@ pub fn lower_variant(_lctx: &LoweringContext, v: &Variant) -> P { id: v.node.id, name: v.node.name.name, attrs: v.node.attrs.clone(), - kind: match v.node.kind { - TupleVariantKind(ref variant_args) => { - hir::TupleVariantKind(variant_args.iter() - .map(|ref x| lower_variant_arg(_lctx, x)) - .collect()) - } - StructVariantKind(ref struct_def) => { - hir::StructVariantKind(lower_struct_def(_lctx, struct_def)) + kind: { + if v.node.def.ctor_id.is_none() { + hir::StructVariantKind(lower_struct_def(_lctx, &v.node.def)) + } else { + hir::TupleVariantKind(v.node.def.fields.iter().map(|ref field| { + hir::VariantArg { id: field.node.id, ty: lower_ty(_lctx, &field.node.ty) } + }).collect()) } }, disr_expr: v.node.disr_expr.as_ref().map(|e| lower_expr(_lctx, e)), @@ -567,13 +566,6 @@ fn lower_bounds(_lctx: &LoweringContext, bounds: &TyParamBounds) -> hir::TyParam bounds.iter().map(|bound| lower_ty_param_bound(_lctx, bound)).collect() } -fn lower_variant_arg(_lctx: &LoweringContext, va: &VariantArg) -> hir::VariantArg { - hir::VariantArg { - id: va.id, - ty: lower_ty(_lctx, &va.ty), - } -} - pub fn lower_block(_lctx: &LoweringContext, b: &Block) -> P { P(hir::Block { id: b.id, diff --git a/src/librustc_trans/save/dump_csv.rs b/src/librustc_trans/save/dump_csv.rs index 09825f1f91939..983f04643c362 100644 --- a/src/librustc_trans/save/dump_csv.rs +++ b/src/librustc_trans/save/dump_csv.rs @@ -504,40 +504,20 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { qualname.push_str("::"); qualname.push_str(name); let val = self.span.snippet(variant.span); - match variant.node.kind { - ast::TupleVariantKind(ref args) => { - // first ident in span is the variant's name - self.fmt.tuple_variant_str(variant.span, - self.span.span_for_first_ident(variant.span), - variant.node.id, - name, - &qualname, - &enum_data.qualname, - &val, - enum_data.id); - for arg in args { - self.visit_ty(&*arg.ty); - } - } - ast::StructVariantKind(ref struct_def) => { - let ctor_id = match struct_def.ctor_id { - Some(node_id) => node_id, - None => ast::DUMMY_NODE_ID, - }; - self.fmt.struct_variant_str(variant.span, - self.span.span_for_first_ident(variant.span), - variant.node.id, - ctor_id, - &qualname, - &enum_data.qualname, - &val, - enum_data.id); - - for field in &struct_def.fields { - self.process_struct_field_def(field, variant.node.id); - self.visit_ty(&*field.node.ty); - } - } + + let ctor_id = variant.node.def.ctor_id.unwrap_or(ast::DUMMY_NODE_ID); + self.fmt.struct_variant_str(variant.span, + self.span.span_for_first_ident(variant.span), + variant.node.id, + ctor_id, + &qualname, + &enum_data.qualname, + &val, + enum_data.id); + + for field in &variant.node.def.fields { + self.process_struct_field_def(field, variant.node.id); + self.visit_ty(&*field.node.ty); } } self.process_generic_params(ty_params, item.span, &enum_data.qualname, enum_data.id); diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 34b99ab8cce1c..57d9837e1aacc 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -1594,7 +1594,7 @@ pub struct EnumDef { pub struct Variant_ { pub name: Ident, pub attrs: Vec, - pub kind: VariantKind, + pub def: P, pub id: NodeId, /// Explicit discriminant, eg `Foo = 1` pub disr_expr: Option>, diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs index 2d266be3242a5..0accf34202ed7 100644 --- a/src/libsyntax/config.rs +++ b/src/libsyntax/config.rs @@ -140,19 +140,14 @@ fn fold_item_underscore(cx: &mut Context, item: ast::Item_) -> ast::Item_ if !(cx.in_cfg)(&v.node.attrs) { None } else { - Some(v.map(|Spanned {node: ast::Variant_ {id, name, attrs, kind, + Some(v.map(|Spanned {node: ast::Variant_ {id, name, attrs, def, disr_expr}, span}| { Spanned { node: ast::Variant_ { id: id, name: name, attrs: attrs, - kind: match kind { - ast::TupleVariantKind(..) => kind, - ast::StructVariantKind(def) => { - ast::StructVariantKind(fold_struct(cx, def)) - } - }, + def: fold_struct(cx, def), disr_expr: disr_expr, }, span: span diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index efea85f916252..d448eb63204eb 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -993,15 +993,20 @@ impl<'a> AstBuilder for ExtCtxt<'a> { } fn variant(&self, span: Span, name: Ident, tys: Vec> ) -> ast::Variant { - let args = tys.into_iter().map(|ty| { - ast::VariantArg { ty: ty, id: ast::DUMMY_NODE_ID } + let fields = tys.into_iter().map(|ty| { + Spanned { span: ty.span, node: ast::StructField_ { + ty: ty, + kind: ast::UnnamedField(ast::Inherited), + attrs: Vec::new(), + id: ast::DUMMY_NODE_ID, + }} }).collect(); respan(span, ast::Variant_ { name: name, attrs: Vec::new(), - kind: ast::TupleVariantKind(args), + def: P(ast::StructDef { fields: fields, ctor_id: Some(ast::DUMMY_NODE_ID) }), id: ast::DUMMY_NODE_ID, disr_expr: None, }) diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs index 9fc2745cf929a..f6ea6aef108a1 100644 --- a/src/libsyntax/ext/deriving/generic/mod.rs +++ b/src/libsyntax/ext/deriving/generic/mod.rs @@ -700,16 +700,8 @@ impl<'a> TraitDef<'a> { let mut field_tys = Vec::new(); for variant in &enum_def.variants { - match variant.node.kind { - ast::VariantKind::TupleVariantKind(ref args) => { - field_tys.extend(args.iter() - .map(|arg| arg.ty.clone())); - } - ast::VariantKind::StructVariantKind(ref args) => { - field_tys.extend(args.fields.iter() - .map(|field| field.node.ty.clone())); - } - } + field_tys.extend(variant.node.def.fields.iter() + .map(|field| field.node.ty.clone())); } let methods = self.methods.iter().map(|method_def| { @@ -1413,14 +1405,7 @@ impl<'a> MethodDef<'a> { -> P { let summary = enum_def.variants.iter().map(|v| { let ident = v.node.name; - let summary = match v.node.kind { - ast::TupleVariantKind(ref args) => { - Unnamed(args.iter().map(|va| trait_.set_expn_info(cx, va.ty.span)).collect()) - } - ast::StructVariantKind(ref struct_def) => { - trait_.summarise_struct(cx, &**struct_def) - } - }; + let summary = trait_.summarise_struct(cx, &v.node.def); (ident, v.span, summary) }).collect(); self.call_substructure_method(cx, trait_, type_ident, @@ -1560,34 +1545,7 @@ impl<'a> TraitDef<'a> { -> (P, Vec<(Span, Option, P, &'a [ast::Attribute])>) { let variant_ident = variant.node.name; let variant_path = cx.path(variant.span, vec![enum_ident, variant_ident]); - match variant.node.kind { - ast::TupleVariantKind(ref variant_args) => { - if variant_args.is_empty() { - return (cx.pat_enum(variant.span, variant_path, vec![]), vec![]); - } - - let mut paths = Vec::new(); - let mut ident_expr: Vec<(_, _, _, &'a [ast::Attribute])> = Vec::new(); - for (i, va) in variant_args.iter().enumerate() { - let sp = self.set_expn_info(cx, va.ty.span); - let ident = cx.ident_of(&format!("{}_{}", prefix, i)); - let path1 = codemap::Spanned{span: sp, node: ident}; - paths.push(path1); - let expr_path = cx.expr_path(cx.path_ident(sp, ident)); - let val = cx.expr(sp, ast::ExprParen(cx.expr_deref(sp, expr_path))); - ident_expr.push((sp, None, val, &[])); - } - - let subpats = self.create_subpatterns(cx, paths, mutbl); - - (cx.pat_enum(variant.span, variant_path, subpats), - ident_expr) - } - ast::StructVariantKind(ref struct_def) => { - self.create_struct_pattern(cx, variant_path, &**struct_def, - prefix, mutbl) - } - } + self.create_struct_pattern(cx, variant_path, &variant.node.def, prefix, mutbl) } } diff --git a/src/libsyntax/ext/deriving/primitive.rs b/src/libsyntax/ext/deriving/primitive.rs index 5d3cc50557cde..2fdaa9b7550b5 100644 --- a/src/libsyntax/ext/deriving/primitive.rs +++ b/src/libsyntax/ext/deriving/primitive.rs @@ -94,45 +94,35 @@ fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure let mut arms = Vec::new(); for variant in &enum_def.variants { - match variant.node.kind { - ast::TupleVariantKind(ref args) => { - if !args.is_empty() { - cx.span_err(trait_span, - "`FromPrimitive` cannot be derived for \ - enum variants with arguments"); - return cx.expr_fail(trait_span, - InternedString::new("")); - } - let span = variant.span; + let def = &variant.node.def; + if def.ctor_id.is_none() || !def.fields.is_empty() { + cx.span_err(trait_span, "`FromPrimitive` cannot be derived \ + for enums with non-unit variants"); + return cx.expr_fail(trait_span, + InternedString::new("")); + } - // expr for `$n == $variant as $name` - let path = cx.path(span, vec![substr.type_ident, variant.node.name]); - let variant = cx.expr_path(path); - let ty = cx.ty_ident(span, cx.ident_of(name)); - let cast = cx.expr_cast(span, variant.clone(), ty); - let guard = cx.expr_binary(span, ast::BiEq, n.clone(), cast); + let span = variant.span; - // expr for `Some($variant)` - let body = cx.expr_some(span, variant); + // expr for `$n == $variant as $name` + let path = cx.path(span, vec![substr.type_ident, variant.node.name]); + let variant = cx.expr_path(path); + let ty = cx.ty_ident(span, cx.ident_of(name)); + let cast = cx.expr_cast(span, variant.clone(), ty); + let guard = cx.expr_binary(span, ast::BiEq, n.clone(), cast); - // arm for `_ if $guard => $body` - let arm = ast::Arm { - attrs: vec!(), - pats: vec!(cx.pat_wild(span)), - guard: Some(guard), - body: body, - }; + // expr for `Some($variant)` + let body = cx.expr_some(span, variant); - arms.push(arm); - } - ast::StructVariantKind(_) => { - cx.span_err(trait_span, - "`FromPrimitive` cannot be derived for enums \ - with struct variants"); - return cx.expr_fail(trait_span, - InternedString::new("")); - } - } + // arm for `_ if $guard => $body` + let arm = ast::Arm { + attrs: vec!(), + pats: vec!(cx.pat_wild(span)), + guard: Some(guard), + body: body, + }; + + arms.push(arm); } // arm for `_ => None` diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 3c1aa992a3c16..88781c3664ab2 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -450,20 +450,12 @@ pub fn noop_fold_foreign_mod(ForeignMod {abi, items}: ForeignMod, } pub fn noop_fold_variant(v: P, fld: &mut T) -> P { - v.map(|Spanned {node: Variant_ {id, name, attrs, kind, disr_expr}, span}| Spanned { + v.map(|Spanned {node: Variant_ {id, name, attrs, def, disr_expr}, span}| Spanned { node: Variant_ { id: fld.new_id(id), name: name, attrs: fold_attrs(attrs, fld), - kind: match kind { - TupleVariantKind(variant_args) => { - TupleVariantKind(variant_args.move_map(|x| - fld.fold_variant_arg(x))) - } - StructVariantKind(struct_def) => { - StructVariantKind(fld.fold_struct_def(struct_def)) - } - }, + def: fld.fold_struct_def(def), disr_expr: disr_expr.map(|e| fld.fold_expr(e)), }, span: fld.new_span(span), diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 443cea696b682..0748c898a828b 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -46,11 +46,11 @@ use ast::PatWildSingle; use ast::{PolyTraitRef, QSelf}; use ast::{Return, BiShl, BiShr, Stmt, StmtDecl}; use ast::{StmtExpr, StmtSemi, StmtMac, StructDef, StructField}; -use ast::{StructVariantKind, BiSub, StrStyle}; +use ast::{BiSub, StrStyle}; use ast::{SelfExplicit, SelfRegion, SelfStatic, SelfValue}; use ast::{Delimited, SequenceRepetition, TokenTree, TraitItem, TraitRef}; use ast::{TtDelimited, TtSequence, TtToken}; -use ast::{TupleVariantKind, Ty, Ty_, TypeBinding}; +use ast::{Ty, Ty_, TypeBinding}; use ast::{TyMac}; use ast::{TyFixedLengthVec, TyBareFn, TyTypeof, TyInfer}; use ast::{TyParam, TyParamBound, TyParen, TyPath, TyPolyTraitRef, TyPtr}; @@ -5131,22 +5131,13 @@ impl<'a> Parser<'a> { let variant_attrs = self.parse_outer_attributes(); let vlo = self.span.lo; - let kind; - let mut args = Vec::new(); + let struct_def; let mut disr_expr = None; let ident = try!(self.parse_ident()); if try!(self.eat(&token::OpenDelim(token::Brace)) ){ // Parse a struct variant. all_nullary = false; - let start_span = self.span; - let struct_def = try!(self.parse_struct_def()); - if struct_def.fields.is_empty() { - self.span_err(start_span, - &format!("unit-like struct variant should be written \ - without braces, as `{},`", - ident)); - } - kind = StructVariantKind(struct_def); + struct_def = try!(self.parse_struct_def()); } else if self.check(&token::OpenDelim(token::Paren)) { all_nullary = false; let arg_tys = try!(self.parse_enum_variant_seq( @@ -5155,25 +5146,31 @@ impl<'a> Parser<'a> { seq_sep_trailing_allowed(token::Comma), |p| p.parse_ty_sum() )); + let mut fields = Vec::new(); for ty in arg_tys { - args.push(ast::VariantArg { + fields.push(Spanned { span: ty.span, node: ast::StructField_ { ty: ty, + kind: ast::UnnamedField(ast::Inherited), + attrs: Vec::new(), id: ast::DUMMY_NODE_ID, - }); + }}); } - kind = TupleVariantKind(args); + struct_def = P(StructDef { fields: fields, + ctor_id: Some(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); - kind = TupleVariantKind(args); + struct_def = P(StructDef { fields: Vec::new(), + ctor_id: Some(ast::DUMMY_NODE_ID) }); } else { - kind = TupleVariantKind(Vec::new()); + struct_def = P(StructDef { fields: Vec::new(), + ctor_id: Some(ast::DUMMY_NODE_ID) }); } let vr = ast::Variant_ { name: ident, attrs: variant_attrs, - kind: kind, + def: struct_def, id: ast::DUMMY_NODE_ID, disr_expr: disr_expr, }; diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index f5f3907a4e6c8..678b8e0489741 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1223,7 +1223,7 @@ impl<'a> State<'a> { } ast::ItemStruct(ref struct_def, ref generics) => { try!(self.head(&visibility_qualified(item.vis,"struct"))); - try!(self.print_struct(&**struct_def, generics, item.ident, item.span)); + try!(self.print_struct(&struct_def, generics, item.ident, item.span, true)); } ast::ItemDefaultImpl(unsafety, ref trait_ref) => { @@ -1388,7 +1388,8 @@ impl<'a> State<'a> { struct_def: &ast::StructDef, generics: &ast::Generics, ident: ast::Ident, - span: codemap::Span) -> io::Result<()> { + span: codemap::Span, + print_finalizer: bool) -> io::Result<()> { try!(self.print_ident(ident)); try!(self.print_generics(generics)); if ast_util::struct_def_is_tuple_like(struct_def) { @@ -1410,7 +1411,9 @@ impl<'a> State<'a> { try!(self.pclose()); } try!(self.print_where_clause(&generics.where_clause)); - try!(word(&mut self.s, ";")); + if print_finalizer { + try!(word(&mut self.s, ";")); + } try!(self.end()); self.end() // close the outer-box } else { @@ -1505,23 +1508,9 @@ impl<'a> State<'a> { } pub fn print_variant(&mut self, v: &ast::Variant) -> io::Result<()> { - match v.node.kind { - ast::TupleVariantKind(ref args) => { - try!(self.print_ident(v.node.name)); - if !args.is_empty() { - try!(self.popen()); - try!(self.commasep(Consistent, - &args[..], - |s, arg| s.print_type(&*arg.ty))); - try!(self.pclose()); - } - } - ast::StructVariantKind(ref struct_def) => { - try!(self.head("")); - let generics = ast_util::empty_generics(); - try!(self.print_struct(&**struct_def, &generics, v.node.name, v.span)); - } - } + try!(self.head("")); + let generics = ast_util::empty_generics(); + try!(self.print_struct(&v.node.def, &generics, v.node.name, v.span, false)); match v.node.disr_expr { Some(ref d) => { try!(space(&mut self.s)); @@ -3103,6 +3092,7 @@ mod tests { use ast_util; use codemap; use parse::token; + use ptr::P; #[test] fn test_fun_to_string() { @@ -3129,7 +3119,7 @@ mod tests { name: ident, attrs: Vec::new(), // making this up as I go.... ? - kind: ast::TupleVariantKind(Vec::new()), + def: P(ast::StructDef { fields: Vec::new(), ctor_id: Some(ast::DUMMY_NODE_ID) }), id: 0, disr_expr: None, }); diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 091580b9bd837..fe64f87e68174 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -315,20 +315,7 @@ pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V, variant: &'v Variant, generics: &'v Generics) { visitor.visit_ident(variant.span, variant.node.name); - - match variant.node.kind { - TupleVariantKind(ref variant_arguments) => { - for variant_argument in variant_arguments { - visitor.visit_ty(&variant_argument.ty) - } - } - StructVariantKind(ref struct_definition) => { - visitor.visit_struct_def(struct_definition, - variant.node.name, - generics, - variant.node.id) - } - } + visitor.visit_struct_def(&variant.node.def, variant.node.name, generics, variant.node.id); walk_list!(visitor, visit_expr, &variant.node.disr_expr); walk_list!(visitor, visit_attribute, &variant.node.attrs); } diff --git a/src/test/compile-fail/deriving-primitive.rs b/src/test/compile-fail/deriving-primitive.rs index 6e9b120aa69b5..e8e37d8804986 100644 --- a/src/test/compile-fail/deriving-primitive.rs +++ b/src/test/compile-fail/deriving-primitive.rs @@ -23,12 +23,12 @@ struct B(isize); #[derive(FromPrimitive)] enum C { Foo(isize), Bar(usize) } -//~^^ ERROR `FromPrimitive` cannot be derived for enum variants with arguments -//~^^^ ERROR `FromPrimitive` cannot be derived for enum variants with arguments +//~^^ ERROR `FromPrimitive` cannot be derived for enums with non-unit variants +//~^^^ ERROR `FromPrimitive` cannot be derived for enums with non-unit variants #[derive(FromPrimitive)] enum D { Baz { x: isize } } -//~^^ ERROR `FromPrimitive` cannot be derived for enums with struct variants -//~^^^ ERROR `FromPrimitive` cannot be derived for enums with struct variants +//~^^ ERROR `FromPrimitive` cannot be derived for enums with non-unit variants +//~^^^ ERROR `FromPrimitive` cannot be derived for enums with non-unit variants pub fn main() {} diff --git a/src/test/parse-fail/struct-variant-no-fields.rs b/src/test/parse-fail/struct-variant-no-fields.rs deleted file mode 100644 index 68cf661e21805..0000000000000 --- a/src/test/parse-fail/struct-variant-no-fields.rs +++ /dev/null @@ -1,15 +0,0 @@ -// Copyright 2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// compile-flags: -Z parse-only - -enum Foo { - Bar {} //~ ERROR unit-like struct variant should be written without braces, as `Bar,` -} From 2314ab29c26c9364c7f8e26b55ce091998489f58 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Fri, 2 Oct 2015 00:03:22 +0300 Subject: [PATCH 02/13] Unify structures and enum variants in HIR --- src/librustc/front/map/collector.rs | 21 +++------- src/librustc/front/map/mod.rs | 6 +-- src/librustc_front/fold.rs | 27 +++++-------- src/librustc_front/hir.rs | 2 +- src/librustc_front/lowering.rs | 12 +----- src/librustc_front/print/pprust.rs | 27 +++++-------- src/librustc_front/visit.rs | 15 +------ src/librustc_resolve/build_reduced_graph.rs | 8 ++-- src/librustc_resolve/lib.rs | 14 +------ src/librustc_trans/trans/base.rs | 11 +++--- src/librustc_trans/trans/callee.rs | 7 ++-- src/librustc_typeck/check/wf.rs | 36 +---------------- src/librustc_typeck/check/wfcheck.rs | 36 +---------------- src/librustc_typeck/collect.rs | 43 +++------------------ src/librustdoc/clean/mod.rs | 12 +++++- src/librustdoc/doctree.rs | 2 +- src/librustdoc/visit_ast.rs | 2 +- 17 files changed, 62 insertions(+), 219 deletions(-) diff --git a/src/librustc/front/map/collector.rs b/src/librustc/front/map/collector.rs index 5f3148c7c33c5..3edeaaccbde44 100644 --- a/src/librustc/front/map/collector.rs +++ b/src/librustc/front/map/collector.rs @@ -138,22 +138,11 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> { NodeVariant(&**v), DefPathData::EnumVariant(v.node.name)); - match v.node.kind { - TupleVariantKind(ref args) => { - for arg in args { - self.create_def_with_parent(Some(variant_def_index), - arg.id, - DefPathData::PositionalField); - } - } - StructVariantKind(ref def) => { - for field in &def.fields { - self.create_def_with_parent( - Some(variant_def_index), - field.node.id, - DefPathData::Field(field.node.kind)); - } - } + for field in &v.node.def.fields { + self.create_def_with_parent( + Some(variant_def_index), + field.node.id, + DefPathData::Field(field.node.kind)); } } } diff --git a/src/librustc/front/map/mod.rs b/src/librustc/front/map/mod.rs index 396e2bb5703b1..96e103aa4f4b7 100644 --- a/src/librustc/front/map/mod.rs +++ b/src/librustc/front/map/mod.rs @@ -475,13 +475,13 @@ impl<'ast> Map<'ast> { match self.find(id) { Some(NodeItem(i)) => { match i.node { - ItemStruct(ref struct_def, _) => &**struct_def, + ItemStruct(ref struct_def, _) => struct_def, _ => panic!("struct ID bound to non-struct") } } Some(NodeVariant(variant)) => { - match variant.node.kind { - StructVariantKind(ref struct_def) => &**struct_def, + match variant.node.def.ctor_id { + None => &variant.node.def, _ => panic!("struct ID bound to enum variant that isn't struct-like"), } } diff --git a/src/librustc_front/fold.rs b/src/librustc_front/fold.rs index c6108044beace..876ec804e278e 100644 --- a/src/librustc_front/fold.rs +++ b/src/librustc_front/fold.rs @@ -435,24 +435,15 @@ pub fn noop_fold_foreign_mod(ForeignMod { abi, items }: ForeignMod, } pub fn noop_fold_variant(v: P, fld: &mut T) -> P { - v.map(|Spanned { node: Variant_ { id, name, attrs, kind, disr_expr }, span }| { - Spanned { - node: Variant_ { - id: fld.new_id(id), - name: name, - attrs: fold_attrs(attrs, fld), - kind: match kind { - TupleVariantKind(variant_args) => { - TupleVariantKind(variant_args.move_map(|x| fld.fold_variant_arg(x))) - } - StructVariantKind(struct_def) => { - StructVariantKind(fld.fold_struct_def(struct_def)) - } - }, - disr_expr: disr_expr.map(|e| fld.fold_expr(e)), - }, - span: fld.new_span(span), - } + v.map(|Spanned {node: Variant_ {id, name, attrs, def, disr_expr}, span}| Spanned { + node: Variant_ { + id: fld.new_id(id), + name: name, + attrs: fold_attrs(attrs, fld), + def: fld.fold_struct_def(def), + disr_expr: disr_expr.map(|e| fld.fold_expr(e)), + }, + span: fld.new_span(span), }) } diff --git a/src/librustc_front/hir.rs b/src/librustc_front/hir.rs index 9066b93262cd6..8f5f95b110468 100644 --- a/src/librustc_front/hir.rs +++ b/src/librustc_front/hir.rs @@ -1038,7 +1038,7 @@ pub struct EnumDef { pub struct Variant_ { pub name: Name, pub attrs: Vec, - pub kind: VariantKind, + pub def: P, pub id: NodeId, /// Explicit discriminant, eg `Foo = 1` pub disr_expr: Option>, diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs index bd5f7cf3c626e..0350c9ff11443 100644 --- a/src/librustc_front/lowering.rs +++ b/src/librustc_front/lowering.rs @@ -267,16 +267,8 @@ pub fn lower_variant(_lctx: &LoweringContext, v: &Variant) -> P { id: v.node.id, name: v.node.name.name, attrs: v.node.attrs.clone(), - kind: { - if v.node.def.ctor_id.is_none() { - hir::StructVariantKind(lower_struct_def(_lctx, &v.node.def)) - } else { - hir::TupleVariantKind(v.node.def.fields.iter().map(|ref field| { - hir::VariantArg { id: field.node.id, ty: lower_ty(_lctx, &field.node.ty) } - }).collect()) - } - }, - disr_expr: v.node.disr_expr.as_ref().map(|e| lower_expr(_lctx, e)), + def: lower_struct_def(_lctx, &v.node.def), + disr_expr: v.node.disr_expr.as_ref().map(|e| lower_expr(e)), }, span: v.span, }) diff --git a/src/librustc_front/print/pprust.rs b/src/librustc_front/print/pprust.rs index 80b0a984681a3..ee6be06428e16 100644 --- a/src/librustc_front/print/pprust.rs +++ b/src/librustc_front/print/pprust.rs @@ -734,7 +734,7 @@ impl<'a> State<'a> { } hir::ItemStruct(ref struct_def, ref generics) => { try!(self.head(&visibility_qualified(item.vis, "struct"))); - try!(self.print_struct(&**struct_def, generics, item.name, item.span)); + try!(self.print_struct(&**struct_def, generics, item.name, item.span, true)); } hir::ItemDefaultImpl(unsafety, ref trait_ref) => { @@ -891,7 +891,8 @@ impl<'a> State<'a> { struct_def: &hir::StructDef, generics: &hir::Generics, name: ast::Name, - span: codemap::Span) + span: codemap::Span, + print_finalizer: bool) -> io::Result<()> { try!(self.print_name(name)); try!(self.print_generics(generics)); @@ -913,7 +914,9 @@ impl<'a> State<'a> { try!(self.pclose()); } try!(self.print_where_clause(&generics.where_clause)); - try!(word(&mut self.s, ";")); + if print_finalizer { + try!(word(&mut self.s, ";")); + } try!(self.end()); self.end() // close the outer-box } else { @@ -943,21 +946,9 @@ impl<'a> State<'a> { } pub fn print_variant(&mut self, v: &hir::Variant) -> io::Result<()> { - match v.node.kind { - hir::TupleVariantKind(ref args) => { - try!(self.print_name(v.node.name)); - if !args.is_empty() { - try!(self.popen()); - try!(self.commasep(Consistent, &args[..], |s, arg| s.print_type(&*arg.ty))); - try!(self.pclose()); - } - } - hir::StructVariantKind(ref struct_def) => { - try!(self.head("")); - let generics = ::util::empty_generics(); - try!(self.print_struct(&**struct_def, &generics, v.node.name, v.span)); - } - } + try!(self.head("")); + let generics = ::util::empty_generics(); + try!(self.print_struct(&v.node.def, &generics, v.node.name, v.span, false)); match v.node.disr_expr { Some(ref d) => { try!(space(&mut self.s)); diff --git a/src/librustc_front/visit.rs b/src/librustc_front/visit.rs index 9e91ab34d089a..6f9babcc7fd61 100644 --- a/src/librustc_front/visit.rs +++ b/src/librustc_front/visit.rs @@ -333,20 +333,7 @@ pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V, variant: &'v Variant, generics: &'v Generics) { visitor.visit_name(variant.span, variant.node.name); - - match variant.node.kind { - TupleVariantKind(ref variant_arguments) => { - for variant_argument in variant_arguments { - visitor.visit_ty(&variant_argument.ty) - } - } - StructVariantKind(ref struct_definition) => { - visitor.visit_struct_def(struct_definition, - variant.node.name, - generics, - variant.node.id) - } - } + visitor.visit_struct_def(&variant.node.def, variant.node.name, generics, variant.node.id); walk_list!(visitor, visit_expr, &variant.node.disr_expr); walk_list!(visitor, visit_attribute, &variant.node.attrs); } diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index f74144565fc58..a3f40efa48331 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -49,8 +49,6 @@ use rustc_front::hir::{ItemForeignMod, ItemImpl, ItemMod, ItemStatic, ItemDefaul use rustc_front::hir::{ItemStruct, ItemTrait, ItemTy, ItemUse}; use rustc_front::hir::{NamedField, PathListIdent, PathListMod, Public}; use rustc_front::hir::StmtDecl; -use rustc_front::hir::StructVariantKind; -use rustc_front::hir::TupleVariantKind; use rustc_front::hir::UnnamedField; use rustc_front::hir::{Variant, ViewPathGlob, ViewPathList, ViewPathSimple}; use rustc_front::hir::Visibility; @@ -589,9 +587,9 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { item_id: DefId, parent: &Rc) { let name = variant.node.name; - let is_exported = match variant.node.kind { - TupleVariantKind(_) => false, - StructVariantKind(_) => { + let is_exported = match variant.node.def.ctor_id { + Some(_) => false, + None => { // 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.id); self.structs.insert(variant_def_id, Vec::new()); diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 40477d8698ebe..b3c0aca954ec0 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -501,19 +501,7 @@ impl<'a, 'v, 'tcx> Visitor<'v> for Resolver<'a, 'tcx> { } // `visit::walk_variant` without the discriminant expression. - match variant.node.kind { - hir::TupleVariantKind(ref variant_arguments) => { - for variant_argument in variant_arguments { - self.visit_ty(&*variant_argument.ty); - } - } - hir::StructVariantKind(ref struct_definition) => { - self.visit_struct_def(&**struct_definition, - variant.node.name, - generics, - variant.node.id); - } - } + self.visit_struct_def(&variant.node.def, variant.node.name, generics, variant.node.id); } fn visit_foreign_item(&mut self, foreign_item: &hir::ForeignItem) { execute_callback!(hir_map::Node::NodeForeignItem(foreign_item), self); diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index 05b20ac3fb7d4..6baa3c5e0db6d 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -2428,13 +2428,12 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { hir_map::NodeVariant(ref v) => { let llfn; - let args = match v.node.kind { - hir::TupleVariantKind(ref args) => args, - hir::StructVariantKind(_) => { - ccx.sess().bug("struct variant kind unexpected in get_item_val") - } + let fields = if v.node.def.ctor_id.is_none() { + ccx.sess().bug("struct variant kind unexpected in get_item_val") + } else { + &v.node.def.fields }; - assert!(!args.is_empty()); + assert!(!fields.is_empty()); let ty = ccx.tcx().node_id_to_type(id); let parent = ccx.tcx().map.get_parent(id); let enm = ccx.tcx().map.expect_item(parent); diff --git a/src/librustc_trans/trans/callee.rs b/src/librustc_trans/trans/callee.rs index 86a65f57bdab0..debd4d232b8d1 100644 --- a/src/librustc_trans/trans/callee.rs +++ b/src/librustc_trans/trans/callee.rs @@ -417,10 +417,9 @@ pub fn trans_fn_ref_with_substs<'a, 'tcx>( || "local item should be in ast map".to_string()); match map_node { - hir_map::NodeVariant(v) => match v.node.kind { - hir::TupleVariantKind(ref args) => !args.is_empty(), - _ => false - }, + hir_map::NodeVariant(v) => { + v.node.def.ctor_id.is_some() && !v.node.def.fields.is_empty() + } hir_map::NodeStructCtor(_) => true, _ => false } diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs index b5cf069bda684..e62b7a53049b5 100644 --- a/src/librustc_typeck/check/wf.rs +++ b/src/librustc_typeck/check/wf.rs @@ -647,41 +647,7 @@ fn enum_variants<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, enum_def: &hir::EnumDef) -> Vec> { enum_def.variants.iter() - .map(|variant| { - match variant.node.kind { - hir::TupleVariantKind(ref args) if !args.is_empty() => { - let ctor_ty = fcx.tcx().node_id_to_type(variant.node.id); - - // the regions in the argument types come from the - // enum def'n, and hence will all be early bound - let arg_tys = fcx.tcx().no_late_bound_regions(&ctor_ty.fn_args()).unwrap(); - AdtVariant { - fields: args.iter().enumerate().map(|(index, arg)| { - let arg_ty = arg_tys[index]; - let arg_ty = - fcx.instantiate_type_scheme(variant.span, - &fcx.inh - .infcx - .parameter_environment - .free_substs, - &arg_ty); - AdtField { - ty: arg_ty, - span: arg.ty.span - } - }).collect() - } - } - hir::TupleVariantKind(_) => { - AdtVariant { - fields: Vec::new() - } - } - hir::StructVariantKind(ref struct_def) => { - struct_variant(fcx, &**struct_def) - } - } - }) + .map(|variant| struct_variant(fcx, &variant.node.def)) .collect() } diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index b8d942ad22703..cf1be635ea3af 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -544,41 +544,7 @@ fn enum_variants<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, enum_def: &hir::EnumDef) -> Vec> { enum_def.variants.iter() - .map(|variant| { - match variant.node.kind { - hir::TupleVariantKind(ref args) if !args.is_empty() => { - let ctor_ty = fcx.tcx().node_id_to_type(variant.node.id); - - // the regions in the argument types come from the - // enum def'n, and hence will all be early bound - let arg_tys = fcx.tcx().no_late_bound_regions(&ctor_ty.fn_args()).unwrap(); - AdtVariant { - fields: args.iter().enumerate().map(|(index, arg)| { - let arg_ty = arg_tys[index]; - let arg_ty = - fcx.instantiate_type_scheme(variant.span, - &fcx.inh - .infcx - .parameter_environment - .free_substs, - &arg_ty); - AdtField { - ty: arg_ty, - span: arg.ty.span - } - }).collect() - } - } - hir::TupleVariantKind(_) => { - AdtVariant { - fields: Vec::new() - } - } - hir::StructVariantKind(ref struct_def) => { - struct_variant(fcx, &**struct_def) - } - } - }) + .map(|variant| struct_variant(fcx, &variant.node.def)) .collect() } diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 69d170602303b..4217b0d481f16 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -1065,31 +1065,16 @@ fn convert_enum_variant_types<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, scheme: ty::TypeScheme<'tcx>, predicates: ty::GenericPredicates<'tcx>, variants: &[P]) { - let tcx = ccx.tcx; - let icx = ccx.icx(&predicates); - // fill the field types for (variant, ty_variant) in variants.iter().zip(def.variants.iter()) { - match variant.node.kind { - hir::TupleVariantKind(ref args) => { - let rs = ExplicitRscope; - let input_tys: Vec<_> = args.iter().map(|va| icx.to_ty(&rs, &*va.ty)).collect(); - for (field, &ty) in ty_variant.fields.iter().zip(input_tys.iter()) { - field.fulfill_ty(ty); - } - } - - hir::StructVariantKind(ref struct_def) => { - for (f, ty_f) in struct_def.fields.iter().zip(ty_variant.fields.iter()) { - convert_field(ccx, &scheme.generics, &predicates, f, ty_f) - } - } - }; + for (f, ty_f) in variant.node.def.fields.iter().zip(ty_variant.fields.iter()) { + convert_field(ccx, &scheme.generics, &predicates, f, ty_f) + } // Convert the ctor, if any. This also registers the variant as // an item. convert_variant_ctor( - tcx, + ccx.tcx, variant.node.id, ty_variant, scheme.clone(), @@ -1223,25 +1208,7 @@ fn convert_enum_def<'tcx>(tcx: &ty::ctxt<'tcx>, { let did = tcx.map.local_def_id(v.node.id); let name = v.node.name; - match v.node.kind { - hir::TupleVariantKind(ref va) => { - ty::VariantDefData { - did: did, - name: name, - disr_val: disr, - fields: va.iter().map(|&hir::VariantArg { id, .. }| { - ty::FieldDefData::new( - tcx.map.local_def_id(id), - special_idents::unnamed_field.name, - hir::Visibility::Public - ) - }).collect() - } - } - hir::StructVariantKind(ref def) => { - convert_struct_variant(tcx, did, name, disr, &def) - } - } + convert_struct_variant(tcx, did, name, disr, &v.node.def) } let did = tcx.map.local_def_id(it.id); let repr_hints = tcx.lookup_repr_hints(did); diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 160c7e7d754d9..0d2d1118883b4 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1855,7 +1855,7 @@ impl Clean for doctree::Variant { stability: self.stab.clean(cx), def_id: cx.map.local_def_id(self.id), inner: VariantItem(Variant { - kind: self.kind.clean(cx), + kind: struct_def_to_variant_kind(&self.def, cx), }), } } @@ -1932,6 +1932,16 @@ impl Clean for hir::VariantKind { } } +fn struct_def_to_variant_kind(struct_def: &hir::StructDef, cx: &DocContext) -> VariantKind { + if struct_def.ctor_id.is_none() { + StructVariant(struct_def.clean(cx)) + } else if struct_def.fields.is_empty() { + CLikeVariant + } else { + TupleVariant(struct_def.fields.iter().map(|x| x.node.ty.clean(cx)).collect()) + } +} + #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Span { pub filename: String, diff --git a/src/librustdoc/doctree.rs b/src/librustdoc/doctree.rs index c234ec01b8869..4296c79be50f9 100644 --- a/src/librustdoc/doctree.rs +++ b/src/librustdoc/doctree.rs @@ -119,7 +119,7 @@ pub struct Enum { pub struct Variant { pub name: Name, pub attrs: Vec, - pub kind: hir::VariantKind, + pub def: P, pub id: ast::NodeId, pub stab: Option, pub whence: Span, diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index 264656835a384..303f344d8c371 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -113,7 +113,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { attrs: v.node.attrs.clone(), stab: self.stability(v.node.id), id: v.node.id, - kind: v.node.kind.clone(), + def: v.node.def.clone(), whence: v.span, }).collect(), vis: it.vis, From 495566ee61174066014b928fffd182834c1eb214 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Fri, 2 Oct 2015 03:53:28 +0300 Subject: [PATCH 03/13] Decouple structure kinds from NodeIds --- src/librustc/front/map/collector.rs | 4 +-- src/librustc/front/map/mod.rs | 4 +-- src/librustc/metadata/encoder.rs | 13 +++------ src/librustc/middle/dead.rs | 4 ++- src/librustc/middle/stability.rs | 6 ++--- src/librustc_front/fold.rs | 5 ++-- src/librustc_front/hir.rs | 19 +++++++------- src/librustc_front/lowering.rs | 7 ++++- src/librustc_front/print/pprust.rs | 4 +-- src/librustc_front/util.rs | 8 +----- src/librustc_privacy/lib.rs | 10 +++---- src/librustc_resolve/build_reduced_graph.rs | 12 ++++----- src/librustc_trans/save/dump_csv.rs | 9 ++----- src/librustc_trans/trans/base.rs | 8 +++--- src/librustc_trans/trans/callee.rs | 2 +- src/librustc_trans/trans/inline.rs | 12 ++++----- src/librustc_trans/trans/monomorphize.rs | 6 +++-- src/librustc_typeck/collect.rs | 4 +-- src/librustdoc/clean/mod.rs | 19 ++------------ src/librustdoc/doctree.rs | 2 +- src/libsyntax/ast.rs | 19 +++++++------- src/libsyntax/ast_util.rs | 8 +----- src/libsyntax/config.rs | 5 ++-- src/libsyntax/ext/build.rs | 8 ++++-- src/libsyntax/ext/deriving/primitive.rs | 2 +- src/libsyntax/feature_gate.rs | 2 +- src/libsyntax/fold.rs | 5 ++-- src/libsyntax/parse/parser.rs | 29 ++++++++++++--------- src/libsyntax/print/pprust.rs | 8 +++--- 29 files changed, 113 insertions(+), 131 deletions(-) diff --git a/src/librustc/front/map/collector.rs b/src/librustc/front/map/collector.rs index 3edeaaccbde44..51ba799c5d111 100644 --- a/src/librustc/front/map/collector.rs +++ b/src/librustc/front/map/collector.rs @@ -150,8 +150,8 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> { } ItemStruct(ref struct_def, _) => { // If this is a tuple-like struct, register the constructor. - if let Some(ctor_id) = struct_def.ctor_id { - self.insert_def(ctor_id, + if struct_def.kind != VariantKind::Dict { + self.insert_def(struct_def.id, NodeStructCtor(&**struct_def), DefPathData::StructCtor); } diff --git a/src/librustc/front/map/mod.rs b/src/librustc/front/map/mod.rs index 96e103aa4f4b7..b183f12a092cf 100644 --- a/src/librustc/front/map/mod.rs +++ b/src/librustc/front/map/mod.rs @@ -480,8 +480,8 @@ impl<'ast> Map<'ast> { } } Some(NodeVariant(variant)) => { - match variant.node.def.ctor_id { - None => &variant.node.def, + match variant.node.def.kind { + VariantKind::Dict => &variant.node.def, _ => panic!("struct ID bound to enum variant that isn't struct-like"), } } diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 9d2b1548f29d8..7c08d7618d79b 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -381,12 +381,8 @@ fn each_auxiliary_node_id(item: &hir::Item, callback: F) -> bool where match item.node { hir::ItemStruct(ref struct_def, _) => { // If this is a newtype struct, return the constructor. - match struct_def.ctor_id { - Some(ctor_id) if !struct_def.fields.is_empty() && - struct_def.fields[0].node.kind.is_unnamed() => { - continue_ = callback(ctor_id); - } - _ => {} + if struct_def.kind == hir::VariantKind::Tuple { + continue_ = callback(struct_def.id); } } _ => {} @@ -1085,9 +1081,8 @@ 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 let Some(ctor_id) = struct_def.ctor_id { - encode_info_for_struct_ctor(ecx, rbml_w, item.name, - ctor_id, index, item.id); + if struct_def.kind != hir::VariantKind::Dict { + encode_info_for_struct_ctor(ecx, rbml_w, item.name, struct_def.id, index, item.id); } } hir::ItemDefaultImpl(unsafety, _) => { diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 6e31b733254bd..f977992e735fe 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -426,7 +426,9 @@ fn find_live(tcx: &ty::ctxt, fn get_struct_ctor_id(item: &hir::Item) -> Option { match item.node { - hir::ItemStruct(ref struct_def, _) => struct_def.ctor_id, + hir::ItemStruct(ref struct_def, _) if struct_def.kind != hir::VariantKind::Dict => { + Some(struct_def.id) + } _ => None } } diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index c2235591ceef1..8476adf68381e 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -185,9 +185,9 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Annotator<'a, 'tcx> { |v| visit::walk_item(v, i), required); if let hir::ItemStruct(ref sd, _) = i.node { - sd.ctor_id.map(|id| { - self.annotate(id, true, &i.attrs, i.span, |_| {}, true) - }); + if sd.kind != hir::VariantKind::Dict { + self.annotate(sd.id, true, &i.attrs, i.span, |_| {}, true) + } } } diff --git a/src/librustc_front/fold.rs b/src/librustc_front/fold.rs index 876ec804e278e..3251808179409 100644 --- a/src/librustc_front/fold.rs +++ b/src/librustc_front/fold.rs @@ -699,10 +699,11 @@ pub fn noop_fold_where_predicate(pred: WherePredicate, fld: &mut T) - } pub fn noop_fold_struct_def(struct_def: P, fld: &mut T) -> P { - struct_def.map(|StructDef { fields, ctor_id }| { + struct_def.map(|StructDef { fields, id, kind }| { StructDef { fields: fields.move_map(|f| fld.fold_struct_field(f)), - ctor_id: ctor_id.map(|cid| fld.new_id(cid)), + id: fld.new_id(id), + kind: kind, } }) } diff --git a/src/librustc_front/hir.rs b/src/librustc_front/hir.rs index 8f5f95b110468..b93224165418e 100644 --- a/src/librustc_front/hir.rs +++ b/src/librustc_front/hir.rs @@ -33,7 +33,6 @@ pub use self::Ty_::*; pub use self::TyParamBound::*; pub use self::UnOp::*; pub use self::UnsafeSource::*; -pub use self::VariantKind::*; pub use self::ViewPath_::*; pub use self::Visibility::*; pub use self::PathParameters::*; @@ -1021,14 +1020,6 @@ pub struct VariantArg { pub id: NodeId, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] -pub enum VariantKind { - /// Tuple variant, e.g. `Foo(A, B)` - TupleVariantKind(Vec), - /// Struct variant, e.g. `Foo {x: A, y: B}` - StructVariantKind(P), -} - #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct EnumDef { pub variants: Vec>, @@ -1176,13 +1167,21 @@ impl StructFieldKind { } } +#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +pub enum VariantKind { + Dict, + Tuple, + Unit, +} + #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct StructDef { /// Fields, not including ctor pub fields: Vec, /// ID of the constructor. This is only used for tuple- or enum-like /// structs. - pub ctor_id: Option, + pub id: NodeId, + pub kind: VariantKind, } /* diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs index 0350c9ff11443..1539613070fcd 100644 --- a/src/librustc_front/lowering.rs +++ b/src/librustc_front/lowering.rs @@ -502,7 +502,12 @@ pub fn lower_where_predicate(_lctx: &LoweringContext, pub fn lower_struct_def(_lctx: &LoweringContext, sd: &StructDef) -> P { P(hir::StructDef { fields: sd.fields.iter().map(|f| lower_struct_field(_lctx, f)).collect(), - ctor_id: sd.ctor_id, + id: sd.id, + kind: match sd.kind { + VariantKind::Dict => hir::VariantKind::Dict, + VariantKind::Tuple => hir::VariantKind::Tuple, + VariantKind::Unit => hir::VariantKind::Unit, + } }) } diff --git a/src/librustc_front/print/pprust.rs b/src/librustc_front/print/pprust.rs index ee6be06428e16..8d4422011f00a 100644 --- a/src/librustc_front/print/pprust.rs +++ b/src/librustc_front/print/pprust.rs @@ -896,8 +896,8 @@ impl<'a> State<'a> { -> io::Result<()> { try!(self.print_name(name)); try!(self.print_generics(generics)); - if ::util::struct_def_is_tuple_like(struct_def) { - if !struct_def.fields.is_empty() { + if struct_def.kind != hir::VariantKind::Dict { + if struct_def.kind == hir::VariantKind::Tuple { try!(self.popen()); try!(self.commasep(Inconsistent, &struct_def.fields, diff --git a/src/librustc_front/util.rs b/src/librustc_front/util.rs index c6b2a2acc2b8d..05a548a8c6621 100644 --- a/src/librustc_front/util.rs +++ b/src/librustc_front/util.rs @@ -81,12 +81,6 @@ pub fn binop_to_string(op: BinOp_) -> &'static str { } } -/// Returns true if the given struct def is tuple-like; i.e. that its fields -/// are unnamed. -pub fn struct_def_is_tuple_like(struct_def: &hir::StructDef) -> bool { - struct_def.ctor_id.is_some() -} - pub fn stmt_id(s: &Stmt) -> NodeId { match s.node { StmtDecl(_, id) => id, @@ -298,7 +292,7 @@ impl<'a, 'v, O: ast_util::IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> _: &hir::Generics, id: NodeId) { self.operation.visit_id(id); - struct_def.ctor_id.map(|ctor_id| self.operation.visit_id(ctor_id)); + self.operation.visit_id(struct_def.id); visit::walk_struct_def(self, struct_def); } diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index ca5411f9c790a..4e4609fb083c0 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -132,9 +132,8 @@ impl<'v> Visitor<'v> for ParentVisitor { _: &'v hir::Generics, n: ast::NodeId) { // Struct constructors are parented to their struct definitions because // they essentially are the struct definitions. - match s.ctor_id { - Some(id) => { self.parents.insert(id, n); } - None => {} + if s.kind != hir::VariantKind::Dict { + self.parents.insert(s.id, n); } // While we have the id of the struct definition, go ahead and parent @@ -320,9 +319,8 @@ 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 => { - match def.ctor_id { - Some(id) => { self.exported_items.insert(id); } - None => {} + if def.kind != hir::VariantKind::Dict { + self.exported_items.insert(def.id); } // fields can be public or private, so lets check for field in &def.fields { diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index a3f40efa48331..6b4b33341664b 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -492,9 +492,9 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { // These items live in both the type and value namespaces. ItemStruct(ref struct_def, _) => { // Adding to both Type and Value namespaces or just Type? - let (forbid, ctor_id) = match struct_def.ctor_id { - Some(ctor_id) => (ForbidDuplicateTypesAndValues, Some(ctor_id)), - None => (ForbidDuplicateTypesAndModules, None) + let (forbid, ctor_id) = match struct_def.kind { + hir::VariantKind::Dict => (ForbidDuplicateTypesAndModules, None), + _ => (ForbidDuplicateTypesAndValues, Some(struct_def.id)), }; let name_bindings = self.add_child(name, parent, forbid, sp); @@ -587,14 +587,14 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { item_id: DefId, parent: &Rc) { let name = variant.node.name; - let is_exported = match variant.node.def.ctor_id { - Some(_) => false, - None => { + let is_exported = match variant.node.def.kind { + hir::VariantKind::Dict => { // 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.id); self.structs.insert(variant_def_id, Vec::new()); true } + _ => false, }; let child = self.add_child(name, parent, diff --git a/src/librustc_trans/save/dump_csv.rs b/src/librustc_trans/save/dump_csv.rs index 983f04643c362..fb1c494ffd44e 100644 --- a/src/librustc_trans/save/dump_csv.rs +++ b/src/librustc_trans/save/dump_csv.rs @@ -462,16 +462,12 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { ty_params: &ast::Generics) { let qualname = format!("::{}", self.tcx.map.path_to_string(item.id)); - let ctor_id = match def.ctor_id { - Some(node_id) => node_id, - None => ast::DUMMY_NODE_ID, - }; let val = self.span.snippet(item.span); let sub_span = self.span.sub_span_after_keyword(item.span, keywords::Struct); self.fmt.struct_str(item.span, sub_span, item.id, - ctor_id, + def.id, &qualname, self.cur_scope, &val); @@ -505,11 +501,10 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { qualname.push_str(name); let val = self.span.snippet(variant.span); - let ctor_id = variant.node.def.ctor_id.unwrap_or(ast::DUMMY_NODE_ID); self.fmt.struct_variant_str(variant.span, self.span.span_for_first_ident(variant.span), variant.node.id, - ctor_id, + variant.node.def.id, &qualname, &enum_data.qualname, &val, diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index 6baa3c5e0db6d..06cb8de054229 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -2428,7 +2428,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { hir_map::NodeVariant(ref v) => { let llfn; - let fields = if v.node.def.ctor_id.is_none() { + let fields = if v.node.def.kind == hir::VariantKind::Dict { ccx.sess().bug("struct variant kind unexpected in get_item_val") } else { &v.node.def.fields @@ -2454,12 +2454,12 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { hir_map::NodeStructCtor(struct_def) => { // Only register the constructor if this is a tuple-like struct. - let ctor_id = match struct_def.ctor_id { - None => { + let ctor_id = match struct_def.kind { + hir::VariantKind::Dict => { ccx.sess().bug("attempt to register a constructor of \ a non-tuple-like struct") } - Some(ctor_id) => ctor_id, + _ => struct_def.id, }; let parent = ccx.tcx().map.get_parent(id); let struct_item = ccx.tcx().map.expect_item(parent); diff --git a/src/librustc_trans/trans/callee.rs b/src/librustc_trans/trans/callee.rs index debd4d232b8d1..fdcc2623ef104 100644 --- a/src/librustc_trans/trans/callee.rs +++ b/src/librustc_trans/trans/callee.rs @@ -418,7 +418,7 @@ pub fn trans_fn_ref_with_substs<'a, 'tcx>( match map_node { hir_map::NodeVariant(v) => { - v.node.def.ctor_id.is_some() && !v.node.def.fields.is_empty() + v.node.def.kind == hir::VariantKind::Tuple } hir_map::NodeStructCtor(_) => true, _ => false diff --git a/src/librustc_trans/trans/inline.rs b/src/librustc_trans/trans/inline.rs index b8f75df8c11ca..9cb4b271742c4 100644 --- a/src/librustc_trans/trans/inline.rs +++ b/src/librustc_trans/trans/inline.rs @@ -115,12 +115,12 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: DefId) } } hir::ItemStruct(ref struct_def, _) => { - match struct_def.ctor_id { - None => ccx.sess().bug("instantiate_inline: called on a \ - non-tuple struct"), - Some(ctor_id) => { - ccx.external().borrow_mut().insert(fn_id, Some(ctor_id)); - my_id = ctor_id; + match struct_def.kind { + hir::VariantKind::Dict => ccx.sess().bug("instantiate_inline: called on a \ + non-tuple struct"), + _ => { + ccx.external().borrow_mut().insert(fn_id, Some(struct_def.id)); + my_id = struct_def.id; } } } diff --git a/src/librustc_trans/trans/monomorphize.rs b/src/librustc_trans/trans/monomorphize.rs index 33f798be85e87..49009378bb979 100644 --- a/src/librustc_trans/trans/monomorphize.rs +++ b/src/librustc_trans/trans/monomorphize.rs @@ -246,9 +246,11 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, hir_map::NodeStructCtor(struct_def) => { let d = mk_lldecl(abi::Rust); attributes::inline(d, attributes::InlineAttr::Hint); + if struct_def.kind == hir::VariantKind::Dict { + panic!("ast-mapped struct didn't have a ctor id") + } base::trans_tuple_struct(ccx, - struct_def.ctor_id.expect("ast-mapped tuple struct \ - didn't have a ctor id"), + struct_def.id, psubsts, d); d diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 4217b0d481f16..879432d89c8c8 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -1014,8 +1014,8 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { convert_field(ccx, &scheme.generics, &predicates, f, ty_f) } - if let Some(ctor_id) = struct_def.ctor_id { - convert_variant_ctor(tcx, ctor_id, variant, scheme, predicates); + if struct_def.kind != hir::VariantKind::Dict { + convert_variant_ctor(tcx, struct_def.id, variant, scheme, predicates); } }, hir::ItemTy(_, ref generics) => { diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 0d2d1118883b4..a5ed0ea6c095e 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1917,25 +1917,10 @@ pub enum VariantKind { StructVariant(VariantStruct), } -impl Clean for hir::VariantKind { - fn clean(&self, cx: &DocContext) -> VariantKind { - match self { - &hir::TupleVariantKind(ref args) => { - if args.is_empty() { - CLikeVariant - } else { - TupleVariant(args.iter().map(|x| x.ty.clean(cx)).collect()) - } - }, - &hir::StructVariantKind(ref sd) => StructVariant(sd.clean(cx)), - } - } -} - fn struct_def_to_variant_kind(struct_def: &hir::StructDef, cx: &DocContext) -> VariantKind { - if struct_def.ctor_id.is_none() { + if struct_def.kind == hir::VariantKind::Dict { StructVariant(struct_def.clean(cx)) - } else if struct_def.fields.is_empty() { + } else if struct_def.kind == hir::VariantKind::Unit { CLikeVariant } else { TupleVariant(struct_def.fields.iter().map(|x| x.node.ty.clean(cx)).collect()) diff --git a/src/librustdoc/doctree.rs b/src/librustdoc/doctree.rs index 4296c79be50f9..c65c31e6c3cc3 100644 --- a/src/librustdoc/doctree.rs +++ b/src/librustdoc/doctree.rs @@ -235,7 +235,7 @@ pub struct Import { } pub fn struct_type_from_def(sd: &hir::StructDef) -> StructType { - if sd.ctor_id.is_some() { + if sd.kind != hir::VariantKind::Dict { // We are in a tuple-struct match sd.fields.len() { 0 => Unit, diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 57d9837e1aacc..66c0d858e3c7a 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -44,7 +44,6 @@ pub use self::TyParamBound::*; pub use self::UintTy::*; pub use self::UnOp::*; pub use self::UnsafeSource::*; -pub use self::VariantKind::*; pub use self::ViewPath_::*; pub use self::Visibility::*; pub use self::PathParameters::*; @@ -1577,14 +1576,6 @@ pub struct VariantArg { pub id: NodeId, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] -pub enum VariantKind { - /// Tuple variant, e.g. `Foo(A, B)` - TupleVariantKind(Vec), - /// Struct variant, e.g. `Foo {x: A, y: B}` - StructVariantKind(P), -} - #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct EnumDef { pub variants: Vec>, @@ -1756,13 +1747,21 @@ impl StructFieldKind { } } +#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +pub enum VariantKind { + Dict, + Tuple, + Unit, +} + #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct StructDef { /// Fields, not including ctor pub fields: Vec, /// ID of the constructor. This is only used for tuple- or enum-like /// structs. - pub ctor_id: Option, + pub id: NodeId, + pub kind: VariantKind, } /* diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 905a83b050ed7..87f05f7f41e3f 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -463,7 +463,7 @@ impl<'a, 'v, O: IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> { _: &ast::Generics, id: NodeId) { self.operation.visit_id(id); - struct_def.ctor_id.map(|ctor_id| self.operation.visit_id(ctor_id)); + self.operation.visit_id(struct_def.id); visit::walk_struct_def(self, struct_def); } @@ -529,12 +529,6 @@ pub fn compute_id_range_for_fn_body(fk: FnKind, id_visitor.operation.result } -/// Returns true if the given struct def is tuple-like; i.e. that its fields -/// are unnamed. -pub fn struct_def_is_tuple_like(struct_def: &ast::StructDef) -> bool { - struct_def.ctor_id.is_some() -} - /// Returns true if the given pattern consists solely of an identifier /// and false otherwise. pub fn pat_is_ident(pat: P) -> bool { diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs index 0accf34202ed7..d47072d477e86 100644 --- a/src/libsyntax/config.rs +++ b/src/libsyntax/config.rs @@ -168,12 +168,13 @@ fn fold_item_underscore(cx: &mut Context, item: ast::Item_) -> ast::Item_ fn fold_struct(cx: &mut Context, def: P) -> P where F: FnMut(&[ast::Attribute]) -> bool { - def.map(|ast::StructDef { fields, ctor_id }| { + def.map(|ast::StructDef { fields, id, kind }| { ast::StructDef { fields: fields.into_iter().filter(|m| { (cx.in_cfg)(&m.node.attrs) }).collect(), - ctor_id: ctor_id, + id: id, + kind: kind, } }) } diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index d448eb63204eb..132ab6e67feee 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -993,7 +993,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> { } fn variant(&self, span: Span, name: Ident, tys: Vec> ) -> ast::Variant { - let fields = tys.into_iter().map(|ty| { + let fields: Vec<_> = tys.into_iter().map(|ty| { Spanned { span: ty.span, node: ast::StructField_ { ty: ty, kind: ast::UnnamedField(ast::Inherited), @@ -1002,11 +1002,15 @@ impl<'a> AstBuilder for ExtCtxt<'a> { }} }).collect(); + let kind = if fields.is_empty() { ast::VariantKind::Unit } else { ast::VariantKind::Tuple }; + respan(span, ast::Variant_ { name: name, attrs: Vec::new(), - def: P(ast::StructDef { fields: fields, ctor_id: Some(ast::DUMMY_NODE_ID) }), + def: P(ast::StructDef { fields: fields, + id: ast::DUMMY_NODE_ID, + kind: kind }), id: ast::DUMMY_NODE_ID, disr_expr: None, }) diff --git a/src/libsyntax/ext/deriving/primitive.rs b/src/libsyntax/ext/deriving/primitive.rs index 2fdaa9b7550b5..7b64e5522a4fb 100644 --- a/src/libsyntax/ext/deriving/primitive.rs +++ b/src/libsyntax/ext/deriving/primitive.rs @@ -95,7 +95,7 @@ fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure for variant in &enum_def.variants { let def = &variant.node.def; - if def.ctor_id.is_none() || !def.fields.is_empty() { + if def.kind != ast::VariantKind::Unit { cx.span_err(trait_span, "`FromPrimitive` cannot be derived \ for enums with non-unit variants"); return cx.expr_fail(trait_span, diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index 1d545268e57d7..0b3af659a7b2d 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -828,7 +828,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { } } } - if def.fields.is_empty() && def.ctor_id.is_none() { + if def.fields.is_empty() && def.kind == ast::VariantKind::Dict { self.gate_feature("braced_empty_structs", i.span, "empty structs with braces are unstable"); } diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 88781c3664ab2..8156ef20faf0b 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -820,9 +820,10 @@ pub fn noop_fold_where_predicate( } pub fn noop_fold_struct_def(struct_def: P, fld: &mut T) -> P { - struct_def.map(|StructDef { fields, ctor_id }| StructDef { + struct_def.map(|StructDef { fields, id, kind }| StructDef { fields: fields.move_map(|f| fld.fold_struct_field(f)), - ctor_id: ctor_id.map(|cid| fld.new_id(cid)), + id: fld.new_id(id), + kind: kind, }) } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 0748c898a828b..1b446fb9902ab 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, StructDef, StructField}; +use ast::{StmtExpr, StmtSemi, StmtMac, StructDef, StructField, VariantKind}; use ast::{BiSub, StrStyle}; use ast::{SelfExplicit, SelfRegion, SelfStatic, SelfValue}; use ast::{Delimited, SequenceRepetition, TokenTree, TraitItem, TraitRef}; @@ -4640,26 +4640,26 @@ impl<'a> Parser<'a> { // Otherwise if we look ahead and see a paren we parse a tuple-style // struct. - let (fields, ctor_id) = if self.token.is_keyword(keywords::Where) { + let (fields, kind) = 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 where T: Copy;` style decl. - (Vec::new(), Some(ast::DUMMY_NODE_ID)) + (Vec::new(), VariantKind::Unit) } else { // If we see: `struct Foo where T: Copy { ... }` - (try!(self.parse_record_struct_body()), None) + (try!(self.parse_record_struct_body()), VariantKind::Dict) } // No `where` so: `struct Foo;` } else if try!(self.eat(&token::Semi) ){ - (Vec::new(), Some(ast::DUMMY_NODE_ID)) + (Vec::new(), VariantKind::Unit) // Record-style struct definition } else if self.token == token::OpenDelim(token::Brace) { let fields = try!(self.parse_record_struct_body()); - (fields, None) + (fields, VariantKind::Dict) // Tuple-style struct definition with optional where-clause. } else if self.token == token::OpenDelim(token::Paren) { let fields = try!(self.parse_tuple_struct_body(class_name, &mut generics)); - (fields, Some(ast::DUMMY_NODE_ID)) + (fields, VariantKind::Tuple) } else { let token_str = self.this_token_to_string(); return Err(self.fatal(&format!("expected `where`, `{{`, `(`, or `;` after struct \ @@ -4669,7 +4669,8 @@ impl<'a> Parser<'a> { Ok((class_name, ItemStruct(P(ast::StructDef { fields: fields, - ctor_id: ctor_id, + id: ast::DUMMY_NODE_ID, + kind: kind, }), generics), None)) } @@ -5118,7 +5119,8 @@ impl<'a> Parser<'a> { Ok(P(StructDef { fields: fields, - ctor_id: None, + id: ast::DUMMY_NODE_ID, + kind: VariantKind::Dict, })) } @@ -5156,15 +5158,18 @@ impl<'a> Parser<'a> { }}); } struct_def = P(StructDef { fields: fields, - ctor_id: Some(ast::DUMMY_NODE_ID) }); + id: ast::DUMMY_NODE_ID, + kind: ast::VariantKind::Tuple }); } 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(StructDef { fields: Vec::new(), - ctor_id: Some(ast::DUMMY_NODE_ID) }); + id: ast::DUMMY_NODE_ID, + kind: ast::VariantKind::Unit }); } else { struct_def = P(StructDef { fields: Vec::new(), - ctor_id: Some(ast::DUMMY_NODE_ID) }); + id: ast::DUMMY_NODE_ID, + kind: ast::VariantKind::Unit }); } let vr = ast::Variant_ { diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 678b8e0489741..2d6829c5e75b5 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1392,8 +1392,8 @@ impl<'a> State<'a> { print_finalizer: bool) -> io::Result<()> { try!(self.print_ident(ident)); try!(self.print_generics(generics)); - if ast_util::struct_def_is_tuple_like(struct_def) { - if !struct_def.fields.is_empty() { + if struct_def.kind != ast::VariantKind::Dict { + if struct_def.kind == ast::VariantKind::Tuple { try!(self.popen()); try!(self.commasep( Inconsistent, &struct_def.fields, @@ -3119,7 +3119,9 @@ mod tests { name: ident, attrs: Vec::new(), // making this up as I go.... ? - def: P(ast::StructDef { fields: Vec::new(), ctor_id: Some(ast::DUMMY_NODE_ID) }), + def: P(ast::StructDef { fields: Vec::new(), + id: ast::DUMMY_NODE_ID, + kind: ast::VariantKind::Unit }), id: 0, disr_expr: None, }); From 877c35e8a212d2a4f61c528b93097d185725630b Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Fri, 2 Oct 2015 16:14:20 +0300 Subject: [PATCH 04/13] Remove now redundant NodeId from Variant --- src/librustc/front/map/collector.rs | 2 +- src/librustc/lint/context.rs | 20 +++++++------- src/librustc/metadata/encoder.rs | 2 +- src/librustc/middle/check_static_recursion.rs | 17 ++++++------ src/librustc/middle/const_eval.rs | 2 +- src/librustc/middle/dead.rs | 6 ++--- src/librustc/middle/stability.rs | 6 ++--- src/librustc_back/svh.rs | 7 +++-- src/librustc_front/fold.rs | 3 +-- src/librustc_front/hir.rs | 1 - src/librustc_front/lowering.rs | 1 - src/librustc_front/util.rs | 8 +----- src/librustc_front/visit.rs | 25 ++++++++--------- src/librustc_lint/builtin.rs | 10 +++---- src/librustc_privacy/lib.rs | 16 +++++------ src/librustc_resolve/build_reduced_graph.rs | 6 ++--- src/librustc_resolve/lib.rs | 4 +-- src/librustc_trans/save/dump_csv.rs | 4 +-- src/librustc_trans/trans/inline.rs | 4 +-- src/librustc_typeck/collect.rs | 4 +-- src/librustdoc/clean/mod.rs | 2 +- src/librustdoc/doctree.rs | 1 - src/librustdoc/visit_ast.rs | 3 +-- src/libsyntax/ast.rs | 1 - src/libsyntax/ast_util.rs | 8 +----- src/libsyntax/config.rs | 3 +-- src/libsyntax/ext/build.rs | 1 - src/libsyntax/fold.rs | 3 +-- src/libsyntax/parse/parser.rs | 1 - src/libsyntax/print/pprust.rs | 1 - src/libsyntax/visit.rs | 27 +++++++++---------- 31 files changed, 88 insertions(+), 111 deletions(-) diff --git a/src/librustc/front/map/collector.rs b/src/librustc/front/map/collector.rs index 51ba799c5d111..3d45c52171fa0 100644 --- a/src/librustc/front/map/collector.rs +++ b/src/librustc/front/map/collector.rs @@ -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.id, + self.insert_def(v.node.def.id, NodeVariant(&**v), DefPathData::EnumVariant(v.node.name)); diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index 36236efe50d2c..f66d9a9b3991e 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -665,10 +665,10 @@ impl<'a, 'tcx, 'v> hir_visit::Visitor<'v> for LateContext<'a, 'tcx> { s: &hir::StructDef, name: ast::Name, g: &hir::Generics, - id: ast::NodeId) { - run_lints!(self, check_struct_def, late_passes, s, name, g, id); + item_id: ast::NodeId) { + run_lints!(self, check_struct_def, late_passes, s, name, g, item_id); hir_visit::walk_struct_def(self, s); - run_lints!(self, check_struct_def_post, late_passes, s, name, g, id); + run_lints!(self, check_struct_def_post, late_passes, s, name, g, item_id); } fn visit_struct_field(&mut self, s: &hir::StructField) { @@ -678,10 +678,10 @@ impl<'a, 'tcx, 'v> hir_visit::Visitor<'v> for LateContext<'a, 'tcx> { }) } - fn visit_variant(&mut self, v: &hir::Variant, g: &hir::Generics) { + fn visit_variant(&mut self, v: &hir::Variant, g: &hir::Generics, item_id: ast::NodeId) { self.with_lint_attrs(&v.node.attrs, |cx| { run_lints!(cx, check_variant, late_passes, v, g); - hir_visit::walk_variant(cx, v, g); + hir_visit::walk_variant(cx, v, g, item_id); run_lints!(cx, check_variant_post, late_passes, v, g); }) } @@ -814,10 +814,10 @@ impl<'a, 'v> ast_visit::Visitor<'v> for EarlyContext<'a> { s: &ast::StructDef, ident: ast::Ident, g: &ast::Generics, - id: ast::NodeId) { - run_lints!(self, check_struct_def, early_passes, s, ident, g, id); + item_id: ast::NodeId) { + run_lints!(self, check_struct_def, early_passes, s, ident, g, item_id); ast_visit::walk_struct_def(self, s); - run_lints!(self, check_struct_def_post, early_passes, s, ident, g, id); + run_lints!(self, check_struct_def_post, early_passes, s, ident, g, item_id); } fn visit_struct_field(&mut self, s: &ast::StructField) { @@ -827,10 +827,10 @@ impl<'a, 'v> ast_visit::Visitor<'v> for EarlyContext<'a> { }) } - fn visit_variant(&mut self, v: &ast::Variant, g: &ast::Generics) { + fn visit_variant(&mut self, v: &ast::Variant, g: &ast::Generics, item_id: ast::NodeId) { self.with_lint_attrs(&v.node.attrs, |cx| { run_lints!(cx, check_variant, early_passes, v, g); - ast_visit::walk_variant(cx, v, g); + ast_visit::walk_variant(cx, v, g, item_id); run_lints!(cx, check_variant_post, early_passes, v, g); }) } diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 7c08d7618d79b..75cc04a98c66f 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -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.id)); + encode_variant_id(rbml_w, ecx.tcx.map.local_def_id(v.node.def.id)); } encode_inlined_item(ecx, rbml_w, InlinedItemRef::Item(item)); encode_path(rbml_w, path); diff --git a/src/librustc/middle/check_static_recursion.rs b/src/librustc/middle/check_static_recursion.rs index acb66b8efe7eb..152f2e92490be 100644 --- a/src/librustc/middle/check_static_recursion.rs +++ b/src/librustc/middle/check_static_recursion.rs @@ -54,7 +54,7 @@ impl<'a, 'ast: 'a> Visitor<'ast> for CheckCrateVisitor<'a, 'ast> { let mut recursion_visitor = CheckItemRecursionVisitor::new(self, &variant.span); recursion_visitor.populate_enum_discriminants(enum_def); - recursion_visitor.visit_variant(variant, generics); + recursion_visitor.visit_variant(variant, generics, it.id); } } } @@ -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.id) => { + Some(variant) if discriminant_map.contains_key(&variant.node.def.id) => { return; } _ => {} @@ -177,7 +177,7 @@ impl<'a, 'ast: 'a> CheckItemRecursionVisitor<'a, 'ast> { // Go through all the variants. let mut variant_stack: Vec = Vec::new(); for variant in enum_definition.variants.iter().rev() { - variant_stack.push(variant.node.id); + variant_stack.push(variant.node.def.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 { @@ -201,14 +201,14 @@ impl<'a, 'ast: 'a> Visitor<'ast> for CheckItemRecursionVisitor<'a, 'ast> { } fn visit_enum_def(&mut self, enum_definition: &'ast hir::EnumDef, - generics: &'ast hir::Generics) { + generics: &'ast hir::Generics, item_id: ast::NodeId) { self.populate_enum_discriminants(enum_definition); - visit::walk_enum_def(self, enum_definition, generics); + visit::walk_enum_def(self, enum_definition, generics, item_id); } fn visit_variant(&mut self, variant: &'ast hir::Variant, - _: &'ast hir::Generics) { - let variant_id = variant.node.id; + _: &'ast hir::Generics, _: ast::NodeId) { + let variant_id = variant.node.def.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` @@ -269,9 +269,10 @@ impl<'a, 'ast: 'a> Visitor<'ast> for CheckItemRecursionVisitor<'a, 'ast> { self.ast_map.expect_item(enum_node_id).node { self.populate_enum_discriminants(enum_def); + let enum_id = self.ast_map.as_local_node_id(enum_id).unwrap(); let variant_id = self.ast_map.as_local_node_id(variant_id).unwrap(); let variant = self.ast_map.expect_variant(variant_id); - self.visit_variant(variant, generics); + self.visit_variant(variant, generics, enum_id); } else { self.sess.span_bug(e.span, "`check_static_recursion` found \ diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index acda0fe2f0e35..550094d2746b3 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -63,7 +63,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt, fn variant_expr<'a>(variants: &'a [P], id: ast::NodeId) -> Option<&'a Expr> { for variant in variants { - if variant.node.id == id { + if variant.node.def.id == id { return variant.node.disr_expr.as_ref().map(|e| &**e); } } diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index f977992e735fe..c243e30e9f92d 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -339,7 +339,7 @@ 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.id)); + self.worklist.extend(enum_def.variants.iter().map(|variant| variant.node.def.id)); } hir::ItemTrait(_, _, _, ref trait_items) => { for trait_item in trait_items { @@ -466,7 +466,7 @@ impl<'a, 'tcx> DeadVisitor<'a, 'tcx> { } fn should_warn_about_variant(&mut self, variant: &hir::Variant_) -> bool { - !self.symbol_is_live(variant.id, None) + !self.symbol_is_live(variant.def.id, None) && !has_allow_dead_code_or_lang_attr(&variant.attrs) } @@ -542,7 +542,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.id, variant.span, + self.warn_dead_code(variant.node.def.id, variant.span, variant.node.name, "variant"); } } diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index 8476adf68381e..5a83899e02b6b 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -207,9 +207,9 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Annotator<'a, 'tcx> { |v| visit::walk_impl_item(v, ii), true); } - fn visit_variant(&mut self, var: &Variant, g: &'v Generics) { - self.annotate(var.node.id, true, &var.node.attrs, var.span, - |v| visit::walk_variant(v, var, g), true) + fn visit_variant(&mut self, var: &Variant, g: &'v Generics, item_id: NodeId) { + self.annotate(var.node.def.id, true, &var.node.attrs, var.span, + |v| visit::walk_variant(v, var, g, item_id), true) } fn visit_struct_field(&mut self, s: &StructField) { diff --git a/src/librustc_back/svh.rs b/src/librustc_back/svh.rs index 25b4cfad01ce0..57b52eae8efb7 100644 --- a/src/librustc_back/svh.rs +++ b/src/librustc_back/svh.rs @@ -301,18 +301,17 @@ mod svh_visitor { } impl<'a, 'v> Visitor<'v> for StrictVersionHashVisitor<'a> { - fn visit_struct_def(&mut self, s: &StructDef, name: Name, - g: &Generics, _: NodeId) { + fn visit_struct_def(&mut self, s: &StructDef, name: Name, g: &Generics, _: NodeId) { SawStructDef(name.as_str()).hash(self.st); visit::walk_generics(self, g); visit::walk_struct_def(self, s) } - fn visit_variant(&mut self, v: &Variant, g: &Generics) { + fn visit_variant(&mut self, v: &Variant, g: &Generics, item_id: NodeId) { SawVariant.hash(self.st); // walk_variant does not call walk_generics, so do it here. visit::walk_generics(self, g); - visit::walk_variant(self, v, g) + visit::walk_variant(self, v, g, item_id) } // All of the remaining methods just record (in the hash diff --git a/src/librustc_front/fold.rs b/src/librustc_front/fold.rs index 3251808179409..409b037d92214 100644 --- a/src/librustc_front/fold.rs +++ b/src/librustc_front/fold.rs @@ -435,9 +435,8 @@ pub fn noop_fold_foreign_mod(ForeignMod { abi, items }: ForeignMod, } pub fn noop_fold_variant(v: P, fld: &mut T) -> P { - v.map(|Spanned {node: Variant_ {id, name, attrs, def, disr_expr}, span}| Spanned { + v.map(|Spanned {node: Variant_ {name, attrs, def, disr_expr}, span}| Spanned { node: Variant_ { - id: fld.new_id(id), name: name, attrs: fold_attrs(attrs, fld), def: fld.fold_struct_def(def), diff --git a/src/librustc_front/hir.rs b/src/librustc_front/hir.rs index b93224165418e..04b54ab47c64c 100644 --- a/src/librustc_front/hir.rs +++ b/src/librustc_front/hir.rs @@ -1030,7 +1030,6 @@ pub struct Variant_ { pub name: Name, pub attrs: Vec, pub def: P, - pub id: NodeId, /// Explicit discriminant, eg `Foo = 1` pub disr_expr: Option>, } diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs index 1539613070fcd..9633fbf6732f8 100644 --- a/src/librustc_front/lowering.rs +++ b/src/librustc_front/lowering.rs @@ -264,7 +264,6 @@ pub fn lower_foreign_mod(_lctx: &LoweringContext, fm: &ForeignMod) -> hir::Forei pub fn lower_variant(_lctx: &LoweringContext, v: &Variant) -> P { P(Spanned { node: hir::Variant_ { - id: v.node.id, name: v.node.name.name, attrs: v.node.attrs.clone(), def: lower_struct_def(_lctx, &v.node.def), diff --git a/src/librustc_front/util.rs b/src/librustc_front/util.rs index 05a548a8c6621..540ca575c15fc 100644 --- a/src/librustc_front/util.rs +++ b/src/librustc_front/util.rs @@ -194,11 +194,6 @@ impl<'a, 'v, O: ast_util::IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> } } } - ItemEnum(ref enum_definition, _) => { - for variant in &enum_definition.variants { - self.operation.visit_id(variant.node.id) - } - } _ => {} } @@ -290,8 +285,7 @@ impl<'a, 'v, O: ast_util::IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> struct_def: &StructDef, _: Name, _: &hir::Generics, - id: NodeId) { - self.operation.visit_id(id); + _: NodeId) { self.operation.visit_id(struct_def.id); visit::walk_struct_def(self, struct_def); } diff --git a/src/librustc_front/visit.rs b/src/librustc_front/visit.rs index 6f9babcc7fd61..4af60c905e4c8 100644 --- a/src/librustc_front/visit.rs +++ b/src/librustc_front/visit.rs @@ -118,14 +118,13 @@ pub trait Visitor<'v> : Sized { fn visit_struct_field(&mut self, s: &'v StructField) { walk_struct_field(self, s) } - fn visit_enum_def(&mut self, enum_definition: &'v EnumDef, generics: &'v Generics) { - walk_enum_def(self, enum_definition, generics) + fn visit_enum_def(&mut self, enum_definition: &'v EnumDef, + generics: &'v Generics, item_id: NodeId) { + walk_enum_def(self, enum_definition, generics, item_id) } - - fn visit_variant(&mut self, v: &'v Variant, g: &'v Generics) { - walk_variant(self, v, g) + fn visit_variant(&mut self, v: &'v Variant, g: &'v Generics, item_id: NodeId) { + walk_variant(self, v, g, item_id) } - fn visit_lifetime(&mut self, lifetime: &'v Lifetime) { walk_lifetime(self, lifetime) } @@ -293,7 +292,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) { } ItemEnum(ref enum_definition, ref type_parameters) => { visitor.visit_generics(type_parameters); - visitor.visit_enum_def(enum_definition, type_parameters) + visitor.visit_enum_def(enum_definition, type_parameters, item.id) } ItemDefaultImpl(_, ref trait_ref) => { visitor.visit_trait_ref(trait_ref) @@ -310,7 +309,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) { } ItemStruct(ref struct_definition, ref generics) => { visitor.visit_generics(generics); - visitor.visit_struct_def(struct_definition, item.name, generics, item.id) + visitor.visit_struct_def(struct_definition, item.name, generics, item.id); } ItemTrait(_, ref generics, ref bounds, ref methods) => { visitor.visit_generics(generics); @@ -323,17 +322,19 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) { pub fn walk_enum_def<'v, V: Visitor<'v>>(visitor: &mut V, enum_definition: &'v EnumDef, - generics: &'v Generics) { + generics: &'v Generics, + item_id: NodeId) { for variant in &enum_definition.variants { - visitor.visit_variant(variant, generics); + visitor.visit_variant(variant, generics, item_id); } } pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V, variant: &'v Variant, - generics: &'v Generics) { + generics: &'v Generics, + item_id: NodeId) { visitor.visit_name(variant.span, variant.node.name); - visitor.visit_struct_def(&variant.node.def, variant.node.name, generics, variant.node.id); + visitor.visit_struct_def(&variant.node.def, variant.node.name, generics, item_id); walk_list!(visitor, visit_expr, &variant.node.disr_expr); walk_list!(visitor, visit_attribute, &variant.node.attrs); } diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index 1df3c1609b890..c9889ee47a6b3 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -428,14 +428,14 @@ impl LateLintPass for MissingDoc { } fn check_struct_def(&mut self, _: &LateContext, _: &hir::StructDef, - _: ast::Name, _: &hir::Generics, id: ast::NodeId) { - self.struct_def_stack.push(id); + _: ast::Name, _: &hir::Generics, item_id: ast::NodeId) { + self.struct_def_stack.push(item_id); } fn check_struct_def_post(&mut self, _: &LateContext, _: &hir::StructDef, - _: ast::Name, _: &hir::Generics, id: ast::NodeId) { + _: ast::Name, _: &hir::Generics, item_id: ast::NodeId) { let popped = self.struct_def_stack.pop().expect("empty struct_def_stack"); - assert!(popped == id); + assert!(popped == item_id); } fn check_crate(&mut self, cx: &LateContext, krate: &hir::Crate) { @@ -527,7 +527,7 @@ 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.id), &v.node.attrs, v.span, "a variant"); + self.check_missing_docs_attrs(cx, Some(v.node.def.id), &v.node.attrs, v.span, "a variant"); assert!(!self.in_variant); self.in_variant = true; } diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 4e4609fb083c0..b5436fb922a2c 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -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.id, item.id); + self.parents.insert(variant.node.def.id, item.id); } } @@ -129,11 +129,11 @@ impl<'v> Visitor<'v> for ParentVisitor { } fn visit_struct_def(&mut self, s: &hir::StructDef, _: ast::Name, - _: &'v hir::Generics, n: ast::NodeId) { + _: &'v hir::Generics, item_id: ast::NodeId) { // Struct constructors are parented to their struct definitions because // they essentially are the struct definitions. if s.kind != hir::VariantKind::Dict { - self.parents.insert(s.id, n); + 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.id); - self.public_items.insert(variant.node.id); + self.exported_items.insert(variant.node.def.id); + self.public_items.insert(variant.node.def.id); } } @@ -1430,10 +1430,10 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> { visit::walk_ty(self, t) } - fn visit_variant(&mut self, v: &hir::Variant, g: &hir::Generics) { - if self.exported_items.contains(&v.node.id) { + fn visit_variant(&mut self, v: &hir::Variant, g: &hir::Generics, item_id: ast::NodeId) { + if self.exported_items.contains(&v.node.def.id) { self.in_variant = true; - visit::walk_variant(self, v, g); + visit::walk_variant(self, v, g, item_id); self.in_variant = false; } } diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 6b4b33341664b..9f19e178a0dd7 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -590,7 +590,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let is_exported = match variant.node.def.kind { hir::VariantKind::Dict => { // 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.id); + let variant_def_id = self.ast_map.local_def_id(variant.node.def.id); self.structs.insert(variant_def_id, Vec::new()); true } @@ -603,10 +603,10 @@ 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.id), is_exported), + self.ast_map.local_def_id(variant.node.def.id), is_exported), variant.span, DefModifiers::PUBLIC | DefModifiers::IMPORTABLE); child.define_type(DefVariant(item_id, - self.ast_map.local_def_id(variant.node.id), is_exported), + self.ast_map.local_def_id(variant.node.def.id), is_exported), variant.span, DefModifiers::PUBLIC | DefModifiers::IMPORTABLE); } diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index b3c0aca954ec0..9c7054e592ccf 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -491,7 +491,7 @@ impl<'a, 'v, 'tcx> Visitor<'v> for Resolver<'a, 'tcx> { } visit::walk_poly_trait_ref(self, tref, m); } - fn visit_variant(&mut self, variant: &hir::Variant, generics: &Generics) { + fn visit_variant(&mut self, variant: &hir::Variant, generics: &Generics, item_id: ast::NodeId) { execute_callback!(hir_map::Node::NodeVariant(variant), self); if let Some(ref dis_expr) = variant.node.disr_expr { // resolve the discriminator expr as a constant @@ -501,7 +501,7 @@ impl<'a, 'v, 'tcx> Visitor<'v> for Resolver<'a, 'tcx> { } // `visit::walk_variant` without the discriminant expression. - self.visit_struct_def(&variant.node.def, variant.node.name, generics, variant.node.id); + self.visit_struct_def(&variant.node.def, variant.node.name, generics, item_id); } fn visit_foreign_item(&mut self, foreign_item: &hir::ForeignItem) { execute_callback!(hir_map::Node::NodeForeignItem(foreign_item), self); diff --git a/src/librustc_trans/save/dump_csv.rs b/src/librustc_trans/save/dump_csv.rs index fb1c494ffd44e..c366872362020 100644 --- a/src/librustc_trans/save/dump_csv.rs +++ b/src/librustc_trans/save/dump_csv.rs @@ -503,7 +503,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { self.fmt.struct_variant_str(variant.span, self.span.span_for_first_ident(variant.span), - variant.node.id, + variant.node.def.id, variant.node.def.id, &qualname, &enum_data.qualname, @@ -511,7 +511,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { enum_data.id); for field in &variant.node.def.fields { - self.process_struct_field_def(field, variant.node.id); + self.process_struct_field_def(field, variant.node.def.id); self.visit_ty(&*field.node.ty); } } diff --git a/src/librustc_trans/trans/inline.rs b/src/librustc_trans/trans/inline.rs index 9cb4b271742c4..0ba4ba3e604ee 100644 --- a/src/librustc_trans/trans/inline.rs +++ b/src/librustc_trans/trans/inline.rs @@ -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.id; } - ccx.external().borrow_mut().insert(ty_v.did, Some(ast_v.node.id)); + if ty_v.did == fn_id { my_id = ast_v.node.def.id; } + ccx.external().borrow_mut().insert(ty_v.did, Some(ast_v.node.def.id)); } } hir::ItemStruct(ref struct_def, _) => { diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 879432d89c8c8..decc269442d81 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -1075,7 +1075,7 @@ fn convert_enum_variant_types<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, // an item. convert_variant_ctor( ccx.tcx, - variant.node.id, + variant.node.def.id, ty_variant, scheme.clone(), predicates.clone() @@ -1206,7 +1206,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.id); + let did = tcx.map.local_def_id(v.node.def.id); let name = v.node.name; convert_struct_variant(tcx, did, name, disr, &v.node.def) } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index a5ed0ea6c095e..59ff7f53f8733 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1853,7 +1853,7 @@ impl Clean for doctree::Variant { source: self.whence.clean(cx), visibility: None, stability: self.stab.clean(cx), - def_id: cx.map.local_def_id(self.id), + def_id: cx.map.local_def_id(self.def.id), inner: VariantItem(Variant { kind: struct_def_to_variant_kind(&self.def, cx), }), diff --git a/src/librustdoc/doctree.rs b/src/librustdoc/doctree.rs index c65c31e6c3cc3..06b1e93e604b5 100644 --- a/src/librustdoc/doctree.rs +++ b/src/librustdoc/doctree.rs @@ -120,7 +120,6 @@ pub struct Variant { pub name: Name, pub attrs: Vec, pub def: P, - pub id: ast::NodeId, pub stab: Option, pub whence: Span, } diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index 303f344d8c371..78c56b934272a 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -111,8 +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.id), - id: v.node.id, + stab: self.stability(v.node.def.id), def: v.node.def.clone(), whence: v.span, }).collect(), diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 66c0d858e3c7a..53246963dc882 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -1586,7 +1586,6 @@ pub struct Variant_ { pub name: Ident, pub attrs: Vec, pub def: P, - pub id: NodeId, /// Explicit discriminant, eg `Foo = 1` pub disr_expr: Option>, } diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 87f05f7f41e3f..592770ea4825c 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -360,11 +360,6 @@ impl<'a, 'v, O: IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> { } } } - ItemEnum(ref enum_definition, _) => { - for variant in &enum_definition.variants { - self.operation.visit_id(variant.node.id) - } - } _ => {} } @@ -461,8 +456,7 @@ impl<'a, 'v, O: IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> { struct_def: &StructDef, _: ast::Ident, _: &ast::Generics, - id: NodeId) { - self.operation.visit_id(id); + _: NodeId) { 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 d47072d477e86..744f83467d601 100644 --- a/src/libsyntax/config.rs +++ b/src/libsyntax/config.rs @@ -140,11 +140,10 @@ fn fold_item_underscore(cx: &mut Context, item: ast::Item_) -> ast::Item_ if !(cx.in_cfg)(&v.node.attrs) { None } else { - Some(v.map(|Spanned {node: ast::Variant_ {id, name, attrs, def, + Some(v.map(|Spanned {node: ast::Variant_ {name, attrs, def, disr_expr}, span}| { Spanned { node: ast::Variant_ { - id: id, name: name, attrs: attrs, def: fold_struct(cx, def), diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index 132ab6e67feee..706a16d1f0228 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -1011,7 +1011,6 @@ impl<'a> AstBuilder for ExtCtxt<'a> { def: P(ast::StructDef { fields: fields, id: ast::DUMMY_NODE_ID, kind: kind }), - id: ast::DUMMY_NODE_ID, disr_expr: None, }) } diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 8156ef20faf0b..7da09f5188356 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -450,9 +450,8 @@ pub fn noop_fold_foreign_mod(ForeignMod {abi, items}: ForeignMod, } pub fn noop_fold_variant(v: P, fld: &mut T) -> P { - v.map(|Spanned {node: Variant_ {id, name, attrs, def, disr_expr}, span}| Spanned { + v.map(|Spanned {node: Variant_ {name, attrs, def, disr_expr}, span}| Spanned { node: Variant_ { - id: fld.new_id(id), name: name, attrs: fold_attrs(attrs, fld), def: fld.fold_struct_def(def), diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 1b446fb9902ab..09ca20653ed53 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -5176,7 +5176,6 @@ impl<'a> Parser<'a> { name: ident, attrs: variant_attrs, def: struct_def, - id: ast::DUMMY_NODE_ID, disr_expr: disr_expr, }; variants.push(P(spanned(vlo, self.last_span.hi, vr))); diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 2d6829c5e75b5..5535064c8eca2 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -3122,7 +3122,6 @@ mod tests { def: P(ast::StructDef { fields: Vec::new(), id: ast::DUMMY_NODE_ID, kind: ast::VariantKind::Unit }), - id: 0, disr_expr: None, }); diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index fe64f87e68174..6dc59b390f60b 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -85,12 +85,12 @@ pub trait Visitor<'v> : Sized { } fn visit_struct_field(&mut self, s: &'v StructField) { walk_struct_field(self, s) } fn visit_enum_def(&mut self, enum_definition: &'v EnumDef, - generics: &'v Generics) { - walk_enum_def(self, enum_definition, generics) + generics: &'v Generics, item_id: NodeId) { + walk_enum_def(self, enum_definition, generics, item_id) + } + fn visit_variant(&mut self, v: &'v Variant, g: &'v Generics, item_id: NodeId) { + walk_variant(self, v, g, item_id) } - - fn visit_variant(&mut self, v: &'v Variant, g: &'v Generics) { walk_variant(self, v, g) } - fn visit_lifetime(&mut self, lifetime: &'v Lifetime) { walk_lifetime(self, lifetime) } @@ -271,7 +271,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) { } ItemEnum(ref enum_definition, ref type_parameters) => { visitor.visit_generics(type_parameters); - visitor.visit_enum_def(enum_definition, type_parameters) + visitor.visit_enum_def(enum_definition, type_parameters, item.id) } ItemDefaultImpl(_, ref trait_ref) => { visitor.visit_trait_ref(trait_ref) @@ -288,10 +288,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) { } ItemStruct(ref struct_definition, ref generics) => { visitor.visit_generics(generics); - visitor.visit_struct_def(struct_definition, - item.ident, - generics, - item.id) + visitor.visit_struct_def(struct_definition, item.ident, generics, item.id); } ItemTrait(_, ref generics, ref bounds, ref methods) => { visitor.visit_generics(generics); @@ -305,17 +302,19 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) { pub fn walk_enum_def<'v, V: Visitor<'v>>(visitor: &mut V, enum_definition: &'v EnumDef, - generics: &'v Generics) { + generics: &'v Generics, + item_id: NodeId) { for variant in &enum_definition.variants { - visitor.visit_variant(variant, generics); + visitor.visit_variant(variant, generics, item_id); } } pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V, variant: &'v Variant, - generics: &'v Generics) { + generics: &'v Generics, + item_id: NodeId) { visitor.visit_ident(variant.span, variant.node.name); - visitor.visit_struct_def(&variant.node.def, variant.node.name, generics, variant.node.id); + visitor.visit_struct_def(&variant.node.def, variant.node.name, generics, item_id); walk_list!(visitor, visit_expr, &variant.node.disr_expr); walk_list!(visitor, visit_attribute, &variant.node.attrs); } From beda1f88a7d87cf994fe8e3a5b2fe126e31fcae9 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Fri, 2 Oct 2015 20:06:59 +0300 Subject: [PATCH 05/13] Provide span for visit_struct_def + remove some dead code --- src/librustc/lint/context.rs | 6 ++++-- src/librustc/middle/dead.rs | 2 +- src/librustc_back/svh.rs | 3 ++- src/librustc_front/fold.rs | 13 ------------- src/librustc_front/hir.rs | 6 ------ src/librustc_front/util.rs | 3 ++- src/librustc_front/visit.rs | 9 ++++++--- src/librustc_privacy/lib.rs | 2 +- src/librustc_resolve/lib.rs | 3 ++- src/libsyntax/ast.rs | 6 ------ src/libsyntax/ast_util.rs | 3 ++- src/libsyntax/fold.rs | 12 ------------ src/libsyntax/visit.rs | 9 ++++++--- 13 files changed, 26 insertions(+), 51 deletions(-) diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index f66d9a9b3991e..dcccd9f2c9770 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -665,7 +665,8 @@ impl<'a, 'tcx, 'v> hir_visit::Visitor<'v> for LateContext<'a, 'tcx> { s: &hir::StructDef, name: ast::Name, g: &hir::Generics, - item_id: ast::NodeId) { + item_id: ast::NodeId, + _: Span) { run_lints!(self, check_struct_def, late_passes, s, name, g, item_id); hir_visit::walk_struct_def(self, s); run_lints!(self, check_struct_def_post, late_passes, s, name, g, item_id); @@ -814,7 +815,8 @@ impl<'a, 'v> ast_visit::Visitor<'v> for EarlyContext<'a> { s: &ast::StructDef, ident: ast::Ident, g: &ast::Generics, - item_id: ast::NodeId) { + item_id: ast::NodeId, + _: Span) { run_lints!(self, check_struct_def, early_passes, s, ident, g, item_id); ast_visit::walk_struct_def(self, s); run_lints!(self, check_struct_def_post, early_passes, s, ident, g, item_id); diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index c243e30e9f92d..8b52536a4a02b 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -216,7 +216,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { impl<'a, 'tcx, 'v> Visitor<'v> for MarkSymbolVisitor<'a, 'tcx> { fn visit_struct_def(&mut self, def: &hir::StructDef, _: ast::Name, - _: &hir::Generics, _: ast::NodeId) { + _: &hir::Generics, _: ast::NodeId, _: codemap::Span) { let has_extern_repr = self.struct_has_extern_repr; let inherited_pub_visibility = self.inherited_pub_visibility; let live_fields = def.fields.iter().filter(|f| { diff --git a/src/librustc_back/svh.rs b/src/librustc_back/svh.rs index 57b52eae8efb7..4b235534bf338 100644 --- a/src/librustc_back/svh.rs +++ b/src/librustc_back/svh.rs @@ -301,7 +301,8 @@ mod svh_visitor { } impl<'a, 'v> Visitor<'v> for StrictVersionHashVisitor<'a> { - fn visit_struct_def(&mut self, s: &StructDef, name: Name, g: &Generics, _: NodeId) { + fn visit_struct_def(&mut self, s: &StructDef, name: Name, + g: &Generics, _: NodeId, _: Span) { SawStructDef(name.as_str()).hash(self.st); visit::walk_generics(self, g); visit::walk_struct_def(self, s) diff --git a/src/librustc_front/fold.rs b/src/librustc_front/fold.rs index 409b037d92214..2cd49bedae3f2 100644 --- a/src/librustc_front/fold.rs +++ b/src/librustc_front/fold.rs @@ -247,10 +247,6 @@ pub trait Folder : Sized { noop_fold_opt_lifetime(o_lt, self) } - fn fold_variant_arg(&mut self, va: VariantArg) -> VariantArg { - noop_fold_variant_arg(va, self) - } - fn fold_opt_bounds(&mut self, b: Option>) -> Option> { @@ -766,15 +762,6 @@ fn noop_fold_bounds(bounds: TyParamBounds, folder: &mut T) -> TyParam bounds.move_map(|bound| folder.fold_ty_param_bound(bound)) } -fn noop_fold_variant_arg(VariantArg { id, ty }: VariantArg, - folder: &mut T) - -> VariantArg { - VariantArg { - id: folder.new_id(id), - ty: folder.fold_ty(ty), - } -} - pub fn noop_fold_block(b: P, folder: &mut T) -> P { b.map(|Block { id, stmts, expr, rules, span }| { Block { diff --git a/src/librustc_front/hir.rs b/src/librustc_front/hir.rs index 04b54ab47c64c..b55bfc395b4ab 100644 --- a/src/librustc_front/hir.rs +++ b/src/librustc_front/hir.rs @@ -1014,12 +1014,6 @@ pub struct ForeignMod { pub items: Vec>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] -pub struct VariantArg { - pub ty: P, - pub id: NodeId, -} - #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct EnumDef { pub variants: Vec>, diff --git a/src/librustc_front/util.rs b/src/librustc_front/util.rs index 540ca575c15fc..16299a83c6687 100644 --- a/src/librustc_front/util.rs +++ b/src/librustc_front/util.rs @@ -285,7 +285,8 @@ impl<'a, 'v, O: ast_util::IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> struct_def: &StructDef, _: Name, _: &hir::Generics, - _: NodeId) { + _: NodeId, + _: Span) { self.operation.visit_id(struct_def.id); visit::walk_struct_def(self, struct_def); } diff --git a/src/librustc_front/visit.rs b/src/librustc_front/visit.rs index 4af60c905e4c8..2bbaeaefa0fab 100644 --- a/src/librustc_front/visit.rs +++ b/src/librustc_front/visit.rs @@ -112,7 +112,8 @@ pub trait Visitor<'v> : Sized { fn visit_poly_trait_ref(&mut self, t: &'v PolyTraitRef, m: &'v TraitBoundModifier) { walk_poly_trait_ref(self, t, m) } - fn visit_struct_def(&mut self, s: &'v StructDef, _: Name, _: &'v Generics, _: NodeId) { + fn visit_struct_def(&mut self, s: &'v StructDef, _: Name, + _: &'v Generics, _: NodeId, _: Span) { walk_struct_def(self, s) } fn visit_struct_field(&mut self, s: &'v StructField) { @@ -309,7 +310,8 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) { } ItemStruct(ref struct_definition, ref generics) => { visitor.visit_generics(generics); - visitor.visit_struct_def(struct_definition, item.name, generics, item.id); + visitor.visit_struct_def(struct_definition, item.name, + generics, item.id, item.span); } ItemTrait(_, ref generics, ref bounds, ref methods) => { visitor.visit_generics(generics); @@ -334,7 +336,8 @@ pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics, item_id: NodeId) { visitor.visit_name(variant.span, variant.node.name); - visitor.visit_struct_def(&variant.node.def, variant.node.name, generics, item_id); + visitor.visit_struct_def(&variant.node.def, variant.node.name, + generics, item_id, variant.span); walk_list!(visitor, visit_expr, &variant.node.disr_expr); walk_list!(visitor, visit_attribute, &variant.node.attrs); } diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index b5436fb922a2c..6ff8239d3aedb 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -129,7 +129,7 @@ impl<'v> Visitor<'v> for ParentVisitor { } fn visit_struct_def(&mut self, s: &hir::StructDef, _: ast::Name, - _: &'v hir::Generics, item_id: ast::NodeId) { + _: &'v hir::Generics, item_id: ast::NodeId, _: Span) { // Struct constructors are parented to their struct definitions because // they essentially are the struct definitions. if s.kind != hir::VariantKind::Dict { diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 9c7054e592ccf..b71f89a75be99 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -501,7 +501,8 @@ impl<'a, 'v, 'tcx> Visitor<'v> for Resolver<'a, 'tcx> { } // `visit::walk_variant` without the discriminant expression. - self.visit_struct_def(&variant.node.def, variant.node.name, generics, item_id); + self.visit_struct_def(&variant.node.def, variant.node.name, + generics, item_id, variant.span); } fn visit_foreign_item(&mut self, foreign_item: &hir::ForeignItem) { execute_callback!(hir_map::Node::NodeForeignItem(foreign_item), self); diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 53246963dc882..b786e778edb11 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -1570,12 +1570,6 @@ pub struct ForeignMod { pub items: Vec>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] -pub struct VariantArg { - pub ty: P, - pub id: NodeId, -} - #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct EnumDef { pub variants: Vec>, diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 592770ea4825c..c52c5984858a9 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -456,7 +456,8 @@ impl<'a, 'v, O: IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> { struct_def: &StructDef, _: ast::Ident, _: &ast::Generics, - _: NodeId) { + _: NodeId, + _: Span) { self.operation.visit_id(struct_def.id); visit::walk_struct_def(self, struct_def); } diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 7da09f5188356..144eab92795b2 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -271,10 +271,6 @@ pub trait Folder : Sized { noop_fold_opt_lifetime(o_lt, self) } - fn fold_variant_arg(&mut self, va: VariantArg) -> VariantArg { - noop_fold_variant_arg(va, self) - } - fn fold_opt_bounds(&mut self, b: Option>) -> Option> { noop_fold_opt_bounds(b, self) @@ -884,14 +880,6 @@ fn noop_fold_bounds(bounds: TyParamBounds, folder: &mut T) bounds.move_map(|bound| folder.fold_ty_param_bound(bound)) } -fn noop_fold_variant_arg(VariantArg {id, ty}: VariantArg, folder: &mut T) - -> VariantArg { - VariantArg { - id: folder.new_id(id), - ty: folder.fold_ty(ty) - } -} - pub fn noop_fold_block(b: P, folder: &mut T) -> P { b.map(|Block {id, stmts, expr, rules, span}| Block { id: folder.new_id(id), diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 6dc59b390f60b..b547f8c019c6e 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -80,7 +80,8 @@ pub trait Visitor<'v> : Sized { fn visit_poly_trait_ref(&mut self, t: &'v PolyTraitRef, m: &'v TraitBoundModifier) { walk_poly_trait_ref(self, t, m) } - fn visit_struct_def(&mut self, s: &'v StructDef, _: Ident, _: &'v Generics, _: NodeId) { + fn visit_struct_def(&mut self, s: &'v StructDef, _: Ident, + _: &'v Generics, _: NodeId, _: Span) { walk_struct_def(self, s) } fn visit_struct_field(&mut self, s: &'v StructField) { walk_struct_field(self, s) } @@ -288,7 +289,8 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) { } ItemStruct(ref struct_definition, ref generics) => { visitor.visit_generics(generics); - visitor.visit_struct_def(struct_definition, item.ident, generics, item.id); + visitor.visit_struct_def(struct_definition, item.ident, + generics, item.id, item.span); } ItemTrait(_, ref generics, ref bounds, ref methods) => { visitor.visit_generics(generics); @@ -314,7 +316,8 @@ pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics, item_id: NodeId) { visitor.visit_ident(variant.span, variant.node.name); - visitor.visit_struct_def(&variant.node.def, variant.node.name, generics, item_id); + visitor.visit_struct_def(&variant.node.def, variant.node.name, + generics, item_id, variant.span); walk_list!(visitor, visit_expr, &variant.node.disr_expr); walk_list!(visitor, visit_attribute, &variant.node.attrs); } From 8a12c19171887ea6d7ff708db2e2581ceaf16c14 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Fri, 2 Oct 2015 22:41:24 +0300 Subject: [PATCH 06/13] Test and gate empty structures and variants better --- src/doc/reference.md | 2 +- src/librustc_typeck/check/_match.rs | 2 +- src/librustc_typeck/check/mod.rs | 22 +++++-- src/libsyntax/feature_gate.rs | 38 ++++++------ src/libsyntax/parse/parser.rs | 9 +-- .../compile-fail/empty-struct-braces-expr.rs | 26 ++++++++ ...ces-3.rs => empty-struct-braces-gate-1.rs} | 14 +++-- .../empty-struct-braces-gate-2.rs | 49 +++++++++++++++ ...aces-2.rs => empty-struct-braces-pat-1.rs} | 22 ++++--- .../compile-fail/empty-struct-braces-pat-2.rs | 39 ++++++++++++ ...-braces-1.rs => empty-struct-unit-expr.rs} | 11 +++- .../compile-fail/empty-struct-unit-pat.rs | 40 +++++++++++++ src/test/compile-fail/issue-16819.rs | 18 ++++++ src/test/compile-fail/issue-27831.rs | 4 +- .../struct-no-fields-enumlike.rs | 4 +- ...-with-braces.rs => empty-struct-braces.rs} | 60 ++++++++++++++----- 16 files changed, 291 insertions(+), 69 deletions(-) create mode 100644 src/test/compile-fail/empty-struct-braces-expr.rs rename src/test/compile-fail/{empty-struct-with-braces-3.rs => empty-struct-braces-gate-1.rs} (68%) create mode 100644 src/test/compile-fail/empty-struct-braces-gate-2.rs rename src/test/compile-fail/{empty-struct-with-braces-2.rs => empty-struct-braces-pat-1.rs} (60%) create mode 100644 src/test/compile-fail/empty-struct-braces-pat-2.rs rename src/test/compile-fail/{empty-struct-with-braces-1.rs => empty-struct-unit-expr.rs} (70%) create mode 100644 src/test/compile-fail/empty-struct-unit-pat.rs create mode 100644 src/test/compile-fail/issue-16819.rs rename src/test/{parse-fail => compile-fail}/struct-no-fields-enumlike.rs (80%) rename src/test/run-pass/{empty-struct-with-braces.rs => empty-struct-braces.rs} (55%) diff --git a/src/doc/reference.md b/src/doc/reference.md index 9ce191ee5897f..8b4e94063f9bd 100644 --- a/src/doc/reference.md +++ b/src/doc/reference.md @@ -2357,7 +2357,7 @@ The currently implemented features of the reference compiler are: terms of encapsulation). * - `default_type_parameter_fallback` - Allows type parameter defaults to influence type inference. -* - `braced_empty_structs` - Allows use of empty structs with braces. +* - `braced_empty_structs` - Allows use of empty structs and enum variants with braces. If a feature is promoted to a language feature, then all existing programs will start to receive compilation warnings about `#![feature]` directives which enabled diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index 8bcff22575563..db5dd19c9236c 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -530,7 +530,7 @@ pub fn check_pat_struct<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &'tcx hir::Pat, let tcx = pcx.fcx.ccx.tcx; let def = tcx.def_map.borrow().get(&pat.id).unwrap().full_def(); - let variant = match fcx.def_struct_variant(def) { + let variant = match fcx.def_struct_variant(def, path.span) { Some((_, variant)) => variant, None => { let name = pprust::path_to_string(path); diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index f6b007018b88a..6b19c8bd2e5ea 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -1464,7 +1464,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { /// Return the dict-like variant corresponding to a given `Def`. pub fn def_struct_variant(&self, - def: def::Def) + def: def::Def, + span: Span) -> Option<(ty::AdtDef<'tcx>, ty::VariantDef<'tcx>)> { let (adt, variant) = match def { @@ -1484,11 +1485,20 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { }; let var_kind = variant.kind(); - if var_kind == ty::VariantKind::Dict || var_kind == ty::VariantKind::Unit { + if var_kind == ty::VariantKind::Dict { Some((adt, variant)) - } else { - None - } + } else if var_kind == ty::VariantKind::Unit { + if !self.tcx().sess.features.borrow().braced_empty_structs { + self.tcx().sess.span_err(span, "empty structs and enum variants \ + with braces are unstable"); + fileline_help!(self.tcx().sess, span, "add #![feature(braced_empty_structs)] to \ + the crate features to enable"); + } + + Some((adt, variant)) + } else { + None + } } pub fn write_nil(&self, node_id: ast::NodeId) { @@ -3177,7 +3187,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, // Find the relevant variant let def = lookup_full_def(tcx, path.span, expr.id); - let (adt, variant) = match fcx.def_struct_variant(def) { + let (adt, variant) = match fcx.def_struct_variant(def, path.span) { Some((adt, variant)) => (adt, variant), None => { span_err!(fcx.tcx().sess, path.span, E0071, diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index 0b3af659a7b2d..66a422ce664c1 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -196,7 +196,7 @@ const KNOWN_FEATURES: &'static [(&'static str, &'static str, Option, Status // allow `#[unwind]` ("unwind_attributes", "1.4.0", None, Active), - // allow empty structs/enum variants with braces + // allow empty structs and enum variants with braces ("braced_empty_structs", "1.5.0", None, Active), // allow overloading augmented assignment operations like `a += b` @@ -486,6 +486,7 @@ pub struct Features { pub cfg_target_feature: bool, pub cfg_target_vendor: bool, pub augmented_assignments: bool, + pub braced_empty_structs: bool, } impl Features { @@ -516,6 +517,7 @@ impl Features { cfg_target_feature: false, cfg_target_vendor: false, augmented_assignments: false, + braced_empty_structs: false, } } } @@ -809,7 +811,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { } } - ast::ItemStruct(ref def, _) => { + ast::ItemStruct(..) => { if attr::contains_name(&i.attrs[..], "simd") { self.gate_feature("simd", i.span, "SIMD types are experimental and possibly buggy"); @@ -828,10 +830,6 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { } } } - if def.fields.is_empty() && def.kind == ast::VariantKind::Dict { - self.gate_feature("braced_empty_structs", i.span, - "empty structs with braces are unstable"); - } } ast::ItemDefaultImpl(..) => { @@ -859,6 +857,21 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { visit::walk_item(self, i); } + fn visit_struct_def(&mut self, s: &'v ast::StructDef, _: ast::Ident, + _: &'v ast::Generics, _: ast::NodeId, span: Span) { + if s.fields.is_empty() { + if s.kind == ast::VariantKind::Dict { + self.gate_feature("braced_empty_structs", span, + "empty structs and enum variants with braces are unstable"); + } else if s.kind == ast::VariantKind::Tuple { + self.context.span_handler.span_err(span, "empty tuple structs and enum variants \ + are not allowed, use unit structs and \ + enum variants instead"); + } + } + visit::walk_struct_def(self, s) + } + fn visit_foreign_item(&mut self, i: &ast::ForeignItem) { let links_to_llvm = match attr::first_attr_value_str_by_name(&i.attrs, "link_name") { @@ -881,12 +894,6 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { "box expression syntax is experimental; \ you can call `Box::new` instead."); } - ast::ExprStruct(_, ref fields, ref expr) => { - if fields.is_empty() && expr.is_none() { - self.gate_feature("braced_empty_structs", e.span, - "empty structs with braces are unstable"); - } - } _ => {} } visit::walk_expr(self, e); @@ -911,12 +918,6 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { pattern.span, "box pattern syntax is experimental"); } - ast::PatStruct(_, ref fields, dotdot) => { - if fields.is_empty() && !dotdot { - self.gate_feature("braced_empty_structs", pattern.span, - "empty structs with braces are unstable"); - } - } _ => {} } visit::walk_pat(self, pattern) @@ -1086,6 +1087,7 @@ fn check_crate_inner(cm: &CodeMap, span_handler: &SpanHandler, cfg_target_feature: cx.has_feature("cfg_target_feature"), cfg_target_vendor: cx.has_feature("cfg_target_vendor"), augmented_assignments: cx.has_feature("augmented_assignments"), + braced_empty_structs: cx.has_feature("braced_empty_structs"), } } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 09ca20653ed53..47632781956e5 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -4658,7 +4658,7 @@ impl<'a> Parser<'a> { (fields, VariantKind::Dict) // Tuple-style struct definition with optional where-clause. } else if self.token == token::OpenDelim(token::Paren) { - let fields = try!(self.parse_tuple_struct_body(class_name, &mut generics)); + let fields = try!(self.parse_tuple_struct_body(&mut generics)); (fields, VariantKind::Tuple) } else { let token_str = self.this_token_to_string(); @@ -4694,7 +4694,6 @@ impl<'a> Parser<'a> { } pub fn parse_tuple_struct_body(&mut self, - class_name: ast::Ident, generics: &mut ast::Generics) -> PResult> { // This is the case where we find `struct Foo(T) where T: Copy;` @@ -4715,12 +4714,6 @@ impl<'a> Parser<'a> { Ok(spanned(lo, p.span.hi, struct_field_)) })); - if fields.is_empty() { - return Err(self.fatal(&format!("unit-like struct definition should be \ - written as `struct {};`", - class_name))); - } - generics.where_clause = try!(self.parse_where_clause()); try!(self.expect(&token::Semi)); Ok(fields) diff --git a/src/test/compile-fail/empty-struct-braces-expr.rs b/src/test/compile-fail/empty-struct-braces-expr.rs new file mode 100644 index 0000000000000..67167086b9c4a --- /dev/null +++ b/src/test/compile-fail/empty-struct-braces-expr.rs @@ -0,0 +1,26 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Can't use empty braced struct as constant or constructor function + +#![feature(braced_empty_structs)] + +struct Empty1 {} + +enum E { + Empty2 {} +} + +fn main() { + let e1 = Empty1; //~ ERROR `Empty1` is the name of a struct or struct variant + let e1 = Empty1(); //~ ERROR `Empty1` is the name of a struct or struct variant + let e2 = E::Empty2; //~ ERROR `E::Empty2` is the name of a struct or struct variant + let e2 = E::Empty2(); //~ ERROR `E::Empty2` is the name of a struct or struct variant +} diff --git a/src/test/compile-fail/empty-struct-with-braces-3.rs b/src/test/compile-fail/empty-struct-braces-gate-1.rs similarity index 68% rename from src/test/compile-fail/empty-struct-with-braces-3.rs rename to src/test/compile-fail/empty-struct-braces-gate-1.rs index e6f20ba345ad3..a131b46e1c19b 100644 --- a/src/test/compile-fail/empty-struct-with-braces-3.rs +++ b/src/test/compile-fail/empty-struct-braces-gate-1.rs @@ -9,13 +9,15 @@ // except according to those terms. // Feature gate test for empty struct with braces +// Can't define an empty braced struct -struct Empty {} //~ ERROR empty structs with braces are unstable +struct Empty1 {} //~ ERROR empty structs and enum variants with braces are unstable +struct Empty2; -fn main() { - let e = Empty {}; //~ ERROR empty structs with braces are unstable +enum E { + Empty4 {}, //~ ERROR empty structs and enum variants with braces are unstable + Empty5, +} - match e { - Empty {} => {} //~ ERROR empty structs with braces are unstable - } +fn main() { } diff --git a/src/test/compile-fail/empty-struct-braces-gate-2.rs b/src/test/compile-fail/empty-struct-braces-gate-2.rs new file mode 100644 index 0000000000000..c1b73bdc96a8f --- /dev/null +++ b/src/test/compile-fail/empty-struct-braces-gate-2.rs @@ -0,0 +1,49 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Feature gate test for empty struct with braces +// Can't use braced expressions and patterns with structs defined without braces + +struct Empty2; + +enum E { + Empty5, +} + +fn main() { + let e2: Empty2 = Empty2 {}; //~ ERROR empty structs and enum variants with braces are unstable + let e2: Empty2 = Empty2; + // Issue #28692 + // let e5: E = E::Empty5 {}; // ERROR empty structs and enum variants with braces are unstable + let e5: E = E::Empty5; + + match e2 { + Empty2 {} => {} //~ ERROR empty structs and enum variants with braces are unstable + } + match e2 { + Empty2 => {} + } + match e2 { + Empty2 { .. } => {} //~ ERROR empty structs and enum variants with braces are unstable + } + // Issue #28692 + // match e5 { + // E::Empty5 {} => {} // ERROR empty structs and enum variants with braces are unstable + // } + match e5 { + E::Empty5 => {} + } + // Issue #28692 + // match e5 { + // E::Empty5 { .. } => {} // ERROR empty structs and enum variants with braces are unstable + // } + + let e22 = Empty2 { ..e2 }; //~ ERROR empty structs and enum variants with braces are unstable +} diff --git a/src/test/compile-fail/empty-struct-with-braces-2.rs b/src/test/compile-fail/empty-struct-braces-pat-1.rs similarity index 60% rename from src/test/compile-fail/empty-struct-with-braces-2.rs rename to src/test/compile-fail/empty-struct-braces-pat-1.rs index 0e72e7dc44185..e095f69ed7da6 100644 --- a/src/test/compile-fail/empty-struct-with-braces-2.rs +++ b/src/test/compile-fail/empty-struct-braces-pat-1.rs @@ -8,18 +8,26 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Empty struct defined with braces shouldn't add names into value namespace +// Can't use empty braced struct as constant pattern -#![feature(braced_empty_structs)] #![deny(warnings)] +#![feature(braced_empty_structs)] -struct Empty {} +struct Empty1 {} + +enum E { + Empty2 {} +} fn main() { - let e = Empty {}; + let e1 = Empty1 {}; + let e2 = E::Empty2 {}; - match e { - Empty => () //~ ERROR unused variable: `Empty` - //~^ ERROR variable `Empty` should have a snake case name such as `empty` + // Issue #28692 + // match e1 { + // Empty1 => () // ERROR incorrect error + // } + match e2 { + E::Empty2 => () //~ ERROR `E::Empty2` does not name a non-struct variant or a tuple struct } } diff --git a/src/test/compile-fail/empty-struct-braces-pat-2.rs b/src/test/compile-fail/empty-struct-braces-pat-2.rs new file mode 100644 index 0000000000000..0e7152ec89a81 --- /dev/null +++ b/src/test/compile-fail/empty-struct-braces-pat-2.rs @@ -0,0 +1,39 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Can't use empty braced struct as enum pattern + +#![feature(braced_empty_structs)] + +struct Empty1 {} + +enum E { + Empty2 {} +} + +fn main() { + let e1 = Empty1 {}; + let e2 = E::Empty2 {}; + + // Rejected by parser as yet + // match e1 { + // Empty1() => () // ERROR unresolved enum variant, struct or const `Empty1` + // } + match e1 { + Empty1(..) => () //~ ERROR unresolved enum variant, struct or const `Empty1` + } + // Issue #28692 + // match e2 { + // E::Empty2() => () // ERROR unresolved enum variant, struct or const `Empty2` + // } + // match e2 { + // E::Empty2(..) => () // ERROR unresolved enum variant, struct or const `Empty2` + // } +} diff --git a/src/test/compile-fail/empty-struct-with-braces-1.rs b/src/test/compile-fail/empty-struct-unit-expr.rs similarity index 70% rename from src/test/compile-fail/empty-struct-with-braces-1.rs rename to src/test/compile-fail/empty-struct-unit-expr.rs index ad412259faa29..199065665b9f6 100644 --- a/src/test/compile-fail/empty-struct-with-braces-1.rs +++ b/src/test/compile-fail/empty-struct-unit-expr.rs @@ -8,12 +8,17 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Empty struct defined with braces shouldn't add names into value namespace +// Can't use unit struct as constructor function #![feature(braced_empty_structs)] -struct Empty {} +struct Empty1; + +enum E { + Empty2 +} fn main() { - let e = Empty; //~ ERROR `Empty` is the name of a struct or struct variant + let e1 = Empty1(); //~ ERROR expected function, found `Empty1` + let e2 = E::Empty2(); //~ ERROR expected function, found `E` } diff --git a/src/test/compile-fail/empty-struct-unit-pat.rs b/src/test/compile-fail/empty-struct-unit-pat.rs new file mode 100644 index 0000000000000..966a2780f9f8c --- /dev/null +++ b/src/test/compile-fail/empty-struct-unit-pat.rs @@ -0,0 +1,40 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Can't use unit struct as enum pattern + +#![feature(braced_empty_structs)] + +FIXME //~ ERROR expected item, found `FIXME` + +struct Empty1; + +enum E { + Empty2 +} + +fn main() { + let e1 = Empty1; + let e2 = E::Empty2; + + // Issue #28692 + // match e1 { + // Empty1() => () // ERROR variable `Empty1` should have a snake case name + // } + // match e1 { + // Empty1(..) => () // ERROR variable `Empty1` should have a snake case name + // } + // match e2 { + // E::Empty2() => () // ERROR variable `Empty2` should have a snake case name + // } + // match e2 { + // E::Empty2(..) => () // ERROR variable `Empty2` should have a snake case name + // } +} diff --git a/src/test/compile-fail/issue-16819.rs b/src/test/compile-fail/issue-16819.rs new file mode 100644 index 0000000000000..065b29d29aca5 --- /dev/null +++ b/src/test/compile-fail/issue-16819.rs @@ -0,0 +1,18 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +struct TS ( //~ ERROR empty tuple structs and enum variants are not allowed + #[cfg(untrue)] + int, +); + +fn main() { + let s = S; +} diff --git a/src/test/compile-fail/issue-27831.rs b/src/test/compile-fail/issue-27831.rs index 533387c576008..3cdb370f0e94c 100644 --- a/src/test/compile-fail/issue-27831.rs +++ b/src/test/compile-fail/issue-27831.rs @@ -22,8 +22,8 @@ fn main() { let Foo { .. } = x; //~ ERROR `Foo` does not name a struct let x = Bar; - Bar { ..x }; - let Bar { .. } = x; + Bar { ..x }; //~ ERROR empty structs and enum variants with braces are unstable + let Bar { .. } = x; //~ ERROR empty structs and enum variants with braces are unstable match Enum::Bar { Enum::Bar { .. } //~ ERROR `Enum::Bar` does not name a struct diff --git a/src/test/parse-fail/struct-no-fields-enumlike.rs b/src/test/compile-fail/struct-no-fields-enumlike.rs similarity index 80% rename from src/test/parse-fail/struct-no-fields-enumlike.rs rename to src/test/compile-fail/struct-no-fields-enumlike.rs index 19a395806d6cf..6bdbae1e4b9d9 100644 --- a/src/test/parse-fail/struct-no-fields-enumlike.rs +++ b/src/test/compile-fail/struct-no-fields-enumlike.rs @@ -8,8 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// compile-flags: -Z parse-only - -struct Foo(); //~ ERROR unit-like struct definition should be written as `struct Foo;` +struct Foo(); //~ ERROR empty tuple structs and enum variants are not allowed fn main() {} diff --git a/src/test/run-pass/empty-struct-with-braces.rs b/src/test/run-pass/empty-struct-braces.rs similarity index 55% rename from src/test/run-pass/empty-struct-with-braces.rs rename to src/test/run-pass/empty-struct-braces.rs index dc806acb980dd..f2fbf2dd337e7 100644 --- a/src/test/run-pass/empty-struct-with-braces.rs +++ b/src/test/run-pass/empty-struct-braces.rs @@ -18,39 +18,71 @@ struct Empty2; struct Empty3 {} const Empty3: Empty3 = Empty3 {}; +enum E { + Empty4 {}, + Empty5, +} + fn main() { let e1: Empty1 = Empty1 {}; let e2: Empty2 = Empty2 {}; let e2: Empty2 = Empty2; let e3: Empty3 = Empty3 {}; let e3: Empty3 = Empty3; + let e4: E = E::Empty4 {}; + // let e5: E = E::Empty5 {}; // Issue #28692 + let e5: E = E::Empty5; match e1 { - Empty1 {} => () - } - match e2 { - Empty2 {} => () + Empty1 {} => {} } match e2 { - Empty2 => () + Empty2 {} => {} } match e3 { - Empty3 {} => () + Empty3 {} => {} } - match e3 { - Empty3 => () + match e4 { + E::Empty4 {} => {} + _ => {} } + // Issue #28692 + // match e5 { + // E::Empty5 {} => {} + // _ => {} + // } + match e1 { - Empty1 { .. } => () + Empty1 { .. } => {} } match e2 { - Empty2 { .. } => () + Empty2 { .. } => {} } match e3 { - Empty3 { .. } => () + Empty3 { .. } => {} + } + match e4 { + E::Empty4 { .. } => {} + _ => {} + } + // Issue #28692 + // match e5 { + // E::Empty5 { .. } => {} + // _ => {} + // } + + match e2 { + Empty2 => {} + } + match e3 { + Empty3 => {} + } + match e5 { + E::Empty5 => {} + _ => {} } - let e11 = Empty1 { ..e1 }; - let e22 = Empty2 { ..e2 }; - let e33 = Empty3 { ..e3 }; + let e11: Empty1 = Empty1 { ..e1 }; + let e22: Empty2 = Empty2 { ..e2 }; + let e33: Empty3 = Empty3 { ..e3 }; } From b404ded15b0873696181114766967e2e154a6425 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sat, 3 Oct 2015 00:18:48 +0300 Subject: [PATCH 07/13] Fix failing privacy test --- src/librustc_privacy/lib.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 6ff8239d3aedb..bc9727c580705 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -1439,11 +1439,11 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> { } fn visit_struct_field(&mut self, s: &hir::StructField) { - match s.node.kind { - hir::NamedField(_, vis) if vis == hir::Public || self.in_variant => { - visit::walk_struct_field(self, s); - } - _ => {} + let vis = match s.node.kind { + hir::NamedField(_, vis) | hir::UnnamedField(vis) => vis + }; + if vis == hir::Public || self.in_variant { + visit::walk_struct_field(self, s); } } From f4e3851aa7bbd49294c20cc63eef9974f20192c8 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sun, 4 Oct 2015 13:11:56 +0300 Subject: [PATCH 08/13] Fix rebase --- src/librustc/metadata/encoder.rs | 4 ++-- src/librustc/middle/astencode.rs | 4 ++-- src/librustc_typeck/collect.rs | 9 ++++++--- 3 files changed, 10 insertions(+), 7 deletions(-) diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 75cc04a98c66f..2ea4f694ec4bb 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -1068,8 +1068,8 @@ fn encode_info_for_item<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, // Encode inherent implementations for this structure. encode_inherent_implementations(ecx, rbml_w, def_id); - if let Some(ctor_id) = struct_def.ctor_id { - let ctor_did = ecx.tcx.map.local_def_id(ctor_id); + if struct_def.kind != hir::VariantKind::Dict { + 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)); } diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 3b4cb56ec741f..20ffa8c3e9548 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -1316,11 +1316,11 @@ fn copy_item_types(dcx: &DecodeContext, ii: &InlinedItem, orig_did: DefId) { { debug!("astencode: copying variant {:?} => {:?}", orig_variant.did, i_variant.node.id); - copy_item_type(dcx, i_variant.node.id, orig_variant.did); + copy_item_type(dcx, i_variant.node.def.id, orig_variant.did); } } hir::ItemStruct(ref def, _) => { - if let Some(ctor_id) = def.ctor_id { + if def.kind != hir::VariantKind::Dict { let ctor_did = dcx.tcx.lookup_adt_def(orig_did) .struct_variant().did; debug!("astencode: copying ctor {:?} => {:?}", ctor_did, diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index decc269442d81..a52226db4aa62 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -1125,8 +1125,11 @@ fn convert_struct_def<'tcx>(tcx: &ty::ctxt<'tcx>, { let did = tcx.map.local_def_id(it.id); - let ctor_id = def.ctor_id.map_or(did, - |ctor_id| tcx.map.local_def_id(ctor_id)); + let ctor_id = if def.kind != hir::VariantKind::Dict { + tcx.map.local_def_id(def.id) + } else { + did + }; tcx.intern_adt_def( did, ty::AdtKind::Struct, @@ -1208,7 +1211,7 @@ fn convert_enum_def<'tcx>(tcx: &ty::ctxt<'tcx>, { let did = tcx.map.local_def_id(v.node.def.id); let name = v.node.name; - convert_struct_variant(tcx, did, name, disr, &v.node.def) + convert_struct_variant(tcx, did, name, disr, &v.node.def, did) } let did = tcx.map.local_def_id(it.id); let repr_hints = tcx.lookup_repr_hints(did); From 30af54dede8b9f03a83dd5ad588bb430a5a76270 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Thu, 8 Oct 2015 03:20:57 +0300 Subject: [PATCH 09/13] Dict -> Struct, StructDef -> VariantData, def -> data --- src/librustc/front/map/collector.rs | 6 ++--- src/librustc/front/map/mod.rs | 10 ++++---- src/librustc/lint/context.rs | 8 +++---- src/librustc/lint/mod.rs | 8 +++---- src/librustc/metadata/encoder.rs | 10 ++++---- src/librustc/middle/astencode.rs | 4 ++-- src/librustc/middle/check_match.rs | 2 +- src/librustc/middle/check_static_recursion.rs | 6 ++--- src/librustc/middle/const_eval.rs | 2 +- src/librustc/middle/dead.rs | 10 ++++---- src/librustc/middle/def.rs | 4 ++-- src/librustc/middle/stability.rs | 4 ++-- src/librustc/middle/ty/mod.rs | 4 ++-- src/librustc_back/svh.rs | 2 +- src/librustc_front/fold.rs | 14 +++++------ src/librustc_front/hir.rs | 8 +++---- src/librustc_front/lowering.rs | 8 +++---- src/librustc_front/print/pprust.rs | 6 ++--- src/librustc_front/util.rs | 4 ++-- src/librustc_front/visit.rs | 8 +++---- src/librustc_lint/bad_style.rs | 2 +- src/librustc_lint/builtin.rs | 6 ++--- src/librustc_privacy/lib.rs | 16 ++++++------- src/librustc_resolve/build_reduced_graph.rs | 12 +++++----- src/librustc_resolve/lib.rs | 2 +- src/librustc_trans/save/dump_csv.rs | 10 ++++---- src/librustc_trans/trans/base.rs | 6 ++--- src/librustc_trans/trans/callee.rs | 2 +- src/librustc_trans/trans/consts.rs | 2 +- .../trans/debuginfo/metadata.rs | 4 ++-- src/librustc_trans/trans/inline.rs | 6 ++--- src/librustc_trans/trans/monomorphize.rs | 2 +- src/librustc_typeck/check/mod.rs | 2 +- src/librustc_typeck/check/wf.rs | 4 ++-- src/librustc_typeck/check/wfcheck.rs | 4 ++-- src/librustc_typeck/collect.rs | 18 +++++++------- src/librustdoc/clean/mod.rs | 8 +++---- src/librustdoc/doctree.rs | 6 ++--- src/librustdoc/visit_ast.rs | 10 ++++---- src/libsyntax/ast.rs | 8 +++---- src/libsyntax/ast_util.rs | 4 ++-- src/libsyntax/config.rs | 10 ++++---- src/libsyntax/ext/build.rs | 10 ++++---- src/libsyntax/ext/deriving/generic/mod.rs | 24 +++++++++---------- src/libsyntax/ext/deriving/primitive.rs | 2 +- src/libsyntax/feature_gate.rs | 4 ++-- src/libsyntax/fold.rs | 12 +++++----- src/libsyntax/parse/parser.rs | 22 ++++++++--------- src/libsyntax/print/pprust.rs | 8 +++---- src/libsyntax/visit.rs | 8 +++---- 50 files changed, 181 insertions(+), 181 deletions(-) diff --git a/src/librustc/front/map/collector.rs b/src/librustc/front/map/collector.rs index 3d45c52171fa0..a3542ff9b1077 100644 --- a/src/librustc/front/map/collector.rs +++ b/src/librustc/front/map/collector.rs @@ -134,11 +134,11 @@ 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.def.id, + self.insert_def(v.node.data.id, NodeVariant(&**v), DefPathData::EnumVariant(v.node.name)); - for field in &v.node.def.fields { + for field in &v.node.data.fields { self.create_def_with_parent( Some(variant_def_index), field.node.id, @@ -150,7 +150,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.kind != VariantKind::Dict { + if struct_def.kind != VariantKind::Struct { self.insert_def(struct_def.id, NodeStructCtor(&**struct_def), DefPathData::StructCtor); diff --git a/src/librustc/front/map/mod.rs b/src/librustc/front/map/mod.rs index b183f12a092cf..1e31bfe9acabf 100644 --- a/src/librustc/front/map/mod.rs +++ b/src/librustc/front/map/mod.rs @@ -124,7 +124,7 @@ pub enum Node<'ast> { NodeBlock(&'ast Block), /// NodeStructCtor represents a tuple struct. - NodeStructCtor(&'ast StructDef), + NodeStructCtor(&'ast VariantData), NodeLifetime(&'ast Lifetime), NodeTyParam(&'ast TyParam) @@ -149,7 +149,7 @@ pub enum MapEntry<'ast> { EntryLocal(NodeId, &'ast Pat), EntryPat(NodeId, &'ast Pat), EntryBlock(NodeId, &'ast Block), - EntryStructCtor(NodeId, &'ast StructDef), + EntryStructCtor(NodeId, &'ast VariantData), EntryLifetime(NodeId, &'ast Lifetime), EntryTyParam(NodeId, &'ast TyParam), @@ -471,7 +471,7 @@ impl<'ast> Map<'ast> { } } - pub fn expect_struct(&self, id: NodeId) -> &'ast StructDef { + pub fn expect_struct(&self, id: NodeId) -> &'ast VariantData { match self.find(id) { Some(NodeItem(i)) => { match i.node { @@ -480,8 +480,8 @@ impl<'ast> Map<'ast> { } } Some(NodeVariant(variant)) => { - match variant.node.def.kind { - VariantKind::Dict => &variant.node.def, + match variant.node.data.kind { + VariantKind::Struct => &variant.node.data, _ => panic!("struct ID bound to enum variant that isn't struct-like"), } } diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index dcccd9f2c9770..f5c6cfe2437dc 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -661,8 +661,8 @@ impl<'a, 'tcx, 'v> hir_visit::Visitor<'v> for LateContext<'a, 'tcx> { hir_visit::walk_fn(self, fk, decl, body, span); } - fn visit_struct_def(&mut self, - s: &hir::StructDef, + fn visit_variant_data(&mut self, + s: &hir::VariantData, name: ast::Name, g: &hir::Generics, item_id: ast::NodeId, @@ -811,8 +811,8 @@ impl<'a, 'v> ast_visit::Visitor<'v> for EarlyContext<'a> { ast_visit::walk_fn(self, fk, decl, body, span); } - fn visit_struct_def(&mut self, - s: &ast::StructDef, + fn visit_variant_data(&mut self, + s: &ast::VariantData, ident: ast::Ident, g: &ast::Generics, item_id: ast::NodeId, diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs index 5c316b58303fe..14c11af6f3863 100644 --- a/src/librustc/lint/mod.rs +++ b/src/librustc/lint/mod.rs @@ -150,9 +150,9 @@ pub trait LateLintPass: LintPass { fn check_trait_item(&mut self, _: &LateContext, _: &hir::TraitItem) { } fn check_impl_item(&mut self, _: &LateContext, _: &hir::ImplItem) { } fn check_struct_def(&mut self, _: &LateContext, - _: &hir::StructDef, _: ast::Name, _: &hir::Generics, _: ast::NodeId) { } + _: &hir::VariantData, _: ast::Name, _: &hir::Generics, _: ast::NodeId) { } fn check_struct_def_post(&mut self, _: &LateContext, - _: &hir::StructDef, _: ast::Name, _: &hir::Generics, _: ast::NodeId) { } + _: &hir::VariantData, _: ast::Name, _: &hir::Generics, _: ast::NodeId) { } fn check_struct_field(&mut self, _: &LateContext, _: &hir::StructField) { } fn check_variant(&mut self, _: &LateContext, _: &hir::Variant, _: &hir::Generics) { } fn check_variant_post(&mut self, _: &LateContext, _: &hir::Variant, _: &hir::Generics) { } @@ -192,9 +192,9 @@ pub trait EarlyLintPass: LintPass { fn check_trait_item(&mut self, _: &EarlyContext, _: &ast::TraitItem) { } fn check_impl_item(&mut self, _: &EarlyContext, _: &ast::ImplItem) { } fn check_struct_def(&mut self, _: &EarlyContext, - _: &ast::StructDef, _: ast::Ident, _: &ast::Generics, _: ast::NodeId) { } + _: &ast::VariantData, _: ast::Ident, _: &ast::Generics, _: ast::NodeId) { } fn check_struct_def_post(&mut self, _: &EarlyContext, - _: &ast::StructDef, _: ast::Ident, _: &ast::Generics, _: ast::NodeId) { } + _: &ast::VariantData, _: ast::Ident, _: &ast::Generics, _: ast::NodeId) { } fn check_struct_field(&mut self, _: &EarlyContext, _: &ast::StructField) { } fn check_variant(&mut self, _: &EarlyContext, _: &ast::Variant, _: &ast::Generics) { } fn check_variant_post(&mut self, _: &EarlyContext, _: &ast::Variant, _: &ast::Generics) { } diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 2ea4f694ec4bb..2bee3f296c9cc 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -315,7 +315,7 @@ fn encode_enum_variant_info<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, let vid = variant.did; let variant_node_id = ecx.local_id(vid); - if let ty::VariantKind::Dict = variant.kind() { + if let ty::VariantKind::Struct = variant.kind() { // tuple-like enum variant fields aren't really items so // don't try to encode them. for field in &variant.fields { @@ -328,7 +328,7 @@ fn encode_enum_variant_info<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, encode_def_id_and_key(ecx, rbml_w, vid); encode_family(rbml_w, match variant.kind() { ty::VariantKind::Unit | ty::VariantKind::Tuple => 'v', - ty::VariantKind::Dict => 'V' + ty::VariantKind::Struct => 'V' }); encode_name(rbml_w, variant.name); encode_parent_item(rbml_w, ecx.tcx.map.local_def_id(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.def.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); @@ -1068,7 +1068,7 @@ fn encode_info_for_item<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, // Encode inherent implementations for this structure. encode_inherent_implementations(ecx, rbml_w, def_id); - if struct_def.kind != hir::VariantKind::Dict { + if struct_def.kind != hir::VariantKind::Struct { 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)); @@ -1081,7 +1081,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.kind != hir::VariantKind::Dict { + if struct_def.kind != hir::VariantKind::Struct { encode_info_for_struct_ctor(ecx, rbml_w, item.name, struct_def.id, index, item.id); } } diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 20ffa8c3e9548..9bf70cce602ee 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -1316,11 +1316,11 @@ fn copy_item_types(dcx: &DecodeContext, ii: &InlinedItem, orig_did: DefId) { { debug!("astencode: copying variant {:?} => {:?}", orig_variant.did, i_variant.node.id); - copy_item_type(dcx, i_variant.node.def.id, orig_variant.did); + copy_item_type(dcx, i_variant.node.data.id, orig_variant.did); } } hir::ItemStruct(ref def, _) => { - if def.kind != hir::VariantKind::Dict { + if def.kind != hir::VariantKind::Struct { let ctor_did = dcx.tcx.lookup_adt_def(orig_did) .struct_variant().did; debug!("astencode: copying ctor {:?} => {:?}", ctor_did, diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index a8f20815a9a8b..4d7dd60a27156 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -518,7 +518,7 @@ fn construct_witness<'a,'tcx>(cx: &MatchCheckCtxt<'a,'tcx>, ctor: &Constructor, ty::TyEnum(adt, _) | ty::TyStruct(adt, _) => { let v = adt.variant_of_ctor(ctor); - if let VariantKind::Dict = v.kind() { + if let VariantKind::Struct = v.kind() { let field_pats: Vec<_> = v.fields.iter() .zip(pats) .filter(|&(_, ref pat)| pat.node != hir::PatWild(hir::PatWildSingle)) diff --git a/src/librustc/middle/check_static_recursion.rs b/src/librustc/middle/check_static_recursion.rs index 152f2e92490be..226c27ea62048 100644 --- a/src/librustc/middle/check_static_recursion.rs +++ b/src/librustc/middle/check_static_recursion.rs @@ -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.def.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 = Vec::new(); for variant in enum_definition.variants.iter().rev() { - variant_stack.push(variant.node.def.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.def.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` diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 550094d2746b3..e0850a55ff0aa 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -63,7 +63,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt, fn variant_expr<'a>(variants: &'a [P], id: ast::NodeId) -> Option<&'a Expr> { for variant in variants { - if variant.node.def.id == id { + if variant.node.data.id == id { return variant.node.disr_expr.as_ref().map(|e| &**e); } } diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 8b52536a4a02b..d0d6cf39af761 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -215,7 +215,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { impl<'a, 'tcx, 'v> Visitor<'v> for MarkSymbolVisitor<'a, 'tcx> { - fn visit_struct_def(&mut self, def: &hir::StructDef, _: ast::Name, + fn visit_variant_data(&mut self, def: &hir::VariantData, _: ast::Name, _: &hir::Generics, _: ast::NodeId, _: codemap::Span) { let has_extern_repr = self.struct_has_extern_repr; let inherited_pub_visibility = self.inherited_pub_visibility; @@ -339,7 +339,7 @@ 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.def.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 { @@ -426,7 +426,7 @@ fn find_live(tcx: &ty::ctxt, fn get_struct_ctor_id(item: &hir::Item) -> Option { match item.node { - hir::ItemStruct(ref struct_def, _) if struct_def.kind != hir::VariantKind::Dict => { + hir::ItemStruct(ref struct_def, _) if struct_def.kind != hir::VariantKind::Struct => { Some(struct_def.id) } _ => None @@ -466,7 +466,7 @@ impl<'a, 'tcx> DeadVisitor<'a, 'tcx> { } fn should_warn_about_variant(&mut self, variant: &hir::Variant_) -> bool { - !self.symbol_is_live(variant.def.id, None) + !self.symbol_is_live(variant.data.id, None) && !has_allow_dead_code_or_lang_attr(&variant.attrs) } @@ -542,7 +542,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.def.id, variant.span, + self.warn_dead_code(variant.node.data.id, variant.span, variant.node.name, "variant"); } } diff --git a/src/librustc/middle/def.rs b/src/librustc/middle/def.rs index 3e8325b86121d..ef2b918a9f5d7 100644 --- a/src/librustc/middle/def.rs +++ b/src/librustc/middle/def.rs @@ -44,13 +44,13 @@ pub enum Def { ast::NodeId), // expr node that creates the closure /// Note that if it's a tuple struct's definition, the node id of the DefId - /// may either refer to the item definition's id or the StructDef.ctor_id. + /// may either refer to the item definition's id or the VariantData.ctor_id. /// /// The cases that I have encountered so far are (this is not exhaustive): /// - If it's a ty_path referring to some tuple struct, then DefMap maps /// it to a def whose id is the item definition's id. /// - If it's an ExprPath referring to some tuple struct, then DefMap maps - /// it to a def whose id is the StructDef.ctor_id. + /// it to a def whose id is the VariantData.ctor_id. DefStruct(DefId), DefLabel(ast::NodeId), DefMethod(DefId), diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index 5a83899e02b6b..df5582e9414c1 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -185,7 +185,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Annotator<'a, 'tcx> { |v| visit::walk_item(v, i), required); if let hir::ItemStruct(ref sd, _) = i.node { - if sd.kind != hir::VariantKind::Dict { + if sd.kind != hir::VariantKind::Struct { 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.def.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) } diff --git a/src/librustc/middle/ty/mod.rs b/src/librustc/middle/ty/mod.rs index 4ffb519900356..975a5adad2bd2 100644 --- a/src/librustc/middle/ty/mod.rs +++ b/src/librustc/middle/ty/mod.rs @@ -1533,7 +1533,7 @@ impl<'tcx, 'container> Hash for AdtDefData<'tcx, 'container> { pub enum AdtKind { Struct, Enum } #[derive(Copy, Clone, Debug, Eq, PartialEq)] -pub enum VariantKind { Dict, Tuple, Unit } +pub enum VariantKind { Struct, Tuple, Unit } impl<'tcx, 'container> AdtDefData<'tcx, 'container> { fn new(tcx: &ctxt<'tcx>, @@ -1716,7 +1716,7 @@ impl<'tcx, 'container> VariantDefData<'tcx, 'container> { Some(&FieldDefData { name, .. }) if name == special_idents::unnamed_field.name => { VariantKind::Tuple } - Some(_) => VariantKind::Dict + Some(_) => VariantKind::Struct } } diff --git a/src/librustc_back/svh.rs b/src/librustc_back/svh.rs index 4b235534bf338..a9cfc7138d8d9 100644 --- a/src/librustc_back/svh.rs +++ b/src/librustc_back/svh.rs @@ -301,7 +301,7 @@ mod svh_visitor { } impl<'a, 'v> Visitor<'v> for StrictVersionHashVisitor<'a> { - fn visit_struct_def(&mut self, s: &StructDef, name: Name, + fn visit_variant_data(&mut self, s: &VariantData, name: Name, g: &Generics, _: NodeId, _: Span) { SawStructDef(name.as_str()).hash(self.st); visit::walk_generics(self, g); diff --git a/src/librustc_front/fold.rs b/src/librustc_front/fold.rs index 2cd49bedae3f2..ecea50f8495fe 100644 --- a/src/librustc_front/fold.rs +++ b/src/librustc_front/fold.rs @@ -223,7 +223,7 @@ pub trait Folder : Sized { noop_fold_poly_trait_ref(p, self) } - fn fold_struct_def(&mut self, struct_def: P) -> P { + fn fold_variant_data(&mut self, struct_def: P) -> P { noop_fold_struct_def(struct_def, self) } @@ -431,11 +431,11 @@ pub fn noop_fold_foreign_mod(ForeignMod { abi, items }: ForeignMod, } pub fn noop_fold_variant(v: P, fld: &mut T) -> P { - v.map(|Spanned {node: Variant_ {name, attrs, def, disr_expr}, span}| Spanned { + v.map(|Spanned {node: Variant_ {name, attrs, data, disr_expr}, span}| Spanned { node: Variant_ { name: name, attrs: fold_attrs(attrs, fld), - def: fld.fold_struct_def(def), + data: fld.fold_variant_data(data), disr_expr: disr_expr.map(|e| fld.fold_expr(e)), }, span: fld.new_span(span), @@ -693,9 +693,9 @@ pub fn noop_fold_where_predicate(pred: WherePredicate, fld: &mut T) - } } -pub fn noop_fold_struct_def(struct_def: P, fld: &mut T) -> P { - struct_def.map(|StructDef { fields, id, kind }| { - StructDef { +pub fn noop_fold_struct_def(struct_def: P, fld: &mut T) -> P { + struct_def.map(|VariantData { fields, id, kind }| { + VariantData { fields: fields.move_map(|f| fld.fold_struct_field(f)), id: fld.new_id(id), kind: kind, @@ -806,7 +806,7 @@ pub fn noop_fold_item_underscore(i: Item_, folder: &mut T) -> Item_ { folder.fold_generics(generics)) } ItemStruct(struct_def, generics) => { - let struct_def = folder.fold_struct_def(struct_def); + let struct_def = folder.fold_variant_data(struct_def); ItemStruct(struct_def, folder.fold_generics(generics)) } ItemDefaultImpl(unsafety, ref trait_ref) => { diff --git a/src/librustc_front/hir.rs b/src/librustc_front/hir.rs index b55bfc395b4ab..92a52c38176a4 100644 --- a/src/librustc_front/hir.rs +++ b/src/librustc_front/hir.rs @@ -1023,7 +1023,7 @@ pub struct EnumDef { pub struct Variant_ { pub name: Name, pub attrs: Vec, - pub def: P, + pub data: P, /// Explicit discriminant, eg `Foo = 1` pub disr_expr: Option>, } @@ -1162,13 +1162,13 @@ impl StructFieldKind { #[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub enum VariantKind { - Dict, + Struct, Tuple, Unit, } #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] -pub struct StructDef { +pub struct VariantData { /// Fields, not including ctor pub fields: Vec, /// ID of the constructor. This is only used for tuple- or enum-like @@ -1218,7 +1218,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(P, Generics), /// Represents a Trait Declaration ItemTrait(Unsafety, Generics, TyParamBounds, Vec>), diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs index 9633fbf6732f8..ecbfbd1362eb5 100644 --- a/src/librustc_front/lowering.rs +++ b/src/librustc_front/lowering.rs @@ -266,7 +266,7 @@ pub fn lower_variant(_lctx: &LoweringContext, v: &Variant) -> P { node: hir::Variant_ { name: v.node.name.name, attrs: v.node.attrs.clone(), - def: lower_struct_def(_lctx, &v.node.def), + data: lower_struct_def(_lctx, &v.node.data), disr_expr: v.node.disr_expr.as_ref().map(|e| lower_expr(e)), }, span: v.span, @@ -498,12 +498,12 @@ pub fn lower_where_predicate(_lctx: &LoweringContext, } } -pub fn lower_struct_def(_lctx: &LoweringContext, sd: &StructDef) -> P { - P(hir::StructDef { +pub fn lower_struct_def(sd: &VariantData) -> P { + P(hir::VariantData { fields: sd.fields.iter().map(|f| lower_struct_field(_lctx, f)).collect(), id: sd.id, kind: match sd.kind { - VariantKind::Dict => hir::VariantKind::Dict, + VariantKind::Struct => hir::VariantKind::Struct, VariantKind::Tuple => hir::VariantKind::Tuple, VariantKind::Unit => hir::VariantKind::Unit, } diff --git a/src/librustc_front/print/pprust.rs b/src/librustc_front/print/pprust.rs index 8d4422011f00a..948134c8025d3 100644 --- a/src/librustc_front/print/pprust.rs +++ b/src/librustc_front/print/pprust.rs @@ -888,7 +888,7 @@ impl<'a> State<'a> { } pub fn print_struct(&mut self, - struct_def: &hir::StructDef, + struct_def: &hir::VariantData, generics: &hir::Generics, name: ast::Name, span: codemap::Span, @@ -896,7 +896,7 @@ impl<'a> State<'a> { -> io::Result<()> { try!(self.print_name(name)); try!(self.print_generics(generics)); - if struct_def.kind != hir::VariantKind::Dict { + if struct_def.kind != hir::VariantKind::Struct { if struct_def.kind == hir::VariantKind::Tuple { try!(self.popen()); try!(self.commasep(Inconsistent, @@ -948,7 +948,7 @@ impl<'a> State<'a> { pub fn print_variant(&mut self, v: &hir::Variant) -> io::Result<()> { try!(self.head("")); let generics = ::util::empty_generics(); - try!(self.print_struct(&v.node.def, &generics, v.node.name, v.span, false)); + try!(self.print_struct(&v.node.data, &generics, v.node.name, v.span, false)); match v.node.disr_expr { Some(ref d) => { try!(space(&mut self.s)); diff --git a/src/librustc_front/util.rs b/src/librustc_front/util.rs index 16299a83c6687..8bf3ccd0b810c 100644 --- a/src/librustc_front/util.rs +++ b/src/librustc_front/util.rs @@ -281,8 +281,8 @@ impl<'a, 'v, O: ast_util::IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> visit::walk_struct_field(self, struct_field) } - fn visit_struct_def(&mut self, - struct_def: &StructDef, + fn visit_variant_data(&mut self, + struct_def: &VariantData, _: Name, _: &hir::Generics, _: NodeId, diff --git a/src/librustc_front/visit.rs b/src/librustc_front/visit.rs index 2bbaeaefa0fab..8472bef3cd108 100644 --- a/src/librustc_front/visit.rs +++ b/src/librustc_front/visit.rs @@ -112,7 +112,7 @@ pub trait Visitor<'v> : Sized { fn visit_poly_trait_ref(&mut self, t: &'v PolyTraitRef, m: &'v TraitBoundModifier) { walk_poly_trait_ref(self, t, m) } - fn visit_struct_def(&mut self, s: &'v StructDef, _: Name, + fn visit_variant_data(&mut self, s: &'v VariantData, _: Name, _: &'v Generics, _: NodeId, _: Span) { walk_struct_def(self, s) } @@ -310,7 +310,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) { } ItemStruct(ref struct_definition, ref generics) => { visitor.visit_generics(generics); - visitor.visit_struct_def(struct_definition, item.name, + visitor.visit_variant_data(struct_definition, item.name, generics, item.id, item.span); } ItemTrait(_, ref generics, ref bounds, ref methods) => { @@ -336,7 +336,7 @@ pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics, item_id: NodeId) { visitor.visit_name(variant.span, variant.node.name); - visitor.visit_struct_def(&variant.node.def, variant.node.name, + visitor.visit_variant_data(&variant.node.data, variant.node.name, generics, item_id, variant.span); walk_list!(visitor, visit_expr, &variant.node.disr_expr); walk_list!(visitor, visit_attribute, &variant.node.attrs); @@ -628,7 +628,7 @@ pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplIt } } -pub fn walk_struct_def<'v, V: Visitor<'v>>(visitor: &mut V, struct_definition: &'v StructDef) { +pub fn walk_struct_def<'v, V: Visitor<'v>>(visitor: &mut V, struct_definition: &'v VariantData) { walk_list!(visitor, visit_struct_field, &struct_definition.fields); } diff --git a/src/librustc_lint/bad_style.rs b/src/librustc_lint/bad_style.rs index 91d1d398a0e54..6b6b90b1ba66f 100644 --- a/src/librustc_lint/bad_style.rs +++ b/src/librustc_lint/bad_style.rs @@ -280,7 +280,7 @@ impl LateLintPass for NonSnakeCase { } } - fn check_struct_def(&mut self, cx: &LateContext, s: &hir::StructDef, + fn check_struct_def(&mut self, cx: &LateContext, s: &hir::VariantData, _: ast::Name, _: &hir::Generics, _: ast::NodeId) { for sf in &s.fields { if let hir::StructField_ { kind: hir::NamedField(name, _), .. } = sf.node { diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index c9889ee47a6b3..df15dbe4d6ca2 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -427,12 +427,12 @@ impl LateLintPass for MissingDoc { self.doc_hidden_stack.pop().expect("empty doc_hidden_stack"); } - fn check_struct_def(&mut self, _: &LateContext, _: &hir::StructDef, + fn check_struct_def(&mut self, _: &LateContext, _: &hir::VariantData, _: ast::Name, _: &hir::Generics, item_id: ast::NodeId) { self.struct_def_stack.push(item_id); } - fn check_struct_def_post(&mut self, _: &LateContext, _: &hir::StructDef, + fn check_struct_def_post(&mut self, _: &LateContext, _: &hir::VariantData, _: ast::Name, _: &hir::Generics, item_id: ast::NodeId) { let popped = self.struct_def_stack.pop().expect("empty struct_def_stack"); assert!(popped == item_id); @@ -527,7 +527,7 @@ 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.def.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; } diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index bc9727c580705..e1e51ae666ba7 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -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.def.id, item.id); + self.parents.insert(variant.node.data.id, item.id); } } @@ -128,11 +128,11 @@ impl<'v> Visitor<'v> for ParentVisitor { visit::walk_impl_item(self, ii); } - fn visit_struct_def(&mut self, s: &hir::StructDef, _: ast::Name, + fn visit_variant_data(&mut self, s: &hir::VariantData, _: ast::Name, _: &'v hir::Generics, item_id: ast::NodeId, _: Span) { // Struct constructors are parented to their struct definitions because // they essentially are the struct definitions. - if s.kind != hir::VariantKind::Dict { + if s.kind != hir::VariantKind::Struct { self.parents.insert(s.id, item_id); } @@ -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.def.id); - self.public_items.insert(variant.node.def.id); + self.exported_items.insert(variant.node.data.id); + self.public_items.insert(variant.node.data.id); } } @@ -319,7 +319,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.kind != hir::VariantKind::Dict { + if def.kind != hir::VariantKind::Struct { self.exported_items.insert(def.id); } // fields can be public or private, so lets check @@ -1088,7 +1088,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { "visibility has no effect inside functions"); } } - let check_struct = |def: &hir::StructDef| { + let check_struct = |def: &hir::VariantData| { for f in &def.fields { match f.node.kind { hir::NamedField(_, p) => check_inherited(tcx, f.span, p), @@ -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.def.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; diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 9f19e178a0dd7..4484cfe95900a 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -493,7 +493,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { ItemStruct(ref struct_def, _) => { // Adding to both Type and Value namespaces or just Type? let (forbid, ctor_id) = match struct_def.kind { - hir::VariantKind::Dict => (ForbidDuplicateTypesAndModules, None), + hir::VariantKind::Struct => (ForbidDuplicateTypesAndModules, None), _ => (ForbidDuplicateTypesAndValues, Some(struct_def.id)), }; @@ -587,10 +587,10 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { item_id: DefId, parent: &Rc) { let name = variant.node.name; - let is_exported = match variant.node.def.kind { - hir::VariantKind::Dict => { + let is_exported = match variant.node.data.kind { + hir::VariantKind::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.def.id); + let variant_def_id = self.ast_map.local_def_id(variant.node.data.id); self.structs.insert(variant_def_id, Vec::new()); true } @@ -603,10 +603,10 @@ 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.def.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.def.id), is_exported), + self.ast_map.local_def_id(variant.node.data.id), is_exported), variant.span, DefModifiers::PUBLIC | DefModifiers::IMPORTABLE); } diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index b71f89a75be99..ac09534f1e0e5 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -501,7 +501,7 @@ impl<'a, 'v, 'tcx> Visitor<'v> for Resolver<'a, 'tcx> { } // `visit::walk_variant` without the discriminant expression. - self.visit_struct_def(&variant.node.def, variant.node.name, + self.visit_variant_data(&variant.node.data, variant.node.name, generics, item_id, variant.span); } fn visit_foreign_item(&mut self, foreign_item: &hir::ForeignItem) { diff --git a/src/librustc_trans/save/dump_csv.rs b/src/librustc_trans/save/dump_csv.rs index c366872362020..5235bd49a2875 100644 --- a/src/librustc_trans/save/dump_csv.rs +++ b/src/librustc_trans/save/dump_csv.rs @@ -458,7 +458,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { fn process_struct(&mut self, item: &ast::Item, - def: &ast::StructDef, + def: &ast::VariantData, ty_params: &ast::Generics) { let qualname = format!("::{}", self.tcx.map.path_to_string(item.id)); @@ -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.def.id, - variant.node.def.id, + variant.node.data.id, + variant.node.data.id, &qualname, &enum_data.qualname, &val, enum_data.id); - for field in &variant.node.def.fields { - self.process_struct_field_def(field, variant.node.def.id); + for field in &variant.node.data.fields { + self.process_struct_field_def(field, variant.node.data.id); self.visit_ty(&*field.node.ty); } } diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index 06cb8de054229..d7ace6e2541d0 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -2428,10 +2428,10 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { hir_map::NodeVariant(ref v) => { let llfn; - let fields = if v.node.def.kind == hir::VariantKind::Dict { + let fields = if v.node.data.kind == hir::VariantKind::Struct { ccx.sess().bug("struct variant kind unexpected in get_item_val") } else { - &v.node.def.fields + &v.node.data.fields }; assert!(!fields.is_empty()); let ty = ccx.tcx().node_id_to_type(id); @@ -2455,7 +2455,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { hir_map::NodeStructCtor(struct_def) => { // Only register the constructor if this is a tuple-like struct. let ctor_id = match struct_def.kind { - hir::VariantKind::Dict => { + hir::VariantKind::Struct => { ccx.sess().bug("attempt to register a constructor of \ a non-tuple-like struct") } diff --git a/src/librustc_trans/trans/callee.rs b/src/librustc_trans/trans/callee.rs index fdcc2623ef104..455eb70929188 100644 --- a/src/librustc_trans/trans/callee.rs +++ b/src/librustc_trans/trans/callee.rs @@ -418,7 +418,7 @@ pub fn trans_fn_ref_with_substs<'a, 'tcx>( match map_node { hir_map::NodeVariant(v) => { - v.node.def.kind == hir::VariantKind::Tuple + v.node.data.kind == hir::VariantKind::Tuple } hir_map::NodeStructCtor(_) => true, _ => false diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs index f509ed8dc5cbc..7c72b249a6e81 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -818,7 +818,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ty::VariantKind::Tuple => { expr::trans_def_fn_unadjusted(cx, e, def, param_substs).val } - ty::VariantKind::Dict => { + ty::VariantKind::Struct => { cx.sess().span_bug(e.span, "path-expr refers to a dict variant!") } } diff --git a/src/librustc_trans/trans/debuginfo/metadata.rs b/src/librustc_trans/trans/debuginfo/metadata.rs index bc5152cba1f2c..aeda8f723cfee 100644 --- a/src/librustc_trans/trans/debuginfo/metadata.rs +++ b/src/librustc_trans/trans/debuginfo/metadata.rs @@ -1365,7 +1365,7 @@ impl<'tcx> EnumMemberDescriptionFactory<'tcx> { let sole_struct_member_description = MemberDescription { name: match non_null_variant.kind() { ty::VariantKind::Tuple => "__0".to_string(), - ty::VariantKind::Dict => { + ty::VariantKind::Struct => { non_null_variant.fields[0].name.to_string() } ty::VariantKind::Unit => unreachable!() @@ -1540,7 +1540,7 @@ fn describe_enum_variant<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, .map(|(i, _)| format!("__{}", i)) .collect() } - ty::VariantKind::Dict => { + ty::VariantKind::Struct => { variant.fields .iter() .map(|f| f.name.to_string()) diff --git a/src/librustc_trans/trans/inline.rs b/src/librustc_trans/trans/inline.rs index 0ba4ba3e604ee..2f747606e59f4 100644 --- a/src/librustc_trans/trans/inline.rs +++ b/src/librustc_trans/trans/inline.rs @@ -110,13 +110,13 @@ 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.def.id; } - ccx.external().borrow_mut().insert(ty_v.did, Some(ast_v.node.def.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, _) => { match struct_def.kind { - hir::VariantKind::Dict => ccx.sess().bug("instantiate_inline: called on a \ + hir::VariantKind::Struct => ccx.sess().bug("instantiate_inline: called on a \ non-tuple struct"), _ => { ccx.external().borrow_mut().insert(fn_id, Some(struct_def.id)); diff --git a/src/librustc_trans/trans/monomorphize.rs b/src/librustc_trans/trans/monomorphize.rs index 49009378bb979..80d683a8f351a 100644 --- a/src/librustc_trans/trans/monomorphize.rs +++ b/src/librustc_trans/trans/monomorphize.rs @@ -246,7 +246,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, hir_map::NodeStructCtor(struct_def) => { let d = mk_lldecl(abi::Rust); attributes::inline(d, attributes::InlineAttr::Hint); - if struct_def.kind == hir::VariantKind::Dict { + if struct_def.kind == hir::VariantKind::Struct { panic!("ast-mapped struct didn't have a ctor id") } base::trans_tuple_struct(ccx, diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 6b19c8bd2e5ea..ba1af220d8e0f 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -1485,7 +1485,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { }; let var_kind = variant.kind(); - if var_kind == ty::VariantKind::Dict { + if var_kind == ty::VariantKind::Struct { Some((adt, variant)) } else if var_kind == ty::VariantKind::Unit { if !self.tcx().sess.features.borrow().braced_empty_structs { diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs index e62b7a53049b5..ebf54f62b5239 100644 --- a/src/librustc_typeck/check/wf.rs +++ b/src/librustc_typeck/check/wf.rs @@ -624,7 +624,7 @@ struct AdtField<'tcx> { } fn struct_variant<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, - struct_def: &hir::StructDef) + struct_def: &hir::VariantData) -> AdtVariant<'tcx> { let fields = struct_def.fields @@ -647,7 +647,7 @@ fn enum_variants<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, enum_def: &hir::EnumDef) -> Vec> { enum_def.variants.iter() - .map(|variant| struct_variant(fcx, &variant.node.def)) + .map(|variant| struct_variant(fcx, &variant.node.data)) .collect() } diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index cf1be635ea3af..0d2d37714c040 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -521,7 +521,7 @@ struct AdtField<'tcx> { } fn struct_variant<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, - struct_def: &hir::StructDef) + struct_def: &hir::VariantData) -> AdtVariant<'tcx> { let fields = struct_def.fields @@ -544,7 +544,7 @@ fn enum_variants<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, enum_def: &hir::EnumDef) -> Vec> { enum_def.variants.iter() - .map(|variant| struct_variant(fcx, &variant.node.def)) + .map(|variant| struct_variant(fcx, &variant.node.data)) .collect() } diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index a52226db4aa62..c38befd744466 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -1014,7 +1014,7 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { convert_field(ccx, &scheme.generics, &predicates, f, ty_f) } - if struct_def.kind != hir::VariantKind::Dict { + if struct_def.kind != hir::VariantKind::Struct { convert_variant_ctor(tcx, struct_def.id, variant, scheme, predicates); } }, @@ -1039,7 +1039,7 @@ fn convert_variant_ctor<'a, 'tcx>(tcx: &ty::ctxt<'tcx>, scheme: ty::TypeScheme<'tcx>, predicates: ty::GenericPredicates<'tcx>) { let ctor_ty = match variant.kind() { - VariantKind::Unit | VariantKind::Dict => scheme.ty, + VariantKind::Unit | VariantKind::Struct => scheme.ty, VariantKind::Tuple => { let inputs: Vec<_> = variant.fields @@ -1067,7 +1067,7 @@ fn convert_enum_variant_types<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, variants: &[P]) { // fill the field types for (variant, ty_variant) in variants.iter().zip(def.variants.iter()) { - for (f, ty_f) in variant.node.def.fields.iter().zip(ty_variant.fields.iter()) { + for (f, ty_f) in variant.node.data.fields.iter().zip(ty_variant.fields.iter()) { convert_field(ccx, &scheme.generics, &predicates, f, ty_f) } @@ -1075,7 +1075,7 @@ fn convert_enum_variant_types<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, // an item. convert_variant_ctor( ccx.tcx, - variant.node.def.id, + variant.node.data.id, ty_variant, scheme.clone(), predicates.clone() @@ -1087,7 +1087,7 @@ fn convert_struct_variant<'tcx>(tcx: &ty::ctxt<'tcx>, did: DefId, name: ast::Name, disr_val: ty::Disr, - def: &hir::StructDef) -> ty::VariantDefData<'tcx, 'tcx> { + def: &hir::VariantData) -> ty::VariantDefData<'tcx, 'tcx> { let mut seen_fields: FnvHashMap = FnvHashMap(); let fields = def.fields.iter().map(|f| { let fid = tcx.map.local_def_id(f.node.id); @@ -1120,12 +1120,12 @@ fn convert_struct_variant<'tcx>(tcx: &ty::ctxt<'tcx>, fn convert_struct_def<'tcx>(tcx: &ty::ctxt<'tcx>, it: &hir::Item, - def: &hir::StructDef) + def: &hir::VariantData) -> ty::AdtDefMaster<'tcx> { let did = tcx.map.local_def_id(it.id); - let ctor_id = if def.kind != hir::VariantKind::Dict { + let ctor_id = if def.kind != hir::VariantKind::Struct { tcx.map.local_def_id(def.id) } else { did @@ -1209,9 +1209,9 @@ 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.def.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.def, did) + convert_struct_variant(tcx, did, name, disr, &v.node.data, did) } let did = tcx.map.local_def_id(it.id); let repr_hints = tcx.lookup_repr_hints(did); diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 59ff7f53f8733..f935210ef286d 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1805,7 +1805,7 @@ pub struct VariantStruct { pub fields_stripped: bool, } -impl Clean for ::rustc_front::hir::StructDef { +impl Clean for ::rustc_front::hir::VariantData { fn clean(&self, cx: &DocContext) -> VariantStruct { VariantStruct { struct_type: doctree::struct_type_from_def(self), @@ -1871,7 +1871,7 @@ impl<'tcx> Clean for ty::VariantDefData<'tcx, 'static> { self.fields.iter().map(|f| f.unsubst_ty().clean(cx)).collect() ) } - ty::VariantKind::Dict => { + ty::VariantKind::Struct => { StructVariant(VariantStruct { struct_type: doctree::Plain, fields_stripped: false, @@ -1917,8 +1917,8 @@ pub enum VariantKind { StructVariant(VariantStruct), } -fn struct_def_to_variant_kind(struct_def: &hir::StructDef, cx: &DocContext) -> VariantKind { - if struct_def.kind == hir::VariantKind::Dict { +fn struct_def_to_variant_kind(struct_def: &hir::VariantData, cx: &DocContext) -> VariantKind { + if struct_def.kind == hir::VariantKind::Struct { StructVariant(struct_def.clean(cx)) } else if struct_def.kind == hir::VariantKind::Unit { CLikeVariant diff --git a/src/librustdoc/doctree.rs b/src/librustdoc/doctree.rs index 06b1e93e604b5..112c6aebfc552 100644 --- a/src/librustdoc/doctree.rs +++ b/src/librustdoc/doctree.rs @@ -119,7 +119,7 @@ pub struct Enum { pub struct Variant { pub name: Name, pub attrs: Vec, - pub def: P, + pub def: P, pub stab: Option, pub whence: Span, } @@ -233,8 +233,8 @@ pub struct Import { pub whence: Span, } -pub fn struct_type_from_def(sd: &hir::StructDef) -> StructType { - if sd.kind != hir::VariantKind::Dict { +pub fn struct_type_from_def(sd: &hir::VariantData) -> StructType { + if sd.kind != hir::VariantKind::Struct { // We are in a tuple-struct match sd.fields.len() { 0 => Unit, diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index 78c56b934272a..e84d7f549a91d 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -84,8 +84,8 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { self.module.is_crate = true; } - pub fn visit_struct_def(&mut self, item: &hir::Item, - name: ast::Name, sd: &hir::StructDef, + pub fn visit_variant_data(&mut self, item: &hir::Item, + name: ast::Name, sd: &hir::VariantData, generics: &hir::Generics) -> Struct { debug!("Visiting struct"); let struct_type = struct_type_from_def(&*sd); @@ -111,8 +111,8 @@ 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.def.id), - def: v.node.def.clone(), + stab: self.stability(v.node.data.id), + def: v.node.data.clone(), whence: v.span, }).collect(), vis: it.vis, @@ -298,7 +298,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { hir::ItemEnum(ref ed, ref gen) => om.enums.push(self.visit_enum_def(item, name, ed, gen)), hir::ItemStruct(ref sd, ref gen) => - om.structs.push(self.visit_struct_def(item, name, &**sd, gen)), + om.structs.push(self.visit_variant_data(item, name, &**sd, gen)), hir::ItemFn(ref fd, ref unsafety, constness, ref abi, ref gen, _) => om.fns.push(self.visit_fn(item, name, &**fd, unsafety, constness, abi, gen)), diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index b786e778edb11..af6235497675d 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -1579,7 +1579,7 @@ pub struct EnumDef { pub struct Variant_ { pub name: Ident, pub attrs: Vec, - pub def: P, + pub data: P, /// Explicit discriminant, eg `Foo = 1` pub disr_expr: Option>, } @@ -1742,13 +1742,13 @@ impl StructFieldKind { #[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub enum VariantKind { - Dict, + Struct, Tuple, Unit, } #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] -pub struct StructDef { +pub struct VariantData { /// Fields, not including ctor pub fields: Vec, /// ID of the constructor. This is only used for tuple- or enum-like @@ -1798,7 +1798,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(P, Generics), /// Represents a Trait Declaration ItemTrait(Unsafety, Generics, diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index c52c5984858a9..42382d0459fdd 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -452,8 +452,8 @@ impl<'a, 'v, O: IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> { visit::walk_struct_field(self, struct_field) } - fn visit_struct_def(&mut self, - struct_def: &StructDef, + fn visit_variant_data(&mut self, + struct_def: &VariantData, _: ast::Ident, _: &ast::Generics, _: NodeId, diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs index 744f83467d601..02a9d0b5c38cb 100644 --- a/src/libsyntax/config.rs +++ b/src/libsyntax/config.rs @@ -140,13 +140,13 @@ fn fold_item_underscore(cx: &mut Context, item: ast::Item_) -> ast::Item_ if !(cx.in_cfg)(&v.node.attrs) { None } else { - Some(v.map(|Spanned {node: ast::Variant_ {name, attrs, def, + Some(v.map(|Spanned {node: ast::Variant_ {name, attrs, data, disr_expr}, span}| { Spanned { node: ast::Variant_ { name: name, attrs: attrs, - def: fold_struct(cx, def), + data: fold_struct(cx, data), disr_expr: disr_expr, }, span: span @@ -164,11 +164,11 @@ 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, def: P) -> P where F: FnMut(&[ast::Attribute]) -> bool { - def.map(|ast::StructDef { fields, id, kind }| { - ast::StructDef { + def.map(|ast::VariantData { fields, id, kind }| { + ast::VariantData { fields: fields.into_iter().filter(|m| { (cx.in_cfg)(&m.node.attrs) }).collect(), diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index 706a16d1f0228..105a7036c5f6d 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -247,9 +247,9 @@ pub trait AstBuilder { fn item_struct_poly(&self, span: Span, name: Ident, - struct_def: ast::StructDef, + struct_def: ast::VariantData, generics: Generics) -> P; - fn item_struct(&self, span: Span, name: Ident, struct_def: ast::StructDef) -> P; + fn item_struct(&self, span: Span, name: Ident, struct_def: ast::VariantData) -> P; fn item_mod(&self, span: Span, inner_span: Span, name: Ident, attrs: Vec, @@ -1008,7 +1008,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> { ast::Variant_ { name: name, attrs: Vec::new(), - def: P(ast::StructDef { fields: fields, + data: P(ast::VariantData { fields: fields, id: ast::DUMMY_NODE_ID, kind: kind }), disr_expr: None, @@ -1028,7 +1028,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> { } fn item_struct(&self, span: Span, name: Ident, - struct_def: ast::StructDef) -> P { + struct_def: ast::VariantData) -> P { self.item_struct_poly( span, name, @@ -1038,7 +1038,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> { } fn item_struct_poly(&self, span: Span, name: Ident, - struct_def: ast::StructDef, generics: Generics) -> P { + struct_def: ast::VariantData, generics: Generics) -> P { self.item(span, name, Vec::new(), ast::ItemStruct(P(struct_def), generics)) } diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs index f6ea6aef108a1..b375dee4e2c6c 100644 --- a/src/libsyntax/ext/deriving/generic/mod.rs +++ b/src/libsyntax/ext/deriving/generic/mod.rs @@ -174,9 +174,9 @@ //! A static method on the types above would result in, //! //! ```{.text} -//! StaticStruct(, Named(vec![(, )])) +//! StaticStruct(, Named(vec![(, )])) //! -//! StaticStruct(, Unnamed(vec![])) +//! StaticStruct(, Unnamed(vec![])) //! //! StaticEnum(, //! vec![(, , Unnamed(vec![])), @@ -194,7 +194,7 @@ use std::vec; use abi::Abi; use abi; use ast; -use ast::{EnumDef, Expr, Ident, Generics, StructDef}; +use ast::{EnumDef, Expr, Ident, Generics, VariantData}; use ast_util; use attr; use attr::AttrMetaMethods; @@ -317,7 +317,7 @@ pub enum SubstructureFields<'a> { EnumNonMatchingCollapsed(Vec, &'a [P], &'a [Ident]), /// A static method where `Self` is a struct. - StaticStruct(&'a ast::StructDef, StaticFields), + StaticStruct(&'a ast::VariantData, StaticFields), /// A static method where `Self` is an enum. StaticEnum(&'a ast::EnumDef, Vec<(Ident, Span, StaticFields)>), } @@ -649,7 +649,7 @@ impl<'a> TraitDef<'a> { fn expand_struct_def(&self, cx: &mut ExtCtxt, - struct_def: &'a StructDef, + struct_def: &'a VariantData, type_ident: Ident, generics: &Generics) -> P { let field_tys: Vec> = struct_def.fields.iter() @@ -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.def.fields.iter() + field_tys.extend(variant.node.data.fields.iter() .map(|field| field.node.ty.clone())); } @@ -927,7 +927,7 @@ impl<'a> MethodDef<'a> { fn expand_struct_method_body<'b>(&self, cx: &mut ExtCtxt, trait_: &TraitDef<'b>, - struct_def: &'b StructDef, + struct_def: &'b VariantData, type_ident: Ident, self_args: &[P], nonself_args: &[P]) @@ -996,7 +996,7 @@ impl<'a> MethodDef<'a> { fn expand_static_struct_method_body(&self, cx: &mut ExtCtxt, trait_: &TraitDef, - struct_def: &StructDef, + struct_def: &VariantData, type_ident: Ident, self_args: &[P], nonself_args: &[P]) @@ -1405,7 +1405,7 @@ impl<'a> MethodDef<'a> { -> P { let summary = enum_def.variants.iter().map(|v| { let ident = v.node.name; - let summary = trait_.summarise_struct(cx, &v.node.def); + let summary = trait_.summarise_struct(cx, &v.node.data); (ident, v.span, summary) }).collect(); self.call_substructure_method(cx, trait_, type_ident, @@ -1441,7 +1441,7 @@ impl<'a> TraitDef<'a> { fn summarise_struct(&self, cx: &mut ExtCtxt, - struct_def: &StructDef) -> StaticFields { + struct_def: &VariantData) -> StaticFields { let mut named_idents = Vec::new(); let mut just_spans = Vec::new(); for field in struct_def.fields.iter(){ @@ -1477,7 +1477,7 @@ impl<'a> TraitDef<'a> { fn create_struct_pattern(&self, cx: &mut ExtCtxt, struct_path: ast::Path, - struct_def: &'a StructDef, + struct_def: &'a VariantData, prefix: &str, mutbl: ast::Mutability) -> (P, Vec<(Span, Option, @@ -1545,7 +1545,7 @@ impl<'a> TraitDef<'a> { -> (P, Vec<(Span, Option, P, &'a [ast::Attribute])>) { let variant_ident = variant.node.name; let variant_path = cx.path(variant.span, vec![enum_ident, variant_ident]); - self.create_struct_pattern(cx, variant_path, &variant.node.def, prefix, mutbl) + self.create_struct_pattern(cx, variant_path, &variant.node.data, prefix, mutbl) } } diff --git a/src/libsyntax/ext/deriving/primitive.rs b/src/libsyntax/ext/deriving/primitive.rs index 7b64e5522a4fb..3a079717b8b64 100644 --- a/src/libsyntax/ext/deriving/primitive.rs +++ b/src/libsyntax/ext/deriving/primitive.rs @@ -94,7 +94,7 @@ fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure let mut arms = Vec::new(); for variant in &enum_def.variants { - let def = &variant.node.def; + let def = &variant.node.data; if def.kind != ast::VariantKind::Unit { cx.span_err(trait_span, "`FromPrimitive` cannot be derived \ for enums with non-unit variants"); diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index 66a422ce664c1..a6922c2469395 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -857,10 +857,10 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { visit::walk_item(self, i); } - fn visit_struct_def(&mut self, s: &'v ast::StructDef, _: ast::Ident, + fn visit_variant_data(&mut self, s: &'v ast::VariantData, _: ast::Ident, _: &'v ast::Generics, _: ast::NodeId, span: Span) { if s.fields.is_empty() { - if s.kind == ast::VariantKind::Dict { + if s.kind == ast::VariantKind::Struct { self.gate_feature("braced_empty_structs", span, "empty structs and enum variants with braces are unstable"); } else if s.kind == ast::VariantKind::Tuple { diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 144eab92795b2..d7b7fc242b43f 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -231,7 +231,7 @@ pub trait Folder : Sized { noop_fold_poly_trait_ref(p, self) } - fn fold_struct_def(&mut self, struct_def: P) -> P { + fn fold_variant_data(&mut self, struct_def: P) -> P { noop_fold_struct_def(struct_def, self) } @@ -446,11 +446,11 @@ pub fn noop_fold_foreign_mod(ForeignMod {abi, items}: ForeignMod, } pub fn noop_fold_variant(v: P, fld: &mut T) -> P { - v.map(|Spanned {node: Variant_ {name, attrs, def, disr_expr}, span}| Spanned { + v.map(|Spanned {node: Variant_ {name, attrs, data, disr_expr}, span}| Spanned { node: Variant_ { name: name, attrs: fold_attrs(attrs, fld), - def: fld.fold_struct_def(def), + data: fld.fold_variant_data(data), disr_expr: disr_expr.map(|e| fld.fold_expr(e)), }, span: fld.new_span(span), @@ -814,8 +814,8 @@ pub fn noop_fold_where_predicate( } } -pub fn noop_fold_struct_def(struct_def: P, fld: &mut T) -> P { - struct_def.map(|StructDef { fields, id, kind }| StructDef { +pub fn noop_fold_struct_def(struct_def: P, fld: &mut T) -> P { + struct_def.map(|VariantData { fields, id, kind }| VariantData { fields: fields.move_map(|f| fld.fold_struct_field(f)), id: fld.new_id(id), kind: kind, @@ -925,7 +925,7 @@ pub fn noop_fold_item_underscore(i: Item_, folder: &mut T) -> Item_ { folder.fold_generics(generics)) } ItemStruct(struct_def, generics) => { - let struct_def = folder.fold_struct_def(struct_def); + let struct_def = folder.fold_variant_data(struct_def); ItemStruct(struct_def, folder.fold_generics(generics)) } ItemDefaultImpl(unsafety, ref trait_ref) => { diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 47632781956e5..f944c93073a45 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, StructDef, StructField, VariantKind}; +use ast::{StmtExpr, StmtSemi, StmtMac, VariantData, StructField, VariantKind}; use ast::{BiSub, StrStyle}; use ast::{SelfExplicit, SelfRegion, SelfStatic, SelfValue}; use ast::{Delimited, SequenceRepetition, TokenTree, TraitItem, TraitRef}; @@ -4647,7 +4647,7 @@ impl<'a> Parser<'a> { (Vec::new(), VariantKind::Unit) } else { // If we see: `struct Foo where T: Copy { ... }` - (try!(self.parse_record_struct_body()), VariantKind::Dict) + (try!(self.parse_record_struct_body()), VariantKind::Struct) } // No `where` so: `struct Foo;` } else if try!(self.eat(&token::Semi) ){ @@ -4655,7 +4655,7 @@ impl<'a> Parser<'a> { // Record-style struct definition } else if self.token == token::OpenDelim(token::Brace) { let fields = try!(self.parse_record_struct_body()); - (fields, VariantKind::Dict) + (fields, VariantKind::Struct) // Tuple-style struct definition with optional where-clause. } else if self.token == token::OpenDelim(token::Paren) { let fields = try!(self.parse_tuple_struct_body(&mut generics)); @@ -4667,7 +4667,7 @@ impl<'a> Parser<'a> { }; Ok((class_name, - ItemStruct(P(ast::StructDef { + ItemStruct(P(ast::VariantData { fields: fields, id: ast::DUMMY_NODE_ID, kind: kind, @@ -5103,17 +5103,17 @@ 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(StructDef { + Ok(P(VariantData { fields: fields, id: ast::DUMMY_NODE_ID, - kind: VariantKind::Dict, + kind: VariantKind::Struct, })) } @@ -5150,17 +5150,17 @@ impl<'a> Parser<'a> { id: ast::DUMMY_NODE_ID, }}); } - struct_def = P(StructDef { fields: fields, + struct_def = P(VariantData { fields: fields, id: ast::DUMMY_NODE_ID, kind: ast::VariantKind::Tuple }); } 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(StructDef { fields: Vec::new(), + struct_def = P(VariantData { fields: Vec::new(), id: ast::DUMMY_NODE_ID, kind: ast::VariantKind::Unit }); } else { - struct_def = P(StructDef { fields: Vec::new(), + struct_def = P(VariantData { fields: Vec::new(), id: ast::DUMMY_NODE_ID, kind: ast::VariantKind::Unit }); } @@ -5168,7 +5168,7 @@ impl<'a> Parser<'a> { let vr = ast::Variant_ { name: ident, attrs: variant_attrs, - def: struct_def, + data: struct_def, disr_expr: disr_expr, }; variants.push(P(spanned(vlo, self.last_span.hi, vr))); diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 5535064c8eca2..0f6041d2cd071 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1385,14 +1385,14 @@ impl<'a> State<'a> { } pub fn print_struct(&mut self, - struct_def: &ast::StructDef, + struct_def: &ast::VariantData, generics: &ast::Generics, ident: ast::Ident, span: codemap::Span, print_finalizer: bool) -> io::Result<()> { try!(self.print_ident(ident)); try!(self.print_generics(generics)); - if struct_def.kind != ast::VariantKind::Dict { + if struct_def.kind != ast::VariantKind::Struct { if struct_def.kind == ast::VariantKind::Tuple { try!(self.popen()); try!(self.commasep( @@ -1510,7 +1510,7 @@ impl<'a> State<'a> { pub fn print_variant(&mut self, v: &ast::Variant) -> io::Result<()> { try!(self.head("")); let generics = ast_util::empty_generics(); - try!(self.print_struct(&v.node.def, &generics, v.node.name, v.span, false)); + try!(self.print_struct(&v.node.data, &generics, v.node.name, v.span, false)); match v.node.disr_expr { Some(ref d) => { try!(space(&mut self.s)); @@ -3119,7 +3119,7 @@ mod tests { name: ident, attrs: Vec::new(), // making this up as I go.... ? - def: P(ast::StructDef { fields: Vec::new(), + data: P(ast::VariantData { fields: Vec::new(), id: ast::DUMMY_NODE_ID, kind: ast::VariantKind::Unit }), disr_expr: None, diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index b547f8c019c6e..fdff0bf72ebfc 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -80,7 +80,7 @@ pub trait Visitor<'v> : Sized { fn visit_poly_trait_ref(&mut self, t: &'v PolyTraitRef, m: &'v TraitBoundModifier) { walk_poly_trait_ref(self, t, m) } - fn visit_struct_def(&mut self, s: &'v StructDef, _: Ident, + fn visit_variant_data(&mut self, s: &'v VariantData, _: Ident, _: &'v Generics, _: NodeId, _: Span) { walk_struct_def(self, s) } @@ -289,7 +289,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) { } ItemStruct(ref struct_definition, ref generics) => { visitor.visit_generics(generics); - visitor.visit_struct_def(struct_definition, item.ident, + visitor.visit_variant_data(struct_definition, item.ident, generics, item.id, item.span); } ItemTrait(_, ref generics, ref bounds, ref methods) => { @@ -316,7 +316,7 @@ pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics, item_id: NodeId) { visitor.visit_ident(variant.span, variant.node.name); - visitor.visit_struct_def(&variant.node.def, variant.node.name, + visitor.visit_variant_data(&variant.node.data, variant.node.name, generics, item_id, variant.span); walk_list!(visitor, visit_expr, &variant.node.disr_expr); walk_list!(visitor, visit_attribute, &variant.node.attrs); @@ -603,7 +603,7 @@ pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplIt } pub fn walk_struct_def<'v, V: Visitor<'v>>(visitor: &mut V, - struct_definition: &'v StructDef) { + struct_definition: &'v VariantData) { walk_list!(visitor, visit_struct_field, &struct_definition.fields); } From 40aa09e4c9f4c3f0fa2b088895c8f5125325eaa4 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Thu, 8 Oct 2015 23:45:46 +0300 Subject: [PATCH 10/13] Merge struct fields and struct kind --- src/librustc/front/map/collector.rs | 6 ++-- src/librustc/front/map/mod.rs | 7 ++-- src/librustc/metadata/encoder.rs | 6 ++-- src/librustc/middle/astencode.rs | 2 +- src/librustc/middle/dead.rs | 4 +-- src/librustc/middle/stability.rs | 2 +- src/librustc_front/fold.rs | 13 ++++++-- src/librustc_front/hir.rs | 36 ++++++++++++++++---- src/librustc_front/lowering.rs | 13 +++++--- src/librustc_front/print/pprust.rs | 10 +++--- src/librustc_front/visit.rs | 2 +- src/librustc_lint/bad_style.rs | 2 +- src/librustc_lint/builtin.rs | 2 +- src/librustc_privacy/lib.rs | 10 +++--- src/librustc_resolve/build_reduced_graph.rs | 24 ++++++------- src/librustc_trans/save/dump_csv.rs | 4 +-- src/librustc_trans/trans/base.rs | 17 +++++----- src/librustc_trans/trans/callee.rs | 2 +- src/librustc_trans/trans/inline.rs | 13 ++++---- src/librustc_trans/trans/monomorphize.rs | 2 +- src/librustc_typeck/check/wf.rs | 3 +- src/librustc_typeck/check/wfcheck.rs | 3 +- src/librustc_typeck/collect.rs | 10 +++--- src/librustdoc/clean/mod.rs | 8 ++--- src/librustdoc/doctree.rs | 4 +-- src/librustdoc/visit_ast.rs | 2 +- src/libsyntax/ast.rs | 36 ++++++++++++++++---- src/libsyntax/config.rs | 19 ++++++++--- src/libsyntax/ext/build.rs | 11 +++--- src/libsyntax/ext/deriving/generic/mod.rs | 10 +++--- src/libsyntax/ext/deriving/primitive.rs | 2 +- src/libsyntax/feature_gate.rs | 6 ++-- src/libsyntax/fold.rs | 13 ++++++-- src/libsyntax/parse/parser.rs | 37 +++++++++------------ src/libsyntax/print/pprust.rs | 27 ++++++++++----- src/libsyntax/visit.rs | 2 +- 36 files changed, 222 insertions(+), 148 deletions(-) diff --git a/src/librustc/front/map/collector.rs b/src/librustc/front/map/collector.rs index a3542ff9b1077..aa5d482b89a83 100644 --- a/src/librustc/front/map/collector.rs +++ b/src/librustc/front/map/collector.rs @@ -138,7 +138,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> { NodeVariant(&**v), DefPathData::EnumVariant(v.node.name)); - for field in &v.node.data.fields { + for field in v.node.data.fields() { self.create_def_with_parent( Some(variant_def_index), field.node.id, @@ -150,13 +150,13 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> { } ItemStruct(ref struct_def, _) => { // If this is a tuple-like struct, register the constructor. - if struct_def.kind != VariantKind::Struct { + if !struct_def.is_struct() { self.insert_def(struct_def.id, NodeStructCtor(&**struct_def), DefPathData::StructCtor); } - for field in &struct_def.fields { + for field in struct_def.fields() { self.create_def(field.node.id, DefPathData::Field(field.node.kind)); } } diff --git a/src/librustc/front/map/mod.rs b/src/librustc/front/map/mod.rs index 1e31bfe9acabf..028e1ad5ce974 100644 --- a/src/librustc/front/map/mod.rs +++ b/src/librustc/front/map/mod.rs @@ -480,9 +480,10 @@ impl<'ast> Map<'ast> { } } Some(NodeVariant(variant)) => { - match variant.node.data.kind { - VariantKind::Struct => &variant.node.data, - _ => panic!("struct ID bound to enum variant that isn't struct-like"), + if variant.node.data.is_struct() { + &variant.node.data + } else { + panic!("struct ID bound to enum variant that isn't struct-like") } } _ => panic!(format!("expected struct, found {}", self.node_to_string(id))), diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 2bee3f296c9cc..81305099705ce 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -381,7 +381,7 @@ fn each_auxiliary_node_id(item: &hir::Item, callback: F) -> bool where match item.node { hir::ItemStruct(ref struct_def, _) => { // If this is a newtype struct, return the constructor. - if struct_def.kind == hir::VariantKind::Tuple { + if struct_def.is_tuple() { continue_ = callback(struct_def.id); } } @@ -1068,7 +1068,7 @@ fn encode_info_for_item<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, // Encode inherent implementations for this structure. encode_inherent_implementations(ecx, rbml_w, def_id); - if struct_def.kind != hir::VariantKind::Struct { + if !struct_def.is_struct() { 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)); @@ -1081,7 +1081,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.kind != hir::VariantKind::Struct { + if !struct_def.is_struct() { encode_info_for_struct_ctor(ecx, rbml_w, item.name, struct_def.id, index, item.id); } } diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 9bf70cce602ee..ca05de81e77c8 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -1320,7 +1320,7 @@ fn copy_item_types(dcx: &DecodeContext, ii: &InlinedItem, orig_did: DefId) { } } hir::ItemStruct(ref def, _) => { - if def.kind != hir::VariantKind::Struct { + if !def.is_struct() { let ctor_did = dcx.tcx.lookup_adt_def(orig_did) .struct_variant().did; debug!("astencode: copying ctor {:?} => {:?}", ctor_did, diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index d0d6cf39af761..9d15b53a6d826 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -219,7 +219,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for MarkSymbolVisitor<'a, 'tcx> { _: &hir::Generics, _: ast::NodeId, _: codemap::Span) { let has_extern_repr = self.struct_has_extern_repr; let inherited_pub_visibility = self.inherited_pub_visibility; - let live_fields = def.fields.iter().filter(|f| { + let live_fields = def.fields().filter(|f| { has_extern_repr || inherited_pub_visibility || match f.node.kind { hir::NamedField(_, hir::Public) => true, _ => false @@ -426,7 +426,7 @@ fn find_live(tcx: &ty::ctxt, fn get_struct_ctor_id(item: &hir::Item) -> Option { match item.node { - hir::ItemStruct(ref struct_def, _) if struct_def.kind != hir::VariantKind::Struct => { + hir::ItemStruct(ref struct_def, _) if !struct_def.is_struct() => { Some(struct_def.id) } _ => None diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index df5582e9414c1..23bb4a1fe393d 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -185,7 +185,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Annotator<'a, 'tcx> { |v| visit::walk_item(v, i), required); if let hir::ItemStruct(ref sd, _) = i.node { - if sd.kind != hir::VariantKind::Struct { + if !sd.is_struct() { self.annotate(sd.id, true, &i.attrs, i.span, |_| {}, true) } } diff --git a/src/librustc_front/fold.rs b/src/librustc_front/fold.rs index ecea50f8495fe..fd69d2007ff13 100644 --- a/src/librustc_front/fold.rs +++ b/src/librustc_front/fold.rs @@ -694,11 +694,18 @@ pub fn noop_fold_where_predicate(pred: WherePredicate, fld: &mut T) - } pub fn noop_fold_struct_def(struct_def: P, fld: &mut T) -> P { - struct_def.map(|VariantData { fields, id, kind }| { + struct_def.map(|VariantData { data_, id }| { VariantData { - fields: fields.move_map(|f| fld.fold_struct_field(f)), + 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), - kind: kind, } }) } diff --git a/src/librustc_front/hir.rs b/src/librustc_front/hir.rs index 92a52c38176a4..b5170b7496b46 100644 --- a/src/librustc_front/hir.rs +++ b/src/librustc_front/hir.rs @@ -49,6 +49,7 @@ use print::pprust; use util; use std::fmt; +use std::{iter, option, slice}; use serialize::{Encodable, Encoder, Decoder}; #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)] @@ -1160,21 +1161,42 @@ impl StructFieldKind { } } -#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] -pub enum VariantKind { - Struct, - Tuple, +#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +pub enum VariantData_ { + Struct(Vec), + Tuple(Vec), Unit, } #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct VariantData { - /// Fields, not including ctor - pub fields: Vec, + pub data_: VariantData_, /// ID of the constructor. This is only used for tuple- or enum-like /// structs. pub id: NodeId, - pub kind: VariantKind, +} + +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() } + match self.data_ { + VariantData_::Struct(ref fields) | VariantData_::Tuple(ref fields) => Some(fields), + _ => None, + }.into_iter().flat_map(vec_iter) + } + pub fn is_struct(&self) -> bool { + if let VariantData_::Struct(..) = self.data_ { true } else { false } + } + pub fn is_tuple(&self) -> bool { + if let VariantData_::Tuple(..) = self.data_ { true } else { false } + } + pub fn is_unit(&self) -> bool { + if let VariantData_::Unit = self.data_ { true } else { false } + } } /* diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs index ecbfbd1362eb5..cd32ad15744bf 100644 --- a/src/librustc_front/lowering.rs +++ b/src/librustc_front/lowering.rs @@ -500,12 +500,15 @@ pub fn lower_where_predicate(_lctx: &LoweringContext, pub fn lower_struct_def(sd: &VariantData) -> P { P(hir::VariantData { - fields: sd.fields.iter().map(|f| lower_struct_field(_lctx, f)).collect(), id: sd.id, - kind: match sd.kind { - VariantKind::Struct => hir::VariantKind::Struct, - VariantKind::Tuple => hir::VariantKind::Tuple, - VariantKind::Unit => hir::VariantKind::Unit, + 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 } }) } diff --git a/src/librustc_front/print/pprust.rs b/src/librustc_front/print/pprust.rs index 948134c8025d3..5e78aa5fbc1f8 100644 --- a/src/librustc_front/print/pprust.rs +++ b/src/librustc_front/print/pprust.rs @@ -896,11 +896,11 @@ impl<'a> State<'a> { -> io::Result<()> { try!(self.print_name(name)); try!(self.print_generics(generics)); - if struct_def.kind != hir::VariantKind::Struct { - if struct_def.kind == hir::VariantKind::Tuple { + if !struct_def.is_struct() { + if struct_def.is_tuple() { try!(self.popen()); - try!(self.commasep(Inconsistent, - &struct_def.fields, + try!(self.commasep_iter(Inconsistent, + struct_def.fields(), |s, field| { match field.node.kind { hir::NamedField(..) => panic!("unexpected named field"), @@ -925,7 +925,7 @@ impl<'a> State<'a> { try!(self.bopen()); try!(self.hardbreak_if_not_bol()); - for field in &struct_def.fields { + for field in struct_def.fields() { match field.node.kind { hir::UnnamedField(..) => panic!("unexpected unnamed field"), hir::NamedField(name, visibility) => { diff --git a/src/librustc_front/visit.rs b/src/librustc_front/visit.rs index 8472bef3cd108..00c2c3a3ddd65 100644 --- a/src/librustc_front/visit.rs +++ b/src/librustc_front/visit.rs @@ -629,7 +629,7 @@ pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplIt } pub fn walk_struct_def<'v, V: Visitor<'v>>(visitor: &mut V, struct_definition: &'v VariantData) { - walk_list!(visitor, visit_struct_field, &struct_definition.fields); + walk_list!(visitor, visit_struct_field, struct_definition.fields()); } pub fn walk_struct_field<'v, V: Visitor<'v>>(visitor: &mut V, struct_field: &'v StructField) { diff --git a/src/librustc_lint/bad_style.rs b/src/librustc_lint/bad_style.rs index 6b6b90b1ba66f..693de1740bfee 100644 --- a/src/librustc_lint/bad_style.rs +++ b/src/librustc_lint/bad_style.rs @@ -282,7 +282,7 @@ impl LateLintPass for NonSnakeCase { fn check_struct_def(&mut self, cx: &LateContext, s: &hir::VariantData, _: ast::Name, _: &hir::Generics, _: ast::NodeId) { - for sf in &s.fields { + for sf in s.fields() { if let hir::StructField_ { kind: hir::NamedField(name, _), .. } = sf.node { self.check_snake_case(cx, "structure field", &name.as_str(), Some(sf.span)); diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index df15dbe4d6ca2..ea8ea4ebf0dac 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -123,7 +123,7 @@ impl LateLintPass for BoxPointers { // If it's a struct, we also have to check the fields' types match it.node { hir::ItemStruct(ref struct_def, _) => { - for struct_field in &struct_def.fields { + for struct_field in struct_def.fields() { self.check_heap_type(cx, struct_field.span, cx.tcx.node_id_to_type(struct_field.node.id)); } diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index e1e51ae666ba7..b139b27578516 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -132,13 +132,13 @@ impl<'v> Visitor<'v> for ParentVisitor { _: &'v hir::Generics, item_id: ast::NodeId, _: Span) { // Struct constructors are parented to their struct definitions because // they essentially are the struct definitions. - if s.kind != hir::VariantKind::Struct { + if !s.is_struct() { self.parents.insert(s.id, item_id); } // While we have the id of the struct definition, go ahead and parent // all the fields. - for field in &s.fields { + for field in s.fields() { self.parents.insert(field.node.id, self.curparent); } visit::walk_struct_def(self, s) @@ -319,11 +319,11 @@ 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.kind != hir::VariantKind::Struct { + if !def.is_struct() { self.exported_items.insert(def.id); } // fields can be public or private, so lets check - for field in &def.fields { + for field in def.fields() { let vis = match field.node.kind { hir::NamedField(_, vis) | hir::UnnamedField(vis) => vis }; @@ -1089,7 +1089,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { } } let check_struct = |def: &hir::VariantData| { - for f in &def.fields { + for f in def.fields() { match f.node.kind { hir::NamedField(_, p) => check_inherited(tcx, f.span, p), hir::UnnamedField(..) => {} diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 4484cfe95900a..43943fbb129dc 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -492,9 +492,10 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { // These items live in both the type and value namespaces. ItemStruct(ref struct_def, _) => { // Adding to both Type and Value namespaces or just Type? - let (forbid, ctor_id) = match struct_def.kind { - hir::VariantKind::Struct => (ForbidDuplicateTypesAndModules, None), - _ => (ForbidDuplicateTypesAndValues, Some(struct_def.id)), + let (forbid, ctor_id) = if struct_def.is_struct() { + (ForbidDuplicateTypesAndModules, None) + } else { + (ForbidDuplicateTypesAndValues, Some(struct_def.id)) }; let name_bindings = self.add_child(name, parent, forbid, sp); @@ -513,7 +514,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { } // Record the def ID and fields of this struct. - let named_fields = struct_def.fields.iter().filter_map(|f| { + let named_fields = struct_def.fields().filter_map(|f| { match f.node.kind { NamedField(name, _) => Some(name), UnnamedField(_) => None @@ -587,14 +588,13 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { item_id: DefId, parent: &Rc) { let name = variant.node.name; - let is_exported = match variant.node.data.kind { - hir::VariantKind::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); - self.structs.insert(variant_def_id, Vec::new()); - true - } - _ => false, + 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); + self.structs.insert(variant_def_id, Vec::new()); + true + } else { + false }; let child = self.add_child(name, parent, diff --git a/src/librustc_trans/save/dump_csv.rs b/src/librustc_trans/save/dump_csv.rs index 5235bd49a2875..d31b8b6f0e48d 100644 --- a/src/librustc_trans/save/dump_csv.rs +++ b/src/librustc_trans/save/dump_csv.rs @@ -473,7 +473,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { &val); // fields - for field in &def.fields { + for field in def.fields() { self.process_struct_field_def(field, item.id); self.visit_ty(&field.node.ty); } @@ -510,7 +510,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { &val, enum_data.id); - for field in &variant.node.data.fields { + for field in variant.node.data.fields() { self.process_struct_field_def(field, variant.node.data.id); self.visit_ty(&*field.node.ty); } diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index d7ace6e2541d0..c692f8a183605 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -2428,12 +2428,12 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { hir_map::NodeVariant(ref v) => { let llfn; - let fields = if v.node.data.kind == hir::VariantKind::Struct { + let fields = if v.node.data.is_struct() { ccx.sess().bug("struct variant kind unexpected in get_item_val") } else { - &v.node.data.fields + v.node.data.fields() }; - assert!(!fields.is_empty()); + assert!(fields.count() != 0); let ty = ccx.tcx().node_id_to_type(id); let parent = ccx.tcx().map.get_parent(id); let enm = ccx.tcx().map.expect_item(parent); @@ -2454,12 +2454,11 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { hir_map::NodeStructCtor(struct_def) => { // Only register the constructor if this is a tuple-like struct. - let ctor_id = match struct_def.kind { - hir::VariantKind::Struct => { - ccx.sess().bug("attempt to register a constructor of \ - a non-tuple-like struct") - } - _ => struct_def.id, + let ctor_id = if struct_def.is_struct() { + ccx.sess().bug("attempt to register a constructor of \ + a non-tuple-like struct") + } else { + struct_def.id }; let parent = ccx.tcx().map.get_parent(id); let struct_item = ccx.tcx().map.expect_item(parent); diff --git a/src/librustc_trans/trans/callee.rs b/src/librustc_trans/trans/callee.rs index 455eb70929188..c8525e33e2667 100644 --- a/src/librustc_trans/trans/callee.rs +++ b/src/librustc_trans/trans/callee.rs @@ -418,7 +418,7 @@ pub fn trans_fn_ref_with_substs<'a, 'tcx>( match map_node { hir_map::NodeVariant(v) => { - v.node.data.kind == hir::VariantKind::Tuple + v.node.data.is_tuple() } hir_map::NodeStructCtor(_) => true, _ => false diff --git a/src/librustc_trans/trans/inline.rs b/src/librustc_trans/trans/inline.rs index 2f747606e59f4..923214a536227 100644 --- a/src/librustc_trans/trans/inline.rs +++ b/src/librustc_trans/trans/inline.rs @@ -115,13 +115,12 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: DefId) } } hir::ItemStruct(ref struct_def, _) => { - match struct_def.kind { - hir::VariantKind::Struct => ccx.sess().bug("instantiate_inline: called on a \ - non-tuple struct"), - _ => { - ccx.external().borrow_mut().insert(fn_id, Some(struct_def.id)); - my_id = struct_def.id; - } + if struct_def.is_struct() { + 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.sess().bug("instantiate_inline: item has a \ diff --git a/src/librustc_trans/trans/monomorphize.rs b/src/librustc_trans/trans/monomorphize.rs index 80d683a8f351a..440b667e8012d 100644 --- a/src/librustc_trans/trans/monomorphize.rs +++ b/src/librustc_trans/trans/monomorphize.rs @@ -246,7 +246,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, hir_map::NodeStructCtor(struct_def) => { let d = mk_lldecl(abi::Rust); attributes::inline(d, attributes::InlineAttr::Hint); - if struct_def.kind == hir::VariantKind::Struct { + if struct_def.is_struct() { panic!("ast-mapped struct didn't have a ctor id") } base::trans_tuple_struct(ccx, diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs index ebf54f62b5239..14947d9955efd 100644 --- a/src/librustc_typeck/check/wf.rs +++ b/src/librustc_typeck/check/wf.rs @@ -627,8 +627,7 @@ fn struct_variant<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, struct_def: &hir::VariantData) -> AdtVariant<'tcx> { let fields = - struct_def.fields - .iter() + struct_def.fields() .map(|field| { let field_ty = fcx.tcx().node_id_to_type(field.node.id); let field_ty = fcx.instantiate_type_scheme(field.span, diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index 0d2d37714c040..4cfc34dbb2384 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -524,8 +524,7 @@ fn struct_variant<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, struct_def: &hir::VariantData) -> AdtVariant<'tcx> { let fields = - struct_def.fields - .iter() + struct_def.fields() .map(|field| { let field_ty = fcx.tcx().node_id_to_type(field.node.id); let field_ty = fcx.instantiate_type_scheme(field.span, diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index c38befd744466..44e0668877464 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -1010,11 +1010,11 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { let it_def_id = ccx.tcx.map.local_def_id(it.id); let variant = tcx.lookup_adt_def_master(it_def_id).struct_variant(); - for (f, ty_f) in struct_def.fields.iter().zip(variant.fields.iter()) { + for (f, ty_f) in struct_def.fields().zip(variant.fields.iter()) { convert_field(ccx, &scheme.generics, &predicates, f, ty_f) } - if struct_def.kind != hir::VariantKind::Struct { + if !struct_def.is_struct() { convert_variant_ctor(tcx, struct_def.id, variant, scheme, predicates); } }, @@ -1067,7 +1067,7 @@ fn convert_enum_variant_types<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, variants: &[P]) { // fill the field types for (variant, ty_variant) in variants.iter().zip(def.variants.iter()) { - for (f, ty_f) in variant.node.data.fields.iter().zip(ty_variant.fields.iter()) { + for (f, ty_f) in variant.node.data.fields().zip(ty_variant.fields.iter()) { convert_field(ccx, &scheme.generics, &predicates, f, ty_f) } @@ -1089,7 +1089,7 @@ fn convert_struct_variant<'tcx>(tcx: &ty::ctxt<'tcx>, disr_val: ty::Disr, def: &hir::VariantData) -> ty::VariantDefData<'tcx, 'tcx> { let mut seen_fields: FnvHashMap = FnvHashMap(); - let fields = def.fields.iter().map(|f| { + let fields = def.fields().map(|f| { let fid = tcx.map.local_def_id(f.node.id); match f.node.kind { hir::NamedField(name, vis) => { @@ -1125,7 +1125,7 @@ fn convert_struct_def<'tcx>(tcx: &ty::ctxt<'tcx>, { let did = tcx.map.local_def_id(it.id); - let ctor_id = if def.kind != hir::VariantKind::Struct { + let ctor_id = if !def.is_struct() { tcx.map.local_def_id(def.id) } else { did diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index f935210ef286d..e5090c167dfe0 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1809,7 +1809,7 @@ impl Clean for ::rustc_front::hir::VariantData { fn clean(&self, cx: &DocContext) -> VariantStruct { VariantStruct { struct_type: doctree::struct_type_from_def(self), - fields: self.fields.clean(cx), + fields: self.fields().map(|x| x.clean(cx)).collect(), fields_stripped: false, } } @@ -1918,12 +1918,12 @@ pub enum VariantKind { } fn struct_def_to_variant_kind(struct_def: &hir::VariantData, cx: &DocContext) -> VariantKind { - if struct_def.kind == hir::VariantKind::Struct { + if struct_def.is_struct() { StructVariant(struct_def.clean(cx)) - } else if struct_def.kind == hir::VariantKind::Unit { + } else if struct_def.is_unit() { CLikeVariant } else { - TupleVariant(struct_def.fields.iter().map(|x| x.node.ty.clean(cx)).collect()) + TupleVariant(struct_def.fields().map(|x| x.node.ty.clean(cx)).collect()) } } diff --git a/src/librustdoc/doctree.rs b/src/librustdoc/doctree.rs index 112c6aebfc552..47cc007f605eb 100644 --- a/src/librustdoc/doctree.rs +++ b/src/librustdoc/doctree.rs @@ -234,9 +234,9 @@ pub struct Import { } pub fn struct_type_from_def(sd: &hir::VariantData) -> StructType { - if sd.kind != hir::VariantKind::Struct { + if !sd.is_struct() { // We are in a tuple-struct - match sd.fields.len() { + match sd.fields().count() { 0 => Unit, 1 => Newtype, _ => Tuple diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index e84d7f549a91d..19edccc4fe25f 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -97,7 +97,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { stab: self.stability(item.id), attrs: item.attrs.clone(), generics: generics.clone(), - fields: sd.fields.clone(), + fields: sd.fields().cloned().collect(), whence: item.span } } diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index af6235497675d..34181b2e09715 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -65,6 +65,7 @@ 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 @@ -1740,21 +1741,42 @@ impl StructFieldKind { } } -#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] -pub enum VariantKind { - Struct, - Tuple, +#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +pub enum VariantData_ { + Struct(Vec), + Tuple(Vec), Unit, } #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct VariantData { - /// Fields, not including ctor - pub fields: Vec, + pub data_: VariantData_, /// ID of the constructor. This is only used for tuple- or enum-like /// structs. pub id: NodeId, - pub kind: VariantKind, +} + +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() } + match self.data_ { + VariantData_::Struct(ref fields) | VariantData_::Tuple(ref fields) => Some(fields), + _ => None, + }.into_iter().flat_map(vec_iter) + } + pub fn is_struct(&self) -> bool { + if let VariantData_::Struct(..) = self.data_ { true } else { false } + } + pub fn is_tuple(&self) -> bool { + if let VariantData_::Tuple(..) = self.data_ { true } else { false } + } + pub fn is_unit(&self) -> bool { + if let VariantData_::Unit = self.data_ { true } else { false } + } } /* diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs index 02a9d0b5c38cb..739bb36d98525 100644 --- a/src/libsyntax/config.rs +++ b/src/libsyntax/config.rs @@ -167,13 +167,22 @@ fn fold_item_underscore(cx: &mut Context, item: ast::Item_) -> ast::Item_ fn fold_struct(cx: &mut Context, def: P) -> P where F: FnMut(&[ast::Attribute]) -> bool { - def.map(|ast::VariantData { fields, id, kind }| { + def.map(|ast::VariantData { data_, id }| { ast::VariantData { - fields: fields.into_iter().filter(|m| { - (cx.in_cfg)(&m.node.attrs) - }).collect(), + 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, - kind: kind, } }) } diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index 105a7036c5f6d..25657b9c6ccdf 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -1002,15 +1002,18 @@ impl<'a> AstBuilder for ExtCtxt<'a> { }} }).collect(); - let kind = if fields.is_empty() { ast::VariantKind::Unit } else { ast::VariantKind::Tuple }; + let data_ = if fields.is_empty() { + ast::VariantData_::Unit + } else { + ast::VariantData_::Tuple(fields) + }; respan(span, ast::Variant_ { name: name, attrs: Vec::new(), - data: P(ast::VariantData { fields: fields, - id: ast::DUMMY_NODE_ID, - kind: kind }), + data: P(ast::VariantData { data_: data_, + id: ast::DUMMY_NODE_ID}), disr_expr: None, }) } diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs index b375dee4e2c6c..2a5c4993112a9 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.iter() + let field_tys: Vec> = struct_def.fields() .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.iter() + field_tys.extend(variant.node.data.fields() .map(|field| field.node.ty.clone())); } @@ -1444,7 +1444,7 @@ impl<'a> TraitDef<'a> { struct_def: &VariantData) -> StaticFields { let mut named_idents = Vec::new(); let mut just_spans = Vec::new(); - for field in struct_def.fields.iter(){ + 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)), @@ -1483,7 +1483,7 @@ impl<'a> TraitDef<'a> { -> (P, Vec<(Span, Option, P, &'a [ast::Attribute])>) { - if struct_def.fields.is_empty() { + if struct_def.fields().count() == 0 { 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.iter().enumerate() { + for (i, struct_field) in struct_def.fields().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/ext/deriving/primitive.rs b/src/libsyntax/ext/deriving/primitive.rs index 3a079717b8b64..07b587783583e 100644 --- a/src/libsyntax/ext/deriving/primitive.rs +++ b/src/libsyntax/ext/deriving/primitive.rs @@ -95,7 +95,7 @@ fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure for variant in &enum_def.variants { let def = &variant.node.data; - if def.kind != ast::VariantKind::Unit { + if !def.is_unit() { cx.span_err(trait_span, "`FromPrimitive` cannot be derived \ for enums with non-unit variants"); return cx.expr_fail(trait_span, diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index a6922c2469395..be6ad9311114a 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -859,11 +859,11 @@ 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.is_empty() { - if s.kind == ast::VariantKind::Struct { + if s.fields().count() == 0 { + if s.is_struct() { self.gate_feature("braced_empty_structs", span, "empty structs and enum variants with braces are unstable"); - } else if s.kind == ast::VariantKind::Tuple { + } else if s.is_tuple() { self.context.span_handler.span_err(span, "empty tuple structs and enum variants \ are not allowed, use unit structs and \ enum variants instead"); diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index d7b7fc242b43f..329ffb286eb31 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -815,10 +815,17 @@ pub fn noop_fold_where_predicate( } pub fn noop_fold_struct_def(struct_def: P, fld: &mut T) -> P { - struct_def.map(|VariantData { fields, id, kind }| VariantData { - fields: fields.move_map(|f| fld.fold_struct_field(f)), + 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))) + } + ast::VariantData_::Tuple(fields) => { + ast::VariantData_::Tuple(fields.move_map(|f| fld.fold_struct_field(f))) + } + ast::VariantData_::Unit => ast::VariantData_::Unit + }, id: fld.new_id(id), - kind: kind, }) } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index f944c93073a45..2431c8cbe88d8 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, VariantKind}; +use ast::{StmtExpr, StmtSemi, StmtMac, VariantData, StructField, VariantData_}; use ast::{BiSub, StrStyle}; use ast::{SelfExplicit, SelfRegion, SelfStatic, SelfValue}; use ast::{Delimited, SequenceRepetition, TokenTree, TraitItem, TraitRef}; @@ -4640,26 +4640,24 @@ impl<'a> Parser<'a> { // Otherwise if we look ahead and see a paren we parse a tuple-style // struct. - let (fields, kind) = if self.token.is_keyword(keywords::Where) { + let data_ = 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 where T: Copy;` style decl. - (Vec::new(), VariantKind::Unit) + VariantData_::Unit } else { // If we see: `struct Foo where T: Copy { ... }` - (try!(self.parse_record_struct_body()), VariantKind::Struct) + VariantData_::Struct(try!(self.parse_record_struct_body())) } // No `where` so: `struct Foo;` } else if try!(self.eat(&token::Semi) ){ - (Vec::new(), VariantKind::Unit) + VariantData_::Unit // Record-style struct definition } else if self.token == token::OpenDelim(token::Brace) { - let fields = try!(self.parse_record_struct_body()); - (fields, VariantKind::Struct) + VariantData_::Struct(try!(self.parse_record_struct_body())) // Tuple-style struct definition with optional where-clause. } else if self.token == token::OpenDelim(token::Paren) { - let fields = try!(self.parse_tuple_struct_body(&mut generics)); - (fields, VariantKind::Tuple) + VariantData_::Tuple(try!(self.parse_tuple_struct_body(&mut generics))) } else { let token_str = self.this_token_to_string(); return Err(self.fatal(&format!("expected `where`, `{{`, `(`, or `;` after struct \ @@ -4668,9 +4666,8 @@ impl<'a> Parser<'a> { Ok((class_name, ItemStruct(P(ast::VariantData { - fields: fields, + data_: data_, id: ast::DUMMY_NODE_ID, - kind: kind, }), generics), None)) } @@ -5111,9 +5108,8 @@ impl<'a> Parser<'a> { try!(self.bump()); Ok(P(VariantData { - fields: fields, + data_: VariantData_::Struct(fields), id: ast::DUMMY_NODE_ID, - kind: VariantKind::Struct, })) } @@ -5150,19 +5146,16 @@ impl<'a> Parser<'a> { id: ast::DUMMY_NODE_ID, }}); } - struct_def = P(VariantData { fields: fields, - id: ast::DUMMY_NODE_ID, - kind: ast::VariantKind::Tuple }); + struct_def = P(VariantData { data_: ast::VariantData_::Tuple(fields), + id: 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 { fields: Vec::new(), - id: ast::DUMMY_NODE_ID, - kind: ast::VariantKind::Unit }); + struct_def = P(VariantData { data_: ast::VariantData_::Unit, + id: ast::DUMMY_NODE_ID}); } else { - struct_def = P(VariantData { fields: Vec::new(), - id: ast::DUMMY_NODE_ID, - kind: ast::VariantKind::Unit }); + struct_def = P(VariantData { data_: ast::VariantData_::Unit, + id: ast::DUMMY_NODE_ID}); } let vr = ast::Variant_ { diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 0f6041d2cd071..161f6243f85cc 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -520,6 +520,18 @@ 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; @@ -1392,11 +1404,11 @@ impl<'a> State<'a> { print_finalizer: bool) -> io::Result<()> { try!(self.print_ident(ident)); try!(self.print_generics(generics)); - if struct_def.kind != ast::VariantKind::Struct { - if struct_def.kind == ast::VariantKind::Tuple { + if !struct_def.is_struct() { + if struct_def.is_tuple() { try!(self.popen()); - try!(self.commasep( - Inconsistent, &struct_def.fields, + try!(self.commasep_iter( + Inconsistent, struct_def.fields(), |s, field| { match field.node.kind { ast::NamedField(..) => panic!("unexpected named field"), @@ -1422,7 +1434,7 @@ impl<'a> State<'a> { try!(self.bopen()); try!(self.hardbreak_if_not_bol()); - for field in &struct_def.fields { + for field in struct_def.fields() { match field.node.kind { ast::UnnamedField(..) => panic!("unexpected unnamed field"), ast::NamedField(ident, visibility) => { @@ -3119,9 +3131,8 @@ mod tests { name: ident, attrs: Vec::new(), // making this up as I go.... ? - data: P(ast::VariantData { fields: Vec::new(), - id: ast::DUMMY_NODE_ID, - kind: ast::VariantKind::Unit }), + data: P(ast::VariantData { data_: ast::VariantData_::Unit, + id: ast::DUMMY_NODE_ID}), disr_expr: None, }); diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index fdff0bf72ebfc..b7d202804c5a4 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -604,7 +604,7 @@ pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplIt pub fn walk_struct_def<'v, V: Visitor<'v>>(visitor: &mut V, struct_definition: &'v VariantData) { - walk_list!(visitor, visit_struct_field, &struct_definition.fields); + walk_list!(visitor, visit_struct_field, struct_definition.fields()); } pub fn walk_struct_field<'v, V: Visitor<'v>>(visitor: &mut V, From a5225cbe92d962dfed922b434a21f8474f303da2 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Fri, 9 Oct 2015 23:32:37 +0300 Subject: [PATCH 11/13] Fix rebase 2 --- src/librustc/middle/astencode.rs | 6 +++--- src/librustc_front/lowering.rs | 10 ++++++---- src/librustc_typeck/collect.rs | 2 +- 3 files changed, 10 insertions(+), 8 deletions(-) diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index ca05de81e77c8..584f6cb4e99d7 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -1315,7 +1315,7 @@ 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.id); + orig_variant.did, i_variant.node.data.id); copy_item_type(dcx, i_variant.node.data.id, orig_variant.did); } } @@ -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, - ctor_id); - copy_item_type(dcx, ctor_id, ctor_did); + def.id); + copy_item_type(dcx, def.id, ctor_did); } } _ => {} diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs index cd32ad15744bf..2f257a47dbf70 100644 --- a/src/librustc_front/lowering.rs +++ b/src/librustc_front/lowering.rs @@ -267,7 +267,7 @@ pub fn lower_variant(_lctx: &LoweringContext, v: &Variant) -> P { name: v.node.name.name, attrs: v.node.attrs.clone(), data: lower_struct_def(_lctx, &v.node.data), - disr_expr: v.node.disr_expr.as_ref().map(|e| lower_expr(e)), + disr_expr: v.node.disr_expr.as_ref().map(|e| lower_expr(_lctx, e)), }, span: v.span, }) @@ -498,15 +498,17 @@ pub fn lower_where_predicate(_lctx: &LoweringContext, } } -pub fn lower_struct_def(sd: &VariantData) -> P { +pub fn lower_struct_def(_lctx: &LoweringContext, sd: &VariantData) -> P { 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()) + 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()) + hir::VariantData_::Tuple(fields.iter() + .map(|f| lower_struct_field(_lctx, f)).collect()) } VariantData_::Unit => hir::VariantData_::Unit } diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 44e0668877464..31f7f3174b8af 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -1211,7 +1211,7 @@ fn convert_enum_def<'tcx>(tcx: &ty::ctxt<'tcx>, { 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, did) + convert_struct_variant(tcx, did, name, disr, &v.node.data) } let did = tcx.map.local_def_id(it.id); let repr_hints = tcx.lookup_repr_hints(did); From 46750d0409a9c3ba5214aa20ccb0c9bdbf09ea7e Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sat, 10 Oct 2015 03:28:40 +0300 Subject: [PATCH 12/13] Merge VariantData and VariantData_ --- src/librustc/front/map/collector.rs | 4 +-- src/librustc/metadata/encoder.rs | 8 ++--- src/librustc/middle/astencode.rs | 8 ++--- src/librustc/middle/check_static_recursion.rs | 6 ++-- src/librustc/middle/const_eval.rs | 2 +- src/librustc/middle/dead.rs | 9 ++--- src/librustc/middle/stability.rs | 4 +-- src/librustc_front/fold.rs | 21 +++++------ src/librustc_front/hir.rs | 31 ++++++++-------- src/librustc_front/lowering.rs | 21 +++++------ src/librustc_front/util.rs | 2 +- src/librustc_lint/builtin.rs | 3 +- src/librustc_privacy/lib.rs | 12 +++---- src/librustc_resolve/build_reduced_graph.rs | 10 +++--- src/librustc_trans/save/dump_csv.rs | 8 ++--- src/librustc_trans/trans/base.rs | 2 +- src/librustc_trans/trans/inline.rs | 8 ++--- src/librustc_trans/trans/monomorphize.rs | 2 +- src/librustc_typeck/collect.rs | 8 ++--- src/librustdoc/clean/mod.rs | 2 +- src/librustdoc/visit_ast.rs | 2 +- src/libsyntax/ast.rs | 31 ++++++++-------- src/libsyntax/ast_util.rs | 2 +- src/libsyntax/config.rs | 29 +++++++-------- src/libsyntax/ext/build.rs | 9 +++-- src/libsyntax/fold.rs | 19 +++++----- src/libsyntax/parse/parser.rs | 36 ++++++++----------- src/libsyntax/print/pprust.rs | 3 +- 28 files changed, 141 insertions(+), 161 deletions(-) diff --git a/src/librustc/front/map/collector.rs b/src/librustc/front/map/collector.rs index aa5d482b89a83..fc7531d3f61ba 100644 --- a/src/librustc/front/map/collector.rs +++ b/src/librustc/front/map/collector.rs @@ -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); } diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 81305099705ce..8e2c2e6a0bfbd 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -382,7 +382,7 @@ fn each_auxiliary_node_id(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, _) => { diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 584f6cb4e99d7..e81445f19ede6 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -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); } } _ => {} diff --git a/src/librustc/middle/check_static_recursion.rs b/src/librustc/middle/check_static_recursion.rs index 226c27ea62048..fd73fe45180be 100644 --- a/src/librustc/middle/check_static_recursion.rs +++ b/src/librustc/middle/check_static_recursion.rs @@ -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 = 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` diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index e0850a55ff0aa..3c68fb62e2445 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -63,7 +63,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt, fn variant_expr<'a>(variants: &'a [P], 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); } } diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 9d15b53a6d826..7b11419d92562 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -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 { 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"); } } diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index 23bb4a1fe393d..af295c3e584b0 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -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) } diff --git a/src/librustc_front/fold.rs b/src/librustc_front/fold.rs index fd69d2007ff13..dafca7188d5ad 100644 --- a/src/librustc_front/fold.rs +++ b/src/librustc_front/fold.rs @@ -694,18 +694,15 @@ pub fn noop_fold_where_predicate(pred: WherePredicate, fld: &mut T) - } pub fn noop_fold_struct_def(struct_def: P, fld: &mut T) -> P { - 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)) } }) } diff --git a/src/librustc_front/hir.rs b/src/librustc_front/hir.rs index b5170b7496b46..a64e1e147fe80 100644 --- a/src/librustc_front/hir.rs +++ b/src/librustc_front/hir.rs @@ -1162,18 +1162,10 @@ impl StructFieldKind { } #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] -pub enum VariantData_ { - Struct(Vec), - Tuple(Vec), - 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, NodeId), + Tuple(Vec, NodeId), + Unit(NodeId), } pub type FieldIter<'a> = iter::FlatMap>, @@ -1183,19 +1175,24 @@ pub type FieldIter<'a> = iter::FlatMap>, impl VariantData { pub fn fields(&self) -> FieldIter { fn vec_iter(v: &Vec) -> slice::Iter { 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/librustc_front/lowering.rs b/src/librustc_front/lowering.rs index 2f257a47dbf70..890896eb1c5aa 100644 --- a/src/librustc_front/lowering.rs +++ b/src/librustc_front/lowering.rs @@ -499,19 +499,16 @@ pub fn lower_where_predicate(_lctx: &LoweringContext, } pub fn lower_struct_def(_lctx: &LoweringContext, sd: &VariantData) -> P { - 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) }) } diff --git a/src/librustc_front/util.rs b/src/librustc_front/util.rs index 8bf3ccd0b810c..5d8973ead47db 100644 --- a/src/librustc_front/util.rs +++ b/src/librustc_front/util.rs @@ -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); } diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index ea8ea4ebf0dac..f5a58656080db 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -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; } diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index b139b27578516..608558ac2bdb9 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -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; diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 43943fbb129dc..c051f8c263723 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -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); } diff --git a/src/librustc_trans/save/dump_csv.rs b/src/librustc_trans/save/dump_csv.rs index d31b8b6f0e48d..146fa857fc850 100644 --- a/src/librustc_trans/save/dump_csv.rs +++ b/src/librustc_trans/save/dump_csv.rs @@ -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); } } diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index c692f8a183605..9fa1aaf76f819 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -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); diff --git a/src/librustc_trans/trans/inline.rs b/src/librustc_trans/trans/inline.rs index 923214a536227..14e1ca7675f79 100644 --- a/src/librustc_trans/trans/inline.rs +++ b/src/librustc_trans/trans/inline.rs @@ -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 \ diff --git a/src/librustc_trans/trans/monomorphize.rs b/src/librustc_trans/trans/monomorphize.rs index 440b667e8012d..f84f0feb96030 100644 --- a/src/librustc_trans/trans/monomorphize.rs +++ b/src/librustc_trans/trans/monomorphize.rs @@ -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 diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 31f7f3174b8af..194710a46fbce 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -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) } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index e5090c167dfe0..e4420d0dd92fa 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1853,7 +1853,7 @@ impl Clean 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), }), diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index 19edccc4fe25f..1487c1668aac7 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -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(), diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 34181b2e09715..7c82813775e21 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), - Tuple(Vec), - 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, NodeId), + Tuple(Vec, NodeId), + Unit(NodeId), } pub type FieldIter<'a> = iter::FlatMap>, @@ -1763,19 +1755,24 @@ pub type FieldIter<'a> = iter::FlatMap>, impl VariantData { pub fn fields(&self) -> FieldIter { fn vec_iter(v: &Vec) -> slice::Iter { 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 42382d0459fdd..8c3360512d512 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 739bb36d98525..0ca110c5b1ed2 100644 --- a/src/libsyntax/config.rs +++ b/src/libsyntax/config.rs @@ -167,22 +167,19 @@ fn fold_item_underscore(cx: &mut Context, item: ast::Item_) -> ast::Item_ fn fold_struct(cx: &mut Context, def: P) -> P 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 25657b9c6ccdf..9b06fbd0a0b85 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 329ffb286eb31..219a4649339dd 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -815,17 +815,18 @@ pub fn noop_fold_where_predicate( } pub fn noop_fold_struct_def(struct_def: P, fld: &mut T) -> P { - 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 2431c8cbe88d8..934e4472bdc84 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 where T: Copy;` style decl. - VariantData_::Unit + VariantData::Unit(ast::DUMMY_NODE_ID) } else { // If we see: `struct Foo 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;` } 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> { @@ -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 161f6243f85cc..e5a9ce216a92a 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, }); From 607b8c38923878264980503227ff4911d0da5b4b Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Tue, 13 Oct 2015 16:18:33 +0300 Subject: [PATCH 13/13] Comment on the purpose(s) of NodeId in VariantData --- src/librustc_front/hir.rs | 11 +++++++++++ src/libsyntax/ast.rs | 11 +++++++++++ 2 files changed, 22 insertions(+) diff --git a/src/librustc_front/hir.rs b/src/librustc_front/hir.rs index a64e1e147fe80..e62eadaa4387d 100644 --- a/src/librustc_front/hir.rs +++ b/src/librustc_front/hir.rs @@ -1161,6 +1161,17 @@ impl StructFieldKind { } } +/// Fields and Ids of enum variants and structs +/// +/// For enum variants: `NodeId` represents both an Id of the variant itself (relevant for all +/// variant kinds) and an Id of the variant's constructor (not relevant for `Struct`-variants). +/// One shared Id can be successfully used for these two purposes. +/// Id of the whole enum lives in `Item`. +/// +/// For structs: `NodeId` represents an Id of the structure's constructor, so it is not actually +/// used for `Struct`-structs (but still presents). Structures don't have an analogue of "Id of +/// the variant itself" from enum variants. +/// Id of the whole struct lives in `Item`. #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub enum VariantData { Struct(Vec, NodeId), diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 7c82813775e21..720c2ffc6d483 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -1741,6 +1741,17 @@ impl StructFieldKind { } } +/// Fields and Ids of enum variants and structs +/// +/// For enum variants: `NodeId` represents both an Id of the variant itself (relevant for all +/// variant kinds) and an Id of the variant's constructor (not relevant for `Struct`-variants). +/// One shared Id can be successfully used for these two purposes. +/// Id of the whole enum lives in `Item`. +/// +/// For structs: `NodeId` represents an Id of the structure's constructor, so it is not actually +/// used for `Struct`-structs (but still presents). Structures don't have an analogue of "Id of +/// the variant itself" from enum variants. +/// Id of the whole struct lives in `Item`. #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub enum VariantData { Struct(Vec, NodeId),