From 28ecfb691d4690ac8f3f6a2fb7d390a1f4abbbb0 Mon Sep 17 00:00:00 2001 From: Corey Farwell Date: Sat, 20 Aug 2016 13:36:52 -0400 Subject: [PATCH 1/9] =?UTF-8?q?Move=20ItemEnum=20=E2=86=92=20Generics=20lo?= =?UTF-8?q?gic=20into=20method=20on=20ItemEnum.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/librustdoc/clean/mod.rs | 17 +++++++++++++++++ src/librustdoc/html/render.rs | 13 ++----------- 2 files changed, 19 insertions(+), 11 deletions(-) diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 39b1a04e98e69..7a4558d7b79e4 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -380,6 +380,23 @@ pub enum ItemEnum { StrippedItem(Box), } +impl ItemEnum { + pub fn generics(&self) -> Option<&Generics> { + Some(match *self { + ItemEnum::StructItem(ref s) => &s.generics, + ItemEnum::EnumItem(ref e) => &e.generics, + ItemEnum::FunctionItem(ref f) => &f.generics, + ItemEnum::TypedefItem(ref t, _) => &t.generics, + ItemEnum::TraitItem(ref t) => &t.generics, + ItemEnum::ImplItem(ref i) => &i.generics, + ItemEnum::TyMethodItem(ref i) => &i.generics, + ItemEnum::MethodItem(ref i) => &i.generics, + ItemEnum::ForeignFunctionItem(ref f) => &f.generics, + _ => return None, + }) + } +} + #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Module { pub items: Vec, diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index e02cfb96dddf1..289b967333573 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -997,17 +997,8 @@ impl DocFolder for Cache { // Register any generics to their corresponding string. This is used // when pretty-printing types - match item.inner { - clean::StructItem(ref s) => self.generics(&s.generics), - clean::EnumItem(ref e) => self.generics(&e.generics), - clean::FunctionItem(ref f) => self.generics(&f.generics), - clean::TypedefItem(ref t, _) => self.generics(&t.generics), - clean::TraitItem(ref t) => self.generics(&t.generics), - clean::ImplItem(ref i) => self.generics(&i.generics), - clean::TyMethodItem(ref i) => self.generics(&i.generics), - clean::MethodItem(ref i) => self.generics(&i.generics), - clean::ForeignFunctionItem(ref f) => self.generics(&f.generics), - _ => {} + if let Some(generics) = item.inner.generics() { + self.generics(generics); } if !self.seen_mod { From 7dc411667a313f438f9edecb0b19b58d17596915 Mon Sep 17 00:00:00 2001 From: Corey Farwell Date: Sat, 20 Aug 2016 14:22:08 -0400 Subject: [PATCH 2/9] Migrate Context::maybe_ignore_item method to standalone function. The method wasn't using any `self` data from Context, so it seemed miseading to implement it as a method. --- src/librustdoc/html/render.rs | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 289b967333573..5b878c22e79b4 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -1353,7 +1353,7 @@ impl Context { // these modules are recursed into, but not rendered normally // (a flag on the context). if !self.render_redirect_pages { - self.render_redirect_pages = self.maybe_ignore_item(&item); + self.render_redirect_pages = maybe_ignore_item(&item); } if item.is_mod() { @@ -1436,7 +1436,7 @@ impl Context { // BTreeMap instead of HashMap to get a sorted output let mut map = BTreeMap::new(); for item in &m.items { - if self.maybe_ignore_item(item) { continue } + if maybe_ignore_item(item) { continue } let short = item_type(item).css_class(); let myname = match item.name { @@ -1453,17 +1453,6 @@ impl Context { } return map; } - - fn maybe_ignore_item(&self, it: &clean::Item) -> bool { - match it.inner { - clean::StrippedItem(..) => true, - clean::ModuleItem(ref m) => { - it.doc_value().is_none() && m.items.is_empty() - && it.visibility != Some(clean::Public) - }, - _ => false, - } - } } impl<'a> Item<'a> { @@ -1706,7 +1695,7 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context, if let clean::DefaultImplItem(..) = items[*i].inner { return false; } - !cx.maybe_ignore_item(&items[*i]) + !maybe_ignore_item(&items[*i]) }).collect::>(); // the order of item types in the listing @@ -1854,6 +1843,17 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context, Ok(()) } +fn maybe_ignore_item(it: &clean::Item) -> bool { + match it.inner { + clean::StrippedItem(..) => true, + clean::ModuleItem(ref m) => { + it.doc_value().is_none() && m.items.is_empty() + && it.visibility != Some(clean::Public) + }, + _ => false, + } +} + fn short_stability(item: &clean::Item, cx: &Context, show_reason: bool) -> Vec { let mut stability = vec![]; From 30397aee0ddb1a835aefa7e786810acadde53388 Mon Sep 17 00:00:00 2001 From: Corey Farwell Date: Sat, 20 Aug 2016 14:22:16 -0400 Subject: [PATCH 3/9] Migrate ItemType::from_item to convert::From. --- src/librustdoc/clean/mod.rs | 20 ++++++++++---------- src/librustdoc/html/item_type.rs | 6 ++++-- src/librustdoc/html/render.rs | 2 +- 3 files changed, 15 insertions(+), 13 deletions(-) diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 7a4558d7b79e4..d5149293e099a 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -287,34 +287,34 @@ impl Item { } } pub fn is_mod(&self) -> bool { - ItemType::from_item(self) == ItemType::Module + ItemType::from(self) == ItemType::Module } pub fn is_trait(&self) -> bool { - ItemType::from_item(self) == ItemType::Trait + ItemType::from(self) == ItemType::Trait } pub fn is_struct(&self) -> bool { - ItemType::from_item(self) == ItemType::Struct + ItemType::from(self) == ItemType::Struct } pub fn is_enum(&self) -> bool { - ItemType::from_item(self) == ItemType::Module + ItemType::from(self) == ItemType::Module } pub fn is_fn(&self) -> bool { - ItemType::from_item(self) == ItemType::Function + ItemType::from(self) == ItemType::Function } pub fn is_associated_type(&self) -> bool { - ItemType::from_item(self) == ItemType::AssociatedType + ItemType::from(self) == ItemType::AssociatedType } pub fn is_associated_const(&self) -> bool { - ItemType::from_item(self) == ItemType::AssociatedConst + ItemType::from(self) == ItemType::AssociatedConst } pub fn is_method(&self) -> bool { - ItemType::from_item(self) == ItemType::Method + ItemType::from(self) == ItemType::Method } pub fn is_ty_method(&self) -> bool { - ItemType::from_item(self) == ItemType::TyMethod + ItemType::from(self) == ItemType::TyMethod } pub fn is_primitive(&self) -> bool { - ItemType::from_item(self) == ItemType::Primitive + ItemType::from(self) == ItemType::Primitive } pub fn is_stripped(&self) -> bool { match self.inner { StrippedItem(..) => true, _ => false } diff --git a/src/librustdoc/html/item_type.rs b/src/librustdoc/html/item_type.rs index 6b462a76f04ed..31d965fccc2c0 100644 --- a/src/librustdoc/html/item_type.rs +++ b/src/librustdoc/html/item_type.rs @@ -50,8 +50,8 @@ pub enum NameSpace { Macro, } -impl ItemType { - pub fn from_item(item: &clean::Item) -> ItemType { +impl<'a> From<&'a clean::Item> for ItemType { + fn from(item: &'a clean::Item) -> ItemType { let inner = match item.inner { clean::StrippedItem(box ref item) => item, ref inner@_ => inner, @@ -83,7 +83,9 @@ impl ItemType { clean::StrippedItem(..) => unreachable!(), } } +} +impl ItemType { pub fn from_type_kind(kind: clean::TypeKind) -> ItemType { match kind { clean::TypeStruct => ItemType::Struct, diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 5b878c22e79b4..66f54587e6b32 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -833,7 +833,7 @@ fn mkdir(path: &Path) -> io::Result<()> { /// Returns a documentation-level item type from the item. fn item_type(item: &clean::Item) -> ItemType { - ItemType::from_item(item) + ItemType::from(item) } /// Takes a path to a source file and cleans the path to it. This canonicalizes From 0c9ff541396285ac441c5029ae4f0869edc97044 Mon Sep 17 00:00:00 2001 From: Corey Farwell Date: Sat, 20 Aug 2016 15:55:43 -0400 Subject: [PATCH 4/9] Migrate ItemType::from_type_kind to convert::From. --- src/librustdoc/html/item_type.rs | 6 ++++-- src/librustdoc/html/render.rs | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/librustdoc/html/item_type.rs b/src/librustdoc/html/item_type.rs index 31d965fccc2c0..be19217928467 100644 --- a/src/librustdoc/html/item_type.rs +++ b/src/librustdoc/html/item_type.rs @@ -85,8 +85,8 @@ impl<'a> From<&'a clean::Item> for ItemType { } } -impl ItemType { - pub fn from_type_kind(kind: clean::TypeKind) -> ItemType { +impl From for ItemType { + fn from(kind: clean::TypeKind) -> ItemType { match kind { clean::TypeStruct => ItemType::Struct, clean::TypeEnum => ItemType::Enum, @@ -99,7 +99,9 @@ impl ItemType { clean::TypeTypedef => ItemType::Typedef, } } +} +impl ItemType { pub fn css_class(&self) -> &'static str { match *self { ItemType::Module => "mod", diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 66f54587e6b32..6993f85c3d9a4 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -509,7 +509,7 @@ pub fn run(mut krate: clean::Crate, } = renderinfo; let external_paths = external_paths.into_iter() - .map(|(k, (v, t))| (k, (v, ItemType::from_type_kind(t)))) + .map(|(k, (v, t))| (k, (v, ItemType::from(t)))) .collect(); let mut cache = Cache { From 9dde5639908263bb3348616438c59d184fb29530 Mon Sep 17 00:00:00 2001 From: Corey Farwell Date: Tue, 23 Aug 2016 18:48:10 -0400 Subject: [PATCH 5/9] Stop reexporting `PrimitiveType` enum in librustdoc. --- src/librustdoc/clean/mod.rs | 183 +++++++++++++++++----------------- src/librustdoc/html/format.rs | 27 ++--- 2 files changed, 105 insertions(+), 105 deletions(-) diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index d5149293e099a..7e599569a282e 100644 --- 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::PrimitiveType::*; pub use self::TypeKind::*; pub use self::VariantKind::*; pub use self::Mutability::*; @@ -1517,12 +1516,12 @@ impl Type { pub fn primitive_type(&self) -> Option { match *self { Primitive(p) | BorrowedRef { type_: box Primitive(p), ..} => Some(p), - Vector(..) | BorrowedRef{ type_: box Vector(..), .. } => Some(Slice), + Vector(..) | BorrowedRef{ type_: box Vector(..), .. } => Some(PrimitiveType::Slice), FixedVector(..) | BorrowedRef { type_: box FixedVector(..), .. } => { - Some(Array) + Some(PrimitiveType::Array) } - Tuple(..) => Some(PrimitiveTuple), - RawPointer(..) => Some(PrimitiveRawPointer), + Tuple(..) => Some(PrimitiveType::PrimitiveTuple), + RawPointer(..) => Some(PrimitiveType::PrimitiveRawPointer), _ => None, } } @@ -1547,25 +1546,25 @@ impl GetDefId for Type { impl PrimitiveType { fn from_str(s: &str) -> Option { match s { - "isize" => Some(Isize), - "i8" => Some(I8), - "i16" => Some(I16), - "i32" => Some(I32), - "i64" => Some(I64), - "usize" => Some(Usize), - "u8" => Some(U8), - "u16" => Some(U16), - "u32" => Some(U32), - "u64" => Some(U64), - "bool" => Some(Bool), - "char" => Some(Char), - "str" => Some(Str), - "f32" => Some(F32), - "f64" => Some(F64), - "array" => Some(Array), - "slice" => Some(Slice), - "tuple" => Some(PrimitiveTuple), - "pointer" => Some(PrimitiveRawPointer), + "isize" => Some(PrimitiveType::Isize), + "i8" => Some(PrimitiveType::I8), + "i16" => Some(PrimitiveType::I16), + "i32" => Some(PrimitiveType::I32), + "i64" => Some(PrimitiveType::I64), + "usize" => Some(PrimitiveType::Usize), + "u8" => Some(PrimitiveType::U8), + "u16" => Some(PrimitiveType::U16), + "u32" => Some(PrimitiveType::U32), + "u64" => Some(PrimitiveType::U64), + "bool" => Some(PrimitiveType::Bool), + "char" => Some(PrimitiveType::Char), + "str" => Some(PrimitiveType::Str), + "f32" => Some(PrimitiveType::F32), + "f64" => Some(PrimitiveType::F64), + "array" => Some(PrimitiveType::Array), + "slice" => Some(PrimitiveType::Slice), + "tuple" => Some(PrimitiveType::PrimitiveTuple), + "pointer" => Some(PrimitiveType::PrimitiveRawPointer), _ => None, } } @@ -1585,25 +1584,25 @@ impl PrimitiveType { pub fn to_string(&self) -> &'static str { match *self { - Isize => "isize", - I8 => "i8", - I16 => "i16", - I32 => "i32", - I64 => "i64", - Usize => "usize", - U8 => "u8", - U16 => "u16", - U32 => "u32", - U64 => "u64", - F32 => "f32", - F64 => "f64", - Str => "str", - Bool => "bool", - Char => "char", - Array => "array", - Slice => "slice", - PrimitiveTuple => "tuple", - PrimitiveRawPointer => "pointer", + PrimitiveType::Isize => "isize", + PrimitiveType::I8 => "i8", + PrimitiveType::I16 => "i16", + PrimitiveType::I32 => "i32", + PrimitiveType::I64 => "i64", + PrimitiveType::Usize => "usize", + PrimitiveType::U8 => "u8", + PrimitiveType::U16 => "u16", + PrimitiveType::U32 => "u32", + PrimitiveType::U64 => "u64", + PrimitiveType::F32 => "f32", + PrimitiveType::F64 => "f64", + PrimitiveType::Str => "str", + PrimitiveType::Bool => "bool", + PrimitiveType::Char => "char", + PrimitiveType::Array => "array", + PrimitiveType::Slice => "slice", + PrimitiveType::PrimitiveTuple => "tuple", + PrimitiveType::PrimitiveRawPointer => "pointer", } } @@ -1771,21 +1770,21 @@ impl<'tcx> Clean for ty::Ty<'tcx> { fn clean(&self, cx: &DocContext) -> Type { match self.sty { ty::TyNever => Never, - ty::TyBool => Primitive(Bool), - ty::TyChar => Primitive(Char), - ty::TyInt(ast::IntTy::Is) => Primitive(Isize), - ty::TyInt(ast::IntTy::I8) => Primitive(I8), - ty::TyInt(ast::IntTy::I16) => Primitive(I16), - ty::TyInt(ast::IntTy::I32) => Primitive(I32), - ty::TyInt(ast::IntTy::I64) => Primitive(I64), - ty::TyUint(ast::UintTy::Us) => Primitive(Usize), - ty::TyUint(ast::UintTy::U8) => Primitive(U8), - ty::TyUint(ast::UintTy::U16) => Primitive(U16), - ty::TyUint(ast::UintTy::U32) => Primitive(U32), - ty::TyUint(ast::UintTy::U64) => Primitive(U64), - ty::TyFloat(ast::FloatTy::F32) => Primitive(F32), - ty::TyFloat(ast::FloatTy::F64) => Primitive(F64), - ty::TyStr => Primitive(Str), + ty::TyBool => Primitive(PrimitiveType::Bool), + ty::TyChar => Primitive(PrimitiveType::Char), + ty::TyInt(ast::IntTy::Is) => Primitive(PrimitiveType::Isize), + ty::TyInt(ast::IntTy::I8) => Primitive(PrimitiveType::I8), + ty::TyInt(ast::IntTy::I16) => Primitive(PrimitiveType::I16), + ty::TyInt(ast::IntTy::I32) => Primitive(PrimitiveType::I32), + ty::TyInt(ast::IntTy::I64) => Primitive(PrimitiveType::I64), + ty::TyUint(ast::UintTy::Us) => Primitive(PrimitiveType::Usize), + ty::TyUint(ast::UintTy::U8) => Primitive(PrimitiveType::U8), + ty::TyUint(ast::UintTy::U16) => Primitive(PrimitiveType::U16), + ty::TyUint(ast::UintTy::U32) => Primitive(PrimitiveType::U32), + ty::TyUint(ast::UintTy::U64) => Primitive(PrimitiveType::U64), + ty::TyFloat(ast::FloatTy::F32) => Primitive(PrimitiveType::F32), + ty::TyFloat(ast::FloatTy::F64) => Primitive(PrimitiveType::F64), + ty::TyStr => Primitive(PrimitiveType::Str), ty::TyBox(t) => { let box_did = cx.tcx_opt().and_then(|tcx| { tcx.lang_items.owned_box() @@ -2438,25 +2437,25 @@ fn build_deref_target_impls(cx: &DocContext, } }; let did = match primitive { - Isize => tcx.lang_items.isize_impl(), - I8 => tcx.lang_items.i8_impl(), - I16 => tcx.lang_items.i16_impl(), - I32 => tcx.lang_items.i32_impl(), - I64 => tcx.lang_items.i64_impl(), - Usize => tcx.lang_items.usize_impl(), - U8 => tcx.lang_items.u8_impl(), - U16 => tcx.lang_items.u16_impl(), - U32 => tcx.lang_items.u32_impl(), - U64 => tcx.lang_items.u64_impl(), - F32 => tcx.lang_items.f32_impl(), - F64 => tcx.lang_items.f64_impl(), - Char => tcx.lang_items.char_impl(), - Bool => None, - Str => tcx.lang_items.str_impl(), - Slice => tcx.lang_items.slice_impl(), - Array => tcx.lang_items.slice_impl(), - PrimitiveTuple => None, - PrimitiveRawPointer => tcx.lang_items.const_ptr_impl(), + PrimitiveType::Isize => tcx.lang_items.isize_impl(), + PrimitiveType::I8 => tcx.lang_items.i8_impl(), + PrimitiveType::I16 => tcx.lang_items.i16_impl(), + PrimitiveType::I32 => tcx.lang_items.i32_impl(), + PrimitiveType::I64 => tcx.lang_items.i64_impl(), + PrimitiveType::Usize => tcx.lang_items.usize_impl(), + PrimitiveType::U8 => tcx.lang_items.u8_impl(), + PrimitiveType::U16 => tcx.lang_items.u16_impl(), + PrimitiveType::U32 => tcx.lang_items.u32_impl(), + PrimitiveType::U64 => tcx.lang_items.u64_impl(), + PrimitiveType::F32 => tcx.lang_items.f32_impl(), + PrimitiveType::F64 => tcx.lang_items.f64_impl(), + PrimitiveType::Char => tcx.lang_items.char_impl(), + PrimitiveType::Bool => None, + PrimitiveType::Str => tcx.lang_items.str_impl(), + PrimitiveType::Slice => tcx.lang_items.slice_impl(), + PrimitiveType::Array => tcx.lang_items.slice_impl(), + PrimitiveType::PrimitiveTuple => None, + PrimitiveType::PrimitiveRawPointer => tcx.lang_items.const_ptr_impl(), }; if let Some(did) = did { if !did.is_local() { @@ -2739,21 +2738,21 @@ fn resolve_type(cx: &DocContext, let is_generic = match def { Def::PrimTy(p) => match p { - hir::TyStr => return Primitive(Str), - hir::TyBool => return Primitive(Bool), - hir::TyChar => return Primitive(Char), - hir::TyInt(ast::IntTy::Is) => return Primitive(Isize), - hir::TyInt(ast::IntTy::I8) => return Primitive(I8), - hir::TyInt(ast::IntTy::I16) => return Primitive(I16), - hir::TyInt(ast::IntTy::I32) => return Primitive(I32), - hir::TyInt(ast::IntTy::I64) => return Primitive(I64), - hir::TyUint(ast::UintTy::Us) => return Primitive(Usize), - hir::TyUint(ast::UintTy::U8) => return Primitive(U8), - hir::TyUint(ast::UintTy::U16) => return Primitive(U16), - hir::TyUint(ast::UintTy::U32) => return Primitive(U32), - hir::TyUint(ast::UintTy::U64) => return Primitive(U64), - hir::TyFloat(ast::FloatTy::F32) => return Primitive(F32), - hir::TyFloat(ast::FloatTy::F64) => return Primitive(F64), + hir::TyStr => return Primitive(PrimitiveType::Str), + hir::TyBool => return Primitive(PrimitiveType::Bool), + hir::TyChar => return Primitive(PrimitiveType::Char), + hir::TyInt(ast::IntTy::Is) => return Primitive(PrimitiveType::Isize), + hir::TyInt(ast::IntTy::I8) => return Primitive(PrimitiveType::I8), + hir::TyInt(ast::IntTy::I16) => return Primitive(PrimitiveType::I16), + hir::TyInt(ast::IntTy::I32) => return Primitive(PrimitiveType::I32), + hir::TyInt(ast::IntTy::I64) => return Primitive(PrimitiveType::I64), + hir::TyUint(ast::UintTy::Us) => return Primitive(PrimitiveType::Usize), + hir::TyUint(ast::UintTy::U8) => return Primitive(PrimitiveType::U8), + hir::TyUint(ast::UintTy::U16) => return Primitive(PrimitiveType::U16), + hir::TyUint(ast::UintTy::U32) => return Primitive(PrimitiveType::U32), + hir::TyUint(ast::UintTy::U64) => return Primitive(PrimitiveType::U64), + hir::TyFloat(ast::FloatTy::F32) => return Primitive(PrimitiveType::F32), + hir::TyFloat(ast::FloatTy::F64) => return Primitive(PrimitiveType::F64), }, Def::SelfTy(..) if path.segments.len() == 1 => { return Generic(keywords::SelfType.name().to_string()); diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index f8b852074dd2b..2b8db6975f135 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -23,7 +23,7 @@ use rustc::hir::def_id::DefId; use syntax::abi::Abi; use rustc::hir; -use clean; +use clean::{self, PrimitiveType}; use core::DocAccessLevels; use html::item_type::ItemType; use html::escape::Escape; @@ -468,28 +468,28 @@ impl fmt::Display for clean::Type { } clean::Tuple(ref typs) => { match &typs[..] { - &[] => primitive_link(f, clean::PrimitiveTuple, "()"), + &[] => primitive_link(f, PrimitiveType::PrimitiveTuple, "()"), &[ref one] => { - primitive_link(f, clean::PrimitiveTuple, "(")?; + primitive_link(f, PrimitiveType::PrimitiveTuple, "(")?; write!(f, "{},", one)?; - primitive_link(f, clean::PrimitiveTuple, ")") + primitive_link(f, PrimitiveType::PrimitiveTuple, ")") } many => { - primitive_link(f, clean::PrimitiveTuple, "(")?; + primitive_link(f, PrimitiveType::PrimitiveTuple, "(")?; write!(f, "{}", CommaSep(&many))?; - primitive_link(f, clean::PrimitiveTuple, ")") + primitive_link(f, PrimitiveType::PrimitiveTuple, ")") } } } clean::Vector(ref t) => { - primitive_link(f, clean::Slice, &format!("["))?; + primitive_link(f, PrimitiveType::Slice, &format!("["))?; write!(f, "{}", t)?; - primitive_link(f, clean::Slice, &format!("]")) + primitive_link(f, PrimitiveType::Slice, &format!("]")) } clean::FixedVector(ref t, ref s) => { - primitive_link(f, clean::PrimitiveType::Array, "[")?; + primitive_link(f, PrimitiveType::Array, "[")?; write!(f, "{}", t)?; - primitive_link(f, clean::PrimitiveType::Array, + primitive_link(f, PrimitiveType::Array, &format!("; {}]", Escape(s))) } clean::Never => f.write_str("!"), @@ -516,12 +516,13 @@ impl fmt::Display for clean::Type { clean::Vector(ref bt) => { // BorrowedRef{ ... Vector(T) } is &[T] match **bt { clean::Generic(_) => - primitive_link(f, clean::Slice, + primitive_link(f, PrimitiveType::Slice, &format!("&{}{}[{}]", lt, m, **bt)), _ => { - primitive_link(f, clean::Slice, &format!("&{}{}[", lt, m))?; + primitive_link(f, PrimitiveType::Slice, + &format!("&{}{}[", lt, m))?; write!(f, "{}", **bt)?; - primitive_link(f, clean::Slice, "]") + primitive_link(f, PrimitiveType::Slice, "]") } } } From 5c849f4a50a6e6d42776847144e06d1405cb4189 Mon Sep 17 00:00:00 2001 From: Corey Farwell Date: Tue, 23 Aug 2016 18:51:56 -0400 Subject: [PATCH 6/9] Remove unnecessary 'Primitive' prefix on `PrimitiveType` enum variants. --- src/librustdoc/clean/mod.rs | 20 ++++++++++---------- src/librustdoc/html/format.rs | 14 +++++++------- 2 files changed, 17 insertions(+), 17 deletions(-) diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 7e599569a282e..093e6a2adadae 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1485,8 +1485,8 @@ pub enum PrimitiveType { Str, Slice, Array, - PrimitiveTuple, - PrimitiveRawPointer, + Tuple, + RawPointer, } #[derive(Clone, RustcEncodable, RustcDecodable, Copy, Debug)] @@ -1520,8 +1520,8 @@ impl Type { FixedVector(..) | BorrowedRef { type_: box FixedVector(..), .. } => { Some(PrimitiveType::Array) } - Tuple(..) => Some(PrimitiveType::PrimitiveTuple), - RawPointer(..) => Some(PrimitiveType::PrimitiveRawPointer), + Tuple(..) => Some(PrimitiveType::Tuple), + RawPointer(..) => Some(PrimitiveType::RawPointer), _ => None, } } @@ -1563,8 +1563,8 @@ impl PrimitiveType { "f64" => Some(PrimitiveType::F64), "array" => Some(PrimitiveType::Array), "slice" => Some(PrimitiveType::Slice), - "tuple" => Some(PrimitiveType::PrimitiveTuple), - "pointer" => Some(PrimitiveType::PrimitiveRawPointer), + "tuple" => Some(PrimitiveType::Tuple), + "pointer" => Some(PrimitiveType::RawPointer), _ => None, } } @@ -1601,8 +1601,8 @@ impl PrimitiveType { PrimitiveType::Char => "char", PrimitiveType::Array => "array", PrimitiveType::Slice => "slice", - PrimitiveType::PrimitiveTuple => "tuple", - PrimitiveType::PrimitiveRawPointer => "pointer", + PrimitiveType::Tuple => "tuple", + PrimitiveType::RawPointer => "pointer", } } @@ -2454,8 +2454,8 @@ fn build_deref_target_impls(cx: &DocContext, PrimitiveType::Str => tcx.lang_items.str_impl(), PrimitiveType::Slice => tcx.lang_items.slice_impl(), PrimitiveType::Array => tcx.lang_items.slice_impl(), - PrimitiveType::PrimitiveTuple => None, - PrimitiveType::PrimitiveRawPointer => tcx.lang_items.const_ptr_impl(), + PrimitiveType::Tuple => None, + PrimitiveType::RawPointer => tcx.lang_items.const_ptr_impl(), }; if let Some(did) = did { if !did.is_local() { diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index 2b8db6975f135..65992798ab099 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -468,16 +468,16 @@ impl fmt::Display for clean::Type { } clean::Tuple(ref typs) => { match &typs[..] { - &[] => primitive_link(f, PrimitiveType::PrimitiveTuple, "()"), + &[] => primitive_link(f, PrimitiveType::Tuple, "()"), &[ref one] => { - primitive_link(f, PrimitiveType::PrimitiveTuple, "(")?; + primitive_link(f, PrimitiveType::Tuple, "(")?; write!(f, "{},", one)?; - primitive_link(f, PrimitiveType::PrimitiveTuple, ")") + primitive_link(f, PrimitiveType::Tuple, ")") } many => { - primitive_link(f, PrimitiveType::PrimitiveTuple, "(")?; + primitive_link(f, PrimitiveType::Tuple, "(")?; write!(f, "{}", CommaSep(&many))?; - primitive_link(f, PrimitiveType::PrimitiveTuple, ")") + primitive_link(f, PrimitiveType::Tuple, ")") } } } @@ -496,11 +496,11 @@ impl fmt::Display for clean::Type { clean::RawPointer(m, ref t) => { match **t { clean::Generic(_) | clean::ResolvedPath {is_generic: true, ..} => { - primitive_link(f, clean::PrimitiveType::PrimitiveRawPointer, + primitive_link(f, clean::PrimitiveType::RawPointer, &format!("*{}{}", RawMutableSpace(m), t)) } _ => { - primitive_link(f, clean::PrimitiveType::PrimitiveRawPointer, + primitive_link(f, clean::PrimitiveType::RawPointer, &format!("*{}", RawMutableSpace(m)))?; write!(f, "{}", t) } From 8a6f7a5ced0217344f2f8a8c6a98aefb08b10fa7 Mon Sep 17 00:00:00 2001 From: Corey Farwell Date: Tue, 23 Aug 2016 19:12:24 -0400 Subject: [PATCH 7/9] Implement `From` for `PrimitiveType`. --- src/librustdoc/clean/mod.rs | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 093e6a2adadae..3abc7e985366a 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1619,6 +1619,17 @@ impl PrimitiveType { } } +impl From for PrimitiveType { + fn from(int_ty: ast::IntTy) -> PrimitiveType { + match int_ty { + ast::IntTy::Is => PrimitiveType::Isize, + ast::IntTy::I8 => PrimitiveType::I8, + ast::IntTy::I16 => PrimitiveType::I16, + ast::IntTy::I32 => PrimitiveType::I32, + ast::IntTy::I64 => PrimitiveType::I64, + } + } +} // Poor man's type parameter substitution at HIR level. // Used to replace private type aliases in public signatures with their aliased types. @@ -1772,11 +1783,7 @@ impl<'tcx> Clean for ty::Ty<'tcx> { ty::TyNever => Never, ty::TyBool => Primitive(PrimitiveType::Bool), ty::TyChar => Primitive(PrimitiveType::Char), - ty::TyInt(ast::IntTy::Is) => Primitive(PrimitiveType::Isize), - ty::TyInt(ast::IntTy::I8) => Primitive(PrimitiveType::I8), - ty::TyInt(ast::IntTy::I16) => Primitive(PrimitiveType::I16), - ty::TyInt(ast::IntTy::I32) => Primitive(PrimitiveType::I32), - ty::TyInt(ast::IntTy::I64) => Primitive(PrimitiveType::I64), + ty::TyInt(int_ty) => Primitive(int_ty.into()), ty::TyUint(ast::UintTy::Us) => Primitive(PrimitiveType::Usize), ty::TyUint(ast::UintTy::U8) => Primitive(PrimitiveType::U8), ty::TyUint(ast::UintTy::U16) => Primitive(PrimitiveType::U16), @@ -2741,11 +2748,7 @@ fn resolve_type(cx: &DocContext, hir::TyStr => return Primitive(PrimitiveType::Str), hir::TyBool => return Primitive(PrimitiveType::Bool), hir::TyChar => return Primitive(PrimitiveType::Char), - hir::TyInt(ast::IntTy::Is) => return Primitive(PrimitiveType::Isize), - hir::TyInt(ast::IntTy::I8) => return Primitive(PrimitiveType::I8), - hir::TyInt(ast::IntTy::I16) => return Primitive(PrimitiveType::I16), - hir::TyInt(ast::IntTy::I32) => return Primitive(PrimitiveType::I32), - hir::TyInt(ast::IntTy::I64) => return Primitive(PrimitiveType::I64), + hir::TyInt(int_ty) => return Primitive(int_ty.into()), hir::TyUint(ast::UintTy::Us) => return Primitive(PrimitiveType::Usize), hir::TyUint(ast::UintTy::U8) => return Primitive(PrimitiveType::U8), hir::TyUint(ast::UintTy::U16) => return Primitive(PrimitiveType::U16), From 168cfea8afaf2dddae3d848a7f49ecb63d130b47 Mon Sep 17 00:00:00 2001 From: Corey Farwell Date: Tue, 23 Aug 2016 19:22:18 -0400 Subject: [PATCH 8/9] Implement `From` for `PrimitiveType`. --- src/librustdoc/clean/mod.rs | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 3abc7e985366a..4f455e7d073de 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1631,6 +1631,18 @@ impl From for PrimitiveType { } } +impl From for PrimitiveType { + fn from(uint_ty: ast::UintTy) -> PrimitiveType { + match uint_ty { + ast::UintTy::Us => PrimitiveType::Usize, + ast::UintTy::U8 => PrimitiveType::U8, + ast::UintTy::U16 => PrimitiveType::U16, + ast::UintTy::U32 => PrimitiveType::U32, + ast::UintTy::U64 => PrimitiveType::U64, + } + } +} + // Poor man's type parameter substitution at HIR level. // Used to replace private type aliases in public signatures with their aliased types. struct SubstAlias<'a, 'tcx: 'a> { @@ -1784,11 +1796,7 @@ impl<'tcx> Clean for ty::Ty<'tcx> { ty::TyBool => Primitive(PrimitiveType::Bool), ty::TyChar => Primitive(PrimitiveType::Char), ty::TyInt(int_ty) => Primitive(int_ty.into()), - ty::TyUint(ast::UintTy::Us) => Primitive(PrimitiveType::Usize), - ty::TyUint(ast::UintTy::U8) => Primitive(PrimitiveType::U8), - ty::TyUint(ast::UintTy::U16) => Primitive(PrimitiveType::U16), - ty::TyUint(ast::UintTy::U32) => Primitive(PrimitiveType::U32), - ty::TyUint(ast::UintTy::U64) => Primitive(PrimitiveType::U64), + ty::TyUint(uint_ty) => Primitive(uint_ty.into()), ty::TyFloat(ast::FloatTy::F32) => Primitive(PrimitiveType::F32), ty::TyFloat(ast::FloatTy::F64) => Primitive(PrimitiveType::F64), ty::TyStr => Primitive(PrimitiveType::Str), @@ -2749,11 +2757,7 @@ fn resolve_type(cx: &DocContext, hir::TyBool => return Primitive(PrimitiveType::Bool), hir::TyChar => return Primitive(PrimitiveType::Char), hir::TyInt(int_ty) => return Primitive(int_ty.into()), - hir::TyUint(ast::UintTy::Us) => return Primitive(PrimitiveType::Usize), - hir::TyUint(ast::UintTy::U8) => return Primitive(PrimitiveType::U8), - hir::TyUint(ast::UintTy::U16) => return Primitive(PrimitiveType::U16), - hir::TyUint(ast::UintTy::U32) => return Primitive(PrimitiveType::U32), - hir::TyUint(ast::UintTy::U64) => return Primitive(PrimitiveType::U64), + hir::TyUint(uint_ty) => return Primitive(uint_ty.into()), hir::TyFloat(ast::FloatTy::F32) => return Primitive(PrimitiveType::F32), hir::TyFloat(ast::FloatTy::F64) => return Primitive(PrimitiveType::F64), }, From 42e8ac87eb013f34db5739bf154a383424595077 Mon Sep 17 00:00:00 2001 From: Corey Farwell Date: Tue, 23 Aug 2016 19:41:14 -0400 Subject: [PATCH 9/9] Implement `From` for `PrimitiveType`. --- src/librustdoc/clean/mod.rs | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 4f455e7d073de..e2e655ce38bcc 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1643,6 +1643,15 @@ impl From for PrimitiveType { } } +impl From for PrimitiveType { + fn from(float_ty: ast::FloatTy) -> PrimitiveType { + match float_ty { + ast::FloatTy::F32 => PrimitiveType::F32, + ast::FloatTy::F64 => PrimitiveType::F64, + } + } +} + // Poor man's type parameter substitution at HIR level. // Used to replace private type aliases in public signatures with their aliased types. struct SubstAlias<'a, 'tcx: 'a> { @@ -1797,8 +1806,7 @@ impl<'tcx> Clean for ty::Ty<'tcx> { ty::TyChar => Primitive(PrimitiveType::Char), ty::TyInt(int_ty) => Primitive(int_ty.into()), ty::TyUint(uint_ty) => Primitive(uint_ty.into()), - ty::TyFloat(ast::FloatTy::F32) => Primitive(PrimitiveType::F32), - ty::TyFloat(ast::FloatTy::F64) => Primitive(PrimitiveType::F64), + ty::TyFloat(float_ty) => Primitive(float_ty.into()), ty::TyStr => Primitive(PrimitiveType::Str), ty::TyBox(t) => { let box_did = cx.tcx_opt().and_then(|tcx| { @@ -2758,8 +2766,7 @@ fn resolve_type(cx: &DocContext, hir::TyChar => return Primitive(PrimitiveType::Char), hir::TyInt(int_ty) => return Primitive(int_ty.into()), hir::TyUint(uint_ty) => return Primitive(uint_ty.into()), - hir::TyFloat(ast::FloatTy::F32) => return Primitive(PrimitiveType::F32), - hir::TyFloat(ast::FloatTy::F64) => return Primitive(PrimitiveType::F64), + hir::TyFloat(float_ty) => return Primitive(float_ty.into()), }, Def::SelfTy(..) if path.segments.len() == 1 => { return Generic(keywords::SelfType.name().to_string());