Improve array decode (#7342)

## Description

Continuation of #6860.

This PR implements multiple small features focusing on improving
`AbiDecode` for arrays.

1 - Before this PR, the implementation of `AbiDecode` for arrays was
decoding the first element and creating a "repeat array" with it.
Depending on the array length, the initialisation would be five `store`s
or a loop copying the first item over all slots.

Now we create a "repeat array" of zeros of the required size. This will
be initialised with just one `MCLI`/`MCL`. And then we transmute this
into the desired array type.

The final `ASM` is still far from ideal. But will improve with future
optimizations.

```
pshl i15                      ; save registers 16..40
pshh i524288                  ; save registers 40..64
move $$locbase $sp            ; save locals base register for function transmute_by_reference_7
cfei i144                     ; allocate 144 bytes for locals and 0 slots for call arguments
move $r0 $$arg0               ; save argument 0 (__ret_value)
move $r1 $$reta               ; save return address
mcli $$locbase i64            ; clear memory [u8; 64], 64 bytes
addi $r2 $$locbase i72        ; get offset to local __ptr [u8; 64]
mcpi $r2 $$locbase i64        ; copy memory
addi $r2 $$locbase i72        ; get offset to local __ptr [u8; 64]
addi $r3 $$locbase i64        ; get offset to local __ptr __ptr [u8; 64]
sw   $$locbase $r2 i8         ; store word
addi $r2 $$locbase i136       ; get offset to local __ptr __ptr u256
mcpi $r2 $r3 i8               ; copy memory
lw   $r2 $$locbase i17        ; load word
mcpi $r0 $r2 i32              ; copy memory
move $$retv $r0               ; set return value
cfsi i144                     ; free 144 bytes for locals and 0 slots for extra call arguments
move $$reta $r1               ; restore return address
poph i524288                  ; restore registers 40..64
popl i15                      ; restore registers 16..40
jal  $zero $$reta i0          ; return from call
```

2 - Array lengths can now be specified using `const` variables.

One limitation is that these lengths must be limited to simple `const`
variables, local or global, but associated `consts` are still not
working.
Another limitation is that we can't unify arrays lengths that use
variables and literals. For example: `let _: [u64; 1] = [0u64; A]`;

```sway
const GLOBAL_A: u64 = 1;
#[inline(never)]
fn arrays_with_const_length() {
    const A = 1;
    const B = A + 1;

    let _ = [0u64; A];
    let _: [u64; A] = [0u64];
    let _ = [0u64; GLOBAL_A];

    let _ = [0u64; B];
    let _: [u64; B] = [0u64, 1u64];
}
```

3 - `const` declarations can now use `const generics` in their
expressions.

```sway
#[inline(never)]
fn const_with_const_generics<const B: u64>() {
    const A: u64 = B + 1;
    __dbg(A);
}
```

4 - `__transmute` can now transmute references.

```sway
fn transmute_by_reference() -> u256 {
    let mut bytes = [0u8; 32];
    let v: &mut u256 = __transmute::<&mut [u8; 32], &mut u256>(&mut bytes);
    *v
}
```

5 - Snapshot tests now support a "filter-fn" command, which will parse
the compiler output and focus on the specified fns. This will help by
eliminating clutter from the snapshots.

Its first argument is the project that we want to filter, and the second
is a comma-separated list of all function names we want.

In the example below, `{name}` is the name of the project where the
`snapshot.toml` lives.

```toml
cmds = [
    "forc build --path {root} --ir final --asm final | filter-fn {name} transmute_by_reference_7",
]
```

## convert_resolved_type_info

One of the biggest changes was that `convert_resolved_type_info` needs
access to the "context" that is being compiled, as types can include
expressions. At the moment, only `const variables` and `const generics
variables`. But soon enough, we will be able to write more complex
expressions, and we will need full access to available symbols.

## Checklist

- [ ] 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)
- [ ] 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.
- [ ] 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).
- [ ] I have requested a review from the relevant team or maintainers.

Author: xunilrj

sway-core/src/asm_generation/fuel/fuel_asm_builder.rs

@@ -1351,7 +1351,10 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                             byte_offs,
                             instr_reg.clone(),
                             Some(&base_reg),
-                            "get offset to local",
+                            format!(
+                                "get offset to local {}",
+                                local_var.get_type(self.context).as_string(self.context)
+                            ),
                             owning_span,
                         );
                     }

sway-core/src/decl_engine/id.rs

