Started working on support for polymorphic type aliases

IsaacShelton · IsaacShelton · commit 5a902feac973 · 2025-02-14T00:22:32.000-06:00
diff --git a/src/asg/datatype/kind/mod.rs b/src/asg/datatype/kind/mod.rs
@@ -39,7 +39,7 @@ pub enum TypeKind {
     FuncPtr(FuncPtr),
     Enum(HumanName, EnumRef),
     Structure(HumanName, StructRef, Vec<Type>),
-    TypeAlias(HumanName, TypeAliasRef),
+    TypeAlias(HumanName, TypeAliasRef, Vec<Type>),
     Polymorph(String, Vec<Constraint>),
     Trait(HumanName, TraitRef, Vec<Type>),
 }
@@ -68,10 +68,11 @@ impl TypeKind {
             TypeKind::FixedArray(fixed_array) => fixed_array.inner.kind.contains_polymorph(),
             TypeKind::FuncPtr(_) => todo!(),
             TypeKind::Enum(_, _) => false,
-            TypeKind::Structure(_, _, parameters) | TypeKind::Trait(_, _, parameters) => parameters
+            TypeKind::Structure(_, _, parameters)
+            | TypeKind::Trait(_, _, parameters)
+            | TypeKind::TypeAlias(_, _, parameters) => parameters
                 .iter()
                 .any(|parameter| parameter.kind.contains_polymorph()),
-            TypeKind::TypeAlias(_, _) => false,
             TypeKind::Polymorph(_, _) => true,
         }
     }
@@ -88,7 +89,7 @@ impl TypeKind {
             TypeKind::CInteger(integer, sign) => {
                 sign.or_else(|| target.map(|target| target.default_c_integer_sign(*integer)))
             }
-            TypeKind::TypeAlias(_, _type_ref) => todo!(),
+            TypeKind::TypeAlias(_, _, _) => panic!("sign of type alias"),
             TypeKind::Unresolved => panic!(),
             TypeKind::AnonymousEnum(enumeration) => enumeration.backing_type.kind.sign(target),
             TypeKind::Floating(_)
@@ -113,6 +114,9 @@ impl TypeKind {
                 asg.structs.get(*struct_ref).unwrap().params.len()
             }
             TypeKind::Trait(_, trait_ref, _) => asg.traits.get(*trait_ref).unwrap().params.len(),
+            TypeKind::TypeAlias(_, type_alias_ref, _) => {
+                asg.type_aliases.get(*type_alias_ref).unwrap().params.len()
+            }
             _ => 0,
         }
     }
@@ -140,12 +144,11 @@ impl TypeKind {
                 func.return_type.kind.for_each_polymorph(f);
             }
             TypeKind::Enum(_, _) => (),
-            TypeKind::Structure(_, _, params) => {
+            TypeKind::Structure(_, _, params) | TypeKind::TypeAlias(_, _, params) => {
                 for param in params.iter() {
                     param.kind.for_each_polymorph(f);
                 }
             }
-            TypeKind::TypeAlias(_, _) => (),
             TypeKind::Polymorph(name, _) => f(name),
             TypeKind::Trait(_, _, params) => {
                 for param in params.iter() {
@@ -232,7 +235,29 @@ impl TypeKind {
                     mapped,
                 )))
             }
