syntax/rustc_front: Simplify VariantData::fields

petrochenkov · petrochenkov · commit e8ddbba2ed35 · 2015-10-25T18:33:51.000+03:00
And use VariantData instead of P&lt;VariantData&gt; in Item_ and Variant_
diff --git a/src/librustc/front/map/collector.rs b/src/librustc/front/map/collector.rs
@@ -152,7 +152,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
                 // If this is a tuple-like struct, register the constructor.
                 if !struct_def.is_struct() {
                     self.insert_def(struct_def.id(),
-                                    NodeStructCtor(&**struct_def),
+                                    NodeStructCtor(struct_def),
                                     DefPathData::StructCtor);
                 }
 
diff --git 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().filter(|f| {
+        let live_fields = def.fields().iter().filter(|f| {
             has_extern_repr || inherited_pub_visibility || match f.node.kind {
                 hir::NamedField(_, hir::Public) => true,
                 _ => false
diff --git a/src/librustc_front/fold.rs b/src/librustc_front/fold.rs
@@ -223,8 +223,8 @@ pub trait Folder : Sized {
         noop_fold_poly_trait_ref(p, self)
     }
 
-    fn fold_variant_data(&mut self, struct_def: P<VariantData>) -> P<VariantData> {
-        noop_fold_struct_def(struct_def, self)
+    fn fold_variant_data(&mut self, vdata: VariantData) -> VariantData {
+        noop_fold_variant_data(vdata, self)
     }
 
     fn fold_lifetimes(&mut self, lts: Vec<Lifetime>) -> Vec<Lifetime> {
@@ -693,18 +693,16 @@ pub fn noop_fold_where_predicate<T: Folder>(pred: WherePredicate, fld: &mut T) -
     }
 }
 
-pub fn noop_fold_struct_def<T: Folder>(struct_def: P<VariantData>, fld: &mut T) -> P<VariantData> {
-    struct_def.map(|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))
+pub fn noop_fold_variant_data<T: Folder>(vdata: VariantData, fld: &mut T) -> VariantData {
+    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))
+    }
 }
 
 pub fn noop_fold_trait_ref<T: Folder>(p: TraitRef, fld: &mut T) -> TraitRef {
diff --git a/src/librustc_front/hir.rs b/src/librustc_front/hir.rs
@@ -49,7 +49,6 @@ 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)]
@@ -1024,7 +1023,7 @@ pub struct EnumDef {
 pub struct Variant_ {
     pub name: Name,
     pub attrs: Vec<Attribute>,
-    pub data: P<VariantData>,
+    pub data: VariantData,
     /// Explicit discriminant, eg `Foo = 1`
     pub disr_expr: Option<P<Expr>>,
 }
@@ -1179,17 +1178,12 @@ pub enum VariantData {
     Unit(NodeId),
 }
 
-pub type FieldIter<'a> = iter::FlatMap<option::IntoIter<&'a Vec<StructField>>,
-                                       slice::Iter<'a, StructField>,
-                                       fn(&Vec<StructField>) -> slice::Iter<StructField>>;
-
 impl VariantData {
-    pub fn fields(&self) -> FieldIter {
-        fn vec_iter<T>(v: &Vec<T>) -> slice::Iter<T> { v.iter() }
+    pub fn fields(&self) -> &[StructField] {
         match *self {
-            VariantData::Struct(ref fields, _) | VariantData::Tuple(ref fields, _) => Some(fields),
-            _ => None,
-        }.into_iter().flat_map(vec_iter)
+            VariantData::Struct(ref fields, _) | VariantData::Tuple(ref fields, _) => fields,
+            _ => &[],
+        }
     }
     pub fn id(&self) -> NodeId {
         match *self {
@@ -1248,7 +1242,7 @@ pub enum Item_ {
     /// An enum definition, e.g. `enum Foo<A, B> {C<A>, D<B>}`
     ItemEnum(EnumDef, Generics),
     /// A struct definition, e.g. `struct Foo<A> {x: A}`
-    ItemStruct(P<VariantData>, Generics),
+    ItemStruct(VariantData, Generics),
     /// Represents a Trait Declaration
     ItemTrait(Unsafety, Generics, TyParamBounds, Vec<P<TraitItem>>),
 
diff --git 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<hir::Variant> {
         node: hir::Variant_ {
             name: v.node.name.name,
             attrs: v.node.attrs.clone(),
-            data: lower_struct_def(_lctx, &v.node.data),
+            data: lower_variant_data(_lctx, &v.node.data),
             disr_expr: v.node.disr_expr.as_ref().map(|e| lower_expr(_lctx, e)),
         },
         span: v.span,
@@ -498,8 +498,8 @@ pub fn lower_where_predicate(_lctx: &LoweringContext,
     }
 }
 
-pub fn lower_struct_def(_lctx: &LoweringContext, sd: &VariantData) -> P<hir::VariantData> {
-    P(match *sd {
+pub fn lower_variant_data(_lctx: &LoweringContext, vdata: &VariantData) -> hir::VariantData {
+    match *vdata {
         VariantData::Struct(ref fields, id) => {
             hir::VariantData::Struct(fields.iter()
                                            .map(|f| lower_struct_field(_lctx, f)).collect(), id)
@@ -509,7 +509,7 @@ pub fn lower_struct_def(_lctx: &LoweringContext, sd: &VariantData) -> P<hir::Var
                                           .map(|f| lower_struct_field(_lctx, f)).collect(), id)
         }
         VariantData::Unit(id) => hir::VariantData::Unit(id)
-    })
+    }
 }
 
 pub fn lower_trait_ref(_lctx: &LoweringContext, p: &TraitRef) -> hir::TraitRef {
@@ -611,7 +611,7 @@ pub fn lower_item_underscore(_lctx: &LoweringContext, i: &Item_) -> hir::Item_ {
                           lower_generics(_lctx, generics))
         }
         ItemStruct(ref struct_def, ref generics) => {
-            let struct_def = lower_struct_def(_lctx, struct_def);
+            let struct_def = lower_variant_data(_lctx, struct_def);
             hir::ItemStruct(struct_def, lower_generics(_lctx, generics))
         }
         ItemDefaultImpl(unsafety, ref trait_ref) => {
diff --git 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, true));
+                try!(self.print_struct(struct_def, generics, item.name, item.span, true));
             }
 
             hir::ItemDefaultImpl(unsafety, ref trait_ref) => {
@@ -899,7 +899,7 @@ impl<'a> State<'a> {
         if !struct_def.is_struct() {
             if struct_def.is_tuple() {
                 try!(self.popen());
-                try!(self.commasep_iter(Inconsistent,
+                try!(self.commasep(Inconsistent,
                                    struct_def.fields(),
                                    |s, field| {
                                        match field.node.kind {
diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
@@ -1114,7 +1114,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> {
                 }
             }
 
-            hir::ItemStruct(ref def, _) => check_struct(&**def),
+            hir::ItemStruct(ref def, _) => check_struct(def),
 
             hir::ItemEnum(..) |
             hir::ItemExternCrate(_) | hir::ItemUse(_) |
diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs
@@ -514,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().filter_map(|f| {
+                let named_fields = struct_def.fields().iter().filter_map(|f| {
                     match f.node.kind {
                         NamedField(name, _) => Some(name),
                         UnnamedField(_) => None
diff --git a/src/librustc_trans/save/dump_csv.rs b/src/librustc_trans/save/dump_csv.rs
@@ -918,7 +918,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
                 self.process_static_or_const_item(item, typ, expr),
             ast::ItemConst(ref typ, ref expr) =>
                 self.process_static_or_const_item(item, &typ, &expr),
-            ast::ItemStruct(ref def, ref ty_params) => self.process_struct(item, &**def, ty_params),
+            ast::ItemStruct(ref def, ref ty_params) => self.process_struct(item, def, ty_params),
             ast::ItemEnum(ref def, ref ty_params) => self.process_enum(item, def, ty_params),
             ast::ItemImpl(_, _,
                           ref ty_params,
diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs
@@ -2435,7 +2435,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
             } else {
                 v.node.data.fields()
             };
-            assert!(fields.count() != 0);
+            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_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs
@@ -103,7 +103,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> {
             }
             hir::ItemStruct(ref struct_def, ref ast_generics) => {
                 self.check_type_defn(item, |fcx| {
-                    vec![struct_variant(fcx, &**struct_def)]
+                    vec![struct_variant(fcx, struct_def)]
                 });
 
                 self.check_variances_for_type_defn(item, ast_generics);
@@ -627,7 +627,7 @@ fn struct_variant<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
                             struct_def: &hir::VariantData)
                             -> AdtVariant<'tcx> {
     let fields =
-        struct_def.fields()
+        struct_def.fields().iter()
         .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
@@ -112,7 +112,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> {
             }
             hir::ItemStruct(ref struct_def, ref ast_generics) => {
                 self.check_type_defn(item, |fcx| {
-                    vec![struct_variant(fcx, &**struct_def)]
+                    vec![struct_variant(fcx, struct_def)]
                 });
 
                 self.check_variances_for_type_defn(item, ast_generics);
@@ -524,7 +524,7 @@ fn struct_variant<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
                             struct_def: &hir::VariantData)
                             -> AdtVariant<'tcx> {
     let fields =
-        struct_def.fields()
+        struct_def.fields().iter()
         .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
@@ -1010,7 +1010,7 @@ 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().zip(variant.fields.iter()) {
+            for (f, ty_f) in struct_def.fields().iter().zip(variant.fields.iter()) {
                 convert_field(ccx, &scheme.generics, &predicates, f, ty_f)
             }
 
@@ -1067,7 +1067,7 @@ fn convert_enum_variant_types<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
                                         variants: &[P<hir::Variant>]) {
     // fill the field types
     for (variant, ty_variant) in variants.iter().zip(def.variants.iter()) {
-        for (f, ty_f) in variant.node.data.fields().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)
         }
 
@@ -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<ast::Name, Span> = FnvHashMap();
-    let fields = def.fields().map(|f| {
+    let fields = def.fields().iter().map(|f| {
         let fid = tcx.map.local_def_id(f.node.id);
         match f.node.kind {
             hir::NamedField(name, vis) => {
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -1809,7 +1809,7 @@ impl Clean<VariantStruct> for ::rustc_front::hir::VariantData {
     fn clean(&self, cx: &DocContext) -> VariantStruct {
         VariantStruct {
             struct_type: doctree::struct_type_from_def(self),
-            fields: self.fields().map(|x| x.clean(cx)).collect(),
+            fields: self.fields().iter().map(|x| x.clean(cx)).collect(),
             fields_stripped: false,
         }
     }
@@ -1923,7 +1923,7 @@ fn struct_def_to_variant_kind(struct_def: &hir::VariantData, cx: &DocContext) ->
     } else if struct_def.is_unit() {
         CLikeVariant
     } else {
-        TupleVariant(struct_def.fields().map(|x| x.node.ty.clean(cx)).collect())
+        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
@@ -119,7 +119,7 @@ pub struct Enum {
 pub struct Variant {
     pub name: Name,
     pub attrs: Vec<ast::Attribute>,
-    pub def: P<hir::VariantData>,
+    pub def: hir::VariantData,
     pub stab: Option<attr::Stability>,
     pub whence: Span,
 }
@@ -236,7 +236,7 @@ pub struct Import {
 pub fn struct_type_from_def(sd: &hir::VariantData) -> StructType {
     if !sd.is_struct() {
         // We are in a tuple-struct
-        match sd.fields().count() {
+        match sd.fields().len() {
             0 => Unit,
             1 => Newtype,
             _ => Tuple
diff --git 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().cloned().collect(),
+            fields: sd.fields().iter().cloned().collect(),
             whence: item.span
         }
     }
@@ -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_variant_data(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
@@ -65,7 +65,6 @@ 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
@@ -1578,7 +1577,7 @@ pub struct EnumDef {
 pub struct Variant_ {
     pub name: Ident,
     pub attrs: Vec<Attribute>,
-    pub data: P<VariantData>,
+    pub data: VariantData,
     /// Explicit discriminant, eg `Foo = 1`
     pub disr_expr: Option<P<Expr>>,
 }
@@ -1757,17 +1756,12 @@ pub enum VariantData {
     Unit(NodeId),
 }
 
-pub type FieldIter<'a> = iter::FlatMap<option::IntoIter<&'a Vec<StructField>>,
-                                       slice::Iter<'a, StructField>,
-                                       fn(&Vec<StructField>) -> slice::Iter<StructField>>;
-
 impl VariantData {
-    pub fn fields(&self) -> FieldIter {
-        fn vec_iter<T>(v: &Vec<T>) -> slice::Iter<T> { v.iter() }
+    pub fn fields(&self) -> &[StructField] {
         match *self {
-            VariantData::Struct(ref fields, _) | VariantData::Tuple(ref fields, _) => Some(fields),
-            _ => None,
-        }.into_iter().flat_map(vec_iter)
+            VariantData::Struct(ref fields, _) | VariantData::Tuple(ref fields, _) => fields,
+            _ => &[],
+        }
     }
     pub fn id(&self) -> NodeId {
         match *self {
@@ -1826,7 +1820,7 @@ pub enum Item_ {
     /// An enum definition, e.g. `enum Foo<A, B> {C<A>, D<B>}`
     ItemEnum(EnumDef, Generics),
     /// A struct definition, e.g. `struct Foo<A> {x: A}`
-    ItemStruct(P<VariantData>, Generics),
+    ItemStruct(VariantData, Generics),
     /// Represents a Trait Declaration
     ItemTrait(Unsafety,
               Generics,
diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs
@@ -164,24 +164,22 @@ fn fold_item_underscore<F>(cx: &mut Context<F>, item: ast::Item_) -> ast::Item_
     fold::noop_fold_item_underscore(item, cx)
 }
 
-fn fold_struct<F>(cx: &mut Context<F>, def: P<ast::VariantData>) -> P<ast::VariantData> where
+fn fold_struct<F>(cx: &mut Context<F>, vdata: ast::VariantData) -> ast::VariantData where
     F: FnMut(&[ast::Attribute]) -> bool
 {
-    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)
+    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)
+    }
 }
 
 fn retain_stmt<F>(cx: &mut Context<F>, stmt: &ast::Stmt) -> bool where
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs

Original file line number	Diff line number	Diff line change
`@@ -152,7 +152,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {`
`152`	`152`	`// If this is a tuple-like struct, register the constructor.`
`153`	`153`	`if !struct_def.is_struct() {`
`154`	`154`	`self.insert_def(struct_def.id(),`
`155`		`- NodeStructCtor(&**struct_def),`
	`155`	`+ NodeStructCtor(struct_def),`
`156`	`156`	`DefPathData::StructCtor);`
`157`	`157`	`}`
`158`	`158`
Original file line number	Diff line number	Diff line change
`@@ -223,8 +223,8 @@ pub trait Folder : Sized {`
`223`	`223`	`noop_fold_poly_trait_ref(p, self)`
`224`	`224`	`}`
`225`	`225`
`226`		`- fn fold_variant_data(&mut self, struct_def: P<VariantData>) -> P<VariantData> {`
`227`		`- noop_fold_struct_def(struct_def, self)`
	`226`	`+ fn fold_variant_data(&mut self, vdata: VariantData) -> VariantData {`
	`227`	`+ noop_fold_variant_data(vdata, self)`
`228`	`228`	`}`
`229`	`229`
`230`	`230`	`fn fold_lifetimes(&mut self, lts: Vec<Lifetime>) -> Vec<Lifetime> {`
`@@ -693,18 +693,16 @@ pub fn noop_fold_where_predicate<T: Folder>(pred: WherePredicate, fld: &mut T) -`
`693`	`693`	`}`
`694`	`694`	`}`
`695`	`695`
`696`		`-pub fn noop_fold_struct_def<T: Folder>(struct_def: P<VariantData>, fld: &mut T) -> P<VariantData> {`
`697`		`- struct_def.map(\|vdata\| {`
`698`		`- match vdata {`
`699`		`- VariantData::Struct(fields, id) => {`
`700`		`- VariantData::Struct(fields.move_map(\|f\| fld.fold_struct_field(f)), fld.new_id(id))`
`701`		`- }`
`702`		`- VariantData::Tuple(fields, id) => {`
`703`		`- VariantData::Tuple(fields.move_map(\|f\| fld.fold_struct_field(f)), fld.new_id(id))`
`704`		`- }`
`705`		`- VariantData::Unit(id) => VariantData::Unit(fld.new_id(id))`
	`696`	`+pub fn noop_fold_variant_data<T: Folder>(vdata: VariantData, fld: &mut T) -> VariantData {`
	`697`	`+ match vdata {`
	`698`	`+ VariantData::Struct(fields, id) => {`
	`699`	`+ VariantData::Struct(fields.move_map(\|f\| fld.fold_struct_field(f)), fld.new_id(id))`
`706`	`700`	`}`
`707`		`- })`
	`701`	`+ VariantData::Tuple(fields, id) => {`
	`702`	`+ VariantData::Tuple(fields.move_map(\|f\| fld.fold_struct_field(f)), fld.new_id(id))`
	`703`	`+ }`
	`704`	`+ VariantData::Unit(id) => VariantData::Unit(fld.new_id(id))`
	`705`	`+ }`
`708`	`706`	`}`
`709`	`707`
`710`	`708`	`pub fn noop_fold_trait_ref<T: Folder>(p: TraitRef, fld: &mut T) -> TraitRef {`
Original file line number	Diff line number	Diff line change
`@@ -266,7 +266,7 @@ pub fn lower_variant(_lctx: &LoweringContext, v: &Variant) -> P<hir::Variant> {`
`266`	`266`	`node: hir::Variant_ {`
`267`	`267`	`name: v.node.name.name,`
`268`	`268`	`attrs: v.node.attrs.clone(),`
`269`		`- data: lower_struct_def(_lctx, &v.node.data),`
	`269`	`+ data: lower_variant_data(_lctx, &v.node.data),`
`270`	`270`	`disr_expr: v.node.disr_expr.as_ref().map(\|e\| lower_expr(_lctx, e)),`
`271`	`271`	`},`
`272`	`272`	`span: v.span,`
`@@ -498,8 +498,8 @@ pub fn lower_where_predicate(_lctx: &LoweringContext,`
`498`	`498`	`}`
`499`	`499`	`}`
`500`	`500`
`501`		`-pub fn lower_struct_def(_lctx: &LoweringContext, sd: &VariantData) -> P<hir::VariantData> {`
`502`		`- P(match *sd {`
	`501`	`+pub fn lower_variant_data(_lctx: &LoweringContext, vdata: &VariantData) -> hir::VariantData {`
	`502`	`+ match *vdata {`
`503`	`503`	`VariantData::Struct(ref fields, id) => {`
`504`	`504`	`hir::VariantData::Struct(fields.iter()`
`505`	`505`	`.map(\|f\| lower_struct_field(_lctx, f)).collect(), id)`
`@@ -509,7 +509,7 @@ pub fn lower_struct_def(_lctx: &LoweringContext, sd: &VariantData) -> P<hir::Var`
`509`	`509`	`.map(\|f\| lower_struct_field(_lctx, f)).collect(), id)`
`510`	`510`	`}`
`511`	`511`	`VariantData::Unit(id) => hir::VariantData::Unit(id)`
`512`		`- })`
	`512`	`+ }`
`513`	`513`	`}`
`514`	`514`
`515`	`515`	`pub fn lower_trait_ref(_lctx: &LoweringContext, p: &TraitRef) -> hir::TraitRef {`
`@@ -611,7 +611,7 @@ pub fn lower_item_underscore(_lctx: &LoweringContext, i: &Item_) -> hir::Item_ {`
`611`	`611`	`lower_generics(_lctx, generics))`
`612`	`612`	`}`
`613`	`613`	`ItemStruct(ref struct_def, ref generics) => {`
`614`		`- let struct_def = lower_struct_def(_lctx, struct_def);`
	`614`	`+ let struct_def = lower_variant_data(_lctx, struct_def);`
`615`	`615`	`hir::ItemStruct(struct_def, lower_generics(_lctx, generics))`
`616`	`616`	`}`
`617`	`617`	`ItemDefaultImpl(unsafety, ref trait_ref) => {`
Original file line number	Diff line number	Diff line change
`@@ -1114,7 +1114,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> {`
`1114`	`1114`	`}`
`1115`	`1115`	`}`
`1116`	`1116`
`1117`		`- hir::ItemStruct(ref def, _) => check_struct(&**def),`
	`1117`	`+ hir::ItemStruct(ref def, _) => check_struct(def),`
`1118`	`1118`
`1119`	`1119`	`hir::ItemEnum(..) \|`
`1120`	`1120`	`hir::ItemExternCrate(_) \| hir::ItemUse(_) \|`
Original file line number	Diff line number	Diff line change
`@@ -514,7 +514,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {`
`514`	`514`	`}`
`515`	`515`
`516`	`516`	`// Record the def ID and fields of this struct.`
`517`		`- let named_fields = struct_def.fields().filter_map(\|f\| {`
	`517`	`+ let named_fields = struct_def.fields().iter().filter_map(\|f\| {`
`518`	`518`	`match f.node.kind {`
`519`	`519`	`NamedField(name, _) => Some(name),`
`520`	`520`	`UnnamedField(_) => None`