use rustc::hir;
use clean;
+use core::DocAccessLevels;
use html::item_type::ItemType;
use html::render;
use html::render::{cache, CURRENT_LOCATION_KEY};
/// Helper to render an optional visibility with a space after it (if the
/// visibility is preset)
#[derive(Copy, Clone)]
-pub struct VisSpace<'a>(pub &'a Option<hir::Visibility>);
+pub struct VisSpace<'a>(pub &'a Option<clean::Visibility>);
/// Similarly to VisSpace, this structure is used to render a function style with a
/// space after it.
#[derive(Copy, Clone)]
pub struct CommaSep<'a, T: 'a>(pub &'a [T]);
pub struct AbiSpace(pub Abi);
+pub struct HRef<'a> {
+ pub did: DefId,
+ pub text: &'a str,
+}
+
impl<'a> VisSpace<'a> {
- pub fn get(self) -> &'a Option<hir::Visibility> {
+ pub fn get(self) -> &'a Option<clean::Visibility> {
let VisSpace(v) = self; v
}
}
pub fn href(did: DefId) -> Option<(String, ItemType, Vec<String>)> {
let cache = cache();
+ if !did.is_local() && !cache.access_levels.is_doc_reachable(did) {
+ return None
+ }
+
let loc = CURRENT_LOCATION_KEY.with(|l| l.borrow().clone());
let &(ref fqp, shortty) = match cache.paths.get(&did) {
Some(p) => p,
None => return None,
};
+
let mut url = if did.is_local() || cache.inlined.contains(&did) {
repeat("../").take(loc.len()).collect::<String>()
} else {
}
}
}
-
- match href(did) {
- Some((url, shortty, fqp)) => {
- write!(w, "<a class='{}' href='{}' title='{}'>{}</a>",
- shortty, url, fqp.join("::"), last.name)?;
- }
- _ => write!(w, "{}", last.name)?,
- }
- write!(w, "{}", last.params)?;
+ write!(w, "{}{}", HRef::new(did, &last.name), last.params)?;
Ok(())
}
}
}
+impl<'a> HRef<'a> {
+ pub fn new(did: DefId, text: &'a str) -> HRef<'a> {
+ HRef { did: did, text: text }
+ }
+}
+
+impl<'a> fmt::Display for HRef<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match href(self.did) {
+ Some((url, shortty, fqp)) => {
+ write!(f, "<a class='{}' href='{}' title='{}'>{}</a>",
+ shortty, url, fqp.join("::"), self.text)
+ }
+ _ => write!(f, "{}", self.text),
+ }
+ }
+}
+
impl fmt::Display for clean::Type {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
}
}
+fn fmt_impl(i: &clean::Impl, f: &mut fmt::Formatter, link_trait: bool) -> fmt::Result {
+ write!(f, "impl{} ", i.generics)?;
+ if let Some(ref ty) = i.trait_ {
+ write!(f, "{}",
+ if i.polarity == Some(clean::ImplPolarity::Negative) { "!" } else { "" })?;
+ if link_trait {
+ write!(f, "{}", *ty)?;
+ } else {
+ write!(f, "{}", ty.trait_name().unwrap())?;
+ }
+ write!(f, " for ")?;
+ }
+ write!(f, "{}{}", i.for_, WhereClause(&i.generics))?;
+ Ok(())
+}
+
impl fmt::Display for clean::Impl {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "impl{} ", self.generics)?;
- if let Some(ref ty) = self.trait_ {
- write!(f, "{}{} for ",
- if self.polarity == Some(clean::ImplPolarity::Negative) { "!" } else { "" },
- *ty)?;
- }
- write!(f, "{}{}", self.for_, WhereClause(&self.generics))?;
- Ok(())
+ fmt_impl(self, f, true)
}
}
+// The difference from above is that trait is not hyperlinked.
+pub fn fmt_impl_for_trait_page(i: &clean::Impl, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt_impl(i, f, false)
+}
+
impl fmt::Display for clean::Arguments {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for (i, input) in self.values.iter().enumerate() {
impl<'a> fmt::Display for VisSpace<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self.get() {
- Some(hir::Public) => write!(f, "pub "),
- Some(hir::Inherited) | None => Ok(())
+ Some(clean::Public) => write!(f, "pub "),
+ Some(clean::Inherited) | None => Ok(())
}
}
}
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
clean::SimpleImport(ref name, ref src) => {
- if *name == src.path.segments.last().unwrap().name {
+ if *name == src.path.last_name() {
write!(f, "use {};", *src)
} else {
write!(f, "use {} as {};", *src, *name)