Settings
"; themes.push(PathBuf::from("settings.css")); - let layout = self.shared.layout.clone(); - let mut v = Vec::new(); - try_err!(layout::render(&mut v, &layout, - &page, &sidebar, &settings, - self.shared.css_file_extension.is_some(), - &themes, - self.shared.generate_search_filter), - &settings_file); - self.shared.fs.write(&settings_file, &v)?; + let v = layout::render( + &self.shared.layout, + &page, sidebar, settings( + self.shared.static_root_path.as_deref().unwrap_or("./"), + &self.shared.resource_suffix + ), + &themes); + self.shared.fs.write(&settings_file, v.as_bytes())?; Ok(()) } fn render_item(&self, - writer: &mut dyn io::Write, it: &clean::Item, - pushname: bool) - -> io::Result<()> { + pushname: bool) -> String { // A little unfortunate that this is done like this, but it sure // does make formatting *a lot* nicer. CURRENT_DEPTH.with(|slot| { @@ -2022,12 +1966,10 @@ impl Context { } if !self.render_redirect_pages { - layout::render(writer, &self.shared.layout, &page, - &Sidebar{ cx: self, item: it }, - &Item{ cx: self, item: it }, - self.shared.css_file_extension.is_some(), - &self.shared.themes, - self.shared.generate_search_filter)?; + layout::render(&self.shared.layout, &page, + |buf: &mut _| print_sidebar(self, it, buf), + |buf: &mut _| print_item(self, it, buf), + &self.shared.themes) } else { let mut url = self.root_path(); if let Some(&(ref names, ty)) = cache().paths.get(&it.def_id) { @@ -2036,10 +1978,11 @@ impl Context { url.push_str("/"); } url.push_str(&item_path(ty, names.last().unwrap())); - layout::redirect(writer, &url)?; + layout::redirect(&url) + } else { + String::new() } } - Ok(()) } /// Non-parallelized version of rendering an item. This will take the input @@ -2075,13 +2018,12 @@ impl Context { info!("Recursing into {}", self.dst.display()); - let mut buf = Vec::new(); - self.render_item(&mut buf, &item, false).unwrap(); + let buf = self.render_item(&item, false); // buf will be empty if the module is stripped and there is no redirect for it if !buf.is_empty() { self.shared.ensure_dir(&self.dst)?; let joint_dst = self.dst.join("index.html"); - scx.fs.write(&joint_dst, buf)?; + scx.fs.write(&joint_dst, buf.as_bytes())?; } let m = match item.inner { @@ -2094,9 +2036,7 @@ impl Context { if !self.render_redirect_pages { let items = self.build_sidebar_items(&m); let js_dst = self.dst.join("sidebar-items.js"); - let mut v = Vec::new(); - try_err!(write!(&mut v, "initSidebarItems({});", - as_json(&items)), &js_dst); + let v = format!("initSidebarItems({});", as_json(&items)); scx.fs.write(&js_dst, &v)?; } @@ -2110,8 +2050,7 @@ impl Context { self.dst = prev; self.current.pop().unwrap(); } else if item.name.is_some() { - let mut buf = Vec::new(); - self.render_item(&mut buf, &item, true).unwrap(); + let buf = self.render_item(&item, true); // buf will be empty if the item is stripped and there is no redirect for it if !buf.is_empty() { let name = item.name.as_ref().unwrap(); @@ -2119,7 +2058,7 @@ impl Context { let file_name = &item_path(item_type, name); self.shared.ensure_dir(&self.dst)?; let joint_dst = self.dst.join(file_name); - self.shared.fs.write(&joint_dst, buf)?; + self.shared.fs.write(&joint_dst, buf.as_bytes())?; if !self.render_redirect_pages { all.append(full_path(self, &item), &item_type); @@ -2129,18 +2068,16 @@ impl Context { // URL for the page. let redir_name = format!("{}.{}.html", name, item_type.name_space()); let redir_dst = self.dst.join(redir_name); - let mut v = Vec::new(); - try_err!(layout::redirect(&mut v, file_name), &redir_dst); - self.shared.fs.write(&redir_dst, &v)?; + let v = layout::redirect(file_name); + self.shared.fs.write(&redir_dst, v.as_bytes())?; } // If the item is a macro, redirect from the old macro URL (with !) // to the new one (without). if item_type == ItemType::Macro { let redir_name = format!("{}.{}!.html", item_type, name); let redir_dst = self.dst.join(redir_name); - let mut v = Vec::new(); - try_err!(layout::redirect(&mut v, file_name), &redir_dst); - self.shared.fs.write(&redir_dst, &v)?; + let v = layout::redirect(file_name); + self.shared.fs.write(&redir_dst, v.as_bytes())?; } } } @@ -2172,7 +2109,7 @@ impl Context { } } -impl<'a> Item<'a> { +impl Context { /// Generates a url appropriate for an `href` attribute back to the source of /// this item. /// @@ -2182,26 +2119,26 @@ impl<'a> Item<'a> { /// If `None` is returned, then a source link couldn't be generated. This /// may happen, for example, with externally inlined items where the source /// of their crate documentation isn't known. - fn src_href(&self) -> OptionStruct {{ .. }} syntax; cannot be \
matched against without a wildcard ..; 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, "{}extern crate {} as {};",
VisSpace(&myitem.visibility),
anchor(myitem.def_id, src),
- name)?
+ name)
}
None => {
write!(w, " | |
{}{} |
")?;
- render_attributes(w, it, false)?;
+fn item_constant(w: &mut Buffer, cx: &Context, it: &clean::Item, c: &clean::Constant) {
+ write!(w, "");
+ render_attributes(w, it, false);
write!(w, "{vis}const \
{name}: {typ}",
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, "")?;
- render_attributes(w, it, false)?;
+fn item_static(w: &mut Buffer, cx: &Context, it: &clean::Item, s: &clean::Static) {
+ write!(w, "");
+ render_attributes(w, it, false);
write!(w, "{vis}static {mutability}\
{name}: {typ}",
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),
@@ -2898,8 +2821,8 @@ fn item_function(w: &mut fmt::Formatter<'_>, cx: &Context, it: &clean::Item,
it.name.as_ref().unwrap(),
f.generics
).len();
- write!(w, "{}", render_spotlight_traits(it)?)?;
- render_attributes(w, it, false)?;
+ write!(w, "{}", render_spotlight_traits(it));
+ render_attributes(w, it, false);
write!(w,
"{vis}{constness}{unsafety}{asyncness}{abi}fn \
{name}{generics}{decl}{where_clause}",
@@ -2916,12 +2839,12 @@ fn item_function(w: &mut fmt::Formatter<'_>, cx: &Context, it: &clean::Item,
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_ {
@@ -2933,20 +2856,18 @@ fn render_implementor(cx: &Context, implementor: &Impl, w: &mut fmt::Formatter<'
_ => 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 {
@@ -2974,11 +2895,11 @@ fn compare_impl<'a, 'b>(lhs: &'a &&Impl, rhs: &'b &&Impl) -> Ordering {
}
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::>();
let consts = t.items.iter().filter(|m| m.is_associated_const()).collect::>();
@@ -2987,146 +2908,144 @@ fn item_trait(
// Output the trait definition
wrap_into_docblock(w, |w| {
- write!(w, "")?;
- render_attributes(w, it, true)?;
+ write!(w, "");
+ 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, "")?;
+ write!(w, "");
}
}
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, "")?;
+ write!(w, "");
}
}
- write!(w, "}}")?;
+ write!(w, "}}");
}
write!(w, "")
- })?;
+ });
// 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, "
\
{1}\
{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, "{}Loading content...", 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, "{extra}",
- 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, "")?;
- render_stability_since(w, m, t)?;
- write!(w, "
")?;
- document(w, cx, m)?;
- Ok(())
+ ns_id = ns_id);
+ render_assoc_item(w, m, AssocItemLink::Anchor(Some(&id)), ItemType::Impl);
+ write!(w, "");
+ render_stability_since(w, m, t);
+ write!(w, "");
+ document(w, cx, m);
}
if !types.is_empty() {
write_small_section_header(w, "associated-types", "Associated Types",
- "")?;
+ "");
for t in &types {
- trait_item(w, cx, *t, it)?;
+ trait_item(w, cx, *t, it);
}
- write_loading_content(w, "")?;
+ write_loading_content(w, "");
}
if !consts.is_empty() {
write_small_section_header(w, "associated-const", "Associated Constants",
- "")?;
+ "");
for t in &consts {
- trait_item(w, cx, *t, it)?;
+ trait_item(w, cx, *t, it);
}
- write_loading_content(w, "")?;
+ write_loading_content(w, "");
}
// Output the documentation for each function individually
if !required.is_empty() {
write_small_section_header(w, "required-methods", "Required methods",
- "")?;
+ "");
for m in &required {
- trait_item(w, cx, *m, it)?;
+ trait_item(w, cx, *m, it);
}
- write_loading_content(w, "")?;
+ write_loading_content(w, "");
}
if !provided.is_empty() {
write_small_section_header(w, "provided-methods", "Provided methods",
- "")?;
+ "");
for m in &provided {
- trait_item(w, cx, *m, it)?;
+ trait_item(w, cx, *m, it);
}
- write_loading_content(w, "")?;
+ write_loading_content(w, "");
}
// 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();
@@ -3165,7 +3084,7 @@ fn item_trait(
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(
@@ -3174,44 +3093,44 @@ fn item_trait(
);
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",
- "")?;
+ "");
for implementor in concrete {
- render_implementor(cx, implementor, w, &implementor_dups)?;
+ render_implementor(cx, implementor, w, &implementor_dups);
}
- write_loading_content(w, "")?;
+ write_loading_content(w, "");
if t.auto {
write_small_section_header(w, "synthetic-implementors", "Auto implementors",
- "")?;
+ "");
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, "")?;
+ write_loading_content(w, "");
}
} 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",
- "")?;
- write_loading_content(w, "")?;
+ "");
+ write_loading_content(w, "");
if t.auto {
write_small_section_header(w, "synthetic-implementors", "Auto implementors",
- "")?;
- write_loading_content(w, "")?;
+ "");
+ write_loading_content(w, "");
}
}
write!(w, r#""#,
- as_json(&synthetic_types))?;
+ as_json(&synthetic_types));
write!(w, r#"",
- name = it.name.as_ref().map(|x| &x[..]).unwrap_or(""),
- ty = it.type_().css_class(),
- path = relpath)?;
- if parentlen == 0 {
- // There is no sidebar-items.js beyond the crate root path
- // FIXME maybe dynamic crate loading can be merged here
- } else {
- write!(fmt, "",
- path = relpath)?;
- }
- // Closes sidebar-elems div.
- write!(fmt, "")?;
-
- Ok(())
+ _ => "",
+ },
+ it.name.as_ref().unwrap());
+ }
+
+ if it.is_crate() {
+ if let Some(ref version) = cache().crate_version {
+ write!(buffer,
+ "\
+ Version {}
\
+ ",
+ version);
+ }
+ }
+
+ write!(buffer, "");
}
fn get_next_url(used_links: &mut FxHashSet, url: String) -> String {
@@ -4570,8 +4452,7 @@ fn sidebar_assoc_items(it: &clean::Item) -> String {
out
}
-fn sidebar_struct(fmt: &mut fmt::Formatter<'_>, it: &clean::Item,
- s: &clean::Struct) -> fmt::Result {
+fn sidebar_struct(buf: &mut Buffer, it: &clean::Item, s: &clean::Struct) {
let mut sidebar = String::new();
let fields = get_struct_fields_name(&s.fields);
@@ -4585,9 +4466,8 @@ fn sidebar_struct(fmt: &mut fmt::Formatter<'_>, it: &clean::Item,
sidebar.push_str(&sidebar_assoc_items(it));
if !sidebar.is_empty() {
- write!(fmt, "{}", sidebar)?;
+ write!(buf, "{}", sidebar);
}
- Ok(())
}
fn get_id_for_impl_on_foreign_type(for_: &clean::Type, trait_: &clean::Type) -> String {
@@ -4611,8 +4491,7 @@ fn is_negative_impl(i: &clean::Impl) -> bool {
i.polarity == Some(clean::ImplPolarity::Negative)
}
-fn sidebar_trait(fmt: &mut fmt::Formatter<'_>, it: &clean::Item,
- t: &clean::Trait) -> fmt::Result {
+fn sidebar_trait(buf: &mut Buffer, it: &clean::Item, t: &clean::Trait) {
let mut sidebar = String::new();
let types = t.items
@@ -4720,27 +4599,23 @@ fn sidebar_trait(fmt: &mut fmt::Formatter<'_>, it: &clean::Item,
sidebar.push_str(&sidebar_assoc_items(it));
- write!(fmt, "{}", sidebar)
+ write!(buf, "{}", sidebar)
}
-fn sidebar_primitive(fmt: &mut fmt::Formatter<'_>, it: &clean::Item,
- _p: &clean::PrimitiveType) -> fmt::Result {
+fn sidebar_primitive(buf: &mut Buffer, it: &clean::Item, _p: &clean::PrimitiveType) {
let sidebar = sidebar_assoc_items(it);
if !sidebar.is_empty() {
- write!(fmt, "{}", sidebar)?;
+ write!(buf, "{}", sidebar);
}
- Ok(())
}
-fn sidebar_typedef(fmt: &mut fmt::Formatter<'_>, it: &clean::Item,
- _t: &clean::Typedef) -> fmt::Result {
+fn sidebar_typedef(buf: &mut Buffer, it: &clean::Item, _t: &clean::Typedef) {
let sidebar = sidebar_assoc_items(it);
if !sidebar.is_empty() {
- write!(fmt, "{}", sidebar)?;
+ write!(buf, "{}", sidebar);
}
- Ok(())
}
fn get_struct_fields_name(fields: &[clean::Item]) -> String {
@@ -4758,8 +4633,7 @@ fn get_struct_fields_name(fields: &[clean::Item]) -> String {
.collect()
}
-fn sidebar_union(fmt: &mut fmt::Formatter<'_>, it: &clean::Item,
- u: &clean::Union) -> fmt::Result {
+fn sidebar_union(buf: &mut Buffer, it: &clean::Item, u: &clean::Union) {
let mut sidebar = String::new();
let fields = get_struct_fields_name(&u.fields);
@@ -4771,13 +4645,11 @@ fn sidebar_union(fmt: &mut fmt::Formatter<'_>, it: &clean::Item,
sidebar.push_str(&sidebar_assoc_items(it));
if !sidebar.is_empty() {
- write!(fmt, "{}", sidebar)?;
+ write!(buf, "{}", sidebar);
}
- Ok(())
}
-fn sidebar_enum(fmt: &mut fmt::Formatter<'_>, it: &clean::Item,
- e: &clean::Enum) -> fmt::Result {
+fn sidebar_enum(buf: &mut Buffer, it: &clean::Item, e: &clean::Enum) {
let mut sidebar = String::new();
let variants = e.variants.iter()
@@ -4795,9 +4667,8 @@ fn sidebar_enum(fmt: &mut fmt::Formatter<'_>, it: &clean::Item,
sidebar.push_str(&sidebar_assoc_items(it));
if !sidebar.is_empty() {
- write!(fmt, "{}", sidebar)?;
+ write!(buf, "{}", sidebar);
}
- Ok(())
}
fn item_ty_to_strs(ty: &ItemType) -> (&'static str, &'static str) {
@@ -4831,8 +4702,7 @@ fn item_ty_to_strs(ty: &ItemType) -> (&'static str, &'static str) {
}
}
-fn sidebar_module(fmt: &mut fmt::Formatter<'_>, _it: &clean::Item,
- items: &[clean::Item]) -> fmt::Result {
+fn sidebar_module(buf: &mut Buffer, _it: &clean::Item, items: &[clean::Item]) {
let mut sidebar = String::new();
if items.iter().any(|it| it.type_() == ItemType::ExternCrate ||
@@ -4859,72 +4729,67 @@ fn sidebar_module(fmt: &mut fmt::Formatter<'_>, _it: &clean::Item,
}
if !sidebar.is_empty() {
- write!(fmt, "{}
", sidebar)?;
+ write!(buf, "{}
", sidebar);
}
- Ok(())
}
-fn sidebar_foreign_type(fmt: &mut fmt::Formatter<'_>, it: &clean::Item) -> fmt::Result {
+fn sidebar_foreign_type(buf: &mut Buffer, it: &clean::Item) {
let sidebar = sidebar_assoc_items(it);
if !sidebar.is_empty() {
- write!(fmt, "{}", sidebar)?;
+ write!(buf, "{}", sidebar);
}
- Ok(())
}
-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, "")?;
- write!(w, "{}!() {{ /* proc-macro */ }}", name)?;
- write!(w, "")?;
+ write!(w, "");
+ write!(w, "{}!() {{ /* proc-macro */ }}", name);
+ write!(w, "");
}
MacroKind::Attr => {
- write!(w, "")?;
- write!(w, "#[{}]", name)?;
- write!(w, "")?;
+ write!(w, "");
+ write!(w, "#[{}]", name);
+ write!(w, "");
}
MacroKind::Derive => {
- write!(w, "")?;
- write!(w, "#[derive({})]", name)?;
+ write!(w, "");
+ 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, "")?;
+ write!(w, "");
}
}
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)
}
diff --git a/src/librustdoc/html/sources.rs b/src/librustdoc/html/sources.rs
index c1f1f59d9149a..d840683a7af87 100644
--- a/src/librustdoc/html/sources.rs
+++ b/src/librustdoc/html/sources.rs
@@ -4,10 +4,10 @@ use crate::fold::DocFolder;
use crate::html::layout;
use crate::html::render::{Error, SharedContext, BASIC_KEYWORDS};
use crate::html::highlight;
+use crate::html::format::Buffer;
use std::ffi::OsStr;
use std::fs;
use std::path::{Component, Path, PathBuf};
-use std::fmt;
use syntax::source_map::FileName;
crate fn render(dst: &Path, scx: &mut SharedContext,
@@ -105,7 +105,6 @@ impl<'a> SourceCollector<'a> {
cur.push(&fname);
href.push_str(&fname.to_string_lossy());
- let mut v = Vec::new();
let title = format!("{} -- source", cur.file_name().expect("failed to get file name")
.to_string_lossy());
let desc = format!("Source to the Rust file `{}`.", filename);
@@ -120,15 +119,10 @@ impl<'a> SourceCollector<'a> {
extra_scripts: &[&format!("source-files{}", self.scx.resource_suffix)],
static_extra_scripts: &[&format!("source-script{}", self.scx.resource_suffix)],
};
- let result = layout::render(&mut v, &self.scx.layout,
- &page, &(""), &Source(contents),
- self.scx.css_file_extension.is_some(),
- &self.scx.themes,
- self.scx.generate_search_filter);
- if let Err(e) = result {
- return Err(Error::new(e, &cur));
- }
- self.scx.fs.write(&cur, &v)?;
+ let v = layout::render(&self.scx.layout,
+ &page, "", |buf: &mut _| print_src(buf, &contents),
+ &self.scx.themes);
+ self.scx.fs.write(&cur, v.as_bytes())?;
self.scx.local_sources.insert(p.clone(), href);
Ok(())
}
@@ -163,25 +157,19 @@ where
/// Wrapper struct to render the source code of a file. This will do things like
/// adding line numbers to the left-hand side.
-struct Source<'a>(&'a str);
-
-impl<'a> fmt::Display for Source<'a> {
- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
- let Source(s) = *self;
- let lines = s.lines().count();
- let mut cols = 0;
- let mut tmp = lines;
- while tmp > 0 {
- cols += 1;
- tmp /= 10;
- }
- write!(fmt, "")?;
- for i in 1..=lines {
- write!(fmt, "{0:1$}\n", i, cols)?;
- }
- write!(fmt, "")?;
- write!(fmt, "{}",
- highlight::render_with_highlighting(s, None, None, None))?;
- Ok(())
+fn print_src(buf: &mut Buffer, s: &str) {
+ let lines = s.lines().count();
+ let mut cols = 0;
+ let mut tmp = lines;
+ while tmp > 0 {
+ cols += 1;
+ tmp /= 10;
+ }
+ write!(buf, "");
+ for i in 1..=lines {
+ write!(buf, "{0:1$}\n", i, cols);
}
+ write!(buf, "");
+ write!(buf, "{}",
+ highlight::render_with_highlighting(s, None, None, None));
}