bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

rustdoc: Pass the Context down to short_stability()

Browse source
This commit is contained in:
Martin Wernstål 2015-08-16 17:05:18 +02:00
parent 440c0f07c3
commit b31038764d
1 changed files with 58 additions and 56 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1494,16 +1494,16 @@ impl<'a> fmt::Display for Item<'a> {
item_module(fmt, self.cx, self.item, &m.items)
}
clean::FunctionItem(ref f) | clean::ForeignFunctionItem(ref f) =>
item_function(fmt, self.item, f),
item_function(fmt, self.cx, self.item, f),
clean::TraitItem(ref t) => item_trait(fmt, self.cx, self.item, t),
clean::StructItem(ref s) => item_struct(fmt, self.item, s),
clean::EnumItem(ref e) => item_enum(fmt, self.item, e),
clean::TypedefItem(ref t, _) => item_typedef(fmt, self.item, t),
clean::MacroItem(ref m) => item_macro(fmt, self.item, m),
clean::PrimitiveItem(ref p) => item_primitive(fmt, self.item, p),
clean::StructItem(ref s) => item_struct(fmt, self.cx, self.item, s),
clean::EnumItem(ref e) => item_enum(fmt, self.cx, self.item, e),
clean::TypedefItem(ref t, _) => item_typedef(fmt, self.cx, self.item, t),
clean::MacroItem(ref m) => item_macro(fmt, self.cx, self.item, m),
clean::PrimitiveItem(ref p) => item_primitive(fmt, self.cx, self.item, p),
clean::StaticItem(ref i) | clean::ForeignStaticItem(ref i) =>
item_static(fmt, self.item, i),
clean::ConstantItem(ref c) => item_constant(fmt, self.item, c),
item_static(fmt, self.cx, self.item, i),
clean::ConstantItem(ref c) => item_constant(fmt, self.cx, self.item, c),
_ => Ok(())
}
}
@ -1546,8 +1546,8 @@ fn plain_summary_line(s: Option<&str>) -> String {
markdown::plain_summary_line(&line[..])
}
fn document(w: &mut fmt::Formatter, item: &clean::Item) -> fmt::Result {
if let Some(s) = short_stability(item, true) {
fn document(w: &mut fmt::Formatter, cx: &Context, item: &clean::Item) -> fmt::Result {
if let Some(s) = short_stability(item, cx, true) {
try!(write!(w, "<div class='stability'>{}</div>", s));
}
if let Some(s) = item.doc_value() {
@ -1558,7 +1558,7 @@ fn document(w: &mut fmt::Formatter, item: &clean::Item) -> fmt::Result {
fn item_module(w: &mut fmt::Formatter, cx: &Context,
item: &clean::Item, items: &[clean::Item]) -> fmt::Result {
try!(document(w, item));
try!(document(w, cx, item));
let mut indices = (0..items.len()).filter(|i| {
!cx.ignore_private_item(&items[*i])
@ -1666,7 +1666,7 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
_ => {
if myitem.name.is_none() { continue }
let stab_docs = if let Some(s) = short_stability(myitem, false) {
let stab_docs = if let Some(s) = short_stability(myitem, cx, false) {
format!("[{}]", s)
} else {
String::new()
@ -1694,7 +1694,7 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
write!(w, "</table>")
}
fn short_stability(item: &clean::Item, show_reason: bool) -> Option<String> {
fn short_stability(item: &clean::Item, cx: &Context, show_reason: bool) -> Option<String> {
item.stability.as_ref().and_then(|stab| {
let reason = if show_reason && !stab.reason.is_empty() {
format!(": {}", stab.reason)
@ -1729,7 +1729,7 @@ impl<'a> fmt::Display for Initializer<'a> {
}
}
fn item_constant(w: &mut fmt::Formatter, it: &clean::Item,
fn item_constant(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
c: &clean::Constant) -> fmt::Result {
try!(write!(w, "<pre class='rust const'>{vis}const \
{name}: {typ}{init}</pre>",
@ -1737,10 +1737,10 @@ fn item_constant(w: &mut fmt::Formatter, it: &clean::Item,
name = it.name.as_ref().unwrap(),
typ = c.type_,
init = Initializer(&c.expr)));
document(w, it)
document(w, cx, it)
}
fn item_static(w: &mut fmt::Formatter, it: &clean::Item,
fn item_static(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
s: &clean::Static) -> fmt::Result {
try!(write!(w, "<pre class='rust static'>{vis}static {mutability}\
{name}: {typ}{init}</pre>",
@ -1749,10 +1749,10 @@ fn item_static(w: &mut fmt::Formatter, it: &clean::Item,
name = it.name.as_ref().unwrap(),
typ = s.type_,
init = Initializer(&s.expr)));
document(w, it)
document(w, cx, it)
}
fn item_function(w: &mut fmt::Formatter, it: &clean::Item,
fn item_function(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
f: &clean::Function) -> fmt::Result {
try!(write!(w, "<pre class='rust fn'>{vis}{unsafety}{abi}{constness}fn \
{name}{generics}{decl}{where_clause}</pre>",
@ -1764,7 +1764,7 @@ fn item_function(w: &mut fmt::Formatter, it: &clean::Item,
generics = f.generics,
where_clause = WhereClause(&f.generics),
decl = f.decl));
document(w, it)
document(w, cx, it)
}
fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
@ -1841,9 +1841,9 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
try!(write!(w, "</pre>"));
// Trait documentation
try!(document(w, it));
try!(document(w, cx, it));
fn trait_item(w: &mut fmt::Formatter, m: &clean::Item)
fn trait_item(w: &mut fmt::Formatter, cx: &Context, m: &clean::Item)
-> fmt::Result {
try!(write!(w, "<h3 id='{ty}.{name}' class='method stab {stab}'><code>",
ty = shortty(m),
@ -1851,7 +1851,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
stab = m.stability_class()));
try!(render_assoc_item(w, m, AssocItemLink::Anchor));
try!(write!(w, "</code></h3>"));
try!(document(w, m));
try!(document(w, cx, m));
Ok(())
}
@ -1861,7 +1861,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
<div class='methods'>
"));
for t in &types {
try!(trait_item(w, *t));
try!(trait_item(w, cx, *t));
}
try!(write!(w, "</div>"));
}
@ -1872,7 +1872,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
<div class='methods'>
"));
for t in &consts {
try!(trait_item(w, *t));
try!(trait_item(w, cx, *t));
}
try!(write!(w, "</div>"));
}
@ -1884,7 +1884,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
<div class='methods'>
"));
for m in &required {
try!(trait_item(w, *m));
try!(trait_item(w, cx, *m));
}
try!(write!(w, "</div>"));
}
@ -1894,13 +1894,13 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
<div class='methods'>
"));
for m in &provided {
try!(trait_item(w, *m));
try!(trait_item(w, cx, *m));
}
try!(write!(w, "</div>"));
}
// If there are methods directly on this trait object, render them here.
try!(render_assoc_items(w, it.def_id, AssocItemRender::All));
try!(render_assoc_items(w, cx, it.def_id, AssocItemRender::All));
let cache = cache();
try!(write!(w, "
@ -2012,7 +2012,7 @@ fn render_assoc_item(w: &mut fmt::Formatter, meth: &clean::Item,
}
}
fn item_struct(w: &mut fmt::Formatter, it: &clean::Item,
fn item_struct(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
s: &clean::Struct) -> fmt::Result {
try!(write!(w, "<pre class='rust struct'>"));
try!(render_attributes(w, it));
@ -2025,7 +2025,7 @@ fn item_struct(w: &mut fmt::Formatter, it: &clean::Item,
true));
try!(write!(w, "</pre>"));
try!(document(w, it));
try!(document(w, cx, it));
let mut fields = s.fields.iter().filter(|f| {
match f.inner {
clean::StructFieldItem(clean::HiddenStructField) => false,
@ -2042,16 +2042,16 @@ fn item_struct(w: &mut fmt::Formatter, it: &clean::Item,
<code>{name}</code></td><td>",
stab = field.stability_class(),
name = field.name.as_ref().unwrap()));
try!(document(w, field));
try!(document(w, cx, field));
try!(write!(w, "</td></tr>"));
}
try!(write!(w, "</table>"));
}
}
render_assoc_items(w, it.def_id, AssocItemRender::All)
render_assoc_items(w, cx, it.def_id, AssocItemRender::All)
}
fn item_enum(w: &mut fmt::Formatter, it: &clean::Item,
fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
e: &clean::Enum) -> fmt::Result {
try!(write!(w, "<pre class='rust enum'>"));
try!(render_attributes(w, it));
@ -2104,13 +2104,13 @@ fn item_enum(w: &mut fmt::Formatter, it: &clean::Item,
}
try!(write!(w, "</pre>"));
try!(document(w, it));
try!(document(w, cx, it));
if !e.variants.is_empty() {
try!(write!(w, "<h2 class='variants'>Variants</h2>\n<table>"));
for variant in &e.variants {
try!(write!(w, "<tr><td id='variant.{name}'><code>{name}</code></td><td>",
name = variant.name.as_ref().unwrap()));
try!(document(w, variant));
try!(document(w, cx, variant));
match variant.inner {
clean::VariantItem(ref var) => {
match var.kind {
@ -2132,7 +2132,7 @@ fn item_enum(w: &mut fmt::Formatter, it: &clean::Item,
<code>{f}</code></td><td>",
v = variant.name.as_ref().unwrap(),
f = field.name.as_ref().unwrap()));
try!(document(w, field));
try!(document(w, cx, field));
try!(write!(w, "</td></tr>"));
}
try!(write!(w, "</table>"));
@ -2147,7 +2147,7 @@ fn item_enum(w: &mut fmt::Formatter, it: &clean::Item,
try!(write!(w, "</table>"));
}
try!(render_assoc_items(w, it.def_id, AssocItemRender::All));
try!(render_assoc_items(w, cx, it.def_id, AssocItemRender::All));
Ok(())
}
@ -2242,6 +2242,7 @@ enum AssocItemRender<'a> {
}
fn render_assoc_items(w: &mut fmt::Formatter,
cx: &Context,
it: ast::DefId,
what: AssocItemRender) -> fmt::Result {
let c = cache();
@ -2265,7 +2266,7 @@ fn render_assoc_items(w: &mut fmt::Formatter,
}
};
for i in &non_trait {
try!(render_impl(w, i, AssocItemLink::Anchor, render_header));
try!(render_impl(w, cx, i, AssocItemLink::Anchor, render_header));
}
}
if let AssocItemRender::DerefFor { .. } = what {
@ -2281,7 +2282,7 @@ fn render_assoc_items(w: &mut fmt::Formatter,
}
});
if let Some(impl_) = deref_impl {
try!(render_deref_methods(w, impl_));
try!(render_deref_methods(w, cx, impl_));
}
try!(write!(w, "<h2 id='implementations'>Trait \
Implementations</h2>"));
@ -2290,7 +2291,7 @@ fn render_assoc_items(w: &mut fmt::Formatter,
});
for i in &manual {
let did = i.trait_did().unwrap();
try!(render_impl(w, i, AssocItemLink::GotoSource(did), true));
try!(render_impl(w, cx, i, AssocItemLink::GotoSource(did), true));
}
if !derived.is_empty() {
try!(write!(w, "<h3 id='derived_implementations'>\
@ -2298,14 +2299,14 @@ fn render_assoc_items(w: &mut fmt::Formatter,
</h3>"));
for i in &derived {
let did = i.trait_did().unwrap();
try!(render_impl(w, i, AssocItemLink::GotoSource(did), true));
try!(render_impl(w, cx, i, AssocItemLink::GotoSource(did), true));
}
}
}
Ok(())
}
fn render_deref_methods(w: &mut fmt::Formatter, impl_: &Impl) -> fmt::Result {
fn render_deref_methods(w: &mut fmt::Formatter, cx: &Context, impl_: &Impl) -> fmt::Result {
let deref_type = impl_.impl_.trait_.as_ref().unwrap();
let target = impl_.impl_.items.iter().filter_map(|item| {
match item.inner {
@ -2315,12 +2316,12 @@ fn render_deref_methods(w: &mut fmt::Formatter, impl_: &Impl) -> fmt::Result {
}).next().expect("Expected associated type binding");
let what = AssocItemRender::DerefFor { trait_: deref_type, type_: target };
match *target {
clean::ResolvedPath { did, .. } => render_assoc_items(w, did, what),
clean::ResolvedPath { did, .. } => render_assoc_items(w, cx, did, what),
_ => {
if let Some(prim) = target.primitive_type() {
if let Some(c) = cache().primitive_locations.get(&prim) {
let did = ast::DefId { krate: *c, node: prim.to_node_id() };
try!(render_assoc_items(w, did, what));
try!(render_assoc_items(w, cx, did, what));
}
}
Ok(())
@ -2331,7 +2332,7 @@ fn render_deref_methods(w: &mut fmt::Formatter, impl_: &Impl) -> fmt::Result {
// Render_header is false when we are rendering a `Deref` impl and true
// otherwise. If render_header is false, we will avoid rendering static
// methods, since they are not accessible for the type implementing `Deref`
fn render_impl(w: &mut fmt::Formatter, i: &Impl, link: AssocItemLink,
fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLink,
render_header: bool) -> fmt::Result {
if render_header {
try!(write!(w, "<h3 class='impl'><code>{}</code></h3>", i.impl_));
@ -2340,7 +2341,7 @@ fn render_impl(w: &mut fmt::Formatter, i: &Impl, link: AssocItemLink,
}
}
fn doctraititem(w: &mut fmt::Formatter, item: &clean::Item,
fn doctraititem(w: &mut fmt::Formatter, cx: &Context, item: &clean::Item,
link: AssocItemLink, render_static: bool) -> fmt::Result {
match item.inner {
clean::MethodItem(..) | clean::TyMethodItem(..) => {
@ -2390,7 +2391,7 @@ fn render_impl(w: &mut fmt::Formatter, i: &Impl, link: AssocItemLink,
if is_static_method(item) && !render_static {
Ok(())
} else {
document(w, item)
document(w, cx, item)
}
} else {
Ok(())
@ -2407,10 +2408,11 @@ fn render_impl(w: &mut fmt::Formatter, i: &Impl, link: AssocItemLink,
try!(write!(w, "<div class='impl-items'>"));
for trait_item in &i.impl_.items {
try!(doctraititem(w, trait_item, link, render_header));
try!(doctraititem(w, cx, trait_item, link, render_header));
}
fn render_default_items(w: &mut fmt::Formatter,
cx: &Context,
did: ast::DefId,
t: &clean::Trait,
i: &clean::Impl,
@ -2422,7 +2424,7 @@ fn render_impl(w: &mut fmt::Formatter, i: &Impl, link: AssocItemLink,
None => {}
}
try!(doctraititem(w, trait_item, AssocItemLink::GotoSource(did), render_static));
try!(doctraititem(w, cx, trait_item, AssocItemLink::GotoSource(did), render_static));
}
Ok(())
}
@ -2433,7 +2435,7 @@ fn render_impl(w: &mut fmt::Formatter, i: &Impl, link: AssocItemLink,
// for them work.
if let Some(clean::ResolvedPath { did, .. }) = i.impl_.trait_ {
if let Some(t) = cache().traits.get(&did) {
try!(render_default_items(w, did, t, &i.impl_, render_header));
try!(render_default_items(w, cx, did, t, &i.impl_, render_header));
}
}
@ -2441,7 +2443,7 @@ fn render_impl(w: &mut fmt::Formatter, i: &Impl, link: AssocItemLink,
Ok(())
}
fn item_typedef(w: &mut fmt::Formatter, it: &clean::Item,
fn item_typedef(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
t: &clean::Typedef) -> fmt::Result {
try!(write!(w, "<pre class='rust typedef'>type {}{}{where_clause} = {type_};</pre>",
it.name.as_ref().unwrap(),
@ -2449,7 +2451,7 @@ fn item_typedef(w: &mut fmt::Formatter, it: &clean::Item,
where_clause = WhereClause(&t.generics),
type_ = t.type_));
document(w, it)
document(w, cx, it)
}
impl<'a> fmt::Display for Sidebar<'a> {
@ -2520,19 +2522,19 @@ impl<'a> fmt::Display for Source<'a> {
}
}
fn item_macro(w: &mut fmt::Formatter, it: &clean::Item,
fn item_macro(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
t: &clean::Macro) -> fmt::Result {
try!(w.write_str(&highlight::highlight(&t.source,
Some("macro"),
None)));
document(w, it)
document(w, cx, it)
}
fn item_primitive(w: &mut fmt::Formatter,
fn item_primitive(w: &mut fmt::Formatter, cx: &Context,
it: &clean::Item,
_p: &clean::PrimitiveType) -> fmt::Result {
try!(document(w, it));
render_assoc_items(w, it.def_id, AssocItemRender::All)
try!(document(w, cx, it));
render_assoc_items(w, cx, it.def_id, AssocItemRender::All)
}
fn get_basic_keywords() -> &'static str {