Auto merge of #149149 - yotamofek:wip/rustdoc/search_index/misc-cleanups, r=<try>

[WIP] [rustdoc] misc search index cleanups

Author: rust-bors[bot]

src/librustdoc/html/render/search_index.rs

@@ -3,9 +3,9 @@ mod serde;
 
 use std::collections::BTreeSet;
 use std::collections::hash_map::Entry;
-use std::io;
 use std::path::Path;
 use std::string::FromUtf8Error;
+use std::{io, iter};
 
 use ::serde::de::{self, Deserializer, Error as _};
 use ::serde::ser::{SerializeSeq, Serializer};
@@ -256,10 +256,14 @@ impl SerializedSearchIndex {
     /// The returned ID can be used to attach more data to the search result.
     fn add_entry(&mut self, name: Symbol, entry_data: EntryData, desc: String) -> usize {
         let fqp = if let Some(module_path_index) = entry_data.module_path {
-            let mut fqp = self.path_data[module_path_index].as_ref().unwrap().module_path.clone();
-            fqp.push(Symbol::intern(&self.names[module_path_index]));
-            fqp.push(name);
-            fqp
+            self.path_data[module_path_index]
+                .as_ref()
+                .unwrap()
+                .module_path
+                .iter()
+                .copied()
+                .chain([Symbol::intern(&self.names[module_path_index]), name])
+                .collect()
         } else {
             vec![name]
         };
@@ -306,13 +310,13 @@ impl SerializedSearchIndex {
 
     pub(crate) fn union(mut self, other: &SerializedSearchIndex) -> SerializedSearchIndex {
         let other_entryid_offset = self.names.len();
-        let mut map_other_pathid_to_self_pathid: Vec<usize> = Vec::new();
+        let mut map_other_pathid_to_self_pathid = Vec::with_capacity(other.path_data.len());
         let mut skips = FxHashSet::default();
         for (other_pathid, other_path_data) in other.path_data.iter().enumerate() {
             if let Some(other_path_data) = other_path_data {
-                let mut fqp = other_path_data.module_path.clone();
                 let name = Symbol::intern(&other.names[other_pathid]);
-                fqp.push(name);
+                let fqp =
+                    other_path_data.module_path.iter().copied().chain(iter::once(name)).collect();
                 let self_pathid = other_entryid_offset + other_pathid;
                 let self_pathid = match self.crate_paths_index.entry((other_path_data.ty, fqp)) {
                     Entry::Vacant(slot) => {
@@ -458,7 +462,7 @@ impl SerializedSearchIndex {
                     other.descs[other_entryid].clone(),
                     other.function_data[other_entryid].clone().map(|mut func| {
                         fn map_fn_sig_item(
-                            map_other_pathid_to_self_pathid: &mut Vec<usize>,
+                            map_other_pathid_to_self_pathid: &Vec<usize>,
                             ty: &mut RenderType,
                         ) {
                             match ty.id {
@@ -501,14 +505,14 @@ impl SerializedSearchIndex {
                             }
                         }
                         for input in &mut func.inputs {
-                            map_fn_sig_item(&mut map_other_pathid_to_self_pathid, input);
+                            map_fn_sig_item(&map_other_pathid_to_self_pathid, input);
                         }
                         for output in &mut func.output {
-                            map_fn_sig_item(&mut map_other_pathid_to_self_pathid, output);
+                            map_fn_sig_item(&map_other_pathid_to_self_pathid, output);
                         }
                         for clause in &mut func.where_clause {
                             for entry in clause {
-                                map_fn_sig_item(&mut map_other_pathid_to_self_pathid, entry);
+                                map_fn_sig_item(&map_other_pathid_to_self_pathid, entry);
                             }
                         }
                         func
@@ -559,14 +563,9 @@ impl SerializedSearchIndex {
             for (size, other_list) in other_generic_inverted_index.iter().enumerate() {
                 let self_generic_inverted_index = match self.generic_inverted_index.get_mut(i) {
                     Some(self_generic_inverted_index) => self_generic_inverted_index,
-                    None => {
-                        self.generic_inverted_index.push(Vec::new());
-                        self.generic_inverted_index.last_mut().unwrap()
-                    }
+                    None => self.generic_inverted_index.push_mut(Vec::new()),
                 };
-                while self_generic_inverted_index.len() <= size {
-                    self_generic_inverted_index.push(Vec::new());
-                }
+                self_generic_inverted_index.resize(size, Vec::new());
                 self_generic_inverted_index[size].extend(
                     other_list
                         .iter()
@@ -1819,20 +1818,23 @@ pub(crate) fn build_index(
                     tcx,
                 );
             }
-            let mut used_in_constraints = Vec::new();
-            for constraint in &mut search_type.where_clause {
-                let mut used_in_constraint = BTreeSet::new();
-                for trait_ in &mut constraint[..] {
-                    convert_render_type(
-                        trait_,
-                        cache,
-                        &mut serialized_index,
-                        &mut used_in_constraint,
-                        tcx,
-                    );
-                }
-                used_in_constraints.push(used_in_constraint);
-            }
+            let used_in_constraints = search_type
+                .where_clause
+                .iter_mut()
+                .map(|constraint| {
+                    let mut used_in_constraint = BTreeSet::new();
+                    for trait_ in constraint {
+                        convert_render_type(
+                            trait_,
+                            cache,
+                            &mut serialized_index,
+                            &mut used_in_constraint,
+                            tcx,
+                        );
+                    }
+                    used_in_constraint
+                })
+                .collect::<Vec<_>>();
             loop {
                 let mut inserted_any = false;
                 for (i, used_in_constraint) in used_in_constraints.iter().enumerate() {
@@ -1873,16 +1875,14 @@ pub(crate) fn build_index(
                         .inverted_function_inputs_index
                 } else {
                     let generic_id = usize::try_from(-index).unwrap() - 1;
-                    for _ in serialized_index.generic_inverted_index.len()..=generic_id {
-                        serialized_index.generic_inverted_index.push(Vec::new());
-                    }
+                    serialized_index.generic_inverted_index.resize(generic_id, Vec::new());
                     &mut serialized_index.generic_inverted_index[generic_id]
                 };
-                while postings.len() <= search_type_size {
-                    postings.push(Vec::new());
-                }
-                if postings[search_type_size].last() != Some(&(new_entry_id as u32)) {
-                    postings[search_type_size].push(new_entry_id as u32);
+                // FIXME(yotamofek): last item should have capacity of 1
+                postings.resize(search_type_size, Vec::new());
+                let posting = &mut postings[search_type_size];
+                if posting.last() != Some(&(new_entry_id as u32)) {
+                    posting.push(new_entry_id as u32);
                 }
             }
             for index in used_in_function_output {
@@ -1899,11 +1899,11 @@ pub(crate) fn build_index(
                     }
                     &mut serialized_index.generic_inverted_index[generic_id]
                 };
-                while postings.len() <= search_type_size {
-                    postings.push(Vec::new());
-                }
-                if postings[search_type_size].last() != Some(&(new_entry_id as u32)) {
-                    postings[search_type_size].push(new_entry_id as u32);
+                // FIXME(yotamofek): last item should have capacity of 1
+                postings.resize(search_type_size, Vec::new());
+                let posting = &mut postings[search_type_size];
+                if posting.last() != Some(&(new_entry_id as u32)) {
+                    posting.push(new_entry_id as u32);
                 }
             }
         }

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

@@ -52,6 +52,9 @@ pub fn read_signed_vlqhex_from_string(string: &[u8]) -> Option<(i32, usize)> {
 }
 
 pub fn write_postings_to_string(postings: &[Vec<u32>], buf: &mut Vec<u8>) {
+    // there's gonna be at least 1 byte pushed for every posting
+    buf.reserve(postings.len());
+
     for list in postings {
         if list.is_empty() {
             buf.push(0);
@@ -63,29 +66,22 @@ pub fn write_postings_to_string(postings: &[Vec<u32>], buf: &mut Vec<u8>) {
         if len_after - len_before > 1 + (4 * list.len()) && list.len() < 0x3a {
             buf.truncate(len_before);
             buf.push(list.len() as u8);
-            for &item in list {
-                buf.push(item as u8);
-                buf.push((item >> 8) as u8);
-                buf.push((item >> 16) as u8);
-                buf.push((item >> 24) as u8);
-            }
+            buf.extend(list.iter().copied().map(u32::to_le_bytes).flatten());
         }
     }
 }
 
 pub fn read_postings_from_string(postings: &mut Vec<Vec<u32>>, mut buf: &[u8]) {
     use stringdex::internals::decode::RoaringBitmap;
-    while let Some(&c) = buf.get(0) {
+    while let Some(&c) = buf.first() {
         if c < 0x3a {
             buf = &buf[1..];
             let buf = buf.split_off(..usize::from(c) * size_of::<u32>()).unwrap();
             let (chunks, _) = buf.as_chunks();
             let slot = chunks.iter().copied().map(u32::from_le_bytes).collect();
             postings.push(slot);
         } else {
-            let (bitmap, consumed_bytes_len) =
-                RoaringBitmap::from_bytes(buf).unwrap_or_else(|| (RoaringBitmap::default(), 0));
-            assert_ne!(consumed_bytes_len, 0);
+            let (bitmap, consumed_bytes_len) = RoaringBitmap::from_bytes(buf).unwrap();
             postings.push(bitmap.to_vec());
             buf = &buf[consumed_bytes_len..];
         }

src/librustdoc/lib.rs

@@ -15,6 +15,7 @@
 #![feature(iter_advance_by)]
 #![feature(iter_intersperse)]
 #![feature(iter_order_by)]
+#![feature(push_mut)]
 #![feature(rustc_private)]
 #![feature(test)]
 #![feature(trim_prefix_suffix)]