Auto merge of #147402 - yotamofek:wip/rustdoc/search_index/impl-display, r=<try>

[PERF] [rustdoc] Try to speed up search index building

Author: rust-bors[bot]

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

@@ -61,13 +61,15 @@ use rustc_middle::ty::print::PrintTraitRefExt;
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_span::symbol::{Symbol, sym};
 use rustc_span::{BytePos, DUMMY_SP, FileName, RealFileName};
+use serde::ser::SerializeSeq as _;
+use serde::{Deserialize, Serialize};
 use tracing::{debug, info};
 
 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;
@@ -144,7 +146,7 @@ pub(crate) struct IndexItem {
 }
 
 /// A type used for the search index.
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 struct RenderType {
     id: Option<RenderTypeId>,
     generics: Option<Vec<RenderType>>,
@@ -153,59 +155,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 +242,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 +286,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 +295,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)
@@ -301,7 +313,7 @@ impl RenderTypeId {
 }
 
 /// Full type of functions/methods in the search index.
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) struct IndexItemFunctionType {
     inputs: Vec<RenderType>,
     output: Vec<RenderType>,
@@ -311,13 +323,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 +379,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,50 +388,94 @@ 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);
+            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))
                 }
-                _ => {
-                    string.push('{');
-                    for item in &self.inputs[..] {
-                        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)?;
                 }
+                self.where_clause
+                    .iter()
+                    .map(|constraints| write_render_types(constraints))
+                    .joined("", f)?;
+
+                Ok(())
+            }))
+        }
+    }
+}
+
+impl Serialize for IndexItemFunctionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut seq = serializer.serialize_seq(Some(2))?;
+        seq.serialize_element(&self.write_to_string_without_param_names().to_string())?;
+
+        struct ParamNames<'a>(&'a [Option<Symbol>]);
+
+        impl<'a> Serialize for ParamNames<'a> {
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: serde::Serializer,
+            {
+                serializer.collect_seq(
+                    self.0
+                        .iter()
+                        .map(|symbol| symbol.as_ref().map(ToString::to_string).unwrap_or_default()),
+                )
             }
-            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('}');
-                }
+        }
+
+        seq.serialize_element(&ParamNames(&self.param_names))?;
+        seq.end()
+    }
+}
+
+impl<'de> Deserialize<'de> for IndexItemFunctionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        use serde::de::{self, Error as _};
+
+        struct FunctionDataVisitor;
+        impl<'de> de::Visitor<'de> for FunctionDataVisitor {
+            type Value = IndexItemFunctionType;
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> fmt::Result {
+                write!(formatter, "fn data")
             }
-            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('}');
-                }
+            fn visit_seq<A: de::SeqAccess<'de>>(self, mut v: A) -> Result<Self::Value, A::Error> {
+                let (mut function_signature, _) = v
+                    .next_element()?
+                    .map(|fn_: String| {
+                        IndexItemFunctionType::read_from_string_without_param_names(fn_.as_bytes())
+                    })
+                    .ok_or_else(|| A::Error::missing_field("function_signature"))?;
+                let param_names: Vec<Option<Symbol>> = v
+                    .next_element()?
+                    .map(|param_names: Vec<String>| {
+                        param_names
+                            .into_iter()
+                            .map(|symbol| {
+                                if symbol.is_empty() { None } else { Some(Symbol::intern(&symbol)) }
+                            })
+                            .collect()
+                    })
+                    .ok_or_else(|| A::Error::missing_field("param_names"))?;
+                function_signature.param_names = param_names;
+                Ok(function_signature)
             }
-            string.push('}');
         }
+        deserializer.deserialize_any(FunctionDataVisitor)
     }
 }