@@ -2,8 +2,8 @@ use crate::{
     decl_engine::*,
     engine_threading::*,
     language::ty::{
-        TyDeclParsedType, TyEnumDecl, TyFunctionDecl, TyImplSelfOrTrait, TyStructDecl, TyTraitDecl,
-        TyTraitFn, TyTraitType, TyTypeAliasDecl,
+        TyConstantDecl, TyDeclParsedType, TyEnumDecl, TyFunctionDecl, TyImplSelfOrTrait,
+        TyStructDecl, TyTraitDecl, TyTraitFn, TyTraitType, TyTypeAliasDecl,
     },
     type_system::*,
 };
@@ -240,6 +240,19 @@ impl SubstTypes for DeclId<TyTraitType> {
     }
 }
 
+impl SubstTypes for DeclId<TyConstantDecl> {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        let decl_engine = ctx.engines.de();
+        let mut decl = (*decl_engine.get(self)).clone();
+        if decl.subst(ctx).has_changes() {
+            decl_engine.replace(*self, decl);
+            HasChanges::Yes
+        } else {
+            HasChanges::No
+        }
+    }
+}
+
 impl<T> DeclId<T>
 where
     DeclEngine: DeclEngineIndex<T> + DeclEngineInsert<T> + DeclEngineGetParsedDeclId<T>,

sway-core/src/ir_generation/compile.rs

