Add parallel processing to forc-doc using rayon to improve performance (#7296)

## Description
Key changes:
  - Parallelize document rendering and link generation
- Add type aliases for complex nested types (`DocLinkMap`, `ModuleMap`,
`RenderResult`)
  - Remove unnecessary wrapper functions and clones

The parallel processing maintains insertion order through sequential
merging, ensuring identical documentation output.

Not sure why the codspeed report isn't showing this below but when I run
`cargo bench` locally i'm seeing these results.

| Metric | Before | After | Improvement |
|--------|--------|-------|-------------|
| build_std_lib_docs | 70.069 ms | 43.227 ms | **43.2% faster** |

## Checklist

- [ ] I have linked to any relevant issues.
- [x] I have commented my code, particularly in hard-to-understand
areas.
- [ ] I have updated the documentation where relevant (API docs, the
reference, and the Sway book).
- [ ] If my change requires substantial documentation changes, I have
[requested support from the DevRel
team](https://github.com/FuelLabs/devrel-requests/issues/new/choose)
- [ ] I have added tests that prove my fix is effective or that my
feature works.
- [ ] I have added (or requested a maintainer to add) the necessary
`Breaking*` or `New Feature` labels where relevant.
- [x] I have done my best to ensure that my PR adheres to [the Fuel Labs
Code Review
Standards](https://github.com/FuelLabs/rfcs/blob/master/text/code-standards/external-contributors.md).
- [x] I have requested a review from the relevant team or maintainers.

Author: JoshuaBatty

Cargo.lock

@@ -19,6 +19,7 @@ horrorshow.workspace = true
 include_dir.workspace = true
 minifier.workspace = true
 opener.workspace = true
+rayon.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 sway-ast.workspace = true

forc-plugins/forc-doc/Cargo.toml

@@ -27,7 +27,7 @@ trait RequiredMethods {
 impl RequiredMethods for Vec<DeclRefTraitFn> {
     fn to_methods(&self, decl_engine: &DeclEngine) -> Vec<TyTraitFn> {
         self.iter()
-            .map(|decl_ref| (*decl_engine.get_trait_fn(decl_ref)).clone())
+            .map(|decl_ref| decl_engine.get_trait_fn(decl_ref).as_ref().clone())
             .collect()
     }
 }
@@ -371,7 +371,7 @@ impl Descriptor {
                     module_info,
                     ty: DocumentableType::Primitive(type_info.clone()),
                     item_name: item_name.clone(),
-                    code_str: item_name.clone().to_string(),
+                    code_str: item_name.to_string(),
                     attrs_opt: attrs_opt.clone(),
                     item_context: Default::default(),
                 },

forc-plugins/forc-doc/src/doc/descriptor.rs

@@ -14,6 +14,7 @@ use crate::{
     },
 };
 use anyhow::Result;
+use rayon::prelude::*;
 use std::{
     collections::HashMap,
     ops::{Deref, DerefMut},
@@ -80,14 +81,24 @@ impl Documentation {
             .collect::<HashMap<BaseIdent, ModuleInfo>>();
 
         // Add one documentation page for each primitive type that has an implementation.
-        for (impl_trait, module_info) in impl_traits.iter() {
-            let impl_for_type = engines.te().get(impl_trait.implementing_for.type_id());
-            if let Ok(Descriptor::Documentable(doc)) =
-                Descriptor::from_type_info(impl_for_type.as_ref(), engines, module_info.clone())
-            {
-                if !docs.contains(&doc) {
-                    docs.push(doc);
+        let primitive_docs: Vec<_> = impl_traits
+            .par_iter()
+            .filter_map(|(impl_trait, module_info)| {
+                let impl_for_type = engines.te().get(impl_trait.implementing_for.type_id());
+                if let Ok(Descriptor::Documentable(doc)) =
+                    Descriptor::from_type_info(impl_for_type.as_ref(), engines, module_info.clone())
+                {
+                    Some(doc)
+                } else {
+                    None
                 }
+            })
+            .collect();
+
+        // Add unique primitive docs
+        for doc in primitive_docs {
+            if !docs.contains(&doc) {
+                docs.push(doc);
             }
         }
 
@@ -103,7 +114,7 @@ impl Documentation {
                 DocumentableType::Declared(TyDecl::StructDecl(_))
                 | DocumentableType::Declared(TyDecl::EnumDecl(_))
                 | DocumentableType::Primitive(_) => {
-                    let item_name = doc.item_header.item_name.clone();
+                    let item_name = &doc.item_header.item_name;
                     for (impl_trait, _) in impl_traits.iter_mut() {
                         // Check if this implementation is for this struct/enum.
                         if item_name.as_str()
@@ -157,13 +168,23 @@ impl Documentation {
         document_private_items: bool,
         experimental: ExperimentalFeatures,
     ) -> Result<()> {
-        for ast_node in &ty_module.all_nodes {
-            if let TyAstNodeContent::Declaration(ref decl) = ast_node.content {
+        let results: Result<Vec<_>, anyhow::Error> = ty_module
+            .all_nodes
+            .par_iter()
+            .filter_map(|ast_node| {
+                if let TyAstNodeContent::Declaration(ref decl) = ast_node.content {
+                    Some(decl)
+                } else {
+                    None
+                }
+            })
+            .map(|decl| {
                 if let TyDecl::ImplSelfOrTrait(impl_trait) = decl {
-                    impl_traits.push((
+                    let impl_data = (
                         (*decl_engine.get_impl_self_or_trait(&impl_trait.decl_id)).clone(),
                         module_info.clone(),
-                    ));
+                    );
+                    Ok((Some(impl_data), None))
                 } else {
                     let desc = Descriptor::from_typed_decl(
                         decl_engine,
@@ -173,10 +194,21 @@ impl Documentation {
                         experimental,
                     )?;
 
-                    if let Descriptor::Documentable(doc) = desc {
-                        docs.push(doc);
-                    }
+                    let doc = match desc {
+                        Descriptor::Documentable(doc) => Some(doc),
+                        Descriptor::NonDocumentable => None,
+                    };
+                    Ok((None, doc))
                 }
+            })
+            .collect();
+
+        for (impl_trait_opt, doc_opt) in results? {
+            if let Some(impl_trait) = impl_trait_opt {
+                impl_traits.push(impl_trait);
+            }
+            if let Some(doc) = doc_opt {
+                docs.push(doc);
             }
         }
 

forc-plugins/forc-doc/src/doc/mod.rs

@@ -16,6 +16,13 @@ use sway_types::BaseIdent;
 
 use super::documentable_type::DocumentableType;
 
+// Asset file names to avoid repeated string formatting
+const SWAY_LOGO_FILE: &str = "sway-logo.svg";
+const NORMALIZE_CSS_FILE: &str = "normalize.css";
+const SWAYDOC_CSS_FILE: &str = "swaydoc.css";
+const AYU_CSS_FILE: &str = "ayu.css";
+const AYU_MIN_CSS_FILE: &str = "ayu.min.css";
+
 /// All necessary components to render the header portion of
 /// the item html doc.
 #[derive(Clone, Debug)]
@@ -33,15 +40,16 @@ impl Renderable for ItemHeader {
             item_name,
         } = self;
 
-        let favicon =
-            module_info.to_html_shorthand_path_string(&format!("{ASSETS_DIR_NAME}/sway-logo.svg"));
-        let normalize =
-            module_info.to_html_shorthand_path_string(&format!("{ASSETS_DIR_NAME}/normalize.css"));
-        let swaydoc =
-            module_info.to_html_shorthand_path_string(&format!("{ASSETS_DIR_NAME}/swaydoc.css"));
-        let ayu = module_info.to_html_shorthand_path_string(&format!("{ASSETS_DIR_NAME}/ayu.css"));
-        let ayu_hjs =
-            module_info.to_html_shorthand_path_string(&format!("{ASSETS_DIR_NAME}/ayu.min.css"));
+        let favicon = module_info
+            .to_html_shorthand_path_string(&format!("{ASSETS_DIR_NAME}/{SWAY_LOGO_FILE}"));
+        let normalize = module_info
+            .to_html_shorthand_path_string(&format!("{ASSETS_DIR_NAME}/{NORMALIZE_CSS_FILE}"));
+        let swaydoc = module_info
+            .to_html_shorthand_path_string(&format!("{ASSETS_DIR_NAME}/{SWAYDOC_CSS_FILE}"));
+        let ayu =
+            module_info.to_html_shorthand_path_string(&format!("{ASSETS_DIR_NAME}/{AYU_CSS_FILE}"));
+        let ayu_hjs = module_info
+            .to_html_shorthand_path_string(&format!("{ASSETS_DIR_NAME}/{AYU_MIN_CSS_FILE}"));
 
         Ok(box_html! {
             head {

forc-plugins/forc-doc/src/render/item/components.rs

@@ -67,16 +67,16 @@ pub(crate) fn render_type_anchor(
             let enum_decl = render_plan.engines.de().get_enum(&decl_id);
             if !render_plan.document_private_items && enum_decl.visibility.is_private() {
                 Ok(box_html! {
-                    : enum_decl.name().clone().as_str();
+                    : enum_decl.name().as_str();
                 })
             } else {
                 let module_info = ModuleInfo::from_call_path(&enum_decl.call_path);
-                let file_name = format!("enum.{}.html", enum_decl.name().clone().as_str());
+                let file_name = format!("enum.{}.html", enum_decl.name().as_str());
                 let href =
                     module_info.file_path_from_location(&file_name, current_module_info, false)?;
                 Ok(box_html! {
                     a(class="enum", href=href) {
-                        : enum_decl.name().clone().as_str();
+                        : enum_decl.name().as_str();
                     }
                 })
             }
@@ -85,16 +85,16 @@ pub(crate) fn render_type_anchor(
             let struct_decl = render_plan.engines.de().get_struct(&decl_id);
             if !render_plan.document_private_items && struct_decl.visibility.is_private() {
                 Ok(box_html! {
-                    : struct_decl.name().clone().as_str();
+                    : struct_decl.name().as_str();
                 })
             } else {
                 let module_info = ModuleInfo::from_call_path(&struct_decl.call_path);
-                let file_name = format!("struct.{}.html", struct_decl.name().clone().as_str());
+                let file_name = format!("struct.{}.html", struct_decl.name().as_str());
                 let href =
                     module_info.file_path_from_location(&file_name, current_module_info, false)?;
                 Ok(box_html! {
                     a(class="struct", href=href) {
-                        : struct_decl.name().clone().as_str();
+                        : struct_decl.name().as_str();
                     }
                 })
             }

forc-plugins/forc-doc/src/render/item/type_anchor.rs

@@ -14,6 +14,7 @@ use crate::{
 };
 use anyhow::Result;
 use horrorshow::{box_html, helper::doctype, html, prelude::*};
+use rayon::prelude::*;
 use std::{
     collections::BTreeMap,
     ops::{Deref, DerefMut},
@@ -33,6 +34,10 @@ pub const ALL_DOC_FILENAME: &str = "all.html";
 pub const INDEX_FILENAME: &str = "index.html";
 pub const IDENTITY: &str = "#";
 
+type DocLinkMap = BTreeMap<BlockTitle, Vec<DocLink>>;
+type ModuleMap = BTreeMap<ModulePrefixes, DocLinkMap>;
+type RenderResult = (RenderedDocument, ModuleMap, DocLinks);
+
 /// Something that can be rendered to HTML.
 pub(crate) trait Renderable {
     fn render(self, render_plan: RenderPlan) -> Result<Box<dyn RenderBox>>;
@@ -90,19 +95,36 @@ impl RenderedDocumentation {
             style: DocStyle::AllDoc(program_kind.as_title_str().to_string()),
             links: BTreeMap::default(),
         };
-        let mut module_map: BTreeMap<ModulePrefixes, BTreeMap<BlockTitle, Vec<DocLink>>> =
-            BTreeMap::new();
-        for doc in raw_docs.0 {
-            rendered_docs
-                .0
-                .push(RenderedDocument::from_doc(&doc, render_plan.clone())?);
+        // Parallel document rendering
+        let rendered_results: Result<Vec<RenderResult>, anyhow::Error> = raw_docs
+            .0
+            .par_iter()
+            .map(|doc| {
+                let rendered_doc = RenderedDocument::from_doc(doc, render_plan.clone())?;
+                let mut local_module_map = ModuleMap::new();
+                let mut local_all_docs = DocLinks {
+                    style: DocStyle::AllDoc(program_kind.as_title_str().to_string()),
+                    links: BTreeMap::default(),
+                };
+
+                populate_decls(doc, &mut local_module_map);
+                populate_modules(doc, &mut local_module_map);
+                populate_doc_links(doc, &mut local_all_docs.links);
+
+                Ok((rendered_doc, local_module_map, local_all_docs))
+            })
+            .collect();
 
-            // Here we gather all of the `doc_links` based on which module they belong to.
-            populate_decls(&doc, &mut module_map);
-            // Create links to child modules.
-            populate_modules(&doc, &mut module_map);
-            // Above we check for the module a link belongs to, here we want _all_ links so the check is much more shallow.
-            populate_all_doc(&doc, &mut all_docs);
+        // Merge results sequentially
+        let mut module_map = ModuleMap::new();
+        for (rendered_doc, local_module_map, local_all_docs) in rendered_results? {
+            rendered_docs.0.push(rendered_doc);
+
+            for (key, value) in local_module_map {
+                module_map.entry(key).or_default().extend(value);
+            }
+
+            all_docs.links.extend(local_all_docs.links);
         }
 
         // ProjectIndex
@@ -199,7 +221,8 @@ impl DerefMut for RenderedDocumentation {
     }
 }
 
-fn populate_doc_links(doc: &Document, doc_links: &mut BTreeMap<BlockTitle, Vec<DocLink>>) {
+/// Adds a document's link to the appropriate category in the doc links map.
+fn populate_doc_links(doc: &Document, doc_links: &mut DocLinkMap) {
     let key = doc.item_body.ty.as_block_title();
     match doc_links.get_mut(&key) {
         Some(links) => links.push(doc.link()),
@@ -208,23 +231,19 @@ fn populate_doc_links(doc: &Document, doc_links: &mut BTreeMap<BlockTitle, Vec<D
         }
     }
 }
-fn populate_decls(
-    doc: &Document,
-    module_map: &mut BTreeMap<ModulePrefixes, BTreeMap<BlockTitle, Vec<DocLink>>>,
-) {
+/// Organizes document links by module prefix for navigation.
+fn populate_decls(doc: &Document, module_map: &mut ModuleMap) {
     let module_prefixes = &doc.module_info.module_prefixes;
     if let Some(doc_links) = module_map.get_mut(module_prefixes) {
         populate_doc_links(doc, doc_links)
     } else {
-        let mut doc_links: BTreeMap<BlockTitle, Vec<DocLink>> = BTreeMap::new();
+        let mut doc_links = DocLinkMap::new();
         populate_doc_links(doc, &mut doc_links);
         module_map.insert(module_prefixes.clone(), doc_links);
     }
 }
-fn populate_modules(
-    doc: &Document,
-    module_map: &mut BTreeMap<ModulePrefixes, BTreeMap<BlockTitle, Vec<DocLink>>>,
-) {
+/// Creates links to parent modules for hierarchical navigation.
+fn populate_modules(doc: &Document, module_map: &mut ModuleMap) {
     let mut module_clone = doc.module_info.clone();
     while module_clone.parent().is_some() {
         let html_filename = if module_clone.depth() > 2 {
@@ -257,16 +276,13 @@ fn populate_modules(
                 }
             }
         } else {
-            let mut doc_links: BTreeMap<BlockTitle, Vec<DocLink>> = BTreeMap::new();
+            let mut doc_links = DocLinkMap::new();
             doc_links.insert(BlockTitle::Modules, vec![module_link]);
             module_map.insert(module_prefixes.clone(), doc_links);
         }
         module_clone.module_prefixes.pop();
     }
 }
-fn populate_all_doc(doc: &Document, all_docs: &mut DocLinks) {
-    populate_doc_links(doc, &mut all_docs.links);
-}
 
 /// The finalized HTML file contents.
 #[derive(Debug)]