Remove redundant 'Variant' in variant names, stop reexporting.

diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index a85e0193a97018c41e03a2c129ea47a698b0a45e..cf20572510b5c81eb49cda40bc89cf369976d6da 100644 (file)
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -12,7 +12,6 @@
 //! that clean them.
 
 pub use self::Type::*;
-pub use self::VariantKind::*;
 pub use self::Mutability::*;
 pub use self::ItemEnum::*;
 pub use self::Attribute::*;
@@ -317,7 +316,7 @@ pub fn has_stripped_fields(&self) -> Option<bool> {
         match self.inner {
             StructItem(ref _struct) => Some(_struct.fields_stripped),
             UnionItem(ref union) => Some(union.fields_stripped),
-            VariantItem(Variant { kind: StructVariant(ref vstruct)} ) => {
+            VariantItem(Variant { kind: VariantKind::Struct(ref vstruct)} ) => {
                 Some(vstruct.fields_stripped)
             },
             _ => None,
@@ -2034,14 +2033,14 @@ fn clean(&self, cx: &DocContext) -> Item {
 impl<'tcx> Clean<Item> for ty::VariantDefData<'tcx, 'static> {
     fn clean(&self, cx: &DocContext) -> Item {
         let kind = match self.kind {
-            ty::VariantKind::Unit => CLikeVariant,
+            ty::VariantKind::Unit => VariantKind::CLike,
             ty::VariantKind::Tuple => {
-                TupleVariant(
+                VariantKind::Tuple(
                     self.fields.iter().map(|f| f.unsubst_ty().clean(cx)).collect()
                 )
             }
             ty::VariantKind::Struct => {
-                StructVariant(VariantStruct {
+                VariantKind::Struct(VariantStruct {
                     struct_type: doctree::Plain,
                     fields_stripped: false,
                     fields: self.fields.iter().map(|field| {
@@ -2074,19 +2073,19 @@ fn clean(&self, cx: &DocContext) -> Item {
 
 #[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
 pub enum VariantKind {
-    CLikeVariant,
-    TupleVariant(Vec<Type>),
-    StructVariant(VariantStruct),
+    CLike,
+    Tuple(Vec<Type>),
+    Struct(VariantStruct),
 }
 
 impl Clean<VariantKind> for hir::VariantData {
     fn clean(&self, cx: &DocContext) -> VariantKind {
         if self.is_struct() {
-            StructVariant(self.clean(cx))
+            VariantKind::Struct(self.clean(cx))
         } else if self.is_unit() {
-            CLikeVariant
+            VariantKind::CLike
         } else {
-            TupleVariant(self.fields().iter().map(|x| x.ty.clean(cx)).collect())
+            VariantKind::Tuple(self.fields().iter().map(|x| x.ty.clean(cx)).collect())
         }
     }
 }
@@ -2552,8 +2551,7 @@ fn clean(&self, cx: &DocContext) -> Vec<Item> {
                 if remaining.is_empty() {
                     return ret;
                 }
-                (ret, Import::List(resolve_use_source(cx, p.clean(cx), self.id),
-                                   remaining))
+                (ret, Import::List(resolve_use_source(cx, p.clean(cx), self.id), remaining))
             }
             hir::ViewPathSimple(name, ref p) => {
                 if !denied {

diff --git a/src/librustdoc/fold.rs b/src/librustdoc/fold.rs
index 8d6ab221c4fcedc3952adb208b9e3faaff08daf6..e269d940bfabf8a79931f0b4a8869ca88f654da1 100644 (file)
--- a/src/librustdoc/fold.rs
+++ b/src/librustdoc/fold.rs
@@ -74,12 +74,12 @@ fn fold_inner_recur(&mut self, inner: ItemEnum) -> ItemEnum {
             VariantItem(i) => {
                 let i2 = i.clone(); // this clone is small
                 match i.kind {
-                    StructVariant(mut j) => {
+                    VariantKind::Struct(mut j) => {
                         let num_fields = j.fields.len();
                         j.fields = j.fields.into_iter().filter_map(|x| self.fold_item(x)).collect();
                         j.fields_stripped |= num_fields != j.fields.len() ||
                                              j.fields.iter().any(|f| f.is_stripped());
-                        VariantItem(Variant {kind: StructVariant(j), ..i2})
+                        VariantItem(Variant {kind: VariantKind::Struct(j), ..i2})
                     },
                     _ => VariantItem(i2)
                 }

diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
index d2d12ef3c328028cc28898ae8cd6519b9260ee00..5a6e167188226a660299e4b7593f745af05f0d8b 100644 (file)
--- a/src/librustdoc/html/render.rs
+++ b/src/librustdoc/html/render.rs
@@ -2378,8 +2378,8 @@ fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
             match v.inner {
                 clean::VariantItem(ref var) => {
                     match var.kind {
-                        clean::CLikeVariant => write!(w, "{}", name)?,
-                        clean::TupleVariant(ref tys) => {
+                        clean::VariantKind::CLike => write!(w, "{}", name)?,
+                        clean::VariantKind::Tuple(ref tys) => {
                             write!(w, "{}(", name)?;
                             for (i, ty) in tys.iter().enumerate() {
                                 if i > 0 {
@@ -2389,7 +2389,7 @@ fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
                             }
                             write!(w, ")")?;
                         }
-                        clean::StructVariant(ref s) => {
+                        clean::VariantKind::Struct(ref s) => {
                             render_struct(w,
                                           v,
                                           None,
@@ -2429,7 +2429,7 @@ fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
                    ns_id = ns_id,
                    name = variant.name.as_ref().unwrap())?;
             if let clean::VariantItem(ref var) = variant.inner {
-                if let clean::TupleVariant(ref tys) = var.kind {
+                if let clean::VariantKind::Tuple(ref tys) = var.kind {
                     write!(w, "(")?;
                     for (i, ty) in tys.iter().enumerate() {
                         if i > 0 {
@@ -2443,8 +2443,10 @@ fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
             write!(w, "</code></span></span>")?;
             document(w, cx, variant)?;
 
-            use clean::{Variant, StructVariant};
-            if let clean::VariantItem( Variant { kind: StructVariant(ref s) } ) = variant.inner {
+            use clean::{Variant, VariantKind};
+            if let clean::VariantItem(Variant {
+                kind: VariantKind::Struct(ref s)
+            }) = variant.inner {
                 write!(w, "<h3 class='fields'>Fields</h3>\n
                            <table>")?;
                 for field in &s.fields {

diff --git a/src/librustdoc/passes/mod.rs b/src/librustdoc/passes/mod.rs
index a1b330e9b842349e72f68f3d37b7846a2723e5e0..1cc4f9371cb68689e02b0b3339e8731b237474fc 100644 (file)
--- a/src/librustdoc/passes/mod.rs
+++ b/src/librustdoc/passes/mod.rs
@@ -131,7 +131,7 @@ fn fold_item(&mut self, i: Item) -> Option<Item> {
             clean::ImplItem(ref imp) if imp.trait_.is_some() => true,
             // Struct variant fields have inherited visibility
             clean::VariantItem(clean::Variant {
-                kind: clean::StructVariant(..)
+                kind: clean::VariantKind::Struct(..)
             }) => true,
             _ => false,
         };