Finished basic support for generic type aliases

Author: IsaacShelton

Diff for: src/asg/mod.rs

@@ -20,7 +20,11 @@ mod variable_storage;
 
 pub use self::variable_storage::VariableStorageKey;
 pub use crate::ast::{IntegerBits, IntegerSign};
-use crate::{ast::AstWorkspace, source_files::SourceFiles};
+use crate::{
+    ast::AstWorkspace,
+    resolve::{PolyRecipe, PolyValue, PolymorphErrorKind},
+    source_files::SourceFiles,
+};
 pub use block::*;
 pub use datatype::*;
 pub use destination::*;
@@ -33,9 +37,13 @@ pub use helper_expr::*;
 pub use human_name::*;
 pub use impl_params::*;
 pub use implementation::*;
+use indexmap::IndexMap;
 pub use overload::*;
 use slotmap::{new_key_type, SlotMap};
-use std::collections::{HashMap, HashSet};
+use std::{
+    borrow::Cow,
+    collections::{HashMap, HashSet},
+};
 pub use stmt::*;
 pub use structure::*;
 pub use trait_constraint::*;
@@ -85,21 +93,42 @@ impl<'a> Asg<'a> {
         }
     }
 
-    pub fn unalias(&'a self, whole_type: &'a Type) -> Result<&'a Type, UnaliasError> {
-        let mut running = whole_type;
+    pub fn unalias(&'a self, whole_type: &'a Type) -> Result<Cow<'a, Type>, UnaliasError> {
+        let mut running = Cow::Borrowed(whole_type);
         let mut depth = 0;
 