-            TypeKind::TypeAlias(_, _) => Ok(Cow::Borrowed(self)),
+            TypeKind::TypeAlias(human_name, type_alias_ref, type_args) => {
+                if type_args.is_empty() {
+                    return Ok(Cow::Borrowed(self));
+                }
+
+                let mut mapped = vec![];
+
+                for (i, type_arg) in type_args.iter().enumerate() {
+                    let TypeParam::Type(inner) = mapper(TypeParam::Type(Cow::Borrowed(type_arg)))
+                        .map_err(TypeParamError::MappingError)?
+                    else {
+                        return Err(TypeParamError::ExpectedType { index: i });
+                    };
+
+                    mapped.push(inner.into_owned());
+                }
+
+                Ok(Cow::Owned(Self::TypeAlias(
+                    human_name.clone(),
+                    *type_alias_ref,
+                    mapped,
+                )))
+            }
             TypeKind::Polymorph(_, _) => Ok(Cow::Borrowed(self)),
             TypeKind::Trait(human_name, trait_ref, type_args) => {
                 if type_args.is_empty() {
@@ -279,7 +304,10 @@ impl Display for TypeKind {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             TypeKind::Unresolved => panic!("cannot display unresolved type"),
-            TypeKind::TypeAlias(name, _) => write!(f, "{}", name)?,
+            TypeKind::TypeAlias(name, _, type_args) => {
+                write!(f, "{}", name)?;
+                write_parameters(f, type_args)?;
+            }
             TypeKind::Boolean => write!(f, "bool")?,
             TypeKind::Integer(bits, sign) => {
                 f.write_str(match (bits, sign) {
@@ -315,9 +343,9 @@ impl Display for TypeKind {
             }
             TypeKind::Void => f.write_str("void")?,
             TypeKind::Never => f.write_str("never")?,
-            TypeKind::Structure(name, _, parameters) => {
+            TypeKind::Structure(name, _, type_args) => {
                 write!(f, "{}", name)?;
-                write_parameters(f, parameters)?;
+                write_parameters(f, type_args)?;
             }
             TypeKind::AnonymousStruct() => f.write_str("anonymous-struct")?,
             TypeKind::AnonymousUnion() => f.write_str("anonymous-union")?,
diff --git a/src/asg/datatype/mod.rs b/src/asg/datatype/mod.rs
@@ -52,12 +52,11 @@ impl Type {
                 func.return_type.strip_constraints();
             }
             TypeKind::Enum(_, _) => (),
-            TypeKind::Structure(_, _, parameters) => {
-                for parameter in parameters {
+            TypeKind::Structure(_, _, params) | TypeKind::TypeAlias(_, _, params) => {
+                for parameter in params {
                     parameter.strip_constraints();
                 }
             }
-            TypeKind::TypeAlias(_, _) => (),
             TypeKind::Polymorph(_, constraints) => {
                 constraints.drain(..);
             }
diff --git a/src/asg/mod.rs b/src/asg/mod.rs
@@ -14,6 +14,7 @@ mod overload;
 mod stmt;
 mod structure;
 mod trait_constraint;
+mod type_alias;
 mod type_decl;
 mod variable_storage;
 
@@ -38,6 +39,7 @@ use std::collections::{HashMap, HashSet};
 pub use stmt::*;
 pub use structure::*;
 pub use trait_constraint::*;
+pub use type_alias::TypeAlias;
 pub use type_decl::*;
 pub use variable_storage::*;
 
@@ -59,7 +61,7 @@ pub struct Asg<'a> {
     pub structs: SlotMap<StructRef, Struct>,
     pub globals: SlotMap<GlobalVarRef, GlobalVar>,
     pub enums: SlotMap<EnumRef, Enum>,
-    pub type_aliases: SlotMap<TypeAliasRef, Type>,
+    pub type_aliases: SlotMap<TypeAliasRef, TypeAlias>,
     pub traits: SlotMap<TraitRef, Trait>,
     pub impls: SlotMap<ImplRef, Impl>,
     pub workspace: &'a AstWorkspace<'a>,
@@ -87,12 +89,17 @@ impl<'a> Asg<'a> {
         let mut running = whole_type;
         let mut depth = 0;
 
-        while let TypeKind::TypeAlias(_, type_alias_ref) = running.kind {
-            running = self
+        while let TypeKind::TypeAlias(_, type_alias_ref, type_args) = &running.kind {
+            let alias = self
                 .type_aliases
-                .get(type_alias_ref)
+                .get(*type_alias_ref)
                 .expect("valid type alias ref");
 
+            if !type_args.is_empty() || !alias.params.is_empty() {
+                todo!("unalias type alias with type args");
+            }
+
+            running = &alias.becomes;
             depth += 1;
 
             if depth > Self::MAX_UNALIAS_DEPTH {
@@ -108,12 +115,18 @@ impl<'a> Asg<'a> {
         let mut running = whole_type;
         let mut depth = 0;
 
-        while let TypeKind::TypeAlias(human_name, type_alias_ref) = &running.kind {
-            running = self
+        while let TypeKind::TypeAlias(human_name, type_alias_ref, type_args) = &running.kind {
+            let alias = self
                 .type_aliases
                 .get(*type_alias_ref)
                 .expect("valid type alias ref");
 
+            if !type_args.is_empty() || !alias.params.is_empty() {
+                todo!("unalias type alias with type args");
+            }
+
+            running = &alias.becomes;
+
             if !seen.insert(type_alias_ref) {
                 return UnaliasError::SelfReferentialTypeAlias(human_name.0.clone());
             }
diff --git a/src/asg/type_alias.rs b/src/asg/type_alias.rs
@@ -0,0 +1,11 @@
+use super::{HumanName, Type};
+use crate::source_files::Source;
+use indexmap::IndexSet;
+
+#[derive(Clone, Debug)]
+pub struct TypeAlias {
+    pub human_name: HumanName,
+    pub source: Source,
+    pub params: IndexSet<String>,
+    pub becomes: Type,
+}
diff --git a/src/ast/type_alias.rs b/src/ast/type_alias.rs
@@ -1,9 +1,11 @@
 use super::{Privacy, Type};
 use crate::source_files::Source;
+use indexmap::IndexSet;
 
 #[derive(Clone, Debug)]
 pub struct TypeAlias {
     pub name: String,
+    pub params: IndexSet<String>,
     pub value: Type,
     pub source: Source,
     pub privacy: Privacy,
diff --git a/src/c/translation/mod.rs b/src/c/translation/mod.rs
@@ -11,6 +11,7 @@ use crate::{
     c::parser::{CTypedef, DeclarationSpecifiers, Declarator, ParseError},
     diagnostics::Diagnostics,
 };
+use indexmap::IndexSet;
 use std::collections::HashMap;
 
 pub fn declare_named_declaration(
@@ -33,6 +34,7 @@ pub fn declare_named_declaration(
     if is_typedef {
         ast_file.type_aliases.push(ast::TypeAlias {
             name: name.clone(),
+            params: IndexSet::new(),
             value: ast_type.clone(),
             source: declarator.source,
             privacy: Privacy::Public,
diff --git a/src/lower/datatype.rs b/src/lower/datatype.rs
@@ -122,13 +122,21 @@ pub fn lower_type(
                 asg,
             )
         }
-        asg::TypeKind::TypeAlias(_, type_alias_ref) => {
-            let ty = asg
+        asg::TypeKind::TypeAlias(_, type_alias_ref, type_args) => {
+            if !type_args.is_empty() {
+                todo!("lower_type for type alias with type args");
+            }
+
+            let type_alias = asg
                 .type_aliases
                 .get(*type_alias_ref)
                 .expect("referenced type alias to exist");
 
-            lower_type(ir_module, &ConcreteType(Cow::Borrowed(ty)), asg)
+            lower_type(
+                ir_module,
+                &ConcreteType(Cow::Borrowed(&type_alias.becomes)),
+                asg,
+            )
         }
     }
 }
diff --git a/src/parser/parse_type_alias.rs b/src/parser/parse_type_alias.rs
@@ -18,6 +18,8 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
         let name = self.parse_identifier(Some("for alias name after 'typealias' keyword"))?;
         self.ignore_newlines();
 
+        let params = self.parse_type_params()?.into_keys().collect();
+
         for annotation in annotations {
             match annotation.kind {
                 AnnotationKind::Public => privacy = Privacy::Public,
@@ -31,6 +33,7 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
 
         Ok(TypeAlias {
             name,
+            params,
             value: becomes_type,
             source,
             privacy,
diff --git a/src/resolve/collect_constraints.rs b/src/resolve/collect_constraints.rs
@@ -33,12 +33,11 @@ pub fn collect_constraints_into(map: &mut HashMap<String, HashSet<Constraint>>,
         asg::TypeKind::FixedArray(fixed_array) => collect_constraints_into(map, &fixed_array.inner),
         asg::TypeKind::FuncPtr(_) => todo!(),
         asg::TypeKind::Enum(_, _) => (),
-        asg::TypeKind::Structure(_, _, parameters) => {
-            for parameter in parameters {
+        asg::TypeKind::Structure(_, _, params) | asg::TypeKind::TypeAlias(_, _, params) => {
+            for parameter in params {
                 collect_constraints_into(map, parameter);
             }
         }
-        asg::TypeKind::TypeAlias(_, _) => (),
         asg::TypeKind::Polymorph(name, constraints) => {
             let set = map.entry(name.to_string()).or_default();
             for constraint in constraints {
diff --git a/src/resolve/error.rs b/src/resolve/error.rs
@@ -225,7 +225,6 @@ pub enum ResolveErrorKind {
         name: String,
     },
     CannotCreateOutOfRangeFloat,
-    TypeAliasesCannotContainPolymorphs,
     FailedToConformArgumentToDefaultValue,
     Other {
         message: String,
@@ -565,9 +564,6 @@ impl Display for ResolveErrorKind {
             ResolveErrorKind::CannotCreateOutOfRangeFloat => {
                 write!(f, "Cannot create out-of-range floating-point number")?;
             }
-            ResolveErrorKind::TypeAliasesCannotContainPolymorphs => {
-                write!(f, "Type aliases cannot contain polymorphs")?;
-            }
             ResolveErrorKind::FailedToConformArgumentToDefaultValue => {
                 write!(f, "Failed to conform argument to default value")?;
             }
diff --git a/src/resolve/impl_head/mod.rs b/src/resolve/impl_head/mod.rs
@@ -268,13 +268,19 @@ fn matches(
             }
             _ => Err(mismatch(ty_in_impl.source)),
         },
-        asg::TypeKind::TypeAlias(_, trait_alias_ref) => match &ty_in_impl.kind {
-            asg::TypeKind::TypeAlias(_, impl_alias_ref) => {
-                if trait_alias_ref == impl_alias_ref {
-                    Ok(())
-                } else {
-                    Err(mismatch(ty_in_impl.source))
+        asg::TypeKind::TypeAlias(_, trait_type_alias_ref, trait_args) => match &ty_in_impl.kind {
+            asg::TypeKind::TypeAlias(_, impl_type_alias_ref, impl_args) => {
+                if trait_type_alias_ref != impl_type_alias_ref
+                    || trait_args.len() != impl_args.len()
+                {
+                    return Err(mismatch(ty_in_impl.source));
+                }
+
+                for (trait_arg, impl_arg) in trait_args.iter().zip(impl_args.iter()) {
+                    matches(ctx, asg, expected, for_alls, trait_arg, impl_arg)?;
                 }
+
+                Ok(())
             }
             _ => Err(mismatch(ty_in_impl.source)),
         },
diff --git a/src/resolve/polymorph/matcher.rs b/src/resolve/polymorph/matcher.rs
diff --git a/src/resolve/polymorph/resolver.rs b/src/resolve/polymorph/resolver.rs
diff --git a/src/resolve/type_definition/prepare.rs b/src/resolve/type_definition/prepare.rs
diff --git a/src/resolve/type_definition/resolve.rs b/src/resolve/type_definition/resolve.rs

Original file line number	Diff line number	Diff line change
`@@ -52,12 +52,11 @@ impl Type {`
`52`	`52`	`func.return_type.strip_constraints();`
`53`	`53`	`}`
`54`	`54`	`TypeKind::Enum(_, _) => (),`
`55`		`- TypeKind::Structure(_, _, parameters) => {`
`56`		`- for parameter in parameters {`
	`55`	`+ TypeKind::Structure(_, _, params) \| TypeKind::TypeAlias(_, _, params) => {`
	`56`	`+ for parameter in params {`
`57`	`57`	`parameter.strip_constraints();`
`58`	`58`	`}`
`59`	`59`	`}`
`60`		`- TypeKind::TypeAlias(_, _) => (),`
`61`	`60`	`TypeKind::Polymorph(_, constraints) => {`
`62`	`61`	`constraints.drain(..);`
`63`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -122,13 +122,21 @@ pub fn lower_type(`
`122`	`122`	`asg,`
`123`	`123`	`)`
`124`	`124`	`}`
`125`		`- asg::TypeKind::TypeAlias(_, type_alias_ref) => {`
`126`		`- let ty = asg`
	`125`	`+ asg::TypeKind::TypeAlias(_, type_alias_ref, type_args) => {`
	`126`	`+ if !type_args.is_empty() {`
	`127`	`+ todo!("lower_type for type alias with type args");`
	`128`	`+ }`
	`129`	`+`
	`130`	`+ let type_alias = asg`
`127`	`131`	`.type_aliases`
`128`	`132`	`.get(*type_alias_ref)`
`129`	`133`	`.expect("referenced type alias to exist");`
`130`	`134`
`131`		`- lower_type(ir_module, &ConcreteType(Cow::Borrowed(ty)), asg)`
	`135`	`+ lower_type(`
	`136`	`+ ir_module,`
	`137`	`+ &ConcreteType(Cow::Borrowed(&type_alias.becomes)),`
	`138`	`+ asg,`
	`139`	`+ )`
`132`	`140`	`}`
`133`	`141`	`}`
`134`	`142`	`}`