bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Merge Variant and Variant_

Browse source
This commit is contained in:
Caio 2019-08-13 21:40:21 -03:00
parent 60960a260f
commit 6a42b0b28d
46 changed files with 162 additions and 166 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/librustc/hir/check_attr.rs
View file

@ -336,7 +336,7 @@ impl Visitor<'tcx> for CheckAttrVisitor<'tcx> {
fn is_c_like_enum(item: &hir::Item) -> bool { fn is_c_like_enum(item: &hir::Item) -> bool {
if let hir::ItemKind::Enum(ref def, _) = item.node { if let hir::ItemKind::Enum(ref def, _) = item.node {
for variant in &def.variants { for variant in &def.variants {
match variant.node.data { match variant.data {
hir::VariantData::Unit(..) => { /* continue */ } hir::VariantData::Unit(..) => { /* continue */ }
_ => { return false; } _ => { return false; }
} }

12
src/librustc/hir/intravisit.rs
View file

@ -577,15 +577,15 @@ pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V,
variant: &'v Variant, variant: &'v Variant,
generics: &'v Generics, generics: &'v Generics,
parent_item_id: HirId) { parent_item_id: HirId) {
visitor.visit_ident(variant.node.ident); visitor.visit_ident(variant.ident);
visitor.visit_id(variant.node.id); visitor.visit_id(variant.id);
visitor.visit_variant_data(&variant.node.data, visitor.visit_variant_data(&variant.data,
variant.node.ident.name, variant.ident.name,
generics, generics,
parent_item_id, parent_item_id,
variant.span); variant.span);
walk_list!(visitor, visit_anon_const, &variant.node.disr_expr); walk_list!(visitor, visit_anon_const, &variant.disr_expr);
walk_list!(visitor, visit_attribute, &variant.node.attrs); walk_list!(visitor, visit_attribute, &variant.attrs);
} }
pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) { pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) {

14
src/librustc/hir/lowering/item.rs
View file

@ -733,14 +733,12 @@ impl LoweringContext<'_> {
} }
fn lower_variant(&mut self, v: &Variant) -> hir::Variant { fn lower_variant(&mut self, v: &Variant) -> hir::Variant {
Spanned { hir::Variant {
node: hir::VariantKind { attrs: self.lower_attrs(&v.attrs),
ident: v.node.ident, data: self.lower_variant_data(&v.data),
id: self.lower_node_id(v.node.id), disr_expr: v.disr_expr.as_ref().map(|e| self.lower_anon_const(e)),
attrs: self.lower_attrs(&v.node.attrs), id: self.lower_node_id(v.id),
data: self.lower_variant_data(&v.node.data), ident: v.ident,
disr_expr: v.node.disr_expr.as_ref().map(|e| self.lower_anon_const(e)),
},
span: v.span, span: v.span,
} }
} }

8
src/librustc/hir/map/collector.rs
View file

@ -544,11 +544,11 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
} }
fn visit_variant(&mut self, v: &'hir Variant, g: &'hir Generics, item_id: HirId) { fn visit_variant(&mut self, v: &'hir Variant, g: &'hir Generics, item_id: HirId) {
self.insert(v.span, v.node.id, Node::Variant(v)); self.insert(v.span, v.id, Node::Variant(v));
self.with_parent(v.node.id, |this| { self.with_parent(v.id, |this| {
// Register the constructor of this variant. // Register the constructor of this variant.
if let Some(ctor_hir_id) = v.node.data.ctor_hir_id() { if let Some(ctor_hir_id) = v.data.ctor_hir_id() {
this.insert(v.span, ctor_hir_id, Node::Ctor(&v.node.data)); this.insert(v.span, ctor_hir_id, Node::Ctor(&v.data));
} }
intravisit::walk_variant(this, v, g, item_id); intravisit::walk_variant(this, v, g, item_id);
}); });

6
src/librustc/hir/map/def_collector.rs
View file

@ -155,11 +155,11 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
} }
fn visit_variant(&mut self, v: &'a Variant, g: &'a Generics, item_id: NodeId) { fn visit_variant(&mut self, v: &'a Variant, g: &'a Generics, item_id: NodeId) {
let def = self.create_def(v.node.id, let def = self.create_def(v.id,
DefPathData::TypeNs(v.node.ident.as_interned_str()), DefPathData::TypeNs(v.ident.as_interned_str()),
v.span); v.span);
self.with_parent(def, |this| { self.with_parent(def, |this| {
if let Some(ctor_hir_id) = v.node.data.ctor_id() { if let Some(ctor_hir_id) = v.data.ctor_id() {
this.create_def(ctor_hir_id, DefPathData::Ctor, v.span); this.create_def(ctor_hir_id, DefPathData::Ctor, v.span);
} }
visit::walk_variant(this, v, g, item_id) visit::walk_variant(this, v, g, item_id)

10
src/librustc/hir/map/mod.rs
View file

@ -885,7 +885,7 @@ impl<'hir> Map<'hir> {
_ => bug!("struct ID bound to non-struct {}", self.node_to_string(id)) _ => bug!("struct ID bound to non-struct {}", self.node_to_string(id))
} }
} }
Some(Node::Variant(variant)) => &variant.node.data, Some(Node::Variant(variant)) => &variant.data,
Some(Node::Ctor(data)) => data, Some(Node::Ctor(data)) => data,
_ => bug!("expected struct or variant, found {}", self.node_to_string(id)) _ => bug!("expected struct or variant, found {}", self.node_to_string(id))
} }
@ -918,7 +918,7 @@ impl<'hir> Map<'hir> {
Node::ForeignItem(fi) => fi.ident.name, Node::ForeignItem(fi) => fi.ident.name,
Node::ImplItem(ii) => ii.ident.name, Node::ImplItem(ii) => ii.ident.name,
Node::TraitItem(ti) => ti.ident.name, Node::TraitItem(ti) => ti.ident.name,
Node::Variant(v) => v.node.ident.name, Node::Variant(v) => v.ident.name,
Node::Field(f) => f.ident.name, Node::Field(f) => f.ident.name,
Node::Lifetime(lt) => lt.name.ident().name, Node::Lifetime(lt) => lt.name.ident().name,
Node::GenericParam(param) => param.name.ident().name, Node::GenericParam(param) => param.name.ident().name,
@ -939,7 +939,7 @@ impl<'hir> Map<'hir> {
Some(Node::ForeignItem(fi)) => Some(&fi.attrs[..]), Some(Node::ForeignItem(fi)) => Some(&fi.attrs[..]),
Some(Node::TraitItem(ref ti)) => Some(&ti.attrs[..]), Some(Node::TraitItem(ref ti)) => Some(&ti.attrs[..]),
Some(Node::ImplItem(ref ii)) => Some(&ii.attrs[..]), Some(Node::ImplItem(ref ii)) => Some(&ii.attrs[..]),
Some(Node::Variant(ref v)) => Some(&v.node.attrs[..]), Some(Node::Variant(ref v)) => Some(&v.attrs[..]),
Some(Node::Field(ref f)) => Some(&f.attrs[..]), Some(Node::Field(ref f)) => Some(&f.attrs[..]),
Some(Node::Expr(ref e)) => Some(&*e.attrs), Some(Node::Expr(ref e)) => Some(&*e.attrs),
Some(Node::Stmt(ref s)) => Some(s.node.attrs()), Some(Node::Stmt(ref s)) => Some(s.node.attrs()),
@ -1133,7 +1133,7 @@ impl<T:Named> Named for Spanned<T> { fn name(&self) -> Name { self.node.name() }
impl Named for Item { fn name(&self) -> Name { self.ident.name } } impl Named for Item { fn name(&self) -> Name { self.ident.name } }
impl Named for ForeignItem { fn name(&self) -> Name { self.ident.name } } impl Named for ForeignItem { fn name(&self) -> Name { self.ident.name } }
impl Named for VariantKind { fn name(&self) -> Name { self.ident.name } } impl Named for Variant { fn name(&self) -> Name { self.ident.name } }
impl Named for StructField { fn name(&self) -> Name { self.ident.name } } impl Named for StructField { fn name(&self) -> Name { self.ident.name } }
impl Named for TraitItem { fn name(&self) -> Name { self.ident.name } } impl Named for TraitItem { fn name(&self) -> Name { self.ident.name } }
impl Named for ImplItem { fn name(&self) -> Name { self.ident.name } } impl Named for ImplItem { fn name(&self) -> Name { self.ident.name } }
@ -1310,7 +1310,7 @@ fn hir_id_to_string(map: &Map<'_>, id: HirId, include_id: bool) -> String {
} }
Some(Node::Variant(ref variant)) => { Some(Node::Variant(ref variant)) => {
format!("variant {} in {}{}", format!("variant {} in {}{}",
variant.node.ident, variant.ident,
path_str(), id_str) path_str(), id_str)
} }
Some(Node::Field(ref field)) => { Some(Node::Field(ref field)) => {

6
src/librustc/hir/mod.rs
View file

@ -2193,7 +2193,7 @@ pub struct EnumDef {
} }
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)] #[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct VariantKind { pub struct Variant {
/// Name of the variant. /// Name of the variant.
#[stable_hasher(project(name))] #[stable_hasher(project(name))]
pub ident: Ident, pub ident: Ident,
@ -2205,10 +2205,10 @@ pub struct VariantKind {
pub data: VariantData, pub data: VariantData,
/// Explicit discriminant (e.g., `Foo = 1`). /// Explicit discriminant (e.g., `Foo = 1`).
pub disr_expr: Option<AnonConst>, pub disr_expr: Option<AnonConst>,
/// Span
pub span: Span
} }
pub type Variant = Spanned<VariantKind>;
#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable)] #[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable)]
pub enum UseKind { pub enum UseKind {
/// One import, e.g., `use foo::bar` or `use foo::bar as baz`. /// One import, e.g., `use foo::bar` or `use foo::bar as baz`.

6
src/librustc/hir/print.rs
View file

@ -737,7 +737,7 @@ impl<'a> State<'a> {
for v in variants { for v in variants {
self.space_if_not_bol(); self.space_if_not_bol();
self.maybe_print_comment(v.span.lo()); self.maybe_print_comment(v.span.lo());
self.print_outer_attributes(&v.node.attrs); self.print_outer_attributes(&v.attrs);
self.ibox(INDENT_UNIT); self.ibox(INDENT_UNIT);
self.print_variant(v); self.print_variant(v);
self.s.word(","); self.s.word(",");
@ -829,8 +829,8 @@ impl<'a> State<'a> {
pub fn print_variant(&mut self, v: &hir::Variant) { pub fn print_variant(&mut self, v: &hir::Variant) {
self.head(""); self.head("");
let generics = hir::Generics::empty(); let generics = hir::Generics::empty();
self.print_struct(&v.node.data, &generics, v.node.ident.name, v.span, false); self.print_struct(&v.data, &generics, v.ident.name, v.span, false);
if let Some(ref d) = v.node.disr_expr { if let Some(ref d) = v.disr_expr {
self.s.space(); self.s.space();
self.word_space("="); self.word_space("=");
self.print_anon_const(d); self.print_anon_const(d);

2
src/librustc/ich/impls_hir.rs
View file

@ -304,7 +304,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for hir::Mod {
} }
} }
impl_stable_hash_for_spanned!(hir::VariantKind); impl_stable_hash_for_spanned!(hir::Variant);
impl<'a> HashStable<StableHashingContext<'a>> for hir::Item { impl<'a> HashStable<StableHashingContext<'a>> for hir::Item {

4
src/librustc/lint/context.rs
View file

@ -1060,7 +1060,7 @@ for LateContextAndPass<'a, 'tcx, T> {
v: &'tcx hir::Variant, v: &'tcx hir::Variant,
g: &'tcx hir::Generics, g: &'tcx hir::Generics,
item_id: hir::HirId) { item_id: hir::HirId) {
self.with_lint_attrs(v.node.id, &v.node.attrs, |cx| { self.with_lint_attrs(v.id, &v.attrs, |cx| {
lint_callback!(cx, check_variant, v, g); lint_callback!(cx, check_variant, v, g);
hir_visit::walk_variant(cx, v, g, item_id); hir_visit::walk_variant(cx, v, g, item_id);
lint_callback!(cx, check_variant_post, v, g); lint_callback!(cx, check_variant_post, v, g);
@ -1236,7 +1236,7 @@ impl<'a, T: EarlyLintPass> ast_visit::Visitor<'a> for EarlyContextAndPass<'a, T>
} }
fn visit_variant(&mut self, v: &'a ast::Variant, g: &'a ast::Generics, item_id: ast::NodeId) { fn visit_variant(&mut self, v: &'a ast::Variant, g: &'a ast::Generics, item_id: ast::NodeId) {
self.with_lint_attrs(item_id, &v.node.attrs, |cx| { self.with_lint_attrs(item_id, &v.attrs, |cx| {
run_early_pass!(cx, check_variant, v, g); run_early_pass!(cx, check_variant, v, g);
ast_visit::walk_variant(cx, v, g, item_id); ast_visit::walk_variant(cx, v, g, item_id);
run_early_pass!(cx, check_variant_post, v, g); run_early_pass!(cx, check_variant_post, v, g);

2
src/librustc/lint/mod.rs
View file

@ -846,7 +846,7 @@ impl intravisit::Visitor<'tcx> for LintLevelMapBuilder<'tcx> {
v: &'tcx hir::Variant, v: &'tcx hir::Variant,
g: &'tcx hir::Generics, g: &'tcx hir::Generics,
item_id: hir::HirId) { item_id: hir::HirId) {
self.with_lint_attrs(v.node.id, &v.node.attrs, |builder| { self.with_lint_attrs(v.id, &v.attrs, |builder| {
intravisit::walk_variant(builder, v, g, item_id); intravisit::walk_variant(builder, v, g, item_id);
}) })
} }

12
src/librustc/middle/dead.rs
View file

@ -366,12 +366,12 @@ impl<'v, 'k, 'tcx> ItemLikeVisitor<'v> for LifeSeeder<'k, 'tcx> {
match item.node { match item.node {
hir::ItemKind::Enum(ref enum_def, _) => { hir::ItemKind::Enum(ref enum_def, _) => {
if allow_dead_code { 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.id));
} }
for variant in &enum_def.variants { for variant in &enum_def.variants {
if let Some(ctor_hir_id) = variant.node.data.ctor_hir_id() { if let Some(ctor_hir_id) = variant.data.ctor_hir_id() {
self.struct_constructors.insert(ctor_hir_id, variant.node.id); self.struct_constructors.insert(ctor_hir_id, variant.id);
} }
} }
} }
@ -497,7 +497,7 @@ impl DeadVisitor<'tcx> {
&& !has_allow_dead_code_or_lang_attr(self.tcx, field.hir_id, &field.attrs) && !has_allow_dead_code_or_lang_attr(self.tcx, field.hir_id, &field.attrs)
} }
fn should_warn_about_variant(&mut self, variant: &hir::VariantKind) -> bool { fn should_warn_about_variant(&mut self, variant: &hir::Variant) -> bool {
!self.symbol_is_live(variant.id) !self.symbol_is_live(variant.id)
&& !has_allow_dead_code_or_lang_attr(self.tcx, && !has_allow_dead_code_or_lang_attr(self.tcx,
variant.id, variant.id,
@ -596,8 +596,8 @@ impl Visitor<'tcx> for DeadVisitor<'tcx> {
variant: &'tcx hir::Variant, variant: &'tcx hir::Variant,
g: &'tcx hir::Generics, g: &'tcx hir::Generics,
id: hir::HirId) { id: hir::HirId) {
if self.should_warn_about_variant(&variant.node) { if self.should_warn_about_variant(&variant) {
self.warn_dead_code(variant.node.id, variant.span, variant.node.ident.name, self.warn_dead_code(variant.id, variant.span, variant.ident.name,
"variant", "constructed"); "variant", "constructed");
} else { } else {
intravisit::walk_variant(self, variant, g, id); intravisit::walk_variant(self, variant, g, id);

8
src/librustc/middle/stability.rs
View file

@ -290,10 +290,10 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
} }
fn visit_variant(&mut self, var: &'tcx Variant, g: &'tcx Generics, item_id: HirId) { fn visit_variant(&mut self, var: &'tcx Variant, g: &'tcx Generics, item_id: HirId) {
self.annotate(var.node.id, &var.node.attrs, var.span, AnnotationKind::Required, self.annotate(var.id, &var.attrs, var.span, AnnotationKind::Required,
|v| { |v| {
if let Some(ctor_hir_id) = var.node.data.ctor_hir_id() { if let Some(ctor_hir_id) = var.data.ctor_hir_id() {
v.annotate(ctor_hir_id, &var.node.attrs, var.span, AnnotationKind::Required, v.annotate(ctor_hir_id, &var.attrs, var.span, AnnotationKind::Required,
|_| {}); |_| {});
} }
@ -372,7 +372,7 @@ impl<'a, 'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'a, 'tcx> {
} }
fn visit_variant(&mut self, var: &'tcx Variant, g: &'tcx Generics, item_id: HirId) { fn visit_variant(&mut self, var: &'tcx Variant, g: &'tcx Generics, item_id: HirId) {
self.check_missing_stability(var.node.id, var.span, "variant"); self.check_missing_stability(var.id, var.span, "variant");
intravisit::walk_variant(self, var, g, item_id); intravisit::walk_variant(self, var, g, item_id);
} }

4
src/librustc_lint/builtin.rs
View file

@ -484,8 +484,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {
fn check_variant(&mut self, cx: &LateContext<'_, '_>, v: &hir::Variant, _: &hir::Generics) { fn check_variant(&mut self, cx: &LateContext<'_, '_>, v: &hir::Variant, _: &hir::Generics) {
self.check_missing_docs_attrs(cx, self.check_missing_docs_attrs(cx,
Some(v.node.id), Some(v.id),
&v.node.attrs, &v.attrs,
v.span, v.span,
"a variant"); "a variant");
} }

2
src/librustc_lint/nonstandard_style.rs
View file

@ -147,7 +147,7 @@ impl EarlyLintPass for NonCamelCaseTypes {
} }
fn check_variant(&mut self, cx: &EarlyContext<'_>, v: &ast::Variant, _: &ast::Generics) { fn check_variant(&mut self, cx: &EarlyContext<'_>, v: &ast::Variant, _: &ast::Generics) {
self.check_case(cx, "variant", &v.node.ident); self.check_case(cx, "variant", &v.ident);
} }
fn check_generic_param(&mut self, cx: &EarlyContext<'_>, param: &ast::GenericParam) { fn check_generic_param(&mut self, cx: &EarlyContext<'_>, param: &ast::GenericParam) {

2
src/librustc_lint/types.rs
View file

@ -976,7 +976,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for VariantSizeDifferences {
let bytes = variant_layout.size.bytes().saturating_sub(discr_size); let bytes = variant_layout.size.bytes().saturating_sub(discr_size);
debug!("- variant `{}` is {} bytes large", debug!("- variant `{}` is {} bytes large",
variant.node.ident, variant.ident,
bytes); bytes);
bytes bytes
}) })

2
src/librustc_metadata/encoder.rs
View file

@ -1676,7 +1676,7 @@ impl Visitor<'tcx> for EncodeContext<'tcx> {
id: hir::HirId) { id: hir::HirId) {
intravisit::walk_variant(self, v, g, id); intravisit::walk_variant(self, v, g, id);
if let Some(ref discr) = v.node.disr_expr { if let Some(ref discr) = v.disr_expr {
let def_id = self.tcx.hir().local_def_id(discr.hir_id); let def_id = self.tcx.hir().local_def_id(discr.hir_id);
self.record(def_id, EncodeContext::encode_info_for_anon_const, def_id); self.record(def_id, EncodeContext::encode_info_for_anon_const, def_id);
} }

2
src/librustc_passes/ast_validation.rs
View file

@ -602,7 +602,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
} }
ItemKind::Enum(ref def, _) => { ItemKind::Enum(ref def, _) => {
for variant in &def.variants { for variant in &def.variants {
for field in variant.node.data.fields() { for field in variant.data.fields() {
self.invalid_visibility(&field.vis, None); self.invalid_visibility(&field.vis, None);
} }
} }

14
src/librustc_privacy/lib.rs
View file

@ -687,11 +687,11 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> {
match item.node { match item.node {
hir::ItemKind::Enum(ref def, _) => { hir::ItemKind::Enum(ref def, _) => {
for variant in &def.variants { for variant in &def.variants {
let variant_level = self.update(variant.node.id, item_level); let variant_level = self.update(variant.id, item_level);
if let Some(ctor_hir_id) = variant.node.data.ctor_hir_id() { if let Some(ctor_hir_id) = variant.data.ctor_hir_id() {
self.update(ctor_hir_id, item_level); self.update(ctor_hir_id, item_level);
} }
for field in variant.node.data.fields() { for field in variant.data.fields() {
self.update(field.hir_id, variant_level); self.update(field.hir_id, variant_level);
} }
} }
@ -810,9 +810,9 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> {
self.reach(item.hir_id, item_level).generics().predicates(); self.reach(item.hir_id, item_level).generics().predicates();
} }
for variant in &def.variants { for variant in &def.variants {
let variant_level = self.get(variant.node.id); let variant_level = self.get(variant.id);
if variant_level.is_some() { if variant_level.is_some() {
for field in variant.node.data.fields() { for field in variant.data.fields() {
self.reach(field.hir_id, variant_level).ty(); self.reach(field.hir_id, variant_level).ty();
} }
// Corner case: if the variant is reachable, but its // Corner case: if the variant is reachable, but its
@ -1647,7 +1647,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> {
v: &'tcx hir::Variant, v: &'tcx hir::Variant,
g: &'tcx hir::Generics, g: &'tcx hir::Generics,
item_id: hir::HirId) { item_id: hir::HirId) {
if self.access_levels.is_reachable(v.node.id) { if self.access_levels.is_reachable(v.id) {
self.in_variant = true; self.in_variant = true;
intravisit::walk_variant(self, v, g, item_id); intravisit::walk_variant(self, v, g, item_id);
self.in_variant = false; self.in_variant = false;
@ -1898,7 +1898,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrivateItemsInPublicInterfacesVisitor<'a, 'tcx>
self.check(item.hir_id, item_visibility).generics().predicates(); self.check(item.hir_id, item_visibility).generics().predicates();
for variant in &def.variants { for variant in &def.variants {
for field in variant.node.data.fields() { for field in variant.data.fields() {
self.check(field.hir_id, item_visibility).ty(); self.check(field.hir_id, item_visibility).ty();
} }
} }

10
src/librustc_resolve/build_reduced_graph.rs
View file

@ -799,17 +799,17 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
parent: Module<'a>, parent: Module<'a>,
vis: ty::Visibility, vis: ty::Visibility,
expn_id: ExpnId) { expn_id: ExpnId) {
let ident = variant.node.ident; let ident = variant.ident;
// Define a name in the type namespace. // Define a name in the type namespace.
let def_id = self.r.definitions.local_def_id(variant.node.id); let def_id = self.r.definitions.local_def_id(variant.id);
let res = Res::Def(DefKind::Variant, def_id); let res = Res::Def(DefKind::Variant, def_id);
self.r.define(parent, ident, TypeNS, (res, vis, variant.span, expn_id)); self.r.define(parent, ident, TypeNS, (res, vis, variant.span, expn_id));
// If the variant is marked as non_exhaustive then lower the visibility to within the // If the variant is marked as non_exhaustive then lower the visibility to within the
// crate. // crate.
let mut ctor_vis = vis; let mut ctor_vis = vis;
let has_non_exhaustive = attr::contains_name(&variant.node.attrs, sym::non_exhaustive); let has_non_exhaustive = attr::contains_name(&variant.attrs, sym::non_exhaustive);
if has_non_exhaustive && vis == ty::Visibility::Public { if has_non_exhaustive && vis == ty::Visibility::Public {
ctor_vis = ty::Visibility::Restricted(DefId::local(CRATE_DEF_INDEX)); ctor_vis = ty::Visibility::Restricted(DefId::local(CRATE_DEF_INDEX));
} }
@ -819,9 +819,9 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
// value namespace, they are reserved for possible future use. // value namespace, they are reserved for possible future use.
// It's ok to use the variant's id as a ctor id since an // It's ok to use the variant's id as a ctor id since an
// error will be reported on any use of such resolution anyway. // error will be reported on any use of such resolution anyway.
let ctor_node_id = variant.node.data.ctor_id().unwrap_or(variant.node.id); let ctor_node_id = variant.data.ctor_id().unwrap_or(variant.id);
let ctor_def_id = self.r.definitions.local_def_id(ctor_node_id); let ctor_def_id = self.r.definitions.local_def_id(ctor_node_id);
let ctor_kind = CtorKind::from_ast(&variant.node.data); let ctor_kind = CtorKind::from_ast(&variant.data);
let ctor_res = Res::Def(DefKind::Ctor(CtorOf::Variant, ctor_kind), ctor_def_id); let ctor_res = Res::Def(DefKind::Ctor(CtorOf::Variant, ctor_kind), ctor_def_id);
self.r.define(parent, ident, ValueNS, (ctor_res, ctor_vis, variant.span, expn_id)); self.r.define(parent, ident, ValueNS, (ctor_res, ctor_vis, variant.span, expn_id));
} }

22
src/librustc_save_analysis/dump_visitor.rs
View file

@ -557,11 +557,11 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {
let access = access_from!(self.save_ctxt, item, hir_id); let access = access_from!(self.save_ctxt, item, hir_id);
for variant in &enum_definition.variants { for variant in &enum_definition.variants {
let name = variant.node.ident.name.to_string(); let name = variant.ident.name.to_string();
let qualname = format!("{}::{}", enum_data.qualname, name); let qualname = format!("{}::{}", enum_data.qualname, name);
let name_span = variant.node.ident.span; let name_span = variant.ident.span;
match variant.node.data { match variant.data {
ast::VariantData::Struct(ref fields, ..) => { ast::VariantData::Struct(ref fields, ..) => {
let fields_str = fields let fields_str = fields
.iter() .iter()
@ -574,7 +574,7 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {
let value = format!("{}::{} {{ {} }}", enum_data.name, name, fields_str); let value = format!("{}::{} {{ {} }}", enum_data.name, name, fields_str);
if !self.span.filter_generated(name_span) { if !self.span.filter_generated(name_span) {
let span = self.span_from_span(name_span); let span = self.span_from_span(name_span);
let id = id_from_node_id(variant.node.id, &self.save_ctxt); let id = id_from_node_id(variant.id, &self.save_ctxt);
let parent = Some(id_from_node_id(item.id, &self.save_ctxt)); let parent = Some(id_from_node_id(item.id, &self.save_ctxt));
self.dumper.dump_def( self.dumper.dump_def(
@ -589,10 +589,10 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {
parent, parent,
children: vec![], children: vec![],
decl_id: None, decl_id: None,
docs: self.save_ctxt.docs_for_attrs(&variant.node.attrs), docs: self.save_ctxt.docs_for_attrs(&variant.attrs),
sig: sig::variant_signature(variant, &self.save_ctxt), sig: sig::variant_signature(variant, &self.save_ctxt),
attributes: lower_attributes( attributes: lower_attributes(
variant.node.attrs.clone(), variant.attrs.clone(),
&self.save_ctxt, &self.save_ctxt,
), ),
}, },
@ -612,7 +612,7 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {
} }
if !self.span.filter_generated(name_span) { if !self.span.filter_generated(name_span) {
let span = self.span_from_span(name_span); let span = self.span_from_span(name_span);
let id = id_from_node_id(variant.node.id, &self.save_ctxt); let id = id_from_node_id(variant.id, &self.save_ctxt);
let parent = Some(id_from_node_id(item.id, &self.save_ctxt)); let parent = Some(id_from_node_id(item.id, &self.save_ctxt));
self.dumper.dump_def( self.dumper.dump_def(
@ -627,10 +627,10 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {
parent, parent,
children: vec![], children: vec![],
decl_id: None, decl_id: None,
docs: self.save_ctxt.docs_for_attrs(&variant.node.attrs), docs: self.save_ctxt.docs_for_attrs(&variant.attrs),
sig: sig::variant_signature(variant, &self.save_ctxt), sig: sig::variant_signature(variant, &self.save_ctxt),
attributes: lower_attributes( attributes: lower_attributes(
variant.node.attrs.clone(), variant.attrs.clone(),
&self.save_ctxt, &self.save_ctxt,
), ),
}, },
@ -640,8 +640,8 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {
} }
for field in variant.node.data.fields() { for field in variant.data.fields() {
self.process_struct_field_def(field, variant.node.id); self.process_struct_field_def(field, variant.id);
self.visit_ty(&field.ty); self.visit_ty(&field.ty);
} }
} }

4
src/librustc_save_analysis/lib.rs
View file

@ -277,7 +277,7 @@ impl<'l, 'tcx> SaveContext<'l, 'tcx> {
filter!(self.span_utils, item.ident.span); filter!(self.span_utils, item.ident.span);
let variants_str = def.variants let variants_str = def.variants
.iter() .iter()
.map(|v| v.node.ident.to_string()) .map(|v| v.ident.to_string())
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join(", "); .join(", ");
let value = format!("{}::{{{}}}", name, variants_str); let value = format!("{}::{{{}}}", name, variants_str);
@ -291,7 +291,7 @@ impl<'l, 'tcx> SaveContext<'l, 'tcx> {
parent: None, parent: None,
children: def.variants children: def.variants
.iter() .iter()
.map(|v| id_from_node_id(v.node.id, self)) .map(|v| id_from_node_id(v.id, self))
.collect(), .collect(),
decl_id: None, decl_id: None,
docs: self.docs_for_attrs(&item.attrs), docs: self.docs_for_attrs(&item.attrs),

4
src/librustc_save_analysis/sig.rs
View file

@ -65,7 +65,7 @@ pub fn variant_signature(variant: &ast::Variant, scx: &SaveContext<'_, '_>) -> O
if !scx.config.signatures { if !scx.config.signatures {
return None; return None;
} }
variant.node.make(0, None, scx).ok() variant.make(0, None, scx).ok()
} }
pub fn method_signature( pub fn method_signature(
@ -699,7 +699,7 @@ impl Sig for ast::StructField {
} }
impl Sig for ast::Variant_ { impl Sig for ast::Variant {
fn make(&self, offset: usize, parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result { fn make(&self, offset: usize, parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
let mut text = self.ident.to_string(); let mut text = self.ident.to_string();
match self.data { match self.data {

10
src/librustc_typeck/check/mod.rs
View file

@ -1968,19 +1968,19 @@ pub fn check_enum<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, vs: &'tcx [hir::Variant], i
} }
for v in vs { for v in vs {
if let Some(ref e) = v.node.disr_expr { if let Some(ref e) = v.disr_expr {
tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id)); tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
} }
} }
if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant { if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
let is_unit = let is_unit =
|var: &hir::Variant| match var.node.data { |var: &hir::Variant| match var.data {
hir::VariantData::Unit(..) => true, hir::VariantData::Unit(..) => true,
_ => false _ => false
}; };
let has_disr = |var: &hir::Variant| var.node.disr_expr.is_some(); let has_disr = |var: &hir::Variant| var.disr_expr.is_some();
let has_non_units = vs.iter().any(|var| !is_unit(var)); let has_non_units = vs.iter().any(|var| !is_unit(var));
let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var)); let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var)); let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
@ -1999,11 +1999,11 @@ pub fn check_enum<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, vs: &'tcx [hir::Variant], i
let variant_did = def.variants[VariantIdx::new(i)].def_id; let variant_did = def.variants[VariantIdx::new(i)].def_id;
let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap(); let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
let variant_i = tcx.hir().expect_variant(variant_i_hir_id); let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
let i_span = match variant_i.node.disr_expr { let i_span = match variant_i.disr_expr {
Some(ref expr) => tcx.hir().span(expr.hir_id), Some(ref expr) => tcx.hir().span(expr.hir_id),
None => tcx.hir().span(variant_i_hir_id) None => tcx.hir().span(variant_i_hir_id)
}; };
let span = match v.node.disr_expr { let span = match v.disr_expr {
Some(ref expr) => tcx.hir().span(expr.hir_id), Some(ref expr) => tcx.hir().span(expr.hir_id),
None => v.span None => v.span
}; };

2
src/librustc_typeck/check/wfcheck.rs
View file

@ -1119,7 +1119,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
fn enum_variants(&self, enum_def: &hir::EnumDef) -> Vec<AdtVariant<'tcx>> { fn enum_variants(&self, enum_def: &hir::EnumDef) -> Vec<AdtVariant<'tcx>> {
enum_def.variants.iter() enum_def.variants.iter()
.map(|variant| self.non_enum_variant(&variant.node.data)) .map(|variant| self.non_enum_variant(&variant.data))
.collect() .collect()
} }

45
src/librustc_typeck/collect.rs
View file

@ -35,7 +35,6 @@ use rustc_target::spec::abi;
use syntax::ast; use syntax::ast;
use syntax::ast::{Ident, MetaItemKind}; use syntax::ast::{Ident, MetaItemKind};
use syntax::attr::{InlineAttr, OptimizeAttr, list_contains_name, mark_used}; use syntax::attr::{InlineAttr, OptimizeAttr, list_contains_name, mark_used};
use syntax::source_map::Spanned;
use syntax::feature_gate; use syntax::feature_gate;
use syntax::symbol::{InternedString, kw, Symbol, sym}; use syntax::symbol::{InternedString, kw, Symbol, sym};
use syntax_pos::{Span, DUMMY_SP}; use syntax_pos::{Span, DUMMY_SP};
@ -520,7 +519,11 @@ fn convert_variant_ctor(tcx: TyCtxt<'_>, ctor_id: hir::HirId) {
tcx.predicates_of(def_id); tcx.predicates_of(def_id);
} }
fn convert_enum_variant_types<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, variants: &[hir::Variant]) { fn convert_enum_variant_types<'tcx>(
tcx: TyCtxt<'tcx>,
def_id: DefId,
variants: &[hir::Variant]
) {
let def = tcx.adt_def(def_id); let def = tcx.adt_def(def_id);
let repr_type = def.repr.discr_type(); let repr_type = def.repr.discr_type();
let initial = repr_type.initial_discriminant(tcx); let initial = repr_type.initial_discriminant(tcx);
@ -530,7 +533,7 @@ fn convert_enum_variant_types<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, variants:
for variant in variants { for variant in variants {
let wrapped_discr = prev_discr.map_or(initial, |d| d.wrap_incr(tcx)); let wrapped_discr = prev_discr.map_or(initial, |d| d.wrap_incr(tcx));
prev_discr = Some( prev_discr = Some(
if let Some(ref e) = variant.node.disr_expr { if let Some(ref e) = variant.disr_expr {
let expr_did = tcx.hir().local_def_id(e.hir_id); let expr_did = tcx.hir().local_def_id(e.hir_id);
def.eval_explicit_discr(tcx, expr_did) def.eval_explicit_discr(tcx, expr_did)
} else if let Some(discr) = repr_type.disr_incr(tcx, prev_discr) { } else if let Some(discr) = repr_type.disr_incr(tcx, prev_discr) {
@ -546,14 +549,14 @@ fn convert_enum_variant_types<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, variants:
format!("overflowed on value after {}", prev_discr.unwrap()), format!("overflowed on value after {}", prev_discr.unwrap()),
).note(&format!( ).note(&format!(
"explicitly set `{} = {}` if that is desired outcome", "explicitly set `{} = {}` if that is desired outcome",
variant.node.ident, wrapped_discr variant.ident, wrapped_discr
)) ))
.emit(); .emit();
None None
}.unwrap_or(wrapped_discr), }.unwrap_or(wrapped_discr),
); );
for f in variant.node.data.fields() { for f in variant.data.fields() {
let def_id = tcx.hir().local_def_id(f.hir_id); let def_id = tcx.hir().local_def_id(f.hir_id);
tcx.generics_of(def_id); tcx.generics_of(def_id);
tcx.type_of(def_id); tcx.type_of(def_id);
@ -562,7 +565,7 @@ fn convert_enum_variant_types<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, variants:
// Convert the ctor, if any. This also registers the variant as // Convert the ctor, if any. This also registers the variant as
// an item. // an item.
if let Some(ctor_hir_id) = variant.node.data.ctor_hir_id() { if let Some(ctor_hir_id) = variant.data.ctor_hir_id() {
convert_variant_ctor(tcx, ctor_hir_id); convert_variant_ctor(tcx, ctor_hir_id);
} }
} }
@ -641,11 +644,11 @@ fn adt_def(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::AdtDef {
let variants = def.variants let variants = def.variants
.iter() .iter()
.map(|v| { .map(|v| {
let variant_did = Some(tcx.hir().local_def_id(v.node.id)); let variant_did = Some(tcx.hir().local_def_id(v.id));
let ctor_did = v.node.data.ctor_hir_id() let ctor_did = v.data.ctor_hir_id()
.map(|hir_id| tcx.hir().local_def_id(hir_id)); .map(|hir_id| tcx.hir().local_def_id(hir_id));
let discr = if let Some(ref e) = v.node.disr_expr { let discr = if let Some(ref e) = v.disr_expr {
distance_from_explicit = 0; distance_from_explicit = 0;
ty::VariantDiscr::Explicit(tcx.hir().local_def_id(e.hir_id)) ty::VariantDiscr::Explicit(tcx.hir().local_def_id(e.hir_id))
} else { } else {
@ -653,8 +656,8 @@ fn adt_def(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::AdtDef {
}; };
distance_from_explicit += 1; distance_from_explicit += 1;
convert_variant(tcx, variant_did, ctor_did, v.node.ident, discr, convert_variant(tcx, variant_did, ctor_did, v.ident, discr,
&v.node.data, AdtKind::Enum, def_id) &v.data, AdtKind::Enum, def_id)
}) })
.collect(); .collect();
@ -1314,10 +1317,9 @@ pub fn checked_type_of(tcx: TyCtxt<'_>, def_id: DefId, fail: bool) -> Option<Ty<
ForeignItemKind::Type => tcx.mk_foreign(def_id), ForeignItemKind::Type => tcx.mk_foreign(def_id),
}, },
Node::Ctor(&ref def) | Node::Variant(&Spanned { Node::Ctor(&ref def) | Node::Variant(
node: hir::VariantKind { data: ref def, .. }, hir::Variant { data: ref def, .. }
.. ) => match *def {
}) => match *def {
VariantData::Unit(..) | VariantData::Struct(..) => { VariantData::Unit(..) | VariantData::Struct(..) => {
tcx.type_of(tcx.hir().get_parent_did(hir_id)) tcx.type_of(tcx.hir().get_parent_did(hir_id))
} }
@ -1363,13 +1365,9 @@ pub fn checked_type_of(tcx: TyCtxt<'_>, def_id: DefId, fail: bool) -> Option<Ty<
tcx.types.usize tcx.types.usize
} }
Node::Variant(&Spanned { Node::Variant(Variant {
node:
VariantKind {
disr_expr: Some(ref e), disr_expr: Some(ref e),
.. ..
},
..
}) if e.hir_id == hir_id => }) if e.hir_id == hir_id =>
{ {
tcx.adt_def(tcx.hir().get_parent_did(hir_id)) tcx.adt_def(tcx.hir().get_parent_did(hir_id))
@ -1809,10 +1807,9 @@ fn fn_sig(tcx: TyCtxt<'_>, def_id: DefId) -> ty::PolyFnSig<'_> {
compute_sig_of_foreign_fn_decl(tcx, def_id, fn_decl, abi) compute_sig_of_foreign_fn_decl(tcx, def_id, fn_decl, abi)
} }
Ctor(data) | Variant(Spanned { Ctor(data) | Variant(
node: hir::VariantKind { data, .. }, hir::Variant { data, .. }
.. ) if data.ctor_hir_id().is_some() => {
}) if data.ctor_hir_id().is_some() => {
let ty = tcx.type_of(tcx.hir().get_parent_did(hir_id)); let ty = tcx.type_of(tcx.hir().get_parent_did(hir_id));
let inputs = data.fields() let inputs = data.fields()
.iter() .iter()

4
src/librustc_typeck/variance/constraints.rs
View file

@ -82,8 +82,8 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for ConstraintContext<'a, 'tcx> {
self.visit_node_helper(item.hir_id); self.visit_node_helper(item.hir_id);
for variant in &enum_def.variants { for variant in &enum_def.variants {
if let hir::VariantData::Tuple(..) = variant.node.data { if let hir::VariantData::Tuple(..) = variant.data {
self.visit_node_helper(variant.node.data.ctor_hir_id().unwrap()); self.visit_node_helper(variant.data.ctor_hir_id().unwrap());
} }
} }
} }

4
src/librustc_typeck/variance/terms.rs
View file

@ -145,8 +145,8 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for TermsContext<'a, 'tcx> {
self.add_inferreds_for_item(item.hir_id); self.add_inferreds_for_item(item.hir_id);
for variant in &enum_def.variants { for variant in &enum_def.variants {
if let hir::VariantData::Tuple(..) = variant.node.data { if let hir::VariantData::Tuple(..) = variant.data {
self.add_inferreds_for_item(variant.node.data.ctor_hir_id().unwrap()); self.add_inferreds_for_item(variant.data.ctor_hir_id().unwrap());
} }
} }
} }

2
src/librustdoc/test.rs
View file

@ -951,7 +951,7 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for HirCollector<'a, 'hir> {
v: &'hir hir::Variant, v: &'hir hir::Variant,
g: &'hir hir::Generics, g: &'hir hir::Generics,
item_id: hir::HirId) { item_id: hir::HirId) {
self.visit_testable(v.node.ident.to_string(), &v.node.attrs, |this| { self.visit_testable(v.ident.to_string(), &v.attrs, |this| {
intravisit::walk_variant(this, v, g, item_id); intravisit::walk_variant(this, v, g, item_id);
}); });
} }

8
src/librustdoc/visit_ast.rs
View file

@ -130,10 +130,10 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
Enum { Enum {
name, name,
variants: def.variants.iter().map(|v| Variant { variants: def.variants.iter().map(|v| Variant {
name: v.node.ident.name, name: v.ident.name,
id: v.node.id, id: v.id,
attrs: &v.node.attrs, attrs: &v.attrs,
def: &v.node.data, def: &v.data,
whence: v.span, whence: v.span,
}).collect(), }).collect(),
vis: &it.vis, vis: &it.vis,

6
src/libsyntax/ast.rs
View file

@ -2038,7 +2038,7 @@ pub struct EnumDef {
} }
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] #[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct Variant_ { pub struct Variant {
/// Name of the variant. /// Name of the variant.
pub ident: Ident, pub ident: Ident,
/// Attributes of the variant. /// Attributes of the variant.
@ -2049,10 +2049,10 @@ pub struct Variant_ {
pub data: VariantData, pub data: VariantData,
/// Explicit discriminant, e.g., `Foo = 1`. /// Explicit discriminant, e.g., `Foo = 1`.
pub disr_expr: Option<AnonConst>, pub disr_expr: Option<AnonConst>,
/// Span
pub span: Span,
} }
pub type Variant = Spanned<Variant_>;
/// Part of `use` item to the right of its prefix. /// Part of `use` item to the right of its prefix.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] #[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub enum UseTreeKind { pub enum UseTreeKind {

2
src/libsyntax/attr/mod.rs
View file

@ -712,7 +712,7 @@ macro_rules! derive_has_attrs {
derive_has_attrs! { derive_has_attrs! {
Item, Expr, Local, ast::ForeignItem, ast::StructField, ast::ImplItem, ast::TraitItem, ast::Arm, Item, Expr, Local, ast::ForeignItem, ast::StructField, ast::ImplItem, ast::TraitItem, ast::Arm,
ast::Field, ast::FieldPat, ast::Variant_, ast::Arg ast::Field, ast::FieldPat, ast::Variant, ast::Arg
} }
pub fn inject(mut krate: ast::Crate, parse_sess: &ParseSess, attrs: &[String]) -> ast::Crate { pub fn inject(mut krate: ast::Crate, parse_sess: &ParseSess, attrs: &[String]) -> ast::Crate {

2
src/libsyntax/config.rs
View file

@ -260,7 +260,7 @@ impl<'a> StripUnconfigured<'a> {
ast::ItemKind::Enum(ast::EnumDef { variants }, _generics) => { ast::ItemKind::Enum(ast::EnumDef { variants }, _generics) => {
variants.flat_map_in_place(|variant| self.configure(variant)); variants.flat_map_in_place(|variant| self.configure(variant));
for variant in variants { for variant in variants {
self.configure_variant_data(&mut variant.node.data); self.configure_variant_data(&mut variant.data);
} }
} }
_ => {} _ => {}

10
src/libsyntax/ext/build.rs
View file

@ -781,14 +781,14 @@ impl<'a> ExtCtxt<'a> {
ast::VariantData::Tuple(fields, ast::DUMMY_NODE_ID) ast::VariantData::Tuple(fields, ast::DUMMY_NODE_ID)
}; };
respan(span, ast::Variant {
ast::Variant_ {
ident,
id: ast::DUMMY_NODE_ID,
attrs: Vec::new(), attrs: Vec::new(),
data: vdata, data: vdata,
disr_expr: None, disr_expr: None,
}) id: ast::DUMMY_NODE_ID,
ident,
span,
}
} }
pub fn item_enum_poly(&self, span: Span, name: Ident, pub fn item_enum_poly(&self, span: Span, name: Ident,

2
src/libsyntax/feature_gate.rs
View file

@ -1956,7 +1956,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
ast::ItemKind::Enum(ast::EnumDef{ref variants, ..}, ..) => { ast::ItemKind::Enum(ast::EnumDef{ref variants, ..}, ..) => {
for variant in variants { for variant in variants {
match (&variant.node.data, &variant.node.disr_expr) { match (&variant.data, &variant.disr_expr) {
(ast::VariantData::Unit(..), _) => {}, (ast::VariantData::Unit(..), _) => {},
(_, Some(disr_expr)) => (_, Some(disr_expr)) =>
gate_feature_post!( gate_feature_post!(

2
src/libsyntax/mut_visit.rs
View file

@ -455,7 +455,7 @@ pub fn noop_visit_foreign_mod<T: MutVisitor>(foreign_mod: &mut ForeignMod, vis:
} }
pub fn noop_visit_variant<T: MutVisitor>(variant: &mut Variant, vis: &mut T) { pub fn noop_visit_variant<T: MutVisitor>(variant: &mut Variant, vis: &mut T) {
let Spanned { node: Variant_ { ident, attrs, id, data, disr_expr }, span } = variant; let Variant { ident, attrs, id, data, disr_expr, span } = variant;
vis.visit_ident(ident); vis.visit_ident(ident);
visit_attrs(attrs, vis); visit_attrs(attrs, vis);
vis.visit_id(id); vis.visit_id(id);

11
src/libsyntax/parse/diagnostics.rs
View file

@ -8,7 +8,6 @@ use crate::parse::parser::{BlockMode, PathStyle, SemiColonMode, TokenType, Token
use crate::parse::token::{self, TokenKind}; use crate::parse::token::{self, TokenKind};
use crate::print::pprust; use crate::print::pprust;
use crate::ptr::P; use crate::ptr::P;
use crate::source_map::Spanned;
use crate::symbol::{kw, sym}; use crate::symbol::{kw, sym};
use crate::ThinVec; use crate::ThinVec;
use crate::util::parser::AssocOp; use crate::util::parser::AssocOp;
@ -592,18 +591,18 @@ impl<'a> Parser<'a> {
crate fn maybe_report_invalid_custom_discriminants( crate fn maybe_report_invalid_custom_discriminants(
sess: &ParseSess, sess: &ParseSess,
variants: &[Spanned<ast::Variant_>], variants: &[ast::Variant],
) { ) {
let has_fields = variants.iter().any(|variant| match variant.node.data { let has_fields = variants.iter().any(|variant| match variant.data {
VariantData::Tuple(..) | VariantData::Struct(..) => true, VariantData::Tuple(..) | VariantData::Struct(..) => true,
VariantData::Unit(..) => false, VariantData::Unit(..) => false,
}); });
let discriminant_spans = variants.iter().filter(|variant| match variant.node.data { let discriminant_spans = variants.iter().filter(|variant| match variant.data {
VariantData::Tuple(..) | VariantData::Struct(..) => false, VariantData::Tuple(..) | VariantData::Struct(..) => false,
VariantData::Unit(..) => true, VariantData::Unit(..) => true,
}) })
.filter_map(|variant| variant.node.disr_expr.as_ref().map(|c| c.value.span)) .filter_map(|variant| variant.disr_expr.as_ref().map(|c| c.value.span))
.collect::<Vec<_>>(); .collect::<Vec<_>>();
if !discriminant_spans.is_empty() && has_fields { if !discriminant_spans.is_empty() && has_fields {
@ -618,7 +617,7 @@ impl<'a> Parser<'a> {
err.span_label(sp, "disallowed custom discriminant"); err.span_label(sp, "disallowed custom discriminant");
} }
for variant in variants.iter() { for variant in variants.iter() {
match &variant.node.data { match &variant.data {
VariantData::Struct(..) => { VariantData::Struct(..) => {
err.span_label( err.span_label(
variant.span, variant.span,

5
src/libsyntax/parse/parser/item.rs
View file

@ -1564,14 +1564,15 @@ impl<'a> Parser<'a> {
None None
}; };
let vr = ast::Variant_ { let vr = ast::Variant {
ident, ident,
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
attrs: variant_attrs, attrs: variant_attrs,
data: struct_def, data: struct_def,
disr_expr, disr_expr,
span: vlo.to(self.prev_span),
}; };
variants.push(respan(vlo.to(self.prev_span), vr)); variants.push(vr);
if !self.eat(&token::Comma) { if !self.eat(&token::Comma) {
if self.token.is_ident() && !self.token.is_reserved_ident() { if self.token.is_ident() && !self.token.is_reserved_ident() {

6
src/libsyntax/print/pprust.rs
View file

@ -1402,7 +1402,7 @@ impl<'a> State<'a> {
for v in variants { for v in variants {
self.space_if_not_bol(); self.space_if_not_bol();
self.maybe_print_comment(v.span.lo()); self.maybe_print_comment(v.span.lo());
self.print_outer_attributes(&v.node.attrs); self.print_outer_attributes(&v.attrs);
self.ibox(INDENT_UNIT); self.ibox(INDENT_UNIT);
self.print_variant(v); self.print_variant(v);
self.s.word(","); self.s.word(",");
@ -1492,8 +1492,8 @@ impl<'a> State<'a> {
crate fn print_variant(&mut self, v: &ast::Variant) { crate fn print_variant(&mut self, v: &ast::Variant) {
self.head(""); self.head("");
let generics = ast::Generics::default(); let generics = ast::Generics::default();
self.print_struct(&v.node.data, &generics, v.node.ident, v.span, false); self.print_struct(&v.data, &generics, v.ident, v.span, false);
match v.node.disr_expr { match v.disr_expr {
Some(ref d) => { Some(ref d) => {
self.s.space(); self.s.space();
self.word_space("="); self.word_space("=");

5
src/libsyntax/print/pprust/tests.rs
View file

@ -54,14 +54,15 @@ fn test_variant_to_string() {
with_default_globals(|| { with_default_globals(|| {
let ident = ast::Ident::from_str("principal_skinner"); let ident = ast::Ident::from_str("principal_skinner");
let var = source_map::respan(syntax_pos::DUMMY_SP, ast::Variant_ { let var = ast::Variant {
ident, ident,
attrs: Vec::new(), attrs: Vec::new(),
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
// making this up as I go.... ? // making this up as I go.... ?
data: ast::VariantData::Unit(ast::DUMMY_NODE_ID), data: ast::VariantData::Unit(ast::DUMMY_NODE_ID),
disr_expr: None, disr_expr: None,
}); span: syntax_pos::DUMMY_SP,
};
let varstr = variant_to_string(&var); let varstr = variant_to_string(&var);
assert_eq!(varstr, "principal_skinner"); assert_eq!(varstr, "principal_skinner");

8
src/libsyntax/visit.rs
View file

@ -311,11 +311,11 @@ pub fn walk_variant<'a, V>(visitor: &mut V,
item_id: NodeId) item_id: NodeId)
where V: Visitor<'a>, where V: Visitor<'a>,
{ {
visitor.visit_ident(variant.node.ident); visitor.visit_ident(variant.ident);
visitor.visit_variant_data(&variant.node.data, variant.node.ident, visitor.visit_variant_data(&variant.data, variant.ident,
generics, item_id, variant.span); generics, item_id, variant.span);
walk_list!(visitor, visit_anon_const, &variant.node.disr_expr); walk_list!(visitor, visit_anon_const, &variant.disr_expr);
walk_list!(visitor, visit_attribute, &variant.node.attrs); walk_list!(visitor, visit_attribute, &variant.attrs);
} }
pub fn walk_ty<'a, V: Visitor<'a>>(visitor: &mut V, typ: &'a Ty) { pub fn walk_ty<'a, V: Visitor<'a>>(visitor: &mut V, typ: &'a Ty) {

6
src/libsyntax_ext/deriving/clone.rs
View file

@ -138,7 +138,7 @@ fn cs_clone_shallow(name: &str,
} }
StaticEnum(enum_def, ..) => { StaticEnum(enum_def, ..) => {
for variant in &enum_def.variants { for variant in &enum_def.variants {
process_variant(cx, &mut stmts, &variant.node.data); process_variant(cx, &mut stmts, &variant.data);
} }
} }
_ => cx.span_bug(trait_span, &format!("unexpected substructure in \ _ => cx.span_bug(trait_span, &format!("unexpected substructure in \
@ -170,9 +170,9 @@ fn cs_clone(name: &str,
vdata = vdata_; vdata = vdata_;
} }
EnumMatching(.., variant, ref af) => { EnumMatching(.., variant, ref af) => {
ctor_path = cx.path(trait_span, vec![substr.type_ident, variant.node.ident]); ctor_path = cx.path(trait_span, vec![substr.type_ident, variant.ident]);
all_fields = af; all_fields = af;
vdata = &variant.node.data; vdata = &variant.data;
} }
EnumNonMatchingCollapsed(..) => { EnumNonMatchingCollapsed(..) => {
cx.span_bug(trait_span, cx.span_bug(trait_span,

2
src/libsyntax_ext/deriving/cmp/eq.rs
View file

@ -75,7 +75,7 @@ fn cs_total_eq_assert(cx: &mut ExtCtxt<'_>,
} }
StaticEnum(enum_def, ..) => { StaticEnum(enum_def, ..) => {
for variant in &enum_def.variants { for variant in &enum_def.variants {
process_variant(cx, &mut stmts, &variant.node.data); process_variant(cx, &mut stmts, &variant.data);
} }
} }
_ => cx.span_bug(trait_span, "unexpected substructure in `derive(Eq)`") _ => cx.span_bug(trait_span, "unexpected substructure in `derive(Eq)`")

2
src/libsyntax_ext/deriving/debug.rs
View file

@ -53,7 +53,7 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>
// based on the "shape". // based on the "shape".
let (ident, vdata, fields) = match substr.fields { let (ident, vdata, fields) = match substr.fields {
Struct(vdata, fields) => (substr.type_ident, *vdata, fields), Struct(vdata, fields) => (substr.type_ident, *vdata, fields),
EnumMatching(_, _, v, fields) => (v.node.ident, &v.node.data, fields), EnumMatching(_, _, v, fields) => (v.ident, &v.data, fields),
EnumNonMatchingCollapsed(..) | EnumNonMatchingCollapsed(..) |
StaticStruct(..) | StaticStruct(..) |
StaticEnum(..) => cx.span_bug(span, "nonsensical .fields in `#[derive(Debug)]`"), StaticEnum(..) => cx.span_bug(span, "nonsensical .fields in `#[derive(Debug)]`"),

2
src/libsyntax_ext/deriving/encodable.rs
View file

@ -238,7 +238,7 @@ fn encodable_substructure(cx: &mut ExtCtxt<'_>,
} }
let blk = cx.lambda_stmts_1(trait_span, stmts, blkarg); let blk = cx.lambda_stmts_1(trait_span, stmts, blkarg);
let name = cx.expr_str(trait_span, variant.node.ident.name); let name = cx.expr_str(trait_span, variant.ident.name);
let call = cx.expr_method_call(trait_span, let call = cx.expr_method_call(trait_span,
blkencoder, blkencoder,
cx.ident_of("emit_enum_variant"), cx.ident_of("emit_enum_variant"),

16
src/libsyntax_ext/deriving/generic/mod.rs
View file

@ -758,7 +758,7 @@ impl<'a> TraitDef<'a> {
let mut field_tys = Vec::new(); let mut field_tys = Vec::new();
for variant in &enum_def.variants { for variant in &enum_def.variants {
field_tys.extend(variant.node field_tys.extend(variant
.data .data
.fields() .fields()
.iter() .iter()
@ -1220,7 +1220,7 @@ impl<'a> MethodDef<'a> {
let catch_all_substructure = let catch_all_substructure =
EnumNonMatchingCollapsed(self_arg_idents, &variants[..], &vi_idents[..]); EnumNonMatchingCollapsed(self_arg_idents, &variants[..], &vi_idents[..]);
let first_fieldless = variants.iter().find(|v| v.node.data.fields().is_empty()); let first_fieldless = variants.iter().find(|v| v.data.fields().is_empty());
// These arms are of the form: // These arms are of the form:
// (Variant1, Variant1, ...) => Body1 // (Variant1, Variant1, ...) => Body1
@ -1229,7 +1229,7 @@ impl<'a> MethodDef<'a> {
// where each tuple has length = self_args.len() // where each tuple has length = self_args.len()
let mut match_arms: Vec<ast::Arm> = variants.iter() let mut match_arms: Vec<ast::Arm> = variants.iter()
.enumerate() .enumerate()
.filter(|&(_, v)| !(self.unify_fieldless_variants && v.node.data.fields().is_empty())) .filter(|&(_, v)| !(self.unify_fieldless_variants && v.data.fields().is_empty()))
.map(|(index, variant)| { .map(|(index, variant)| {
let mk_self_pat = |cx: &mut ExtCtxt<'_>, self_arg_name: &str| { let mk_self_pat = |cx: &mut ExtCtxt<'_>, self_arg_name: &str| {
let (p, idents) = trait_.create_enum_variant_pattern(cx, let (p, idents) = trait_.create_enum_variant_pattern(cx,
@ -1513,8 +1513,8 @@ impl<'a> MethodDef<'a> {
.iter() .iter()
.map(|v| { .map(|v| {
let sp = v.span.with_ctxt(trait_.span.ctxt()); let sp = v.span.with_ctxt(trait_.span.ctxt());
let summary = trait_.summarise_struct(cx, &v.node.data); let summary = trait_.summarise_struct(cx, &v.data);
(v.node.ident, sp, summary) (v.ident, sp, summary)
}) })
.collect(); .collect();
self.call_substructure_method(cx, self.call_substructure_method(cx,
@ -1643,9 +1643,9 @@ impl<'a> TraitDef<'a> {
mutbl: ast::Mutability) mutbl: ast::Mutability)
-> (P<ast::Pat>, Vec<(Span, Option<Ident>, P<Expr>, &'a [ast::Attribute])>) { -> (P<ast::Pat>, Vec<(Span, Option<Ident>, P<Expr>, &'a [ast::Attribute])>) {
let sp = variant.span.with_ctxt(self.span.ctxt()); let sp = variant.span.with_ctxt(self.span.ctxt());
let variant_path = cx.path(sp, vec![enum_ident, variant.node.ident]); let variant_path = cx.path(sp, vec![enum_ident, variant.ident]);
let use_temporaries = false; // enums can't be repr(packed) let use_temporaries = false; // enums can't be repr(packed)
self.create_struct_pattern(cx, variant_path, &variant.node.data, prefix, mutbl, self.create_struct_pattern(cx, variant_path, &variant.data, prefix, mutbl,
use_temporaries) use_temporaries)
} }
} }
@ -1776,7 +1776,7 @@ pub fn is_type_without_fields(item: &Annotatable) -> bool {
if let Annotatable::Item(ref item) = *item { if let Annotatable::Item(ref item) = *item {
match item.node { match item.node {
ast::ItemKind::Enum(ref enum_def, _) => { ast::ItemKind::Enum(ref enum_def, _) => {
enum_def.variants.iter().all(|v| v.node.data.fields().is_empty()) enum_def.variants.iter().all(|v| v.data.fields().is_empty())
} }
ast::ItemKind::Struct(ref variant_data, _) => variant_data.fields().is_empty(), ast::ItemKind::Struct(ref variant_data, _) => variant_data.fields().is_empty(),
_ => false, _ => false,