Sway compiler optimizations (#7080)

## Description

This PR is a prequel to #7015.

`Debug` trait auto-implementation is causing some performance issues. So
this PR will try to compensate by doing the following optimizations:

1 - `filter_dummy_methods` is cloning `TyFunctionDecl` needlessly.
Another small optimization is that instead of calling
`ConcurrentSlab::get(...)` and cloning and dropping an `Arc`. There is a
new `ConcurrentSlab::map(...)` method that avoids all that.

2 - A lot of time was being spent on `node_dependencies`. One the
primary wastes was hashing nodes multiple times. To avoid that, each
node will "memoize" its own hash, and a `Hasher` that does nothing is
being used. This means that each node's hash will only be calculated
once.

3 - The third optimization is a little bit more polemic. It involved the
fact that we clone `TyFunctionDecl` a LOT. And some fields are more
expensive than others, for example, `body`, `parameters` and
`constraints`. To alleviate these excessive clonings, these fields are
now behind an `Arc` (because LSP need them to be thread safe), and there
is a "COW` mechanism specifically for them when they need mutation.

## Detailed analysis

The first step is to compile `forc` and run Valgrind. My analysis was
done using the debug build; values may vary on the release build, of
course.

```
cd test/src/e2e_vm_tests/test_programs/should_pass/language/intrinsics/transmute
cargo r -p for
valgrind --tool=callgrind --dump-instr=yes --simulate-cache=yes --collect-jumps=yes /home/xunilrj/github/sway/target/debug/forc build
```

The first that caught my attention was a function called
`filter_dummy_methods` that is called around 150k times. Inside of it,
there is a useless call to `TyFunctinDecl::clone()`. If Valgrind is
correct, this `clone` is spending 10% of the compilation. This explains
the first optimization.


![image](https://github.com/user-attachments/assets/712def8a-d57f-417e-a8f0-63a9a547ed47)

Another 20% of the time is spent inside `order_ast_nodes_by_dependency`.


![image](https://github.com/user-attachments/assets/bd5f3a1d-5e42-4130-ba41-5e592033ca75)

Inside this function, there is a function called
`recursively_depends_on` that corresponds to 10% of the compilation, and
more than half of it is spent hashing nodes. This explains the second
optimization.


![image](https://github.com/user-attachments/assets/ab691d78-e691-4fd6-a2e7-6cd8d7d0c469)

Another source of waste is the amount of `TyFunctionDecl::clone` that we
call. It amounts to 12% of the compilation time. The problem is that it
is much harder to remove/optimize these clones.

I assume that a lot of these clones are not needed. One of the reasons
is the way `SubtsType` and other monomorphization mechanisms were built;
we first need to clone something, and then we try to mutate the cloned
version. I don´t have a number, but I imagine in a lot of cases, the
cloning and the mutation were not needed. **Maybe someone can come up
with a test to see if we can avoid cloning/mutation. I bet that this
will increase performance tremendously.**


![image](https://github.com/user-attachments/assets/650ae7ff-dc1e-4817-8af1-894df820b90c)

But what I did was I chose all the fields that are costly to be cloned:
`body`, `parameters`, `call_path`, `type_parameters`, `return_type`, and
`where_clause`; and I put them behind an `Arc`. If my assumption is
correct, making them cheap to be cloned will improve performance because
we will just clone their `Arc`, and never mutate them.

Unfortunately, there is no easy way to avoid cloning in some cases. For
example, when monomorphizing, our algorithms don´t know "from the
outside" that a `body` will never change, and we trigger the COW
mechanism and end up cloning the item inside the `Arc`, even when we
don´t need it.


![image](https://github.com/user-attachments/assets/2ac9aa4c-ea89-4515-ae6f-52fea61f0ff1)

## Checklist

- [x] I have linked to any relevant issues.
- [ ] 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)
- [x] 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.

---------

Co-authored-by: IGI-111 <[email protected]>

Author: xunilrj

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

@@ -614,7 +614,7 @@ impl Renderable for TyFunctionDecl {
         let attributes = self.attributes.to_html_string();
 
         let mut fn_sig = format!("fn {}(", self.name.as_str());
-        for param in &self.parameters {
+        for param in self.parameters.iter() {
             let mut param_str = String::new();
             if param.is_reference {
                 write!(param_str, "ref ")?;
@@ -651,7 +651,7 @@ impl Renderable for TyFunctionDecl {
                             }
                             : "(";
                             @ if multiline {
-                                @ for param in &self.parameters {
+                                @ for param in self.parameters.iter() {
                                     br;
                                     : "    ";
                                     @ if param.is_reference {
@@ -672,7 +672,7 @@ impl Renderable for TyFunctionDecl {
                                 br;
                                 : ")";
                             } else {
-                                @ for param in &self.parameters {
+                                @ for param in self.parameters.iter() {
                                     @ if param.is_reference {
                                         : "ref";
                                     }

sway-core/src/concurrent_slab.rs

@@ -115,6 +115,15 @@ where
             .clone()
     }
 
+    /// Improve performance by avoiding `Arc::clone`.
+    /// The slab is kept locked while running `f`.
+    pub fn map<R>(&self, index: usize, f: impl FnOnce(&T) -> R) -> R {
+        let inner = self.inner.read();
+        f(inner.items[index]
+            .as_ref()
+            .expect("invalid slab index for ConcurrentSlab::get"))
+    }
+
     pub fn retain(&self, predicate: impl Fn(&usize, &mut Arc<T>) -> bool) {
         let mut inner = self.inner.write();
 

sway-core/src/control_flow_analysis/dead_code_analysis.rs

@@ -1099,7 +1099,7 @@ fn connect_fn_params_struct_enums<'eng: 'cfg, 'cfg>(
     fn_decl_entry_node: NodeIndex,
 ) -> Result<(), CompileError> {
     let type_engine = engines.te();
-    for fn_param in &fn_decl.parameters {
+    for fn_param in fn_decl.parameters.iter() {
         let ty = type_engine.to_typeinfo(
             fn_param.type_argument.type_id(),
             &fn_param.type_argument.span(),

sway-core/src/decl_engine/engine.rs

@@ -121,6 +121,7 @@ impl Clone for DeclEngine {
 
 pub trait DeclEngineGet<I, U> {
     fn get(&self, index: &I) -> Arc<U>;
+    fn map<R>(&self, index: &I, f: impl FnOnce(&U) -> R) -> R;
 }
 
 pub trait DeclEngineGetParsedDeclId<T>
@@ -175,12 +176,20 @@ macro_rules! decl_engine_get {
             fn get(&self, index: &DeclId<$decl>) -> Arc<$decl> {
                 self.$slab.get(index.inner())
             }
+
+            fn map<R>(&self, index: &DeclId<$decl>, f: impl FnOnce(&$decl) -> R) -> R {
+                self.$slab.map(index.inner(), f)
+            }
         }
 
         impl DeclEngineGet<DeclRef<DeclId<$decl>>, $decl> for DeclEngine {
             fn get(&self, index: &DeclRef<DeclId<$decl>>) -> Arc<$decl> {
                 self.$slab.get(index.id().inner())
             }
+
+            fn map<R>(&self, index: &DeclRef<DeclId<$decl>>, f: impl FnOnce(&$decl) -> R) -> R {
+                self.$slab.map(index.id().inner(), f)
+            }
         }
     };
 }

sway-core/src/decl_engine/parsed_engine.rs

@@ -35,6 +35,7 @@ pub struct ParsedDeclEngine {
 
 pub trait ParsedDeclEngineGet<I, U> {
     fn get(&self, index: &I) -> Arc<U>;
+    fn map<R>(&self, index: &I, f: impl FnOnce(&U) -> R) -> R;
 }
 
 pub trait ParsedDeclEngineInsert<T> {
@@ -58,6 +59,10 @@ macro_rules! decl_engine_get {
             fn get(&self, index: &ParsedDeclId<$decl>) -> Arc<$decl> {
                 self.$slab.get(index.inner())
             }
+
+            fn map<R>(&self, index: &ParsedDeclId<$decl>, f: impl FnOnce(&$decl) -> R) -> R {
+                self.$slab.map(index.inner(), f)
+            }
         }
     };
 }

sway-core/src/decl_engine/replace_decls.rs

@@ -30,6 +30,24 @@ pub trait ReplaceDecls {
     }
 }
 
+impl<T: ReplaceDecls + Clone> ReplaceDecls for std::sync::Arc<T> {
+    fn replace_decls_inner(
+        &mut self,
+        decl_mapping: &DeclMapping,
+        handler: &Handler,
+        ctx: &mut TypeCheckContext,
+    ) -> Result<bool, ErrorEmitted> {
+        if let Some(item) = std::sync::Arc::get_mut(self) {
+            item.replace_decls_inner(decl_mapping, handler, ctx)
+        } else {
+            let mut item = self.as_ref().clone();
+            let r = item.replace_decls_inner(decl_mapping, handler, ctx)?;
+            *self = std::sync::Arc::new(item);
+            Ok(r)
+        }
+    }
+}
+
 pub(crate) trait ReplaceFunctionImplementingType {
     fn replace_implementing_type(&mut self, engines: &Engines, implementing_type: ty::TyDecl);
 }
@@ -38,6 +56,18 @@ pub(crate) trait UpdateConstantExpression {
     fn update_constant_expression(&mut self, engines: &Engines, implementing_type: &TyDecl);
 }
 
+impl<T: UpdateConstantExpression + Clone> UpdateConstantExpression for std::sync::Arc<T> {
+    fn update_constant_expression(&mut self, engines: &Engines, implementing_type: &TyDecl) {
+        if let Some(item) = std::sync::Arc::get_mut(self) {
+            item.update_constant_expression(engines, implementing_type);
+        } else {
+            let mut item = self.as_ref().clone();
+            item.update_constant_expression(engines, implementing_type);
+            *self = std::sync::Arc::new(item);
+        }
+    }
+}
+
 // Iterate the tree searching for references to a const generic,
 // and initialize its value with the passed value
 pub(crate) trait MaterializeConstGenerics {
@@ -49,3 +79,22 @@ pub(crate) trait MaterializeConstGenerics {
         value: &TyExpression,
     ) -> Result<(), ErrorEmitted>;
 }
+
+impl<T: MaterializeConstGenerics + Clone> MaterializeConstGenerics for std::sync::Arc<T> {
+    fn materialize_const_generics(
+        &mut self,
+        engines: &Engines,
+        handler: &Handler,
+        name: &str,
+        value: &TyExpression,
+    ) -> Result<(), ErrorEmitted> {
+        if let Some(item) = std::sync::Arc::get_mut(self) {
+            item.materialize_const_generics(engines, handler, name, value)
+        } else {
+            let mut item = self.as_ref().clone();
+            let r = item.materialize_const_generics(engines, handler, name, value);
+            *self = std::sync::Arc::new(item);
+            r
+        }
+    }
+}

sway-core/src/language/ty/declaration/function.rs

@@ -437,7 +437,7 @@ impl TyFunctionDecl {
         TyFunctionDecl {
             purity: *purity,
             name: name.clone(),
-            body: TyCodeBlock::default(),
+            body: <_>::default(),
             implementing_type: None,
             implementing_for_typeid: None,
             span: span.clone(),

sway-core/src/language/ty/program.rs

@@ -49,7 +49,7 @@ fn get_type_not_allowed_error(
 
 fn check_no_ref_main(engines: &Engines, handler: &Handler, main_function: &DeclId<TyFunctionDecl>) {
     let main_function = engines.de().get_function(main_function);
-    for param in &main_function.parameters {
+    for param in main_function.parameters.iter() {
         if param.is_reference && param.is_mutable {
             handler.emit_err(CompileError::RefMutableNotAllowedInMain {
                 param_name: param.name.clone(),

sway-core/src/semantic_analysis/ast_node/declaration/abi.rs

@@ -203,7 +203,7 @@ impl ty::TyAbiDecl {
                     )
                     .unwrap_or_else(|_| ty::TyFunctionDecl::error(&method));
                     error_on_shadowing_superabi_method(&method.name, ctx);
-                    for param in &method.parameters {
+                    for param in method.parameters.iter() {
                         if param.is_reference || param.is_mutable {
                             handler.emit_err(CompileError::RefMutableNotAllowedInContractAbi {
                                 param_name: param.name.clone(),

sway-core/src/semantic_analysis/ast_node/declaration/function.rs

@@ -163,7 +163,7 @@ impl ty::TyFunctionDecl {
 
                 let function_decl = ty::TyFunctionDecl {
                     name: name.clone(),
-                    body: TyCodeBlock::default(),
+                    body: <_>::default(),
                     parameters: new_parameters,
                     implementing_type: None,
                     implementing_for_typeid,
@@ -220,7 +220,7 @@ impl ty::TyFunctionDecl {
                 }
 
                 // Insert the previously type checked function parameters into the current namespace.
-                for p in parameters {
+                for p in parameters.iter() {
                     p.insert_into_namespace(handler, ctx.by_ref());
                 }
 

sway-core/src/semantic_analysis/ast_node/declaration/impl_trait.rs

@@ -1318,7 +1318,7 @@ fn type_check_impl_method(
         for (impl_method_signature_param, impl_method_param) in impl_method_signature
             .parameters
             .iter_mut()
-            .zip(&mut impl_method.parameters)
+            .zip(impl_method.parameters.iter_mut())
         {
             // TODO use trait constraints as part of the type here to
             // implement trait constraint solver */

sway-core/src/semantic_analysis/ast_node/declaration/trait_fn.rs

@@ -103,7 +103,7 @@ impl ty::TyTraitFn {
         ty::TyFunctionDecl {
             purity: self.purity,
             name: self.name.clone(),
-            body: ty::TyCodeBlock::default(),
+            body: <_>::default(),
             parameters: self.parameters.clone(),
             implementing_type: match abi_mode.clone() {
                 AbiMode::ImplAbiFn(_abi_name, abi_decl_id) => {

sway-core/src/semantic_analysis/namespace/trait_map.rs

@@ -701,7 +701,9 @@ impl TraitMap {
                                 *type_id,
                                 *map_type_id,
                                 engines,
-                            ),
+                            )
+                            .map(|(name, item)| (name.to_string(), item))
+                            .collect(),
                             engines,
                         );
                     }
@@ -711,49 +713,51 @@ impl TraitMap {
         trait_map
     }
 
-    fn filter_dummy_methods(
-        map_trait_items: &TraitItems,
+    fn filter_dummy_methods<'a>(
+        map_trait_items: &'a TraitItems,
         type_id: TypeId,
         map_type_id: TypeId,
-        engines: &Engines,
-    ) -> TraitItems {
-        let mut insertable = true;
-        if let TypeInfo::UnknownGeneric {
-            is_from_type_parameter,
-            ..
-        } = *engines.te().get(map_type_id)
-        {
-            insertable = !is_from_type_parameter
-                || matches!(*engines.te().get(type_id), TypeInfo::UnknownGeneric { .. });
-        }
+        engines: &'a Engines,
+    ) -> impl Iterator<Item = (&'a str, ResolvedTraitImplItem)> + 'a {
+        let maybe_is_from_type_parameter = engines.te().map(map_type_id, |x| match x {
+            TypeInfo::UnknownGeneric {
+                is_from_type_parameter,
+                ..
+            } => Some(*is_from_type_parameter),
+            _ => None,
+        });
+        let insertable = if let Some(is_from_type_parameter) = maybe_is_from_type_parameter {
+            !is_from_type_parameter
+                || matches!(*engines.te().get(type_id), TypeInfo::UnknownGeneric { .. })
+        } else {
+            true
+        };
 
         map_trait_items
             .iter()
-            .filter_map(|(name, item)| match item {
+            .filter_map(move |(name, item)| match item {
                 ResolvedTraitImplItem::Parsed(_item) => todo!(),
                 ResolvedTraitImplItem::Typed(item) => match item {
-                    ty::TyTraitItem::Fn(decl_ref) => {
-                        let decl = (*engines.de().get(decl_ref.id())).clone();
+                    ty::TyTraitItem::Fn(decl_ref) => engines.de().map(decl_ref.id(), |decl| {
                         if decl.is_trait_method_dummy && !insertable {
                             None
                         } else {
                             Some((
-                                name.clone(),
+                                name.as_str(),
                                 ResolvedTraitImplItem::Typed(TyImplItem::Fn(decl_ref.clone())),
                             ))
                         }
-                    }
+                    }),
                     ty::TyTraitItem::Constant(decl_ref) => Some((
-                        name.clone(),
+                        name.as_str(),
                         ResolvedTraitImplItem::Typed(TyImplItem::Constant(decl_ref.clone())),
                     )),
                     ty::TyTraitItem::Type(decl_ref) => Some((
-                        name.clone(),
+                        name.as_str(),
                         ResolvedTraitImplItem::Typed(TyImplItem::Type(decl_ref.clone())),
                     )),
                 },
             })
-            .collect()
     }
 
     fn make_item_for_type_mapping(
@@ -859,9 +863,7 @@ impl TraitMap {
                             entry.key.type_id,
                             engines,
                         )
-                        .values()
-                        .cloned()
-                        .map(|i| (i, entry.key.clone()))
+                        .map(|(_, i)| (i, entry.key.clone()))
                         .collect::<Vec<_>>();
 
                         items.extend(trait_items);
@@ -1019,9 +1021,7 @@ impl TraitMap {
                             e.key.type_id,
                             engines,
                         )
-                        .values()
-                        .cloned()
-                        .map(|i| {
+                        .map(|(_, i)| {
                             Self::make_item_for_type_mapping(
                                 engines,
                                 i,