search_index impl Display

Author: yotamofek

src/librustdoc/display.rs

@@ -82,6 +82,10 @@ impl Wrapped<char> {
  pub(crate) fn with_square_brackets() -> Self {
  Self { prefix: '[', suffix: ']' }
  }
+
+ pub(crate) fn with_curly_brackets() -> Self {
+ Self { prefix: '{', suffix: '}' }
+ }
 }
 
 impl<T: Display> Wrapped<T> {

src/librustdoc/html/render/mod.rs

@@ -67,7 +67,7 @@ pub(crate) use self::context::*;
 pub(crate) use self::span_map::{LinkFromSrc, collect_spans_and_sources};
 pub(crate) use self::write_shared::*;
 use crate::clean::{self, ItemId, RenderedLink};
-use crate::display::{Joined as _, MaybeDisplay as _};
+use crate::display::{Joined as _, MaybeDisplay as _, Wrapped};
 use crate::error::Error;
 use crate::formats::Impl;
 use crate::formats::cache::Cache;
@@ -153,59 +153,35 @@ struct RenderType {
 
 impl RenderType {
  fn size(&self) -> usize {
- let mut size = 1;
- if let Some(generics) = &self.generics {
- size += generics.iter().map(RenderType::size).sum::<usize>();
- }
- if let Some(bindings) = &self.bindings {
- for (_, constraints) in bindings.iter() {
- size += 1;
- size += constraints.iter().map(RenderType::size).sum::<usize>();
- }
- }
- size
+ self.bindings
+ .iter()
+ .flatten()
+ .map(|(_, constraints)| constraints)
+ .chain(self.generics.iter())
+ .map(|constraints| constraints.iter().map(RenderType::size).sum::<usize>() + 1)
+ .sum()
  }
- // Types are rendered as lists of lists, because that's pretty compact.
- // The contents of the lists are always integers in self-terminating hex
- // form, handled by `RenderTypeId::write_to_string`, so no commas are
- // needed to separate the items.
- fn write_to_string(&self, string: &mut String) {
- fn write_optional_id(id: Option<RenderTypeId>, string: &mut String) {
- // 0 is a sentinel, everything else is one-indexed
- match id {
- Some(id) => id.write_to_string(string),
- None => string.push('`'),
- }
- }
- // Either just the type id, or `{type, generics, bindings?}`
- // where generics is a list of types,
- // and bindings is a list of `{id, typelist}` pairs.
- if self.generics.is_some() || self.bindings.is_some() {
- string.push('{');
- write_optional_id(self.id, string);
- string.push('{');
- for generic in self.generics.as_deref().unwrap_or_default() {
- generic.write_to_string(string);
- }
- string.push('}');
- if self.bindings.is_some() {
- string.push('{');
- for binding in self.bindings.as_deref().unwrap_or_default() {
- string.push('{');
- binding.0.write_to_string(string);
- string.push('{');
- for constraint in &binding.1[..] {
- constraint.write_to_string(string);
- }
- string.push_str("}}");
- }
- string.push('}');
+
+ fn write_bindings(&self) -> Option<impl fmt::Display> {
+ let Some(bindings) = &self.bindings else {
+ return None;
+ };
+
+ Some(Wrapped::with_curly_brackets().wrap_fn(move |f| {
+ for (binding, constraints) in bindings {
+ Wrapped::with_curly_brackets()
+ .wrap_fn(|f| {
+ binding.write_to_string().fmt(f)?;
+ Wrapped::with_curly_brackets()
+ .wrap_fn(|f| constraints.iter().joined("", f))
+ .fmt(f)
+ })
+ .fmt(f)?;
  }
- string.push('}');
- } else {
- write_optional_id(self.id, string);
- }
+ Ok(())
+ }))
  }
+
  fn read_from_bytes(string: &[u8]) -> (RenderType, usize) {
  let mut i = 0;
  if string[i] == b'{' {
@@ -264,6 +240,40 @@ impl RenderType {
  }
 }
 
+impl fmt::Display for RenderType {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ // Types are rendered as lists of lists, because that's pretty compact.
+ // The contents of the lists are always integers in self-terminating hex
+ // form, handled by `RenderTypeId::write_to_string`, so no commas are
+ // needed to separate the items.
+
+ fn write_optional_id(id: Option<RenderTypeId>) -> impl fmt::Display {
+ // 0 is a sentinel, everything else is one-indexed
+ match id {
+ Some(id) => Either::Left(id.write_to_string()),
+ None => Either::Right('`'),
+ }
+ }
+
+ // Either just the type id, or `{type, generics, bindings?}`
+ // where generics is a list of types,
+ // and bindings is a list of `{id, typelist}` pairs.
+ if self.generics.is_some() || self.bindings.is_some() {
+ Wrapped::with_curly_brackets()
+ .wrap_fn(|f| {
+ let id = write_optional_id(self.id);
+ let generics = Wrapped::with_curly_brackets()
+ .wrap_fn(|f| self.generics.iter().flatten().joined("", f));
+ let bindings = self.write_bindings().maybe_display();
+ write!(f, "{id}{generics}{bindings}")
+ })
+ .fmt(f)
+ } else {
+ write_optional_id(self.id).fmt(f)
+ }
+ }
+}
+
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum RenderTypeId {
  DefId(DefId),
@@ -274,7 +284,7 @@ enum RenderTypeId {
 }
 
 impl RenderTypeId {
- fn write_to_string(&self, string: &mut String) {
+ fn write_to_string(&self) -> impl fmt::Display + use<> {
  let id: i32 = match &self {
  // 0 is a sentinel, everything else is one-indexed
  // concrete type
@@ -283,7 +293,7 @@ impl RenderTypeId {
  RenderTypeId::Index(idx) => (*idx).try_into().unwrap(),
  _ => panic!("must convert render types to indexes before serializing"),
  };
- search_index::encode::write_signed_vlqhex_to_string(id, string);
+ search_index::encode::write_signed_vlqhex_to_string(id)
  }
  fn read_from_bytes(string: &[u8]) -> (Option<RenderTypeId>, usize) {
  let Some((value, offset)) = search_index::encode::read_signed_vlqhex_from_string(string)
@@ -311,13 +321,13 @@ pub(crate) struct IndexItemFunctionType {
 
 impl IndexItemFunctionType {
  fn size(&self) -> usize {
- self.inputs.iter().map(RenderType::size).sum::<usize>()
- + self.output.iter().map(RenderType::size).sum::<usize>()
- + self
-  .where_clause
-  .iter()
-  .map(|constraints| constraints.iter().map(RenderType::size).sum::<usize>())
-  .sum::<usize>()
+ self.where_clause
+ .iter()
+ .flatten()
+ .chain(&self.inputs)
+ .chain(&self.output)
+ .map(RenderType::size)
+ .sum()
  }
  fn read_from_string_without_param_names(string: &[u8]) -> (IndexItemFunctionType, usize) {
  let mut i = 0;
@@ -367,7 +377,7 @@ impl IndexItemFunctionType {
  i += 1;
  (IndexItemFunctionType { inputs, output, where_clause, param_names: Vec::new() }, i)
  }
- fn write_to_string_without_param_names<'a>(&'a self, string: &mut String) {
+ fn write_to_string_without_param_names<'a>(&'a self) -> impl fmt::Display {
  // If we couldn't figure out a type, just write 0,
  // which is encoded as `` ` `` (see RenderTypeId::write_to_string).
  let has_missing = self
@@ -376,49 +386,26 @@ impl IndexItemFunctionType {
  .chain(self.output.iter())
  .any(|i| i.id.is_none() && i.generics.is_none());
  if has_missing {
- string.push('`');
+ Either::Left('`')
  } else {
- string.push('{');
- match &self.inputs[..] {
- [one] if one.generics.is_none() && one.bindings.is_none() => {
- one.write_to_string(string);
- }
- _ => {
- string.push('{');
- for item in &self.inputs[..] {
- item.write_to_string(string);
- }
- string.push('}');
+ Either::Right(Wrapped::with_curly_brackets().wrap_fn(|f| {
+ fn write_render_types(types: &[RenderType]) -> impl fmt::Display {
+ Wrapped::with_curly_brackets()
+ .when(!matches!(types, [one] if one.generics.is_none() && one.bindings.is_none()))
+ .wrap_fn(|f| types.iter().joined("", f))
  }
- }
- match &self.output[..] {
- [] if self.where_clause.is_empty() => {}
- [one] if one.generics.is_none() && one.bindings.is_none() => {
- one.write_to_string(string);
- }
- _ => {
- string.push('{');
- for item in &self.output[..] {
- item.write_to_string(string);
- }
- string.push('}');
- }
- }
- for constraint in &self.where_clause {
- if let [one] = &constraint[..]
- && one.generics.is_none()
- && one.bindings.is_none()
- {
- one.write_to_string(string);
- } else {
- string.push('{');
- for item in &constraint[..] {
- item.write_to_string(string);
- }
- string.push('}');
+
+ write_render_types(&self.inputs).fmt(f)?;
+ if !(self.output.is_empty() && self.where_clause.is_empty()) {
+ write_render_types(&self.output).fmt(f)?;
  }
- }
- string.push('}');
+ self.where_clause
+ .iter()
+ .map(|constraints| write_render_types(constraints))
+ .joined("", f)?;
+
+ Ok(())
+ }))
  }
  }
 }

src/librustdoc/html/render/search_index.rs

@@ -2,6 +2,7 @@ pub(crate) mod encode;
 
 use std::collections::BTreeSet;
 use std::collections::hash_map::Entry;
+use std::fmt::Write as _;
 use std::path::Path;
 
 use rustc_ast::join_path_syms;
@@ -509,7 +510,8 @@ impl SerializedSearchIndex {
  }
  let mut result =
  String::with_capacity(function_data.function_signature.len());
- func.write_to_string_without_param_names(&mut result);
+ write!(result, "{}", func.write_to_string_without_param_names())
+ .unwrap();
  result
  },
  param_names: function_data.param_names.clone(),
@@ -683,7 +685,8 @@ impl SerializedSearchIndex {
  }
  }
  let mut result = String::with_capacity(function_signature.len());
- func.write_to_string_without_param_names(&mut result);
+ write!(result, "{}", func.write_to_string_without_param_names())
+ .unwrap();
  result
  },
  param_names: param_names.clone(),
@@ -1929,9 +1932,7 @@ pub(crate) fn build_index(
  if item.ty.is_fn_like() { 0 } else { 16 };
  serialized_index.function_data[new_entry_id] = Some(FunctionData {
  function_signature: {
- let mut function_signature = String::new();
- search_type.write_to_string_without_param_names(&mut function_signature);
- function_signature
+ search_type.write_to_string_without_param_names().to_string()
  },
  param_names: search_type
  .param_names

src/librustdoc/html/render/search_index/encode.rs

@@ -1,4 +1,6 @@
-pub(crate) fn write_signed_vlqhex_to_string(n: i32, string: &mut String) {
+use std::fmt::{self, Write as _};
+
+pub(crate) fn write_signed_vlqhex_to_string(n: i32) -> impl fmt::Display {
  let (sign, magnitude): (bool, u32) =
  if n >= 0 { (false, n.try_into().unwrap()) } else { (true, (-n).try_into().unwrap()) };
  // zig-zag encoding
@@ -25,14 +27,19 @@ pub(crate) fn write_signed_vlqhex_to_string(n: i32, string: &mut String) {
  shift = shift.wrapping_sub(4);
  mask >>= 4;
  }
- // now write the rest
- while shift < 32 {
- let hexit = (value & mask) >> shift;
- let hex = char::try_from(if shift == 0 { '`' } else { '@' } as u32 + hexit).unwrap();
- string.push(hex);
- shift = shift.wrapping_sub(4);
- mask >>= 4;
- }
+ fmt::from_fn(move |f| {
+ let mut shift = shift;
+ let mut mask = mask;
+ // now write the rest
+ while shift < 32 {
+ let hexit = (value & mask) >> shift;
+ let hex = char::try_from(if shift == 0 { '`' } else { '@' } as u32 + hexit).unwrap();
+ f.write_char(hex)?;
+ shift = shift.wrapping_sub(4);
+ mask >>= 4;
+ }
+ Ok(())
+ })
 }
 
 pub fn read_signed_vlqhex_from_string(string: &[u8]) -> Option<(i32, usize)> {