}
}
-fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter, use_absolute: bool) -> fmt::Result {
+fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter, use_absolute: bool,
+ is_not_debug: bool) -> fmt::Result {
match *t {
clean::Generic(ref name) => {
f.write_str(name)
tybounds(f, typarams)
}
clean::Infer => write!(f, "_"),
- clean::Primitive(prim) => primitive_link(f, prim, prim.as_str()),
+ clean::Primitive(prim) if is_not_debug => primitive_link(f, prim, prim.as_str()),
+ clean::Primitive(prim) => write!(f, "{}", prim.as_str()),
clean::BareFunction(ref decl) => {
if f.alternate() {
write!(f, "{}{}fn{:#}{:#}",
}
clean::Tuple(ref typs) => {
match &typs[..] {
- &[] => primitive_link(f, PrimitiveType::Tuple, "()"),
- &[ref one] => {
+ &[] if is_not_debug => primitive_link(f, PrimitiveType::Tuple, "()"),
+ &[] => write!(f, "()"),
+ &[ref one] if is_not_debug => {
primitive_link(f, PrimitiveType::Tuple, "(")?;
//carry f.alternate() into this display w/o branching manually
fmt::Display::fmt(one, f)?;
primitive_link(f, PrimitiveType::Tuple, ",)")
}
- many => {
+ &[ref one] => write!(f, "({},)", one),
+ many if is_not_debug => {
primitive_link(f, PrimitiveType::Tuple, "(")?;
fmt::Display::fmt(&CommaSep(&many), f)?;
primitive_link(f, PrimitiveType::Tuple, ")")
}
+ many => write!(f, "({})", &CommaSep(&many)),
}
}
- clean::Vector(ref t) => {
+ clean::Vector(ref t) if is_not_debug => {
primitive_link(f, PrimitiveType::Slice, &format!("["))?;
fmt::Display::fmt(t, f)?;
primitive_link(f, PrimitiveType::Slice, &format!("]"))
}
- clean::FixedVector(ref t, ref s) => {
+ clean::Vector(ref t) => write!(f, "[{}]", t),
+ clean::FixedVector(ref t, ref s) if is_not_debug => {
primitive_link(f, PrimitiveType::Array, "[")?;
fmt::Display::fmt(t, f)?;
if f.alternate() {
&format!("; {}]", Escape(s)))
}
}
+ clean::FixedVector(ref t, ref s) => {
+ if f.alternate() {
+ write!(f, "[{}; {}]", t, s)
+ } else {
+ write!(f, "[{}; {}]", t, Escape(s))
+ }
+ }
clean::Never => f.write_str("!"),
clean::RawPointer(m, ref t) => {
match **t {
- clean::Generic(_) | clean::ResolvedPath {is_generic: true, ..} => {
+ clean::Generic(_) | clean::ResolvedPath {is_generic: true, ..} if is_not_debug => {
if f.alternate() {
primitive_link(f, clean::PrimitiveType::RawPointer,
&format!("*{}{:#}", RawMutableSpace(m), t))
&format!("*{}{}", RawMutableSpace(m), t))
}
}
- _ => {
+ clean::Generic(_) | clean::ResolvedPath {is_generic: true, ..} => {
+ if f.alternate() {
+ write!(f, "*{}{:#}", RawMutableSpace(m), t)
+ } else {
+ write!(f, "*{}{}", RawMutableSpace(m), t)
+ }
+ }
+ _ if is_not_debug => {
primitive_link(f, clean::PrimitiveType::RawPointer,
&format!("*{}", RawMutableSpace(m)))?;
fmt::Display::fmt(t, f)
}
+ _ => {
+ write!(f, "*{}{}", RawMutableSpace(m), t)
+ }
}
}
clean::BorrowedRef{ lifetime: ref l, mutability, type_: ref ty} => {
match **ty {
clean::Vector(ref bt) => { // BorrowedRef{ ... Vector(T) } is &[T]
match **bt {
- clean::Generic(_) =>
+ clean::Generic(_) if is_not_debug => {
if f.alternate() {
primitive_link(f, PrimitiveType::Slice,
&format!("&{}{}[{:#}]", lt, m, **bt))
} else {
primitive_link(f, PrimitiveType::Slice,
&format!("&{}{}[{}]", lt, m, **bt))
- },
- _ => {
+ }
+ }
+ clean::Generic(_) => {
+ if f.alternate() {
+ write!(f, "&{}{}[{:#}]", lt, m, **bt)
+ } else {
+ write!(f, "&{}{}[{}]", lt, m, **bt)
+ }
+ }
+ _ if is_not_debug => {
if f.alternate() {
primitive_link(f, PrimitiveType::Slice,
&format!("&{}{}[", lt, m))?;
}
primitive_link(f, PrimitiveType::Slice, "]")
}
+ _ => {
+ if f.alternate() {
+ write!(f, "&{}{}[{:#}]", lt, m, **bt)
+ } else {
+ write!(f, "&{}{}[{}]", lt, m, **bt)
+ }
+ }
}
}
_ => {
if f.alternate() {
write!(f, "&{}{}", lt, m)?;
- fmt_type(&ty, f, use_absolute)
+ fmt_type(&ty, f, use_absolute, is_not_debug)
} else {
- write!(f, "&{}{}", lt, m)?;
- fmt_type(&ty, f, use_absolute)
+ if is_not_debug {
+ write!(f, "&{}{}", lt, m)?;
+ } else {
+ write!(f, "&{}{}", lt, m)?;
+ }
+ fmt_type(&ty, f, use_absolute, is_not_debug)
}
}
}
if f.alternate() {
write!(f, "<{:#} as {:#}>::{}", self_type, trait_, name)
} else {
- write!(f, "<{} as {}>::{}", self_type, trait_, name)
+ if is_not_debug {
+ write!(f, "<{} as {}>::{}", self_type, trait_, name)
+ } else {
+ write!(f, "<{} as {}>::{}", self_type, trait_, name)
+ }
}
}
clean::Unique(..) => {
impl fmt::Display for clean::Type {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- fmt_type(self, f, false)
+ fmt_type(self, f, false, true)
+ }
+}
+
+impl fmt::Debug for clean::Type {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt_type(self, f, false, false)
}
}
plain.push_str(" for ");
}
- fmt_type(&i.for_, f, use_absolute)?;
+ fmt_type(&i.for_, f, use_absolute, true)?;
plain.push_str(&format!("{:#}", i.for_));
fmt::Display::fmt(&WhereClause(&i.generics, plain.len() + 1), f)?;