// identically even with rustdoc running in parallel.
all_implementors.sort();
- let mut v = String::from("(function() {var implementors = {}};\n");
+ let mut v = String::from("(function() {var implementors = {};\n");
for implementor in &all_implementors {
- v.push_str(&format!("{}", *implementor));
+ writeln!(v, "{}", *implementor).unwrap();
}
v.push_str(r"
if (window.register_implementors) {
} else {
window.pending_implementors = implementors;
}
- \n");
+ ");
v.push_str("})()");
cx.shared.fs.write(&mydst, &v)?;
}
}
}
-fn wrap_into_docblock<F>(w: &mut fmt::Formatter<'_>,
- f: F) -> fmt::Result
-where F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result {
- write!(w, "<div class=\"docblock type-decl hidden-by-usual-hider\">")?;
- f(w)?;
+fn wrap_into_docblock<F>(w: &mut Buffer, f: F)
+ where F: FnOnce(&mut Buffer)
+{
+ write!(w, "<div class=\"docblock type-decl hidden-by-usual-hider\">");
+ f(w);
write!(w, "</div>")
}
write!(buf, "</span></h1>"); // in-band
- buf.with_formatter(|fmt| {
match item.inner {
clean::ModuleItem(ref m) =>
- item_module(fmt, cx, item, &m.items),
+ item_module(buf, cx, item, &m.items),
clean::FunctionItem(ref f) | clean::ForeignFunctionItem(ref f) =>
- item_function(fmt, cx, item, f),
- clean::TraitItem(ref t) => item_trait(fmt, cx, item, t),
- clean::StructItem(ref s) => item_struct(fmt, cx, item, s),
- clean::UnionItem(ref s) => item_union(fmt, cx, item, s),
- clean::EnumItem(ref e) => item_enum(fmt, cx, item, e),
- clean::TypedefItem(ref t, _) => item_typedef(fmt, cx, item, t),
- clean::MacroItem(ref m) => item_macro(fmt, cx, item, m),
- clean::ProcMacroItem(ref m) => item_proc_macro(fmt, cx, item, m),
- clean::PrimitiveItem(ref p) => item_primitive(fmt, cx, item, p),
+ item_function(buf, cx, item, f),
+ clean::TraitItem(ref t) => item_trait(buf, cx, item, t),
+ clean::StructItem(ref s) => item_struct(buf, cx, item, s),
+ clean::UnionItem(ref s) => item_union(buf, cx, item, s),
+ clean::EnumItem(ref e) => item_enum(buf, cx, item, e),
+ clean::TypedefItem(ref t, _) => item_typedef(buf, cx, item, t),
+ clean::MacroItem(ref m) => item_macro(buf, cx, item, m),
+ clean::ProcMacroItem(ref m) => item_proc_macro(buf, cx, item, m),
+ clean::PrimitiveItem(ref p) => item_primitive(buf, cx, item, p),
clean::StaticItem(ref i) | clean::ForeignStaticItem(ref i) =>
- item_static(fmt, cx, item, i),
- clean::ConstantItem(ref c) => item_constant(fmt, cx, item, c),
- clean::ForeignTypeItem => item_foreign_type(fmt, cx, item),
- clean::KeywordItem(ref k) => item_keyword(fmt, cx, item, k),
- clean::OpaqueTyItem(ref e, _) => item_opaque_ty(fmt, cx, item, e),
- clean::TraitAliasItem(ref ta) => item_trait_alias(fmt, cx, item, ta),
+ item_static(buf, cx, item, i),
+ clean::ConstantItem(ref c) => item_constant(buf, cx, item, c),
+ clean::ForeignTypeItem => item_foreign_type(buf, cx, item),
+ clean::KeywordItem(ref k) => item_keyword(buf, cx, item, k),
+ clean::OpaqueTyItem(ref e, _) => item_opaque_ty(buf, cx, item, e),
+ clean::TraitAliasItem(ref ta) => item_trait_alias(buf, cx, item, ta),
_ => {
// We don't generate pages for any other type.
unreachable!();
}
}
- })
}
fn item_path(ty: ItemType, name: &str) -> String {
}
}
-fn document(w: &mut fmt::Formatter<'_>, cx: &Context, item: &clean::Item) -> fmt::Result {
+fn document(w: &mut Buffer, cx: &Context, item: &clean::Item) {
if let Some(ref name) = item.name {
info!("Documenting {}", name);
}
- document_stability(w, cx, item, false)?;
- document_full(w, item, cx, "", false)?;
- Ok(())
+ document_stability(w, cx, item, false);
+ document_full(w, item, cx, "", false);
}
/// Render md_text as markdown.
fn render_markdown(
- w: &mut fmt::Formatter<'_>,
+ w: &mut Buffer,
cx: &Context,
md_text: &str,
links: Vec<(String, String)>,
prefix: &str,
is_hidden: bool,
-) -> fmt::Result {
+) {
let mut ids = cx.id_map.borrow_mut();
write!(w, "<div class='docblock{}'>{}{}</div>",
if is_hidden { " hidden" } else { "" },
}
fn document_short(
- w: &mut fmt::Formatter<'_>,
+ w: &mut Buffer,
cx: &Context,
item: &clean::Item,
link: AssocItemLink<'_>,
prefix: &str,
is_hidden: bool,
-) -> fmt::Result {
+) {
if let Some(s) = item.doc_value() {
let markdown = if s.contains('\n') {
format!("{} [Read more]({})",
} else {
plain_summary_line(Some(s))
};
- render_markdown(w, cx, &markdown, item.links(), prefix, is_hidden)?;
+ render_markdown(w, cx, &markdown, item.links(), prefix, is_hidden);
} else if !prefix.is_empty() {
write!(w, "<div class='docblock{}'>{}</div>",
if is_hidden { " hidden" } else { "" },
- prefix)?;
+ prefix);
}
- Ok(())
}
-fn document_full(w: &mut fmt::Formatter<'_>, item: &clean::Item,
- cx: &Context, prefix: &str, is_hidden: bool) -> fmt::Result {
+fn document_full(w: &mut Buffer, item: &clean::Item, cx: &Context, prefix: &str, is_hidden: bool) {
if let Some(s) = cx.shared.maybe_collapsed_doc_value(item) {
debug!("Doc block: =====\n{}\n=====", s);
- render_markdown(w, cx, &*s, item.links(), prefix, is_hidden)?;
+ render_markdown(w, cx, &*s, item.links(), prefix, is_hidden);
} else if !prefix.is_empty() {
write!(w, "<div class='docblock{}'>{}</div>",
if is_hidden { " hidden" } else { "" },
- prefix)?;
+ prefix);
}
- Ok(())
}
-fn document_stability(w: &mut fmt::Formatter<'_>, cx: &Context, item: &clean::Item,
- is_hidden: bool) -> fmt::Result {
+fn document_stability(w: &mut Buffer, cx: &Context, item: &clean::Item, is_hidden: bool) {
let stabilities = short_stability(item, cx);
if !stabilities.is_empty() {
- write!(w, "<div class='stability{}'>", if is_hidden { " hidden" } else { "" })?;
+ write!(w, "<div class='stability{}'>", if is_hidden { " hidden" } else { "" });
for stability in stabilities {
- write!(w, "{}", stability)?;
+ write!(w, "{}", stability);
}
- write!(w, "</div>")?;
+ write!(w, "</div>");
}
- Ok(())
}
fn document_non_exhaustive_header(item: &clean::Item) -> &str {
if item.is_non_exhaustive() { " (Non-exhaustive)" } else { "" }
}
-fn document_non_exhaustive(w: &mut fmt::Formatter<'_>, item: &clean::Item) -> fmt::Result {
+fn document_non_exhaustive(w: &mut Buffer, item: &clean::Item) {
if item.is_non_exhaustive() {
write!(w, "<div class='docblock non-exhaustive non-exhaustive-{}'>", {
if item.is_struct() {
} else {
"type"
}
- })?;
+ });
if item.is_struct() {
write!(w, "Non-exhaustive structs could have additional fields added in future. \
Therefore, non-exhaustive structs cannot be constructed in external crates \
using the traditional <code>Struct {{ .. }}</code> syntax; cannot be \
matched against without a wildcard <code>..</code>; and \
- struct update syntax will not work.")?;
+ struct update syntax will not work.");
} else if item.is_enum() {
write!(w, "Non-exhaustive enums could have additional variants added in future. \
Therefore, when matching against variants of non-exhaustive enums, an \
- extra wildcard arm must be added to account for any future variants.")?;
+ extra wildcard arm must be added to account for any future variants.");
} else if item.is_variant() {
write!(w, "Non-exhaustive enum variants could have additional fields added in future. \
Therefore, non-exhaustive enum variants cannot be constructed in external \
- crates and cannot be matched against.")?;
+ crates and cannot be matched against.");
} else {
write!(w, "This type will require a wildcard arm in any match statements or \
- constructors.")?;
+ constructors.");
}
- write!(w, "</div>")?;
+ write!(w, "</div>");
}
-
- Ok(())
}
fn name_key(name: &str) -> (&str, u64, usize) {
}
}
-fn item_module(w: &mut fmt::Formatter<'_>, cx: &Context,
- item: &clean::Item, items: &[clean::Item]) -> fmt::Result {
- document(w, cx, item)?;
+fn item_module(w: &mut Buffer, cx: &Context, item: &clean::Item, items: &[clean::Item]) {
+ document(w, cx, item);
let mut indices = (0..items.len()).filter(|i| !items[*i].is_stripped()).collect::<Vec<usize>>();
curty = myty;
} else if myty != curty {
if curty.is_some() {
- write!(w, "</table>")?;
+ write!(w, "</table>");
}
curty = myty;
let (short, name) = item_ty_to_strs(&myty.unwrap());
write!(w, "<h2 id='{id}' class='section-header'>\
<a href=\"#{id}\">{name}</a></h2>\n<table>",
- id = cx.derive_id(short.to_owned()), name = name)?;
+ id = cx.derive_id(short.to_owned()), name = name);
}
match myitem.inner {
write!(w, "<tr><td><code>{}extern crate {} as {};",
VisSpace(&myitem.visibility),
anchor(myitem.def_id, src),
- name)?
+ name)
}
None => {
write!(w, "<tr><td><code>{}extern crate {};",
VisSpace(&myitem.visibility),
- anchor(myitem.def_id, name))?
+ anchor(myitem.def_id, name))
}
}
- write!(w, "</code></td></tr>")?;
+ write!(w, "</code></td></tr>");
}
clean::ImportItem(ref import) => {
write!(w, "<tr><td><code>{}{}</code></td></tr>",
- VisSpace(&myitem.visibility), *import)?;
+ VisSpace(&myitem.visibility), *import);
}
_ => {
})
.collect::<Vec<_>>()
.join(" "),
- )?;
+ );
}
}
}
if curty.is_some() {
- write!(w, "</table>")?;
+ write!(w, "</table>");
}
- Ok(())
}
/// Render the stability and deprecation tags that are displayed in the item's summary at the
stability
}
-fn item_constant(w: &mut fmt::Formatter<'_>, cx: &Context, it: &clean::Item,
- c: &clean::Constant) -> fmt::Result {
- write!(w, "<pre class='rust const'>")?;
- render_attributes(w, it, false)?;
+fn item_constant(w: &mut Buffer, cx: &Context, it: &clean::Item, c: &clean::Constant) {
+ write!(w, "<pre class='rust const'>");
+ render_attributes(w, it, false);
write!(w, "{vis}const \
{name}: {typ}</pre>",
vis = VisSpace(&it.visibility),
name = it.name.as_ref().unwrap(),
- typ = c.type_)?;
+ typ = c.type_);
document(w, cx, it)
}
-fn item_static(w: &mut fmt::Formatter<'_>, cx: &Context, it: &clean::Item,
- s: &clean::Static) -> fmt::Result {
- write!(w, "<pre class='rust static'>")?;
- render_attributes(w, it, false)?;
+fn item_static(w: &mut Buffer, cx: &Context, it: &clean::Item, s: &clean::Static) {
+ write!(w, "<pre class='rust static'>");
+ render_attributes(w, it, false);
write!(w, "{vis}static {mutability}\
{name}: {typ}</pre>",
vis = VisSpace(&it.visibility),
mutability = MutableSpace(s.mutability),
name = it.name.as_ref().unwrap(),
- typ = s.type_)?;
+ typ = s.type_);
document(w, cx, it)
}
-fn item_function(w: &mut fmt::Formatter<'_>, cx: &Context, it: &clean::Item,
- f: &clean::Function) -> fmt::Result {
+fn item_function(w: &mut Buffer, cx: &Context, it: &clean::Item, f: &clean::Function) {
let header_len = format!(
"{}{}{}{}{:#}fn {}{:#}",
VisSpace(&it.visibility),
it.name.as_ref().unwrap(),
f.generics
).len();
- write!(w, "{}<pre class='rust fn'>", render_spotlight_traits(it)?)?;
- render_attributes(w, it, false)?;
+ write!(w, "{}<pre class='rust fn'>", render_spotlight_traits(it));
+ render_attributes(w, it, false);
write!(w,
"{vis}{constness}{unsafety}{asyncness}{abi}fn \
{name}{generics}{decl}{where_clause}</pre>",
header_len,
indent: 0,
asyncness: f.header.asyncness,
- })?;
+ });
document(w, cx, it)
}
-fn render_implementor(cx: &Context, implementor: &Impl, w: &mut fmt::Formatter<'_>,
- implementor_dups: &FxHashMap<&str, (DefId, bool)>) -> fmt::Result {
+fn render_implementor(cx: &Context, implementor: &Impl, w: &mut Buffer,
+ implementor_dups: &FxHashMap<&str, (DefId, bool)>) {
// If there's already another implementor that has the same abbridged name, use the
// full path, for example in `std::iter::ExactSizeIterator`
let use_absolute = match implementor.inner_impl().for_ {
_ => false,
};
render_impl(w, cx, implementor, AssocItemLink::Anchor(None), RenderMode::Normal,
- implementor.impl_item.stable_since(), false, Some(use_absolute), false, false)?;
- Ok(())
+ implementor.impl_item.stable_since(), false, Some(use_absolute), false, false);
}
-fn render_impls(cx: &Context, w: &mut fmt::Formatter<'_>,
+fn render_impls(cx: &Context, w: &mut Buffer,
traits: &[&&Impl],
- containing_item: &clean::Item) -> fmt::Result {
+ containing_item: &clean::Item) {
for i in traits {
let did = i.trait_did().unwrap();
let assoc_link = AssocItemLink::GotoSource(did, &i.inner_impl().provided_trait_methods);
render_impl(w, cx, i, assoc_link,
- RenderMode::Normal, containing_item.stable_since(), true, None, false, true)?;
+ RenderMode::Normal, containing_item.stable_since(), true, None, false, true);
}
- Ok(())
}
fn bounds(t_bounds: &[clean::GenericBound], trait_alias: bool) -> String {
}
fn item_trait(
- w: &mut fmt::Formatter<'_>,
+ w: &mut Buffer,
cx: &Context,
it: &clean::Item,
t: &clean::Trait,
-) -> fmt::Result {
+) {
let bounds = bounds(&t.bounds, false);
let types = t.items.iter().filter(|m| m.is_associated_type()).collect::<Vec<_>>();
let consts = t.items.iter().filter(|m| m.is_associated_const()).collect::<Vec<_>>();
// Output the trait definition
wrap_into_docblock(w, |w| {
- write!(w, "<pre class='rust trait'>")?;
- render_attributes(w, it, true)?;
+ write!(w, "<pre class='rust trait'>");
+ render_attributes(w, it, true);
write!(w, "{}{}{}trait {}{}{}",
VisSpace(&it.visibility),
UnsafetySpace(t.unsafety),
if t.is_auto { "auto " } else { "" },
it.name.as_ref().unwrap(),
t.generics,
- bounds)?;
+ bounds);
if !t.generics.where_predicates.is_empty() {
- write!(w, "{}", WhereClause { gens: &t.generics, indent: 0, end_newline: true })?;
+ write!(w, "{}", WhereClause { gens: &t.generics, indent: 0, end_newline: true });
} else {
- write!(w, " ")?;
+ write!(w, " ");
}
if t.items.is_empty() {
- write!(w, "{{ }}")?;
+ write!(w, "{{ }}");
} else {
// FIXME: we should be using a derived_id for the Anchors here
- write!(w, "{{\n")?;
+ write!(w, "{{\n");
for t in &types {
- render_assoc_item(w, t, AssocItemLink::Anchor(None), ItemType::Trait)?;
- write!(w, ";\n")?;
+ render_assoc_item(w, t, AssocItemLink::Anchor(None), ItemType::Trait);
+ write!(w, ";\n");
}
if !types.is_empty() && !consts.is_empty() {
- w.write_str("\n")?;
+ w.write_str("\n");
}
for t in &consts {
- render_assoc_item(w, t, AssocItemLink::Anchor(None), ItemType::Trait)?;
- write!(w, ";\n")?;
+ render_assoc_item(w, t, AssocItemLink::Anchor(None), ItemType::Trait);
+ write!(w, ";\n");
}
if !consts.is_empty() && !required.is_empty() {
- w.write_str("\n")?;
+ w.write_str("\n");
}
for (pos, m) in required.iter().enumerate() {
- render_assoc_item(w, m, AssocItemLink::Anchor(None), ItemType::Trait)?;
- write!(w, ";\n")?;
+ render_assoc_item(w, m, AssocItemLink::Anchor(None), ItemType::Trait);
+ write!(w, ";\n");
if pos < required.len() - 1 {
- write!(w, "<div class='item-spacer'></div>")?;
+ write!(w, "<div class='item-spacer'></div>");
}
}
if !required.is_empty() && !provided.is_empty() {
- w.write_str("\n")?;
+ w.write_str("\n");
}
for (pos, m) in provided.iter().enumerate() {
- render_assoc_item(w, m, AssocItemLink::Anchor(None), ItemType::Trait)?;
+ render_assoc_item(w, m, AssocItemLink::Anchor(None), ItemType::Trait);
match m.inner {
clean::MethodItem(ref inner) if !inner.generics.where_predicates.is_empty() => {
- write!(w, ",\n {{ ... }}\n")?;
+ write!(w, ",\n {{ ... }}\n");
},
_ => {
- write!(w, " {{ ... }}\n")?;
+ write!(w, " {{ ... }}\n");
},
}
if pos < provided.len() - 1 {
- write!(w, "<div class='item-spacer'></div>")?;
+ write!(w, "<div class='item-spacer'></div>");
}
}
- write!(w, "}}")?;
+ write!(w, "}}");
}
write!(w, "</pre>")
- })?;
+ });
// Trait documentation
- document(w, cx, it)?;
+ document(w, cx, it);
fn write_small_section_header(
- w: &mut fmt::Formatter<'_>,
+ w: &mut Buffer,
id: &str,
title: &str,
extra_content: &str,
- ) -> fmt::Result {
+ ) {
write!(w, "
<h2 id='{0}' class='small-section-header'>\
{1}<a href='#{0}' class='anchor'></a>\
</h2>{2}", id, title, extra_content)
}
- fn write_loading_content(w: &mut fmt::Formatter<'_>, extra_content: &str) -> fmt::Result {
+ fn write_loading_content(w: &mut Buffer, extra_content: &str) {
write!(w, "{}<span class='loading-content'>Loading content...</span>", extra_content)
}
- fn trait_item(w: &mut fmt::Formatter<'_>, cx: &Context, m: &clean::Item, t: &clean::Item)
- -> fmt::Result {
+ fn trait_item(w: &mut Buffer, cx: &Context, m: &clean::Item, t: &clean::Item) {
let name = m.name.as_ref().unwrap();
let item_type = m.type_();
let id = cx.derive_id(format!("{}.{}", item_type, name));
let ns_id = cx.derive_id(format!("{}.{}", name, item_type.name_space()));
write!(w, "<h3 id='{id}' class='method'>{extra}<code id='{ns_id}'>",
- extra = render_spotlight_traits(m)?,
+ extra = render_spotlight_traits(m),
id = id,
- ns_id = ns_id)?;
- render_assoc_item(w, m, AssocItemLink::Anchor(Some(&id)), ItemType::Impl)?;
- write!(w, "</code>")?;
- render_stability_since(w, m, t)?;
- write!(w, "</h3>")?;
- document(w, cx, m)?;
- Ok(())
+ ns_id = ns_id);
+ render_assoc_item(w, m, AssocItemLink::Anchor(Some(&id)), ItemType::Impl);
+ write!(w, "</code>");
+ render_stability_since(w, m, t);
+ write!(w, "</h3>");
+ document(w, cx, m);
}
if !types.is_empty() {
write_small_section_header(w, "associated-types", "Associated Types",
- "<div class='methods'>")?;
+ "<div class='methods'>");
for t in &types {
- trait_item(w, cx, *t, it)?;
+ trait_item(w, cx, *t, it);
}
- write_loading_content(w, "</div>")?;
+ write_loading_content(w, "</div>");
}
if !consts.is_empty() {
write_small_section_header(w, "associated-const", "Associated Constants",
- "<div class='methods'>")?;
+ "<div class='methods'>");
for t in &consts {
- trait_item(w, cx, *t, it)?;
+ trait_item(w, cx, *t, it);
}
- write_loading_content(w, "</div>")?;
+ write_loading_content(w, "</div>");
}
// Output the documentation for each function individually
if !required.is_empty() {
write_small_section_header(w, "required-methods", "Required methods",
- "<div class='methods'>")?;
+ "<div class='methods'>");
for m in &required {
- trait_item(w, cx, *m, it)?;
+ trait_item(w, cx, *m, it);
}
- write_loading_content(w, "</div>")?;
+ write_loading_content(w, "</div>");
}
if !provided.is_empty() {
write_small_section_header(w, "provided-methods", "Provided methods",
- "<div class='methods'>")?;
+ "<div class='methods'>");
for m in &provided {
- trait_item(w, cx, *m, it)?;
+ trait_item(w, cx, *m, it);
}
- write_loading_content(w, "</div>")?;
+ write_loading_content(w, "</div>");
}
// If there are methods directly on this trait object, render them here.
- render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)?;
+ render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All);
let cache = cache();
concrete.sort_by(compare_impl);
if !foreign.is_empty() {
- write_small_section_header(w, "foreign-impls", "Implementations on Foreign Types", "")?;
+ write_small_section_header(w, "foreign-impls", "Implementations on Foreign Types", "");
for implementor in foreign {
let assoc_link = AssocItemLink::GotoSource(
);
render_impl(w, cx, &implementor, assoc_link,
RenderMode::Normal, implementor.impl_item.stable_since(), false,
- None, true, false)?;
+ None, true, false);
}
- write_loading_content(w, "")?;
+ write_loading_content(w, "");
}
write_small_section_header(w, "implementors", "Implementors",
- "<div class='item-list' id='implementors-list'>")?;
+ "<div class='item-list' id='implementors-list'>");
for implementor in concrete {
- render_implementor(cx, implementor, w, &implementor_dups)?;
+ render_implementor(cx, implementor, w, &implementor_dups);
}
- write_loading_content(w, "</div>")?;
+ write_loading_content(w, "</div>");
if t.auto {
write_small_section_header(w, "synthetic-implementors", "Auto implementors",
- "<div class='item-list' id='synthetic-implementors-list'>")?;
+ "<div class='item-list' id='synthetic-implementors-list'>");
for implementor in synthetic {
synthetic_types.extend(
collect_paths_for_type(implementor.inner_impl().for_.clone())
);
- render_implementor(cx, implementor, w, &implementor_dups)?;
+ render_implementor(cx, implementor, w, &implementor_dups);
}
- write_loading_content(w, "</div>")?;
+ write_loading_content(w, "</div>");
}
} else {
// even without any implementations to write in, we still want the heading and list, so the
// implementors javascript file pulled in below has somewhere to write the impls into
write_small_section_header(w, "implementors", "Implementors",
- "<div class='item-list' id='implementors-list'>")?;
- write_loading_content(w, "</div>")?;
+ "<div class='item-list' id='implementors-list'>");
+ write_loading_content(w, "</div>");
if t.auto {
write_small_section_header(w, "synthetic-implementors", "Auto implementors",
- "<div class='item-list' id='synthetic-implementors-list'>")?;
- write_loading_content(w, "</div>")?;
+ "<div class='item-list' id='synthetic-implementors-list'>");
+ write_loading_content(w, "</div>");
}
}
write!(w, r#"<script type="text/javascript">window.inlined_types=new Set({});</script>"#,
- as_json(&synthetic_types))?;
+ as_json(&synthetic_types));
write!(w, r#"<script type="text/javascript" async
src="{root_path}/implementors/{path}/{ty}.{name}.js">
path[..path.len() - 1].join("/")
},
ty = it.type_().css_class(),
- name = *it.name.as_ref().unwrap())?;
- Ok(())
+ name = *it.name.as_ref().unwrap());
}
fn naive_assoc_href(it: &clean::Item, link: AssocItemLink<'_>) -> String {
}
}
-fn assoc_const(w: &mut fmt::Formatter<'_>,
+fn assoc_const(w: &mut Buffer,
it: &clean::Item,
ty: &clean::Type,
_default: Option<&String>,
link: AssocItemLink<'_>,
- extra: &str) -> fmt::Result {
+ extra: &str) {
write!(w, "{}{}const <a href='{}' class=\"constant\"><b>{}</b></a>: {}",
extra,
VisSpace(&it.visibility),
naive_assoc_href(it, link),
it.name.as_ref().unwrap(),
- ty)?;
- Ok(())
+ ty);
}
-fn assoc_type<W: fmt::Write>(w: &mut W, it: &clean::Item,
- bounds: &[clean::GenericBound],
- default: Option<&clean::Type>,
- link: AssocItemLink<'_>,
- extra: &str) -> fmt::Result {
+fn assoc_type(w: &mut Buffer, it: &clean::Item,
+ bounds: &[clean::GenericBound],
+ default: Option<&clean::Type>,
+ link: AssocItemLink<'_>,
+ extra: &str) {
write!(w, "{}type <a href='{}' class=\"type\">{}</a>",
extra,
naive_assoc_href(it, link),
- it.name.as_ref().unwrap())?;
+ it.name.as_ref().unwrap());
if !bounds.is_empty() {
- write!(w, ": {}", GenericBounds(bounds))?
+ write!(w, ": {}", GenericBounds(bounds))
}
if let Some(default) = default {
- write!(w, " = {}", default)?;
+ write!(w, " = {}", default)
}
- Ok(())
}
-fn render_stability_since_raw<'a, T: fmt::Write>(
- w: &mut T,
- ver: Option<&'a str>,
- containing_ver: Option<&'a str>,
-) -> fmt::Result {
+fn render_stability_since_raw(w: &mut Buffer, ver: Option<&str>, containing_ver: Option<&str>) {
if let Some(v) = ver {
if containing_ver != ver && v.len() > 0 {
- write!(w, "<span class='since' title='Stable since Rust version {0}'>{0}</span>", v)?
+ write!(w, "<span class='since' title='Stable since Rust version {0}'>{0}</span>", v)
}
}
- Ok(())
}
-fn render_stability_since(w: &mut fmt::Formatter<'_>,
- item: &clean::Item,
- containing_item: &clean::Item) -> fmt::Result {
+fn render_stability_since(w: &mut Buffer, item: &clean::Item, containing_item: &clean::Item) {
render_stability_since_raw(w, item.stable_since(), containing_item.stable_since())
}
-fn render_assoc_item(w: &mut fmt::Formatter<'_>,
+fn render_assoc_item(w: &mut Buffer,
item: &clean::Item,
link: AssocItemLink<'_>,
- parent: ItemType) -> fmt::Result {
- fn method(w: &mut fmt::Formatter<'_>,
+ parent: ItemType) {
+ fn method(w: &mut Buffer,
meth: &clean::Item,
header: hir::FnHeader,
g: &clean::Generics,
d: &clean::FnDecl,
link: AssocItemLink<'_>,
- parent: ItemType)
- -> fmt::Result {
+ parent: ItemType) {
let name = meth.name.as_ref().unwrap();
let anchor = format!("#{}.{}", meth.type_(), name);
let href = match link {
} else {
(0, true)
};
- render_attributes(w, meth, false)?;
+ render_attributes(w, meth, false);
write!(w, "{}{}{}{}{}{}{}fn <a href='{href}' class='fnname'>{name}</a>\
{generics}{decl}{where_clause}",
if parent == ItemType::Trait { " " } else { "" },
})
}
match item.inner {
- clean::StrippedItem(..) => Ok(()),
+ clean::StrippedItem(..) => {},
clean::TyMethodItem(ref m) => {
method(w, item, m.header, &m.generics, &m.decl, link, parent)
}
}
}
-fn item_struct(w: &mut fmt::Formatter<'_>, cx: &Context, it: &clean::Item,
- s: &clean::Struct) -> fmt::Result {
+fn item_struct(w: &mut Buffer, cx: &Context, it: &clean::Item, s: &clean::Struct) {
wrap_into_docblock(w, |w| {
- write!(w, "<pre class='rust struct'>")?;
- render_attributes(w, it, true)?;
+ write!(w, "<pre class='rust struct'>");
+ render_attributes(w, it, true);
render_struct(w,
it,
Some(&s.generics),
s.struct_type,
&s.fields,
"",
- true)?;
+ true);
write!(w, "</pre>")
- })?;
+ });
- document(w, cx, it)?;
+ document(w, cx, it);
let mut fields = s.fields.iter().filter_map(|f| {
match f.inner {
clean::StructFieldItem(ref ty) => Some((f, ty)),
if fields.peek().is_some() {
write!(w, "<h2 id='fields' class='fields small-section-header'>
Fields{}<a href='#fields' class='anchor'></a></h2>",
- document_non_exhaustive_header(it))?;
- document_non_exhaustive(w, it)?;
+ document_non_exhaustive_header(it));
+ document_non_exhaustive(w, it);
for (field, ty) in fields {
let id = cx.derive_id(format!("{}.{}",
ItemType::StructField,
id = id,
ns_id = ns_id,
name = field.name.as_ref().unwrap(),
- ty = ty)?;
- document(w, cx, field)?;
+ ty = ty);
+ document(w, cx, field);
}
}
}
render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
}
-fn item_union(w: &mut fmt::Formatter<'_>, cx: &Context, it: &clean::Item,
- s: &clean::Union) -> fmt::Result {
+fn item_union(w: &mut Buffer, cx: &Context, it: &clean::Item, s: &clean::Union) {
wrap_into_docblock(w, |w| {
- write!(w, "<pre class='rust union'>")?;
- render_attributes(w, it, true)?;
+ write!(w, "<pre class='rust union'>");
+ render_attributes(w, it, true);
render_union(w,
it,
Some(&s.generics),
&s.fields,
"",
- true)?;
+ true);
write!(w, "</pre>")
- })?;
+ });
- document(w, cx, it)?;
+ document(w, cx, it);
let mut fields = s.fields.iter().filter_map(|f| {
match f.inner {
clean::StructFieldItem(ref ty) => Some((f, ty)),
}).peekable();
if fields.peek().is_some() {
write!(w, "<h2 id='fields' class='fields small-section-header'>
- Fields<a href='#fields' class='anchor'></a></h2>")?;
+ Fields<a href='#fields' class='anchor'></a></h2>");
for (field, ty) in fields {
let name = field.name.as_ref().expect("union field name");
let id = format!("{}.{}", ItemType::StructField, name);
id = id,
name = name,
shortty = ItemType::StructField,
- ty = ty)?;
+ ty = ty);
if let Some(stability_class) = field.stability_class() {
write!(w, "<span class='stab {stab}'></span>",
- stab = stability_class)?;
+ stab = stability_class);
}
- document(w, cx, field)?;
+ document(w, cx, field);
}
}
render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
}
-fn item_enum(w: &mut fmt::Formatter<'_>, cx: &Context, it: &clean::Item,
- e: &clean::Enum) -> fmt::Result {
+fn item_enum(w: &mut Buffer, cx: &Context, it: &clean::Item, e: &clean::Enum) {
wrap_into_docblock(w, |w| {
- write!(w, "<pre class='rust enum'>")?;
- render_attributes(w, it, true)?;
+ write!(w, "<pre class='rust enum'>");
+ render_attributes(w, it, true);
write!(w, "{}enum {}{}{}",
VisSpace(&it.visibility),
it.name.as_ref().unwrap(),
e.generics,
- WhereClause { gens: &e.generics, indent: 0, end_newline: true })?;
+ WhereClause { gens: &e.generics, indent: 0, end_newline: true });
if e.variants.is_empty() && !e.variants_stripped {
- write!(w, " {{}}")?;
+ write!(w, " {{}}");
} else {
- write!(w, " {{\n")?;
+ write!(w, " {{\n");
for v in &e.variants {
- write!(w, " ")?;
+ write!(w, " ");
let name = v.name.as_ref().unwrap();
match v.inner {
clean::VariantItem(ref var) => {
match var.kind {
- clean::VariantKind::CLike => write!(w, "{}", name)?,
+ clean::VariantKind::CLike => write!(w, "{}", name),
clean::VariantKind::Tuple(ref tys) => {
- write!(w, "{}(", name)?;
+ write!(w, "{}(", name);
for (i, ty) in tys.iter().enumerate() {
if i > 0 {
- write!(w, ", ")?
+ write!(w, ", ")
}
- write!(w, "{}", *ty)?;
+ write!(w, "{}", *ty);
}
- write!(w, ")")?;
+ write!(w, ")");
}
clean::VariantKind::Struct(ref s) => {
render_struct(w,
s.struct_type,
&s.fields,
" ",
- false)?;
+ false);
}
}
}
_ => unreachable!()
}
- write!(w, ",\n")?;
+ write!(w, ",\n");
}
if e.variants_stripped {
- write!(w, " // some variants omitted\n")?;
+ write!(w, " // some variants omitted\n");
}
- write!(w, "}}")?;
+ write!(w, "}}");
}
write!(w, "</pre>")
- })?;
+ });
- document(w, cx, it)?;
+ document(w, cx, it);
if !e.variants.is_empty() {
write!(w, "<h2 id='variants' class='variants small-section-header'>
Variants{}<a href='#variants' class='anchor'></a></h2>\n",
- document_non_exhaustive_header(it))?;
- document_non_exhaustive(w, it)?;
+ document_non_exhaustive_header(it));
+ document_non_exhaustive(w, it);
for variant in &e.variants {
let id = cx.derive_id(format!("{}.{}",
ItemType::Variant,
<code id='{ns_id}'>{name}",
id = id,
ns_id = ns_id,
- name = variant.name.as_ref().unwrap())?;
+ name = variant.name.as_ref().unwrap());
if let clean::VariantItem(ref var) = variant.inner {
if let clean::VariantKind::Tuple(ref tys) = var.kind {
- write!(w, "(")?;
+ write!(w, "(");
for (i, ty) in tys.iter().enumerate() {
if i > 0 {
- write!(w, ", ")?;
+ write!(w, ", ");
}
- write!(w, "{}", *ty)?;
+ write!(w, "{}", *ty);
}
- write!(w, ")")?;
+ write!(w, ")");
}
}
- write!(w, "</code></div>")?;
- document(w, cx, variant)?;
- document_non_exhaustive(w, variant)?;
+ write!(w, "</code></div>");
+ document(w, cx, variant);
+ document_non_exhaustive(w, variant);
use crate::clean::{Variant, VariantKind};
if let clean::VariantItem(Variant {
ItemType::Variant,
variant.name.as_ref().unwrap()));
write!(w, "<div class='autohide sub-variant' id='{id}'>",
- id = variant_id)?;
+ id = variant_id);
write!(w, "<h3>Fields of <b>{name}</b></h3><div>",
- name = variant.name.as_ref().unwrap())?;
+ name = variant.name.as_ref().unwrap());
for field in &s.fields {
use crate::clean::StructFieldItem;
if let StructFieldItem(ref ty) = field.inner {
id = id,
ns_id = ns_id,
f = field.name.as_ref().unwrap(),
- t = *ty)?;
- document(w, cx, field)?;
+ t = *ty);
+ document(w, cx, field);
}
}
- write!(w, "</div></div>")?;
+ write!(w, "</div></div>");
}
- render_stability_since(w, variant, it)?;
+ render_stability_since(w, variant, it);
}
}
- render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)?;
- Ok(())
+ render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
}
fn render_attribute(attr: &ast::MetaItem) -> Option<String> {
// #[bar] <---- not "top" attribute
// bar: usize,
// }
-fn render_attributes(w: &mut dyn fmt::Write, it: &clean::Item, top: bool) -> fmt::Result {
+fn render_attributes(w: &mut Buffer, it: &clean::Item, top: bool) {
let mut attrs = String::new();
for attr in &it.attrs.other_attrs {
}
if attrs.len() > 0 {
write!(w, "<span class=\"docblock attributes{}\">{}</span>",
- if top { " top-attr" } else { "" }, &attrs)?;
+ if top { " top-attr" } else { "" }, &attrs);
}
- Ok(())
}
-fn render_struct(w: &mut fmt::Formatter<'_>, it: &clean::Item,
+fn render_struct(w: &mut Buffer, it: &clean::Item,
g: Option<&clean::Generics>,
ty: doctree::StructType,
fields: &[clean::Item],
tab: &str,
- structhead: bool) -> fmt::Result {
+ structhead: bool) {
write!(w, "{}{}{}",
VisSpace(&it.visibility),
if structhead {"struct "} else {""},
- it.name.as_ref().unwrap())?;
+ it.name.as_ref().unwrap());
if let Some(g) = g {
- write!(w, "{}", g)?
+ write!(w, "{}", g)
}
match ty {
doctree::Plain => {
if let Some(g) = g {
- write!(w, "{}", WhereClause { gens: g, indent: 0, end_newline: true })?
+ write!(w, "{}", WhereClause { gens: g, indent: 0, end_newline: true })
}
let mut has_visible_fields = false;
- write!(w, " {{")?;
+ write!(w, " {{");
for field in fields {
if let clean::StructFieldItem(ref ty) = field.inner {
write!(w, "\n{} {}{}: {},",
tab,
VisSpace(&field.visibility),
field.name.as_ref().unwrap(),
- *ty)?;
+ *ty);
has_visible_fields = true;
}
}
if has_visible_fields {
if it.has_stripped_fields().unwrap() {
- write!(w, "\n{} // some fields omitted", tab)?;
+ write!(w, "\n{} // some fields omitted", tab);
}
- write!(w, "\n{}", tab)?;
+ write!(w, "\n{}", tab);
} else if it.has_stripped_fields().unwrap() {
// If there are no visible fields we can just display
// `{ /* fields omitted */ }` to save space.
- write!(w, " /* fields omitted */ ")?;
+ write!(w, " /* fields omitted */ ");
}
- write!(w, "}}")?;
+ write!(w, "}}");
}
doctree::Tuple => {
- write!(w, "(")?;
+ write!(w, "(");
for (i, field) in fields.iter().enumerate() {
if i > 0 {
- write!(w, ", ")?;
+ write!(w, ", ");
}
match field.inner {
clean::StrippedItem(box clean::StructFieldItem(..)) => {
- write!(w, "_")?
+ write!(w, "_")
}
clean::StructFieldItem(ref ty) => {
- write!(w, "{}{}", VisSpace(&field.visibility), *ty)?
+ write!(w, "{}{}", VisSpace(&field.visibility), *ty)
}
_ => unreachable!()
}
}
- write!(w, ")")?;
+ write!(w, ")");
if let Some(g) = g {
- write!(w, "{}", WhereClause { gens: g, indent: 0, end_newline: false })?
+ write!(w, "{}", WhereClause { gens: g, indent: 0, end_newline: false })
}
- write!(w, ";")?;
+ write!(w, ";");
}
doctree::Unit => {
// Needed for PhantomData.
if let Some(g) = g {
- write!(w, "{}", WhereClause { gens: g, indent: 0, end_newline: false })?
+ write!(w, "{}", WhereClause { gens: g, indent: 0, end_newline: false })
}
- write!(w, ";")?;
+ write!(w, ";");
}
}
- Ok(())
}
-fn render_union(w: &mut fmt::Formatter<'_>, it: &clean::Item,
+fn render_union(w: &mut Buffer, it: &clean::Item,
g: Option<&clean::Generics>,
fields: &[clean::Item],
tab: &str,
- structhead: bool) -> fmt::Result {
+ structhead: bool) {
write!(w, "{}{}{}",
VisSpace(&it.visibility),
if structhead {"union "} else {""},
- it.name.as_ref().unwrap())?;
+ it.name.as_ref().unwrap());
if let Some(g) = g {
- write!(w, "{}", g)?;
- write!(w, "{}", WhereClause { gens: g, indent: 0, end_newline: true })?;
+ write!(w, "{}", g);
+ write!(w, "{}", WhereClause { gens: g, indent: 0, end_newline: true });
}
- write!(w, " {{\n{}", tab)?;
+ write!(w, " {{\n{}", tab);
for field in fields {
if let clean::StructFieldItem(ref ty) = field.inner {
write!(w, " {}{}: {},\n{}",
VisSpace(&field.visibility),
field.name.as_ref().unwrap(),
*ty,
- tab)?;
+ tab);
}
}
if it.has_stripped_fields().unwrap() {
- write!(w, " // some fields omitted\n{}", tab)?;
+ write!(w, " // some fields omitted\n{}", tab);
}
- write!(w, "}}")?;
- Ok(())
+ write!(w, "}}");
}
#[derive(Copy, Clone)]
ForDeref { mut_: bool },
}
-fn render_assoc_items(w: &mut fmt::Formatter<'_>,
+fn render_assoc_items(w: &mut Buffer,
cx: &Context,
containing_item: &clean::Item,
it: DefId,
- what: AssocItemRender<'_>) -> fmt::Result {
+ what: AssocItemRender<'_>) {
let c = cache();
let v = match c.impls.get(&it) {
Some(v) => v,
- None => return Ok(()),
+ None => return,
};
let (non_trait, traits): (Vec<_>, _) = v.iter().partition(|i| {
i.inner_impl().trait_.is_none()
<h2 id='methods' class='small-section-header'>\
Methods<a href='#methods' class='anchor'></a>\
</h2>\
- ")?;
+ ");
RenderMode::Normal
}
AssocItemRender::DerefFor { trait_, type_, deref_mut_ } => {
Methods from {}<Target = {}>\
<a href='#deref-methods' class='anchor'></a>\
</h2>\
- ", trait_, type_)?;
+ ", trait_, type_);
RenderMode::ForDeref { mut_: deref_mut_ }
}
};
for i in &non_trait {
render_impl(w, cx, i, AssocItemLink::Anchor(None), render_mode,
- containing_item.stable_since(), true, None, false, true)?;
+ containing_item.stable_since(), true, None, false, true);
}
}
if let AssocItemRender::DerefFor { .. } = what {
- return Ok(());
+ return;
}
if !traits.is_empty() {
let deref_impl = traits.iter().find(|t| {
let has_deref_mut = traits.iter().find(|t| {
t.inner_impl().trait_.def_id() == c.deref_mut_trait_did
}).is_some();
- render_deref_methods(w, cx, impl_, containing_item, has_deref_mut)?;
+ render_deref_methods(w, cx, impl_, containing_item, has_deref_mut);
}
let (synthetic, concrete): (Vec<&&Impl>, Vec<&&Impl>) = traits
.iter()
.partition(|t| t.inner_impl().synthetic);
- let (blanket_impl, concrete) = concrete
+ let (blanket_impl, concrete): (Vec<&&Impl>, _) = concrete
.into_iter()
.partition(|t| t.inner_impl().blanket_impl.is_some());
- struct RendererStruct<'a, 'b, 'c>(&'a Context, Vec<&'b &'b Impl>, &'c clean::Item);
-
- impl<'a, 'b, 'c> fmt::Display for RendererStruct<'a, 'b, 'c> {
- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
- render_impls(self.0, fmt, &self.1, self.2)
- }
- }
-
- let impls = RendererStruct(cx, concrete, containing_item).to_string();
+ let mut impls = Buffer::empty_from(&w);
+ render_impls(cx, &mut impls, &concrete, containing_item);
+ let impls = impls.into_inner();
if !impls.is_empty() {
write!(w, "\
<h2 id='implementations' class='small-section-header'>\
Trait Implementations<a href='#implementations' class='anchor'></a>\
</h2>\
- <div id='implementations-list'>{}</div>", impls)?;
+ <div id='implementations-list'>{}</div>", impls);
}
if !synthetic.is_empty() {
<a href='#synthetic-implementations' class='anchor'></a>\
</h2>\
<div id='synthetic-implementations-list'>\
- ")?;
- render_impls(cx, w, &synthetic, containing_item)?;
- write!(w, "</div>")?;
+ ");
+ render_impls(cx, w, &synthetic, containing_item);
+ write!(w, "</div>");
}
if !blanket_impl.is_empty() {
<a href='#blanket-implementations' class='anchor'></a>\
</h2>\
<div id='blanket-implementations-list'>\
- ")?;
- render_impls(cx, w, &blanket_impl, containing_item)?;
- write!(w, "</div>")?;
+ ");
+ render_impls(cx, w, &blanket_impl, containing_item);
+ write!(w, "</div>");
}
}
- Ok(())
}
-fn render_deref_methods(w: &mut fmt::Formatter<'_>, cx: &Context, impl_: &Impl,
- container_item: &clean::Item, deref_mut: bool) -> fmt::Result {
+fn render_deref_methods(w: &mut Buffer, cx: &Context, impl_: &Impl,
+ container_item: &clean::Item, deref_mut: bool) {
let deref_type = impl_.inner_impl().trait_.as_ref().unwrap();
let target = impl_.inner_impl().items.iter().filter_map(|item| {
match item.inner {
} else {
if let Some(prim) = target.primitive_type() {
if let Some(&did) = cache().primitive_locations.get(&prim) {
- render_assoc_items(w, cx, container_item, did, what)?;
+ render_assoc_items(w, cx, container_item, did, what);
}
}
- Ok(())
}
}
}
}
-fn render_spotlight_traits(item: &clean::Item) -> Result<String, fmt::Error> {
+fn render_spotlight_traits(item: &clean::Item) -> String {
let mut out = String::new();
match item.inner {
clean::TyMethodItem(clean::TyMethod { ref decl, .. }) |
clean::MethodItem(clean::Method { ref decl, .. }) |
clean::ForeignFunctionItem(clean::Function { ref decl, .. }) => {
- out = spotlight_decl(decl)?;
+ out = spotlight_decl(decl);
}
_ => {}
}
- Ok(out)
+ out
}
-fn spotlight_decl(decl: &clean::FnDecl) -> Result<String, fmt::Error> {
- let mut out = String::new();
+fn spotlight_decl(decl: &clean::FnDecl) -> String {
+ let mut out = Buffer::html();
let mut trait_ = String::new();
if let Some(did) = decl.output.def_id() {
assoc_type(&mut out, it, &[],
Some(&tydef.type_),
AssocItemLink::GotoSource(t_did, &FxHashSet::default()),
- "")?;
+ "");
out.push_str(";</span>");
}
}
out.push_str("</code></div></div>");
}
- Ok(out)
+ out.into_inner()
}
-fn render_impl(w: &mut fmt::Formatter<'_>, cx: &Context, i: &Impl, link: AssocItemLink<'_>,
+fn render_impl(w: &mut Buffer, cx: &Context, i: &Impl, link: AssocItemLink<'_>,
render_mode: RenderMode, outer_version: Option<&str>, show_def_docs: bool,
use_absolute: Option<bool>, is_on_foreign_type: bool,
- show_default_items: bool) -> fmt::Result {
+ show_default_items: bool) {
if render_mode == RenderMode::Normal {
let id = cx.derive_id(match i.inner_impl().trait_ {
Some(ref t) => if is_on_foreign_type {
None => "impl".to_string(),
});
if let Some(use_absolute) = use_absolute {
- write!(w, "<h3 id='{}' class='impl'><code class='in-band'>", id)?;
- fmt_impl_for_trait_page(&i.inner_impl(), w, use_absolute)?;
+ write!(w, "<h3 id='{}' class='impl'><code class='in-band'>", id);
+ fmt_impl_for_trait_page(&i.inner_impl(), w, use_absolute);
if show_def_docs {
for it in &i.inner_impl().items {
if let clean::TypedefItem(ref tydef, _) = it.inner {
- write!(w, "<span class=\"where fmt-newline\"> ")?;
+ write!(w, "<span class=\"where fmt-newline\"> ");
assoc_type(w, it, &vec![], Some(&tydef.type_),
AssocItemLink::Anchor(None),
- "")?;
- write!(w, ";</span>")?;
+ "");
+ write!(w, ";</span>");
}
}
}
- write!(w, "</code>")?;
+ write!(w, "</code>");
} else {
write!(w, "<h3 id='{}' class='impl'><code class='in-band'>{}</code>",
id, i.inner_impl()
- )?;
+ );
}
- write!(w, "<a href='#{}' class='anchor'></a>", id)?;
+ write!(w, "<a href='#{}' class='anchor'></a>", id);
let since = i.impl_item.stability.as_ref().map(|s| &s.since[..]);
- render_stability_since_raw(w, since, outer_version)?;
+ render_stability_since_raw(w, since, outer_version);
if let Some(l) = cx.src_href(&i.impl_item) {
write!(w, "<a class='srclink' href='{}' title='{}'>[src]</a>",
- l, "goto source code")?;
+ l, "goto source code");
}
- write!(w, "</h3>")?;
+ write!(w, "</h3>");
if let Some(ref dox) = cx.shared.maybe_collapsed_doc_value(&i.impl_item) {
let mut ids = cx.id_map.borrow_mut();
write!(w, "<div class='docblock'>{}</div>",
Markdown(&*dox, &i.impl_item.links(), &mut ids,
- cx.codes, cx.edition, &cx.playground).to_string())?;
+ cx.codes, cx.edition, &cx.playground).to_string());
}
}
- fn doc_impl_item(w: &mut fmt::Formatter<'_>, cx: &Context, item: &clean::Item,
+ fn doc_impl_item(w: &mut Buffer, cx: &Context, item: &clean::Item,
link: AssocItemLink<'_>, render_mode: RenderMode,
is_default_item: bool, outer_version: Option<&str>,
- trait_: Option<&clean::Trait>, show_def_docs: bool) -> fmt::Result {
+ trait_: Option<&clean::Trait>, show_def_docs: bool) {
let item_type = item.type_();
let name = item.name.as_ref().unwrap();
if render_method_item {
let id = cx.derive_id(format!("{}.{}", item_type, name));
let ns_id = cx.derive_id(format!("{}.{}", name, item_type.name_space()));
- write!(w, "<h4 id='{}' class=\"{}{}\">", id, item_type, extra_class)?;
- write!(w, "{}", spotlight_decl(decl)?)?;
- write!(w, "<code id='{}'>", ns_id)?;
- render_assoc_item(w, item, link.anchor(&id), ItemType::Impl)?;
- write!(w, "</code>")?;
- render_stability_since_raw(w, item.stable_since(), outer_version)?;
+ write!(w, "<h4 id='{}' class=\"{}{}\">", id, item_type, extra_class);
+ write!(w, "{}", spotlight_decl(decl));
+ write!(w, "<code id='{}'>", ns_id);
+ render_assoc_item(w, item, link.anchor(&id), ItemType::Impl);
+ write!(w, "</code>");
+ render_stability_since_raw(w, item.stable_since(), outer_version);
if let Some(l) = cx.src_href(item) {
write!(w, "<a class='srclink' href='{}' title='{}'>[src]</a>",
- l, "goto source code")?;
+ l, "goto source code");
}
- write!(w, "</h4>")?;
+ write!(w, "</h4>");
}
}
clean::TypedefItem(ref tydef, _) => {
let id = cx.derive_id(format!("{}.{}", ItemType::AssocType, name));
let ns_id = cx.derive_id(format!("{}.{}", name, item_type.name_space()));
- write!(w, "<h4 id='{}' class=\"{}{}\">", id, item_type, extra_class)?;
- write!(w, "<code id='{}'>", ns_id)?;
- assoc_type(w, item, &Vec::new(), Some(&tydef.type_), link.anchor(&id), "")?;
- write!(w, "</code></h4>")?;
+ write!(w, "<h4 id='{}' class=\"{}{}\">", id, item_type, extra_class);
+ write!(w, "<code id='{}'>", ns_id);
+ assoc_type(w, item, &Vec::new(), Some(&tydef.type_), link.anchor(&id), "");
+ write!(w, "</code></h4>");
}
clean::AssocConstItem(ref ty, ref default) => {
let id = cx.derive_id(format!("{}.{}", item_type, name));
let ns_id = cx.derive_id(format!("{}.{}", name, item_type.name_space()));
- write!(w, "<h4 id='{}' class=\"{}{}\">", id, item_type, extra_class)?;
- write!(w, "<code id='{}'>", ns_id)?;
- assoc_const(w, item, ty, default.as_ref(), link.anchor(&id), "")?;
- write!(w, "</code>")?;
- render_stability_since_raw(w, item.stable_since(), outer_version)?;
+ write!(w, "<h4 id='{}' class=\"{}{}\">", id, item_type, extra_class);
+ write!(w, "<code id='{}'>", ns_id);
+ assoc_const(w, item, ty, default.as_ref(), link.anchor(&id), "");
+ write!(w, "</code>");
+ render_stability_since_raw(w, item.stable_since(), outer_version);
if let Some(l) = cx.src_href(item) {
write!(w, "<a class='srclink' href='{}' title='{}'>[src]</a>",
- l, "goto source code")?;
+ l, "goto source code");
}
- write!(w, "</h4>")?;
+ write!(w, "</h4>");
}
clean::AssocTypeItem(ref bounds, ref default) => {
let id = cx.derive_id(format!("{}.{}", item_type, name));
let ns_id = cx.derive_id(format!("{}.{}", name, item_type.name_space()));
- write!(w, "<h4 id='{}' class=\"{}{}\">", id, item_type, extra_class)?;
- write!(w, "<code id='{}'>", ns_id)?;
- assoc_type(w, item, bounds, default.as_ref(), link.anchor(&id), "")?;
- write!(w, "</code></h4>")?;
+ write!(w, "<h4 id='{}' class=\"{}{}\">", id, item_type, extra_class);
+ write!(w, "<code id='{}'>", ns_id);
+ assoc_type(w, item, bounds, default.as_ref(), link.anchor(&id), "");
+ write!(w, "</code></h4>");
}
- clean::StrippedItem(..) => return Ok(()),
+ clean::StrippedItem(..) => return,
_ => panic!("can't make docs for trait item with name {:?}", item.name)
}
if let Some(it) = t.items.iter().find(|i| i.name == item.name) {
// We need the stability of the item from the trait
// because impls can't have a stability.
- document_stability(w, cx, it, is_hidden)?;
+ document_stability(w, cx, it, is_hidden);
if item.doc_value().is_some() {
- document_full(w, item, cx, "", is_hidden)?;
+ document_full(w, item, cx, "", is_hidden);
} else if show_def_docs {
// In case the item isn't documented,
// provide short documentation from the trait.
- document_short(w, cx, it, link, "", is_hidden)?;
+ document_short(w, cx, it, link, "", is_hidden);
}
}
} else {
- document_stability(w, cx, item, is_hidden)?;
+ document_stability(w, cx, item, is_hidden);
if show_def_docs {
- document_full(w, item, cx, "", is_hidden)?;
+ document_full(w, item, cx, "", is_hidden);
}
}
} else {
- document_stability(w, cx, item, is_hidden)?;
+ document_stability(w, cx, item, is_hidden);
if show_def_docs {
- document_short(w, cx, item, link, "", is_hidden)?;
+ document_short(w, cx, item, link, "", is_hidden);
}
}
}
- Ok(())
}
let traits = &cache().traits;
let trait_ = i.trait_did().map(|did| &traits[&did]);
- write!(w, "<div class='impl-items'>")?;
+ write!(w, "<div class='impl-items'>");
for trait_item in &i.inner_impl().items {
doc_impl_item(w, cx, trait_item, link, render_mode,
- false, outer_version, trait_, show_def_docs)?;
+ false, outer_version, trait_, show_def_docs);
}
- fn render_default_items(w: &mut fmt::Formatter<'_>,
+ fn render_default_items(w: &mut Buffer,
cx: &Context,
t: &clean::Trait,
i: &clean::Impl,
render_mode: RenderMode,
outer_version: Option<&str>,
- show_def_docs: bool) -> fmt::Result {
+ show_def_docs: bool) {
for trait_item in &t.items {
let n = trait_item.name.clone();
if i.items.iter().find(|m| m.name == n).is_some() {
let assoc_link = AssocItemLink::GotoSource(did, &i.provided_trait_methods);
doc_impl_item(w, cx, trait_item, assoc_link, render_mode, true,
- outer_version, None, show_def_docs)?;
+ outer_version, None, show_def_docs);
}
- Ok(())
}
// If we've implemented a trait, then also emit documentation for all
if show_default_items {
if let Some(t) = trait_ {
render_default_items(w, cx, t, &i.inner_impl(),
- render_mode, outer_version, show_def_docs)?;
+ render_mode, outer_version, show_def_docs);
}
}
- write!(w, "</div>")?;
-
- Ok(())
+ write!(w, "</div>");
}
fn item_opaque_ty(
- w: &mut fmt::Formatter<'_>,
+ w: &mut Buffer,
cx: &Context,
it: &clean::Item,
t: &clean::OpaqueTy,
-) -> fmt::Result {
- write!(w, "<pre class='rust opaque'>")?;
- render_attributes(w, it, false)?;
+) {
+ write!(w, "<pre class='rust opaque'>");
+ render_attributes(w, it, false);
write!(w, "type {}{}{where_clause} = impl {bounds};</pre>",
it.name.as_ref().unwrap(),
t.generics,
where_clause = WhereClause { gens: &t.generics, indent: 0, end_newline: true },
- bounds = bounds(&t.bounds, false))?;
+ bounds = bounds(&t.bounds, false));
- document(w, cx, it)?;
+ document(w, cx, it);
// Render any items associated directly to this alias, as otherwise they
// won't be visible anywhere in the docs. It would be nice to also show
render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
}
-fn item_trait_alias(w: &mut fmt::Formatter<'_>, cx: &Context, it: &clean::Item,
- t: &clean::TraitAlias) -> fmt::Result {
- write!(w, "<pre class='rust trait-alias'>")?;
- render_attributes(w, it, false)?;
+fn item_trait_alias(w: &mut Buffer, cx: &Context, it: &clean::Item,
+ t: &clean::TraitAlias) {
+ write!(w, "<pre class='rust trait-alias'>");
+ render_attributes(w, it, false);
write!(w, "trait {}{}{} = {};</pre>",
it.name.as_ref().unwrap(),
t.generics,
WhereClause { gens: &t.generics, indent: 0, end_newline: true },
- bounds(&t.bounds, true))?;
+ bounds(&t.bounds, true));
- document(w, cx, it)?;
+ document(w, cx, it);
// Render any items associated directly to this alias, as otherwise they
// won't be visible anywhere in the docs. It would be nice to also show
render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
}
-fn item_typedef(w: &mut fmt::Formatter<'_>, cx: &Context, it: &clean::Item,
- t: &clean::Typedef) -> fmt::Result {
- write!(w, "<pre class='rust typedef'>")?;
- render_attributes(w, it, false)?;
+fn item_typedef(w: &mut Buffer, cx: &Context, it: &clean::Item, t: &clean::Typedef) {
+ write!(w, "<pre class='rust typedef'>");
+ render_attributes(w, it, false);
write!(w, "type {}{}{where_clause} = {type_};</pre>",
it.name.as_ref().unwrap(),
t.generics,
where_clause = WhereClause { gens: &t.generics, indent: 0, end_newline: true },
- type_ = t.type_)?;
+ type_ = t.type_);
- document(w, cx, it)?;
+ document(w, cx, it);
// Render any items associated directly to this alias, as otherwise they
// won't be visible anywhere in the docs. It would be nice to also show
render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
}
-fn item_foreign_type(w: &mut fmt::Formatter<'_>, cx: &Context, it: &clean::Item) -> fmt::Result {
- writeln!(w, "<pre class='rust foreigntype'>extern {{")?;
- render_attributes(w, it, false)?;
+fn item_foreign_type(w: &mut Buffer, cx: &Context, it: &clean::Item) {
+ writeln!(w, "<pre class='rust foreigntype'>extern {{");
+ render_attributes(w, it, false);
write!(
w,
" {}type {};\n}}</pre>",
VisSpace(&it.visibility),
it.name.as_ref().unwrap(),
- )?;
+ );
- document(w, cx, it)?;
+ document(w, cx, it);
render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
}
}
}
-fn item_macro(w: &mut fmt::Formatter<'_>, cx: &Context, it: &clean::Item,
- t: &clean::Macro) -> fmt::Result {
+fn item_macro(w: &mut Buffer, cx: &Context, it: &clean::Item, t: &clean::Macro) {
wrap_into_docblock(w, |w| {
w.write_str(&highlight::render_with_highlighting(&t.source,
Some("macro"),
None,
None))
- })?;
+ });
document(w, cx, it)
}
-fn item_proc_macro(w: &mut fmt::Formatter<'_>, cx: &Context, it: &clean::Item, m: &clean::ProcMacro)
- -> fmt::Result
-{
+fn item_proc_macro(w: &mut Buffer, cx: &Context, it: &clean::Item, m: &clean::ProcMacro) {
let name = it.name.as_ref().expect("proc-macros always have names");
match m.kind {
MacroKind::Bang => {
- write!(w, "<pre class='rust macro'>")?;
- write!(w, "{}!() {{ /* proc-macro */ }}", name)?;
- write!(w, "</pre>")?;
+ write!(w, "<pre class='rust macro'>");
+ write!(w, "{}!() {{ /* proc-macro */ }}", name);
+ write!(w, "</pre>");
}
MacroKind::Attr => {
- write!(w, "<pre class='rust attr'>")?;
- write!(w, "#[{}]", name)?;
- write!(w, "</pre>")?;
+ write!(w, "<pre class='rust attr'>");
+ write!(w, "#[{}]", name);
+ write!(w, "</pre>");
}
MacroKind::Derive => {
- write!(w, "<pre class='rust derive'>")?;
- write!(w, "#[derive({})]", name)?;
+ write!(w, "<pre class='rust derive'>");
+ write!(w, "#[derive({})]", name);
if !m.helpers.is_empty() {
- writeln!(w, "\n{{")?;
- writeln!(w, " // Attributes available to this derive:")?;
+ writeln!(w, "\n{{");
+ writeln!(w, " // Attributes available to this derive:");
for attr in &m.helpers {
- writeln!(w, " #[{}]", attr)?;
+ writeln!(w, " #[{}]", attr);
}
- write!(w, "}}")?;
+ write!(w, "}}");
}
- write!(w, "</pre>")?;
+ write!(w, "</pre>");
}
}
document(w, cx, it)
}
-fn item_primitive(w: &mut fmt::Formatter<'_>, cx: &Context,
+fn item_primitive(w: &mut Buffer, cx: &Context,
it: &clean::Item,
- _p: &clean::PrimitiveType) -> fmt::Result {
- document(w, cx, it)?;
+ _p: &clean::PrimitiveType) {
+ document(w, cx, it);
render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
}
-fn item_keyword(w: &mut fmt::Formatter<'_>, cx: &Context,
+fn item_keyword(w: &mut Buffer, cx: &Context,
it: &clean::Item,
- _p: &str) -> fmt::Result {
+ _p: &str) {
document(w, cx, it)
}
projects / rust.git / commitdiff