Add trait type parameters to the type engine.

Author: tritao

sway-core/src/abi_generation/abi_str.rs

@@ -93,7 +93,7 @@ impl TypeInfo {
             Never => "never".into(),
             UnknownGeneric { name, .. } => name.to_string(),
             Placeholder(_) => "_".to_string(),
-            TypeParam(n) => format!("typeparam({n})"),
+            TypeParam(param) => format!("typeparam({})", param.name),
             StringSlice => "str".into(),
             StringArray(length) => format!("str[{}]", length.val()),
             UnsignedInteger(x) => match x {

sway-core/src/abi_generation/evm_abi.rs

@@ -69,7 +69,7 @@ pub fn abi_str(type_info: &TypeInfo, engines: &Engines) -> String {
         Never => "never".into(),
         UnknownGeneric { name, .. } => name.to_string(),
         Placeholder(_) => "_".to_string(),
-        TypeParam(n) => format!("typeparam({n})"),
+        TypeParam(param) => format!("typeparam({})", param.name),
         StringSlice => "str".into(),
         StringArray(x) => format!("str[{}]", x.val()),
         UnsignedInteger(x) => match x {

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

@@ -24,7 +24,7 @@ use crate::{
     },
     type_system::{SubstTypes, TypeId},
     IncludeSelf, SubstTypesContext, TraitConstraint, TypeArgument, TypeEngine, TypeInfo,
-    TypeParameter, TypeSubstMap, UnifyCheck,
+    TypeSubstMap, UnifyCheck,
 };
 
 use super::Module;
@@ -102,17 +102,16 @@ type TraitName = Arc<CallPath<TraitSuffix>>;
 pub(crate) struct TraitKey {
     pub(crate) name: TraitName,
     pub(crate) type_id: TypeId,
-    pub(crate) impl_type_parameters: Vec<TypeParameter>,
+    pub(crate) impl_type_parameters: Vec<TypeId>,
     pub(crate) trait_decl_span: Option<Span>,
 }
 
 impl OrdWithEngines for TraitKey {
     fn cmp(&self, other: &Self, ctx: &OrdWithEnginesContext) -> std::cmp::Ordering {
         self.name.cmp(&other.name, ctx).then_with(|| {
-            self.type_id.cmp(&other.type_id).then_with(|| {
-                self.impl_type_parameters
-                    .cmp(&other.impl_type_parameters, ctx)
-            })
+            self.type_id
+                .cmp(&other.type_id)
+                .then_with(|| self.impl_type_parameters.cmp(&other.impl_type_parameters))
         })
     }
 }
@@ -174,7 +173,6 @@ pub(crate) enum TypeRootFilter {
     Unknown,
     Never,
     Placeholder,
-    TypeParam(usize),
     StringSlice,
     StringArray(usize),
     U8,
@@ -234,7 +232,7 @@ impl TraitMap {
         trait_name: CallPath,
         trait_type_args: Vec<TypeArgument>,
         type_id: TypeId,
-        impl_type_parameters: Vec<TypeParameter>,
+        impl_type_parameters: Vec<TypeId>,
         items: &[ResolvedTraitImplItem],
         impl_span: &Span,
         trait_decl_span: Option<Span>,
@@ -465,7 +463,7 @@ impl TraitMap {
         impl_span: Span,
         trait_decl_span: Option<Span>,
         type_id: TypeId,
-        impl_type_parameters: Vec<TypeParameter>,
+        impl_type_parameters: Vec<TypeId>,
         trait_methods: TraitItems,
         engines: &Engines,
     ) {
@@ -1491,7 +1489,7 @@ impl TraitMap {
             Unknown => TypeRootFilter::Unknown,
             Never => TypeRootFilter::Never,
             UnknownGeneric { .. } | Placeholder(_) => TypeRootFilter::Placeholder,
-            TypeParam(n) => TypeRootFilter::TypeParam(*n),
+            TypeParam(_param) => unreachable!(),
             StringSlice => TypeRootFilter::StringSlice,
             StringArray(x) => TypeRootFilter::StringArray(x.val()),
             UnsignedInteger(x) => match x {

sway-core/src/semantic_analysis/type_check_context.rs

@@ -1307,6 +1307,11 @@ impl<'a> TypeCheckContext<'a> {
             })
         });
 
+        let impl_type_parameters_ids = impl_type_parameters
+            .iter()
+            .map(|type_parameter| engines.te().new_type_param(type_parameter.clone()))
+            .collect::<Vec<_>>();
+
         // CallPath::to_fullpath gives a resolvable path, but is not guaranteed to provide the path
         // to the actual trait declaration. Since the path of the trait declaration is used as a key
         // in the trait map, we need to find the actual declaration path.
@@ -1325,7 +1330,7 @@ impl<'a> TypeCheckContext<'a> {
                 canonical_trait_path,
                 trait_type_args,
                 type_id,
-                impl_type_parameters,
+                impl_type_parameters_ids,
                 &items,
                 impl_span,
                 trait_decl_span,

sway-core/src/type_system/engine.rs

@@ -393,6 +393,24 @@ impl TypeEngine {
         )
     }
 
+    /// Inserts a new [TypeInfo::TypeParam] into the [TypeEngine] and returns its [TypeId].
+    ///
+    /// [TypeInfo::TypeParam] is an always replaceable type and the method
+    /// guarantees that a new (or unused) [TypeId] will be returned on every
+    /// call.
+    pub(crate) fn new_type_param(&self, type_parameter: TypeParameter) -> TypeId {
+        self.new_type_param_impl(TypeInfo::TypeParam(type_parameter))
+    }
+
+    fn new_type_param_impl(&self, type_param: TypeInfo) -> TypeId {
+        let source_id = self.get_type_parameter_fallback_source_id(&type_param);
+        let tsi = TypeSourceInfo {
+            type_info: type_param.into(),
+            source_id,
+        };
+        TypeId::new(self.slab.insert(tsi))
+    }
+
     /// Inserts a new [TypeInfo::Placeholder] into the [TypeEngine] and returns its [TypeId].
     ///
     /// [TypeInfo::Placeholder] is an always replaceable type and the method
@@ -831,6 +849,7 @@ impl TypeEngine {
             TypeInfo::Unknown => return self.new_unknown(),
             TypeInfo::Numeric => return self.new_numeric(),
             TypeInfo::Placeholder(_) => return self.new_placeholder_impl(ty),
+            TypeInfo::TypeParam(_) => return self.new_type_param_impl(ty),
             TypeInfo::UnknownGeneric { .. } => return self.new_unknown_generic_impl(ty),
             _ => (),
         }
@@ -1000,9 +1019,6 @@ impl TypeEngine {
             | TypeInfo::Contract
             | TypeInfo::Never => false,
 
-            // Note that `TypeParam` is currently not used at all.
-            TypeInfo::TypeParam(_) => false,
-
             // `StringArray`s are not changeable. We will have one shared
             // `TypeInfo` instance for every string size. Note that in case
             // of explicitly defined string arrays, e.g. in the storage or type ascriptions
@@ -1015,6 +1031,7 @@ impl TypeEngine {
             TypeInfo::Unknown
             | TypeInfo::Numeric
             | TypeInfo::Placeholder(_)
+            | TypeInfo::TypeParam(_)
             | TypeInfo::UnknownGeneric { .. } => true,
 
             // The `ContractCaller` can be replaceable, and thus, sometimes changeable.
@@ -1104,8 +1121,7 @@ impl TypeEngine {
             | TypeInfo::Never
             | TypeInfo::Unknown
             | TypeInfo::Numeric
-            | TypeInfo::Contract
-            | TypeInfo::TypeParam(_) => false,
+            | TypeInfo::Contract => false,
 
             // Types that are always distinguishable because they have the `name: Ident`.
             //
@@ -1232,6 +1248,7 @@ impl TypeEngine {
             // The above reasoning for `TypeArgument`s applies also for the `TypeParameter`s.
             // We only need to check if the `tp` is annotated.
             TypeInfo::Placeholder(tp) => tp.is_annotated(),
+            TypeInfo::TypeParam(tp) => tp.is_annotated(),
 
             // TODO: Improve handling of `TypeInfo::Custom` and `TypeInfo::TraitType`` within the `TypeEngine`:
             //       https://github.com/FuelLabs/sway/issues/6601
@@ -1718,6 +1735,22 @@ impl TypeEngine {
         self.get_source_id_from_type_parameter(tp)
     }
 
+    fn get_type_parameter_fallback_source_id(&self, type_param: &TypeInfo) -> Option<SourceId> {
+        // `TypeInfo::TypeParam` is an always replaceable type and we know we will
+        // get a new instance of it in the engine for every trait type parameter occurrence. This means
+        // that it can never happen that instances from different source files point
+        // to the same `TypeSourceInfo`. Therefore, we can safely remove an instance
+        // of a `TypeParam` from the engine if its source file is garbage collected.
+        //
+        // The source file itself is always the one in which the `name` is situated.
+        let TypeInfo::TypeParam(tp) = &type_param else {
+            unreachable!("The `placeholder` is checked to be of variant `TypeInfo::TypeParam`.");
+        };
+
+        self.get_source_id_from_type_parameter(tp)
+    }
+
+
     fn get_unknown_generic_fallback_source_id(unknown_generic: &TypeInfo) -> Option<SourceId> {
         // `TypeInfo::UnknownGeneric` is an always replaceable type and we know we will
         // get a new instance of it in the engine for every, e.g., "<T1>", "<T2>", etc. occurrence.

sway-core/src/type_system/info.rs

@@ -107,7 +107,7 @@ pub enum TypeInfo {
     ///
     /// NOTE: This type is *not used yet*.
     // https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.TyKind.html#variant.Param
-    TypeParam(usize),
+    TypeParam(TypeParameter),
     StringSlice,
     StringArray(NumericLength),
     UnsignedInteger(IntegerBits),
@@ -226,8 +226,8 @@ impl HashWithEngines for TypeInfo {
             TypeInfo::Placeholder(ty) => {
                 ty.hash(state, engines);
             }
-            TypeInfo::TypeParam(n) => {
-                n.hash(state);
+            TypeInfo::TypeParam(param) => {
+                param.hash(state, engines);
             }
             TypeInfo::Alias { name, ty } => {
                 name.hash(state);
@@ -287,7 +287,7 @@ impl PartialEqWithEngines for TypeInfo {
                 },
             ) => l == r && ltc.eq(rtc, ctx),
             (Self::Placeholder(l), Self::Placeholder(r)) => l.eq(r, ctx),
-            (Self::TypeParam(l), Self::TypeParam(r)) => l == r,
+            (Self::TypeParam(l), Self::TypeParam(r)) => l.eq(r, ctx),
             (
                 Self::Custom {
                     qualified_call_path: l_name,
@@ -544,7 +544,7 @@ impl DisplayWithEngines for TypeInfo {
             Never => "!".into(),
             UnknownGeneric { name, .. } => name.to_string(),
             Placeholder(type_param) => type_param.name.to_string(),
-            TypeParam(n) => format!("{n}"),
+            TypeParam(param) => format!("{}", param.name),
             StringSlice => "str".into(),
             StringArray(x) => format!("str[{}]", x.val()),
             UnsignedInteger(x) => match x {
@@ -662,7 +662,7 @@ impl DebugWithEngines for TypeInfo {
                 }
             }
             Placeholder(t) => format!("placeholder({:?})", engines.help_out(t)),
-            TypeParam(n) => format!("typeparam({n})"),
+            TypeParam(param) => format!("typeparam({})", param.name),
             StringSlice => "str".into(),
             StringArray(x) => format!("str[{}]", x.val()),
             UnsignedInteger(x) => match x {
@@ -1650,7 +1650,7 @@ impl TypeInfo {
             Never => "never".into(),
             UnknownGeneric { name, .. } => name.to_string(),
             Placeholder(_) => "_".to_string(),
-            TypeParam(n) => format!("typeparam({n})"),
+            TypeParam(param) => format!("typeparam({})", param.name),
             StringSlice => "str".into(),
             StringArray(x) => format!("str[{}]", x.val()),
             UnsignedInteger(x) => match x {