mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

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

Browse source
This commit is contained in:
Corey Farwell 2016-10-02 20:07:18 -04:00
parent 88d41441f6
commit 35d214afe6
4 changed files with 22 additions and 22 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
src/librustdoc/clean/mod.rs
View file

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

4
src/librustdoc/fold.rs
View file

@ -74,12 +74,12 @@ pub trait DocFolder : Sized {
VariantItem(i) => { VariantItem(i) => {
let i2 = i.clone(); // this clone is small let i2 = i.clone(); // this clone is small
match i.kind { match i.kind {
StructVariant(mut j) => { VariantKind::Struct(mut j) => {
let num_fields = j.fields.len(); let num_fields = j.fields.len();
j.fields = j.fields.into_iter().filter_map(|x| self.fold_item(x)).collect(); j.fields = j.fields.into_iter().filter_map(|x| self.fold_item(x)).collect();
j.fields_stripped |= num_fields != j.fields.len() || j.fields_stripped |= num_fields != j.fields.len() ||
j.fields.iter().any(|f| f.is_stripped()); j.fields.iter().any(|f| f.is_stripped());
VariantItem(Variant {kind: StructVariant(j), ..i2}) VariantItem(Variant {kind: VariantKind::Struct(j), ..i2})
}, },
_ => VariantItem(i2) _ => VariantItem(i2)
} }

14
src/librustdoc/html/render.rs
View file

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

2
src/librustdoc/passes/mod.rs
View file

@ -131,7 +131,7 @@ impl<'a> fold::DocFolder for Stripper<'a> {
clean::ImplItem(ref imp) if imp.trait_.is_some() => true, clean::ImplItem(ref imp) if imp.trait_.is_some() => true,
// Struct variant fields have inherited visibility // Struct variant fields have inherited visibility
clean::VariantItem(clean::Variant { clean::VariantItem(clean::Variant {
kind: clean::StructVariant(..) kind: clean::VariantKind::Struct(..)
}) => true, }) => true,
_ => false, _ => false,
}; };