Forbid const generics on abis (#7483)

## Description

This PR forbids "const generics" on `abi`s. The reason is that to
correctly support it, we will need to introduce changes to the ABI json.

This will be reserved to the future.

## 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)
- [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.

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> <sup>[Cursor Bugbot](https://cursor.com/dashboard?tab=bugbot) is
generating a summary for commit
1bf3210. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: xunilrj

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

@@ -1,12 +1,18 @@
 use super::{TyDeclParsedType, TyTraitInterfaceItem, TyTraitItem};
 use crate::{
+    ast_elements::type_parameter::ConstGenericExpr,
+    decl_engine::DeclEngineGet as _,
     engine_threading::*,
     language::parsed::{self, AbiDeclaration},
     transform,
     type_system::*,
 };
 use serde::{Deserialize, Serialize};
 use std::hash::{Hash, Hasher};
+use sway_error::{
+    error::CompileError,
+    handler::{ErrorEmitted, Handler},
+};
 use sway_types::{Ident, Named, Span, Spanned};
 
 /// A [TyAbiDecl] contains the type-checked version of the parse tree's
@@ -23,6 +29,133 @@ pub struct TyAbiDecl {
     pub attributes: transform::Attributes,
 }
 
+fn has_const_generics(type_id: TypeId, engines: &Engines) -> bool {
+    let types = type_id.extract_any_including_self(engines, &|_| true, vec![], 0);
+
+    for (t, _) in types {
+        let t = engines.te().get(t);
+        match &*t {
+            TypeInfo::StringArray(length) => match length.expr() {
+                ConstGenericExpr::Literal { .. } => {}
+                ConstGenericExpr::AmbiguousVariableExpression { .. } => return true,
+            },
+            TypeInfo::Enum(decl_id) => {
+                let decl = engines.de().get(decl_id);
+                let any_const_generics = decl
+                    .generic_parameters
+                    .iter()
+                    .any(|x| x.as_const_parameter().is_some());
+                if any_const_generics {
+                    return true;
+                }
+            }
+            TypeInfo::Struct(decl_id) => {
+                let decl = engines.de().get(decl_id);
+                let any_const_generics = decl
+                    .generic_parameters
+                    .iter()
+                    .any(|x| x.as_const_parameter().is_some());
+                if any_const_generics {
+                    return true;
+                }
+
+                for field in decl.fields.iter() {
+                    let any_const_generics =
+                        has_const_generics(field.type_argument.type_id, engines);
+                    if any_const_generics {
+                        return true;
+                    }
+                }
+            }
+            TypeInfo::Tuple(items) => {
+                for item in items {
+                    let any_const_generics = has_const_generics(item.type_id, engines);
+                    if any_const_generics {
+                        return true;
+                    }
+                }
+            }
+            TypeInfo::Array(item, length) => {
+                let any_const_generics = has_const_generics(item.type_id, engines);
+                if any_const_generics {
+                    return true;
+                }
+
+                match length.expr() {
+                    ConstGenericExpr::Literal { .. } => {}
+                    ConstGenericExpr::AmbiguousVariableExpression { .. } => return true,
+                }
+            }
+            _ => {}
+        }
+    }
+
+    false
+}
+
+impl TyAbiDecl {
+    pub(crate) fn forbid_const_generics(
+        &self,
+        handler: &Handler,
+        engines: &Engines,
+    ) -> Result<(), ErrorEmitted> {
+        for item in self.interface_surface.iter() {
+            match item {
+                TyTraitInterfaceItem::TraitFn(decl_ref) => {
+                    let decl = engines.de().get(decl_ref.id());
+
+                    if has_const_generics(decl.return_type.type_id, engines) {
+                        let err = handler.emit_err(CompileError::ConstGenericNotSupportedHere {
+                            span: decl.return_type.span(),
+                        });
+                        return Err(err);
+                    }
+
+                    for arg in decl.parameters.iter() {
+                        if has_const_generics(arg.type_argument.type_id, engines) {
+                            let err =
+                                handler.emit_err(CompileError::ConstGenericNotSupportedHere {
+                                    span: arg.type_argument.span.clone(),
+                                });
+                            return Err(err);
+                        }
+                    }
+                }
+                TyTraitInterfaceItem::Constant(_) => {}
+                TyTraitInterfaceItem::Type(_) => {}
+            }
+        }
+
+        for item in self.items.iter() {
+            match item {
+                TyTraitItem::Fn(decl_ref) => {
+                    let decl = engines.de().get(decl_ref.id());
+                    if has_const_generics(decl.return_type.type_id, engines) {
+                        let err = handler.emit_err(CompileError::ConstGenericNotSupportedHere {
+                            span: decl.return_type.span(),
+                        });
+                        return Err(err);
+                    }
+
+                    for arg in decl.parameters.iter() {
+                        if has_const_generics(arg.type_argument.type_id, engines) {
+                            let err =
+                                handler.emit_err(CompileError::ConstGenericNotSupportedHere {
+                                    span: arg.type_argument.span.clone(),
+                                });
+                            return Err(err);
+                        }
+                    }
+                }
+                TyTraitItem::Constant(_) => {}
+                TyTraitItem::Type(_) => {}
+            }
+        }
+
+        Ok(())
+    }
+}
+
 impl TyDeclParsedType for TyAbiDecl {
     type ParsedType = AbiDeclaration;
 }

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

@@ -233,6 +233,9 @@ impl ty::TyAbiDecl {
                     span,
                     attributes,
                 };
+
+                abi_decl.forbid_const_generics(handler, engines)?;
+
                 Ok(abi_decl)
             })
     }

