mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Stop reexporting PrimitiveType enum in librustdoc.

Browse Source
This commit is contained in:
Corey Farwell 2016-08-23 18:48:10 -04:00
parent 0c9ff54139
commit 9dde563990
2 changed files with 105 additions and 105 deletions
src/librustdoc
clean
mod.rs
html
format.rs

183
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<PrimitiveType> {
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<PrimitiveType> {
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<Type> 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());

27
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!("&amp;{}{}[{}]", lt, m, **bt)),
_ => {
primitive_link(f, clean::Slice, &format!("&amp;{}{}[", lt, m))?;
primitive_link(f, PrimitiveType::Slice,
&format!("&amp;{}{}[", lt, m))?;
write!(f, "{}", **bt)?;
primitive_link(f, clean::Slice, "]")
primitive_link(f, PrimitiveType::Slice, "]")
}
}
}