const generics for standalone fns (#7175)

## Description

This PR is part of #6860 and
allows standalone functions to have "const generics" like the code
below:

```sway
fn return_n<const NNN: u64>() -> u64 {
    NNN
}
```

## 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/function.rs

@@ -530,6 +530,7 @@ impl<'eng> FnCompiler<'eng> {
                     )
                 } else {
                     let function_decl = self.engines.de().get_function(fn_ref);
+
                     self.compile_fn_call(
                         context,
                         md_mgr,

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

@@ -12,6 +12,7 @@ use crate::{
     type_system::*,
     types::*,
 };
+use ast_elements::type_parameter::ConstGenericExpr;
 use monomorphization::MonomorphizeHelper;
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
@@ -74,14 +75,18 @@ impl DebugWithEngines for TyFunctionDecl {
                     self.type_parameters
                         .iter()
                         .map(|p| {
-                            let p = p
-                                .as_type_parameter()
-                                .expect("only works for type parameters");
-                            format!(
-                                "{:?} -> {:?}",
-                                engines.help_out(p.initial_type_id),
-                                engines.help_out(p.type_id)
-                            )
+                            match p {
+                                TypeParameter::Type(p) => {
+                                    format!(
+                                        "{:?} -> {:?}",
+                                        engines.help_out(p.initial_type_id),
+                                        engines.help_out(p.type_id)
+                                    )
+                                }
+                                TypeParameter::Const(p) => {
+                                    format!("{} -> {:?}", p.name, p.expr)
+                                }
+                            }
                         })
                         .collect::<Vec<_>>()
                         .join(", ")
@@ -150,6 +155,19 @@ impl MaterializeConstGenerics for TyFunctionDecl {
         name: &str,
         value: &TyExpression,
     ) -> Result<(), ErrorEmitted> {
+        for tp in self.type_parameters.iter_mut() {
+            match tp {
+                TypeParameter::Type(p) => p
+                    .type_id
+                    .materialize_const_generics(engines, handler, name, value)?,
+                TypeParameter::Const(p) if p.name.as_str() == name => {
+                    assert!(p.expr.is_none());
+                    p.expr = Some(ConstGenericExpr::from_ty_expression(handler, value)?);
+                }
+                _ => {}
+            }
+        }
+
         for param in self.parameters.iter_mut() {
             param
                 .type_argument
@@ -666,11 +684,17 @@ impl TyFunctionParameter {
     }
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum TyFunctionSigTypeParameter {
+    Type(TypeId),
+    Const(ConstGenericExpr),
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct TyFunctionSig {
     pub return_type: TypeId,
     pub parameters: Vec<TypeId>,
-    pub type_parameters: Vec<TypeId>,
+    pub type_parameters: Vec<TyFunctionSigTypeParameter>,
 }
 
 impl DisplayWithEngines for TyFunctionSig {
@@ -688,7 +712,11 @@ impl DebugWithEngines for TyFunctionSig {
                 "<{}>",
                 self.type_parameters
                     .iter()
-                    .map(|p| format!("{}", engines.help_out(p)))
+                    .map(|p| match p {
+                        TyFunctionSigTypeParameter::Type(t) => format!("{:?}", engines.help_out(t)),
+                        TyFunctionSigTypeParameter::Const(expr) =>
+                            format!("{:?}", engines.help_out(expr)),
+                    })
                     .collect::<Vec<_>>()
                     .join(", "),
             )
@@ -719,9 +747,16 @@ impl TyFunctionSig {
             type_parameters: fn_decl
                 .type_parameters
                 .iter()
-                .filter_map(|x| x.as_type_parameter())
-                .map(|p| p.type_id)
-                .collect::<Vec<_>>(),
+                .map(|x| match x {
+                    TypeParameter::Type(p) => TyFunctionSigTypeParameter::Type(p.type_id),
+                    TypeParameter::Const(p) => {
+                        let expr = ConstGenericExpr::AmbiguousVariableExpression {
+                            ident: p.name.clone(),
+                        };
+                        TyFunctionSigTypeParameter::Const(p.expr.clone().unwrap_or(expr))
+                    }
+                })
+                .collect(),
         }
     }
 
@@ -735,7 +770,11 @@ impl TyFunctionSig {
             && self
                 .type_parameters
                 .iter()
-                .all(|p| p.is_concrete(engines, TreatNumericAs::Concrete))
+                .filter_map(|x| match x {
+                    TyFunctionSigTypeParameter::Type(type_id) => Some(type_id),
+                    TyFunctionSigTypeParameter::Const(_) => None,
+                })
+                .all(|type_id| type_id.is_concrete(engines, TreatNumericAs::Concrete))
     }
 
     /// Returns a String representing the function.
@@ -749,7 +788,15 @@ impl TyFunctionSig {
                 "<{}>",
                 self.type_parameters
                     .iter()
-                    .map(|p| p.get_type_str(engines))
+                    .map(|x| match x {
+                        TyFunctionSigTypeParameter::Type(type_id) => type_id.get_type_str(engines),
+                        TyFunctionSigTypeParameter::Const(p) => {
+                            match p {
+                                ConstGenericExpr::Literal { val, .. } => val.to_string(),
+                                ConstGenericExpr::AmbiguousVariableExpression { .. } => todo!(),
+                            }
+                        }
+                    })
                     .collect::<Vec<_>>()
                     .join(", "),
             )

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

@@ -9,11 +9,14 @@ use sway_error::{
 use symbol_collection_context::SymbolCollectionContext;
 
 use crate::{
-    decl_engine::{parsed_id::ParsedDeclId, DeclId, DeclRefFunction},
+    decl_engine::{
+        parsed_id::ParsedDeclId, DeclEngineInsert as _, DeclId, DeclRefFunction,
+        ParsedDeclEngineGet as _,
+    },
     language::{
         parsed::*,
-        ty::{self, TyCodeBlock, TyFunctionDecl},
-        CallPath, Visibility,
+        ty::{self, ConstGenericDecl, TyCodeBlock, TyConstGenericDecl, TyDecl, TyFunctionDecl},
+        CallPath, CallPathType, Visibility,
     },
     semantic_analysis::*,
     type_system::*,
@@ -34,6 +37,22 @@ impl ty::TyFunctionDecl {
 
         // create a namespace for the function
         let _ = ctx.scoped(engines, fn_decl.span.clone(), Some(decl), |scoped_ctx| {
+            let const_generic_parameters = fn_decl
+                .type_parameters
+                .iter()
+                .filter_map(|x| x.as_const_parameter())
+                .filter_map(|x| x.id.as_ref());
+
+            for const_generic_parameter in const_generic_parameters {
+                let const_generic_decl = engines.pe().get(const_generic_parameter);
+                scoped_ctx.insert_parsed_symbol(
+                    handler,
+                    engines,
+                    const_generic_decl.name.clone(),
+                    Declaration::ConstGenericDeclaration(*const_generic_parameter),
+                )?;
+            }
+
             TyCodeBlock::collect(handler, engines, scoped_ctx, &fn_decl.body)
         });
         Ok(())
@@ -114,6 +133,36 @@ impl ty::TyFunctionDecl {
                     None,
                 )?;
 
+                // const generic parameters
+                let const_generic_parameters = type_parameters
+                    .iter()
+                    .filter_map(|x| x.as_const_parameter())
+                    .filter_map(|x| x.id.as_ref());
+                for const_generic_decl_id in const_generic_parameters {
+                    let const_generic_decl = ctx.engines.pe().get(const_generic_decl_id);
+                    let decl_ref = ctx.engines.de().insert(
+                        TyConstGenericDecl {
+                            call_path: CallPath {
+                                prefixes: vec![],
+                                suffix: const_generic_decl.name.clone(),
+                                callpath_type: CallPathType::Ambiguous,
+                            },
+                            span: const_generic_decl.span.clone(),
+                            return_type: const_generic_decl.ty,
+                            value: None,
+                        },
+                        Some(const_generic_decl_id),
+                    );
+
+                    ctx.insert_symbol(
+                        handler,
+                        const_generic_decl.name.clone(),
+                        TyDecl::ConstGenericDecl(ConstGenericDecl {
+                            decl_id: *decl_ref.id(),
+                        }),
+                    )?;
+                }
+
                 // type check the function parameters, which will also insert them into the namespace
                 let mut new_parameters = vec![];
                 handler.scope(|handler| {
@@ -212,10 +261,10 @@ impl ty::TyFunctionDecl {
 
                 // Insert the previously type checked type parameters into the current namespace.
                 // We insert all type parameter before the constraints because some constraints may depend on the parameters.
-                for p in type_parameters.iter().filter_map(|x| x.as_type_parameter()) {
+                for p in type_parameters.iter() {
                     p.insert_into_namespace_self(handler, ctx.by_ref())?;
                 }
-                for p in type_parameters.iter().filter_map(|x| x.as_type_parameter()) {
+                for p in type_parameters.iter() {
                     p.insert_into_namespace_constraints(handler, ctx.by_ref())?;
                 }
 

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

@@ -96,7 +96,6 @@ pub(crate) fn instantiate_function_application(
                 function_decl.name.as_str(),
                 &call_path_binding.span(),
             )?;
-
             function_decl.replace_decls(&decl_mapping, handler, &mut ctx)?;
         }
 

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

@@ -300,11 +300,7 @@ pub(crate) fn struct_instantiation(
         .scoped(handler, None, |scoped_ctx| {
             // Insert struct type parameter into namespace.
             // This is required so check_type_parameter_bounds can resolve generic trait type parameters.
-            for p in struct_decl
-                .generic_parameters
-                .iter()
-                .filter_map(|x| x.as_type_parameter())
-            {
+            for p in struct_decl.generic_parameters.iter() {
                 p.insert_into_namespace_self(handler, scoped_ctx.by_ref())?;
             }
 

sway-core/src/transform/to_parsed_lang/convert_parse_tree.rs

@@ -561,7 +561,7 @@ pub fn item_fn_to_function_declaration(
     let kind = override_kind.unwrap_or(kind);
     let implementing_type = context.implementing_type.clone();
 
-    let generic_parameters = generic_params_opt_to_type_parameters_with_parent(
+    let mut generic_parameters = generic_params_opt_to_type_parameters_with_parent(
         context,
         handler,
         engines,
@@ -571,6 +571,19 @@ pub fn item_fn_to_function_declaration(
         parent_where_clause_opt,
     )?;
 
+    for p in generic_parameters.iter_mut() {
+        match p {
+            TypeParameter::Type(_) => {}
+            TypeParameter::Const(p) => {
+                p.id = Some(engines.pe().insert(ConstGenericDeclaration {
+                    name: p.name.clone(),
+                    ty: p.ty,
+                    span: p.span.clone(),
+                }));
+            }
+        }
+    }
+
     let fn_decl = FunctionDeclaration {
         purity: attributes.purity(),
         attributes,

sway-core/src/type_system/ast_elements/binding.rs

@@ -319,6 +319,7 @@ impl TypeCheckTypeBinding<ty::TyFunctionDecl> for TypeBinding<CallPath> {
         let fn_ref = unknown_decl.to_fn_ref(handler, ctx.engines())?;
         // Get a new copy from the declaration engine.
         let mut new_copy = (*decl_engine.get_function(fn_ref.id())).clone();
+
         match self.type_arguments {
             // Monomorphize the copy, in place.
             TypeArgs::Regular(_) => {
@@ -352,6 +353,7 @@ impl TypeCheckTypeBinding<ty::TyFunctionDecl> for TypeBinding<CallPath> {
                 decl_engine.get_parsed_decl_id(fn_ref.id()).as_ref(),
             )
             .with_parent(ctx.engines.de(), fn_ref.id().into());
+
         Ok((new_fn_ref, None, None))
     }
 }