Dict -> Struct, StructDef -> VariantData, def -> data

Author: petrochenkov

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

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

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,

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

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

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,

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

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<ast::NodeId> = 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`

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<hir::Variant>], 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);
             }
         }

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<ast::NodeId> {
     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");
                         }
                     }