AbiDecode for arrays using const_generics (#7008)

## Description

This is part of #6860.

This completes abi encoding for arrays. Allowing arrays of any size as
inputs and outputs in predicates/scripts/contracts.
This PR also allows arrays to be initialized with "const generics" such
as:

```sway
#[cfg(experimental_const_generics = true)]
impl<T, const N: u64> AbiDecode for [T; N]
where
    T: AbiDecode,
{
    fn abi_decode(ref mut buffer: BufferReader) -> [T; N] {
        let first: T = buffer.decode::<T>();
        let mut array = [first; N];  // <-------------------- This can used now
        ...
        array
    }
}
```` 


## Checklist

- [x] 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)
- [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.

Author: xunilrj

sway-core/src/ir_generation/const_eval.rs

@@ -308,8 +308,9 @@ fn const_eval_typed_expr(
     }
 
     Ok(match &expr.expression {
-        ty::TyExpressionVariant::ConstGenericExpression { .. } => {
-            todo!("Will be implemented by https://github.com/FuelLabs/sway/issues/6860")
+        ty::TyExpressionVariant::ConstGenericExpression { decl, .. } => {
+            assert!(decl.value.is_some());
+            const_eval_typed_expr(lookup, known_consts, decl.value.as_ref().unwrap())?
         }
         ty::TyExpressionVariant::Literal(Literal::Numeric(n)) => {
             let implied_lit = match &*lookup.engines.te().get(expr.return_type) {

sway-core/src/ir_generation/function.rs

@@ -3679,8 +3679,8 @@ impl<'eng> FnCompiler<'eng> {
         context: &mut Context,
         md_mgr: &mut MetadataManager,
         elem_type: TypeId,
-        value: &ty::TyExpression,
-        length: &ty::TyExpression,
+        value_expr: &ty::TyExpression,
+        length_expr: &ty::TyExpression,
         span_md_idx: Option<MetadataIndex>,
     ) -> Result<TerminatorValue, CompileError> {
         let elem_type = convert_resolved_typeid_no_span(
@@ -3690,7 +3690,17 @@ impl<'eng> FnCompiler<'eng> {
             elem_type,
         )?;
 
-        let length_as_u64 = length.as_literal_u64().unwrap();
+        let length_as_u64 = compile_constant_expression_to_constant(
+            self.engines,
+            context,
+            md_mgr,
+            self.module,
+            None,
+            Some(self),
+            length_expr,
+        )?;
+        // SAFETY: Safe by the type-checking, that only allows u64 as the array length
+        let length_as_u64 = length_as_u64.get_content(context).as_uint().unwrap();
         let array_type = Type::new_array(context, elem_type, length_as_u64);
 
         let temp_name = self.lexical_map.insert_anon();
@@ -3705,7 +3715,7 @@ impl<'eng> FnCompiler<'eng> {
             .add_metadatum(context, span_md_idx);
 
         let value_value = return_on_termination_or_extract!(
-            self.compile_expression_to_value(context, md_mgr, value)?
+            self.compile_expression_to_value(context, md_mgr, value_expr)?
         );
 
         if length_as_u64 > 5 {

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

@@ -147,13 +147,14 @@ impl MaterializeConstGenerics for TyAstNode {
         name: &str,
         value: &TyExpression,
     ) -> Result<(), ErrorEmitted> {
-        match self.content {
-            TyAstNodeContent::Declaration(_) => Ok(()),
-            TyAstNodeContent::Expression(ref mut expr) => {
+        match &mut self.content {
+            TyAstNodeContent::Declaration(TyDecl::VariableDecl(decl)) => decl
+                .body
+                .materialize_const_generics(engines, handler, name, value),
+            TyAstNodeContent::Expression(expr) => {
                 expr.materialize_const_generics(engines, handler, name, value)
             }
-            TyAstNodeContent::SideEffect(_) => Ok(()),
-            TyAstNodeContent::Error(_, _) => Ok(()),
+            _ => Ok(()),
         }
     }
 }

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

@@ -1,10 +1,8 @@
 use crate::{
-    //decl_engine::MaterializeConstGenerics,
     decl_engine::MaterializeConstGenerics,
     language::{parsed::ConstGenericDeclaration, ty::TyExpression, CallPath},
     semantic_analysis::{TypeCheckAnalysis, TypeCheckAnalysisContext},
-    SubstTypes,
-    TypeId,
+    SubstTypes, TypeId,
 };
 use serde::{Deserialize, Serialize};
 use sway_error::handler::{ErrorEmitted, Handler};

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

@@ -150,7 +150,9 @@ impl MaterializeConstGenerics for TyFunctionDecl {
                 .type_id
                 .materialize_const_generics(engines, handler, name, value)?;
         }
-
+        self.return_type
+            .type_id
+            .materialize_const_generics(engines, handler, name, value)?;
         self.body
             .materialize_const_generics(engines, handler, name, value)
     }

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

@@ -416,6 +416,18 @@ impl MaterializeConstGenerics for TyExpression {
             TyExpressionVariant::Literal(_) | TyExpressionVariant::VariableExpression { .. } => {
                 Ok(())
             }
+            TyExpressionVariant::ArrayRepeat {
+                elem_type,
+                value: elem_value,
+                length,
+            } => {
+                elem_type.materialize_const_generics(engines, handler, name, value)?;
+                elem_value.materialize_const_generics(engines, handler, name, value)?;
+                length.materialize_const_generics(engines, handler, name, value)
+            }
+            TyExpressionVariant::Ref(r) => {
+                r.materialize_const_generics(engines, handler, name, value)
+            }
             _ => Err(handler.emit_err(
                 sway_error::error::CompileError::ConstGenericNotSupportedHere {
                     span: self.span.clone(),
@@ -730,13 +742,6 @@ impl TyExpression {
         }
     }
 
-    pub(crate) fn as_literal_u64(&self) -> Option<u64> {
-        match &self.expression {
-            TyExpressionVariant::Literal(Literal::U64(v)) => Some(*v),
-            _ => None,
-        }
-    }
-
     pub fn as_intrinsic(&self) -> Option<&TyIntrinsicFunctionKind> {
         match &self.expression {
             TyExpressionVariant::IntrinsicFunction(v) => Some(v),

sway-core/src/language/ty/expression/expression_variant.rs

@@ -52,7 +52,7 @@ pub enum TyExpressionVariant {
     ConstGenericExpression {
         span: Span,
         decl: Box<TyConstGenericDecl>,
-        call_path: Option<CallPath>,
+        call_path: CallPath,
     },
     VariableExpression {
         name: Ident,

sway-core/src/semantic_analysis/ast_node/expression/typed_expression.rs

@@ -703,11 +703,11 @@ impl ty::TyExpression {
                     expression: ty::TyExpressionVariant::ConstGenericExpression {
                         decl: Box::new(decl),
                         span: name.span(),
-                        call_path: Some(CallPath {
+                        call_path: CallPath {
                             prefixes: vec![],
                             suffix: name.clone(),
                             callpath_type: CallPathType::Ambiguous,
-                        }),
+                        },
                     },
                     span,
                 }
@@ -2046,6 +2046,12 @@ impl ty::TyExpression {
             _ => TypeInfo::Unknown,
         };
         let elem_type = type_engine.insert(engines, elem_type, None);
+        let elem_type_arg = TypeArgument {
+            type_id: elem_type,
+            initial_type_id: elem_type,
+            span: span.clone(),
+            call_path_tree: None,
+        };
 
         let value_ctx = ctx
             .by_ref()
@@ -2058,17 +2064,27 @@ impl ty::TyExpression {
             .by_ref()
             .with_help_text("")
             .with_type_annotation(type_engine.id_of_u64());
-        let length = Self::type_check(handler, length_ctx, length)
+        let length_expr = Self::type_check(handler, length_ctx, length)
             .unwrap_or_else(|err| ty::TyExpression::error(err, span.clone(), engines));
-        let length_u64 = length.as_literal_u64().unwrap() as usize;
+        let length = match &length_expr.expression {
+            TyExpressionVariant::Literal(Literal::U64(val)) => Length::Literal {
+                val: *val as usize,
+                span: span.clone(),
+            },
+            TyExpressionVariant::ConstGenericExpression { call_path, .. } => {
+                Length::AmbiguousVariableExpression {
+                    ident: call_path.suffix.clone(),
+                }
+            }
+            _ => return Err(handler.emit_err(CompileError::ConstGenericNotSupportedHere { span })),
+        };
 
-        let return_type =
-            type_engine.insert_array_without_annotations(engines, elem_type, length_u64);
+        let return_type = type_engine.insert_array(engines, elem_type_arg, length);
         Ok(ty::TyExpression {
             expression: ty::TyExpressionVariant::ArrayRepeat {
                 elem_type,
                 value: Box::new(value),
-                length: Box::new(length),
+                length: Box::new(length_expr),
             },
             return_type,
             span,

sway-lib-std/generate.sh

@@ -21,7 +21,7 @@ remove_generated_code "ARRAY_DECODE"
 START=1
 END=64
 for ((i=END;i>=START;i--)); do
-    CODE="impl<T> AbiDecode for [T; $i] where T: AbiDecode { fn abi_decode(ref mut buffer: BufferReader) -> [T; $i] { let first: T = buffer.decode::<T>(); let mut array = [first; $i]; let mut i = 1; while i < $i { array[i] = buffer.decode::<T>(); i += 1; }; array } }"
+    CODE="#[cfg(experimental_const_generics = false)]\nimpl<T> AbiDecode for [T; $i] where T: AbiDecode { fn abi_decode(ref mut buffer: BufferReader) -> [T; $i] { let first: T = buffer.decode::<T>(); let mut array = [first; $i]; let mut i = 1; while i < $i { array[i] = buffer.decode::<T>(); i += 1; }; array } }"
     sed -i "s/\/\/ BEGIN ARRAY_DECODE/\/\/ BEGIN ARRAY_DECODE\n$CODE/g" ./src/codec.sw
 done