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
@@ -555,19 +559,19 @@ impl SerializedSearchIndex {
                 );
             }
         }
-        for (i, other_generic_inverted_index) in other.generic_inverted_index.iter().enumerate() {
-            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()
-                    }
-                };
-                while self_generic_inverted_index.len() <= size {
-                    self_generic_inverted_index.push(Vec::new());
-                }
-                self_generic_inverted_index[size].extend(
+        if other.generic_inverted_index.len() > self.generic_inverted_index.len() {
+            self.generic_inverted_index.resize(other.generic_inverted_index.len(), Vec::new());
+        }
+        for (other_generic_inverted_index, self_generic_inverted_index) in
+            iter::zip(&other.generic_inverted_index, &mut self.generic_inverted_index)
+        {
+            if other_generic_inverted_index.len() > self_generic_inverted_index.len() {
+                self_generic_inverted_index.resize(other_generic_inverted_index.len(), Vec::new());
+            }
+            for (other_list, self_list) in
+                iter::zip(other_generic_inverted_index, self_generic_inverted_index)
+            {
+                self_list.extend(
                     other_list
                         .iter()
                         .copied()
@@ -1819,20 +1823,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() {
@@ -1864,48 +1871,49 @@ pub(crate) fn build_index(
                 // unoccupied size.
                 if item.ty.is_fn_like() { 0 } else { 16 };
             serialized_index.function_data[new_entry_id] = Some(search_type.clone());
-            for index in used_in_function_inputs {
-                let postings = if index >= 0 {
-                    assert!(serialized_index.path_data[index as usize].is_some());
-                    &mut serialized_index.type_data[index as usize]
-                        .as_mut()
-                        .unwrap()
-                        .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());
+            fn process_used_in_function(
+                serialized_index: &mut SerializedSearchIndex,
+                search_type_size: usize,
+                new_entry_id: usize,
+                get_index: impl Fn(&mut TypeData) -> &mut Vec<Vec<u32>>,
+                used_in_function: BTreeSet<isize>,
+            ) {
+                for index in used_in_function {
+                    let postings = if index >= 0 {
+                        assert!(serialized_index.path_data[index as usize].is_some());
+                        get_index(serialized_index.type_data[index as usize].as_mut().unwrap())
+                    } else {
+                        let generic_id = usize::try_from(-index).unwrap() - 1;
+                        if generic_id >= serialized_index.generic_inverted_index.len() {
+                            serialized_index
+                                .generic_inverted_index
+                                .resize(generic_id + 1, Vec::new());
+                        }
+                        &mut serialized_index.generic_inverted_index[generic_id]
+                    };
+                    if search_type_size >= postings.len() {
+                        postings.resize(search_type_size + 1, 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);
-                }
-            }
-            for index in used_in_function_output {
-                let postings = if index >= 0 {
-                    assert!(serialized_index.path_data[index as usize].is_some());
-                    &mut serialized_index.type_data[index as usize]
-                        .as_mut()
-                        .unwrap()
-                        .inverted_function_output_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());
+                    let posting = &mut postings[search_type_size];
+                    if posting.last() != Some(&(new_entry_id as u32)) {
+                        posting.push(new_entry_id as u32);
                     }
-                    &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);
                 }
             }
+            process_used_in_function(
+                &mut serialized_index,
+                search_type_size,
+                new_entry_id,
+                |type_data| &mut type_data.inverted_function_inputs_index,
+                used_in_function_inputs,
+            );
+            process_used_in_function(
+                &mut serialized_index,
+                search_type_size,
+                new_entry_id,
+                |type_data| &mut type_data.inverted_function_output_index,
+                used_in_function_output,
+            );
         }
     }
 

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..];
         }