sway-core/src/type_system/substitute/subst_map.rs

@@ -198,18 +198,18 @@ impl TypeSubstMap {
             (TypeInfo::Enum(decl_ref_params), TypeInfo::Enum(decl_ref_args)) => {
                 let decl_params = decl_engine.get_enum(decl_ref_params);
                 let decl_args = decl_engine.get_enum(decl_ref_args);
-                let type_parameters = decl_params.generic_parameters.iter().map(|x| {
-                    let x = x
-                        .as_type_parameter()
-                        .expect("will only work with type parameters");
-                    x.type_id
-                });
-                let type_arguments = decl_args.generic_parameters.iter().map(|x| {
-                    let x = x
-                        .as_type_parameter()
-                        .expect("will only work with type parameters");
-                    x.type_id
-                });
+
+                let type_parameters = decl_params
+                    .generic_parameters
+                    .iter()
+                    .filter_map(|x| x.as_type_parameter())
+                    .map(|x| x.type_id);
+                let type_arguments = decl_args
+                    .generic_parameters
+                    .iter()
+                    .filter_map(|x| x.as_type_parameter())
+                    .map(|x| x.type_id);
+
                 TypeSubstMap::from_superset_and_subset_helper(
                     engines,
                     type_parameters,
@@ -220,18 +220,17 @@ impl TypeSubstMap {
                 let decl_params = decl_engine.get_struct(decl_ref_params);
                 let decl_args = decl_engine.get_struct(decl_ref_args);
 
-                let type_parameters = decl_params.generic_parameters.iter().map(|x| {
-                    let x = x
-                        .as_type_parameter()
-                        .expect("only works with type parameters");
-                    x.type_id
-                });
-                let type_arguments = decl_args.generic_parameters.iter().map(|x| {
-                    let x = x
-                        .as_type_parameter()
-                        .expect("only works with type parameters");
-                    x.type_id
-                });
+                let type_parameters = decl_params
+                    .generic_parameters
+                    .iter()
+                    .filter_map(|x| x.as_type_parameter())
+                    .map(|x| x.type_id);
+                let type_arguments = decl_args
+                    .generic_parameters
+                    .iter()
+                    .filter_map(|x| x.as_type_parameter())
+                    .map(|x| x.type_id);
+
                 TypeSubstMap::from_superset_and_subset_helper(
                     engines,
                     type_parameters,

test/src/e2e_vm_tests/test_programs/should_fail/const_generics/Forc.lock renamed to test/src/e2e_vm_tests/test_programs/should_fail/unsupported_const_generics/Forc.lock

@@ -1,8 +1,8 @@
 [[package]]
-name = "const_generics"
-source = "member"
-dependencies = ["std"]
+name = "std"
+source = "path+from-root-73072EFA61E741F9"
 
 [[package]]
-name = "std"
-source = "path+from-root-04B19932ACF7269D"
+name = "unsupported_const_generics"
+source = "member"
+dependencies = ["std"]

test/src/e2e_vm_tests/test_programs/should_fail/const_generics/Forc.toml renamed to test/src/e2e_vm_tests/test_programs/should_fail/unsupported_const_generics/Forc.toml

@@ -2,7 +2,7 @@
 authors = ["Fuel Labs <[email protected]>"]
 entry = "main.sw"
 license = "Apache-2.0"
-name = "const_generics"
+name = "unsupported_const_generics"
 
 [dependencies]
 std = { path = "../../../../../../sway-lib-std" }

test/src/e2e_vm_tests/test_programs/should_fail/const_generics/snapshot.toml renamed to test/src/e2e_vm_tests/test_programs/should_fail/unsupported_const_generics/snapshot.toml

@@ -42,6 +42,30 @@ impl<const N: u64> A for CrazyEnum<N> {
     }
 }
 
+abi NoConstGenericsOnArgs {
+    fn f(a: CrazyStruct<1>);
+}
+
+abi NoConstGenericsOnReturn {
+    fn f() -> CrazyEnum<1>;
+}
+
+struct StructWithConstGenericInside {
+    a: CrazyStruct<1>,
+}
+
+abi NoConstGenericsIndirectStruct {
+    fn f() -> StructWithConstGenericInside;
+}
+
+enum EnumWithConstGenericInside {
+    A: CrazyStruct<1>,
+}
+
+abi NoConstGenericsIndirectEnum {
+    fn f() -> EnumWithConstGenericInside;
+}
+
 fn main() {
     let _: CrazyStruct<UNKNOWN> = CrazyStruct { };
     let _: CrazyEnum<UNKNOWN> = CrazyEnum::A;