-        while let TypeKind::TypeAlias(_, type_alias_ref, type_args) = &running.kind {
+        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");
+            if type_args.len() != alias.params.len() {
+                return Err(UnaliasError::IncorrectNumberOfTypeArgsForAlias(
+                    human_name.0.clone(),
+                ));
+            }
+
+            if alias.params.is_empty() {
+                running = Cow::Borrowed(&alias.becomes);
+            } else {
+                let polymorphs = IndexMap::<String, PolyValue>::from_iter(
+                    alias
+                        .params
+                        .iter()
+                        .cloned()
+                        .zip(type_args.iter().cloned().map(PolyValue::Type)),
+                );
+
+                let recipe = PolyRecipe { polymorphs };
+
+                running = Cow::Owned(
+                    recipe
+                        .resolve_type(&alias.becomes)
+                        .map_err(|e| UnaliasError::PolymorphError(e.kind))?,
+                )
             }
 
-            running = &alias.becomes;
             depth += 1;
 
             if depth > Self::MAX_UNALIAS_DEPTH {
@@ -146,4 +175,6 @@ impl<'a> Asg<'a> {
 pub enum UnaliasError {
     MaxDepthExceeded,
     SelfReferentialTypeAlias(String),
+    IncorrectNumberOfTypeArgsForAlias(String),
+    PolymorphError(PolymorphErrorKind),
 }

Diff for: src/resolve/conform/mod.rs

@@ -88,7 +88,7 @@ pub fn conform_expr<O: Objective>(
 
     if *from_type == *to_type {
         return O::success(|| TypedExpr {
-            ty: to_type.clone(),
+            ty: to_type.into_owned(),
             expr: expr.expr.clone(),
             is_initialized: expr.is_initialized,
         });
@@ -99,29 +99,29 @@ pub fn conform_expr<O: Objective>(
             from,
             behavior.c_integer_assumptions(),
             expr.expr.source,
-            to_type,
+            &to_type,
         ),
         TypeKind::Integer(from_bits, from_sign) => from_integer::<O>(
-            &expr.expr, from_type, mode, behavior, *from_bits, *from_sign, to_type,
+            &expr.expr, &from_type, mode, behavior, *from_bits, *from_sign, &to_type,
         ),
-        TypeKind::FloatLiteral(from) => from_float_literal::<O>(*from, to_type, conform_source),
-        TypeKind::Floating(from_size) => from_float::<O>(&expr.expr, mode, *from_size, to_type),
-        TypeKind::Ptr(from_inner) => from_pointer::<O>(ctx, &expr.expr, mode, from_inner, to_type),
+        TypeKind::FloatLiteral(from) => from_float_literal::<O>(*from, &to_type, conform_source),
+        TypeKind::Floating(from_size) => from_float::<O>(&expr.expr, mode, *from_size, &to_type),
+        TypeKind::Ptr(from_inner) => from_pointer::<O>(ctx, &expr.expr, mode, from_inner, &to_type),
         TypeKind::CInteger(from_size, from_sign) => from_c_integer::<O>(
             &expr.expr,
-            from_type,
+            &from_type,
             mode,
             behavior,
             *from_size,
             *from_sign,
-            to_type,
+            &to_type,
             conform_source,
         ),
         TypeKind::AnonymousEnum(enumeration) => from_anonymous_enum::<O>(
             &expr.expr,
-            from_type,
+            &from_type,
             mode,
-            to_type,
+            &to_type,
             enumeration.as_ref(),
             conform_source,
         ),

Diff for: src/resolve/core_struct_info.rs

@@ -3,30 +3,41 @@ use crate::{
     asg::{self, Asg, HumanName, StructRef},
     source_files::Source,
 };
+use std::borrow::Cow;
 
 #[derive(Clone, Debug)]
 pub struct CoreStructInfo<'a> {
-    pub name: &'a HumanName,
+    pub name: Cow<'a, HumanName>,
     pub struct_ref: StructRef,
-    pub arguments: &'a [asg::Type],
+    pub arguments: Cow<'a, [asg::Type]>,
 }
 
 pub fn get_core_struct_info<'a, 'b>(
     asg: &'b Asg<'a>,
     ty: &'a asg::Type,
     source: Source,
 ) -> Result<CoreStructInfo<'b>, Option<ResolveError>> {
-    match &asg
+    let t = asg
         .unalias(ty)
         .map_err(|e| ResolveErrorKind::from(e).at(source))
-        .map_err(Some)?
-        .kind
-    {
-        asg::TypeKind::Structure(name, struct_ref, arguments) => Ok(CoreStructInfo {
-            name,
-            struct_ref: *struct_ref,
-            arguments: arguments.as_slice(),
-        }),
-        _ => Err(None),
+        .map_err(Some)?;
+
+    match t {
+        Cow::Borrowed(t) => match &t.kind {
+            asg::TypeKind::Structure(name, struct_ref, arguments) => Ok(CoreStructInfo {
+                name: Cow::Borrowed(&name),
+                struct_ref: *struct_ref,
+                arguments: Cow::Borrowed(arguments.as_slice()),
+            }),
+            _ => Err(None),
+        },
+        Cow::Owned(t) => match &t.kind {
+            asg::TypeKind::Structure(name, struct_ref, arguments) => Ok(CoreStructInfo {
+                name: Cow::Owned(name.clone()),
+                struct_ref: *struct_ref,
+                arguments: Cow::Owned(arguments.as_slice().to_owned()),
+            }),
+            _ => Err(None),
+        },
     }
 }

Diff for: src/resolve/error.rs

@@ -526,6 +526,14 @@ impl Display for ResolveErrorKind {
                 UnaliasError::SelfReferentialTypeAlias(type_alias_name) => {
                     write!(f, "Type alias '{}' is self-referential", type_alias_name)?
                 }
+                UnaliasError::IncorrectNumberOfTypeArgsForAlias(type_alias_name) => write!(
+                    f,
+                    "Incorrect number of type arguments for type alias '{}'",
+                    type_alias_name
+                )?,
+                UnaliasError::PolymorphError(e) => {
+                    e.fmt(f)?;
+                }
             },
             ResolveErrorKind::CannotDeclareVariableOutsideFunction => {
                 write!(f, "Cannot declare variable outside of function")?;

Diff for: src/resolve/expr/struct_literal.rs

@@ -76,7 +76,7 @@ pub fn resolve_struct_literal_expr(
         })
     })?;
 
-    let struct_name = struct_name.clone();
+    let struct_name = struct_name.into_owned();
     let arguments = arguments.to_vec();
 
     let mut next_index = 0;

Diff for: src/resolve/type_ctx/resolve_type.rs

@@ -41,7 +41,7 @@ impl<'a> ResolveTypeCtx<'a> {
                 .unalias(&ty)
                 .map_err(ResolveErrorKind::from)
                 .map_err(|e| e.at(ast_type.source))?
-                .clone()),
+                .into_owned()),
             ResolveTypeOptions::KeepAliases => Ok(ty),
         }
     }

Diff for: tests/success/generics_type_alias/main.adept

@@ -0,0 +1,13 @@
+
+pragma => adept("3.0")
+
+#[foreign]
+func printf(format ptr#char, ...) int
+
+typealias t<$T> = $T
+
+func main {
+    x t<int> = 13
+
+    printf(c"x = %d\n", x)
+}