@@ -364,9 +364,11 @@ pub(crate) fn compile_configurables(
             let decl = engines.de().get(decl_id);
 
             let ty = convert_resolved_type_id(
-                engines.te(),
-                engines.de(),
+                engines,
                 context,
+                md_mgr,
+                module,
+                None,
                 decl.type_ascription.type_id(),
                 &decl.type_ascription.span(),
             )
@@ -577,9 +579,6 @@ fn compile_fn(
     test_decl_ref: Option<DeclRefFunction>,
     cache: &mut CompiledFunctionCache,
 ) -> Result<Function, Vec<CompileError>> {
-    let type_engine = engines.te();
-    let decl_engine = engines.de();
-
     let inline = ast_fn_decl.inline();
     let trace = ast_fn_decl.trace();
     let ty::TyFunctionDecl {
@@ -615,9 +614,11 @@ fn compile_fn(
         .map(|param| {
             // Convert to an IR type.
             convert_resolved_type_id(
-                type_engine,
-                decl_engine,
+                engines,
                 context,
+                md_mgr,
+                module,
+                None,
                 param.type_argument.type_id(),
                 &param.type_argument.span(),
             )
@@ -643,9 +644,11 @@ fn compile_fn(
         .map_err(|err| vec![err])?;
 
     let ret_type = convert_resolved_type_id(
-        type_engine,
-        decl_engine,
+        engines,
         context,
+        md_mgr,
+        module,
+        None,
         return_type.type_id(),
         &return_type.span(),
     )

sway-core/src/ir_generation/const_eval.rs

@@ -265,7 +265,6 @@ fn create_array_from_vec(
     element_types: Vec<crate::TypeId>,
     element_vals: Vec<Constant>,
 ) -> Option<Constant> {
-    let te = lookup.engines.te();
     assert!({
         let unify_check = UnifyCheck::coercion(lookup.engines);
         element_types
@@ -274,9 +273,10 @@ fn create_array_from_vec(
     });
 
     let arr = create_array_aggregate(
-        te,
-        lookup.engines.de(),
+        lookup.engines,
         lookup.context,
+        lookup.md_mgr,
+        lookup.module,
         elem_type,
         element_types.len().try_into().unwrap(),
     )
@@ -357,22 +357,15 @@ fn const_eval_typed_expr(
 
             res?
         }
-        ty::TyExpressionVariant::ConstantExpression {
-            decl: const_decl, ..
-        } => {
-            let call_path = &const_decl.call_path;
+        ty::TyExpressionVariant::ConstantExpression { decl, .. } => {
+            let call_path = &decl.call_path;
             let name = &call_path.suffix;
-
             match known_consts.get(name) {
-                // 1. Check if name/call_path is in known_consts.
-                Some(cvs) => Some(*cvs),
-                None => {
-                    // 2. Check if name is a global constant.
-                    (lookup.lookup)(lookup, call_path, &Some(*const_decl.clone()))
-                        .ok()
-                        .flatten()
-                        .and_then(|v| v.get_constant(lookup.context).cloned())
-                }
+                Some(constant) => Some(*constant),
+                None => (lookup.lookup)(lookup, call_path, &Some(*decl.clone()))
+                    .ok()
+                    .flatten()
+                    .and_then(|v| v.get_constant(lookup.context).cloned()),
             }
         }
         ty::TyExpressionVariant::ConfigurableExpression { span, .. } => {
@@ -419,9 +412,10 @@ fn const_eval_typed_expr(
             assert!(field_vals.len() == fields.len());
 
             get_struct_for_types(
-                lookup.engines.te(),
-                lookup.engines.de(),
+                lookup.engines,
                 lookup.context,
+                lookup.md_mgr,
+                lookup.module,
                 &field_types,
             )
             .map_or(None, |struct_ty| {
@@ -456,9 +450,10 @@ fn const_eval_typed_expr(
             assert!(field_vals.len() == fields.len());
 
             create_tuple_aggregate(
-                lookup.engines.te(),
-                lookup.engines.de(),
+                lookup.engines,
                 lookup.context,
+                lookup.md_mgr,
+                lookup.module,
                 &field_types,
             )
             .map_or(None, |tuple_ty| {
@@ -525,9 +520,10 @@ fn const_eval_typed_expr(
         } => {
             let enum_decl = lookup.engines.de().get_enum(enum_ref);
             let aggregate = create_tagged_union_type(
-                lookup.engines.te(),
-                lookup.engines.de(),
+                lookup.engines,
                 lookup.context,
+                lookup.md_mgr,
+                lookup.module,
                 &enum_decl.variants,
             );
 
@@ -1177,9 +1173,11 @@ fn const_eval_intrinsic(
         Intrinsic::SizeOfType => {
             let targ = &intrinsic.type_arguments[0];
             let ir_type = convert_resolved_type_id(
-                lookup.engines.te(),
-                lookup.engines.de(),
+                lookup.engines,
                 lookup.context,
+                lookup.md_mgr,
+                lookup.module,
+                lookup.function_compiler,
                 targ.type_id(),
                 &targ.span(),
             )
@@ -1195,9 +1193,11 @@ fn const_eval_intrinsic(
             let val = &intrinsic.arguments[0];
             let type_id = val.return_type;
             let ir_type = convert_resolved_type_id(
-                lookup.engines.te(),
-                lookup.engines.de(),
+                lookup.engines,
                 lookup.context,
+                lookup.md_mgr,
+                lookup.module,
+                lookup.function_compiler,
                 type_id,
                 &val.span,
             )
@@ -1211,9 +1211,11 @@ fn const_eval_intrinsic(
         Intrinsic::SizeOfStr => {
             let targ = &intrinsic.type_arguments[0];
             let ir_type = convert_resolved_type_id(
-                lookup.engines.te(),
-                lookup.engines.de(),
+                lookup.engines,
                 lookup.context,
+                lookup.md_mgr,
+                lookup.module,
+                lookup.function_compiler,
                 targ.type_id(),
                 &targ.span(),
             )
@@ -1229,9 +1231,11 @@ fn const_eval_intrinsic(
         Intrinsic::AssertIsStrArray => {
             let targ = &intrinsic.type_arguments[0];
             let ir_type = convert_resolved_type_id(
-                lookup.engines.te(),
-                lookup.engines.de(),
+                lookup.engines,
                 lookup.context,
+                lookup.md_mgr,
+                lookup.module,
+                lookup.function_compiler,
                 targ.type_id(),
                 &targ.span(),
             )
@@ -1547,19 +1551,23 @@ fn const_eval_intrinsic(
         Intrinsic::Transmute => {
             let src_type = &intrinsic.type_arguments[0];
             let src_ir_type = convert_resolved_type_id(
-                lookup.engines.te(),
-                lookup.engines.de(),
+                lookup.engines,
                 lookup.context,
+                lookup.md_mgr,
+                lookup.module,
+                lookup.function_compiler,
                 src_type.type_id(),
                 &src_type.span(),
             )
             .unwrap();
 
             let dst_type = &intrinsic.type_arguments[1];
             let dst_ir_type = convert_resolved_type_id(
-                lookup.engines.te(),
-                lookup.engines.de(),
+                lookup.engines,
                 lookup.context,
+                lookup.md_mgr,
+                lookup.module,
+                lookup.function_compiler,
                 dst_type.type_id(),
                 &dst_type.span(),
             )