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)> {