Added ability to resolve polymorphic types with polymorphic type catalogs, and updated function call resulting types to have polymorphs substituted

Author: IsaacShelton

src/resolve/error.rs

@@ -182,6 +182,8 @@ pub enum ResolveErrorKind {
     CannotDeclareVariableOutsideFunction,
     CannotReturnOutsideFunction,
     CannotAssignVariableOutsideFunction,
+    NonExistentPolymorph(String),
+    PolymorphIsNotAType(String),
     Other {
         message: String,
     },
@@ -501,6 +503,12 @@ impl Display for ResolveErrorKind {
                     "Cannot assign variable outside of function"
                 )?;
             }
+            ResolveErrorKind::NonExistentPolymorph(name) => {
+                write!(f, "Non-existent polymorph '${}'", name)?;
+            }
+            ResolveErrorKind::PolymorphIsNotAType(name) => {
+                write!(f, "Polymorph '${}' is not a type", name)?;
+            }
             ResolveErrorKind::Other { message } => {
                 write!(f, "{}", message)?;
             }

src/resolve/expr/call.rs

@@ -7,9 +7,10 @@ use crate::{
         error::{ResolveError, ResolveErrorKind},
         Initialized,
     },
-    resolved::{self, Cast, CastFrom, TypedExpr},
+    resolved::{self, Cast, CastFrom, PolyValue, TypedExpr},
     source_files::Source,
 };
+use indexmap::IndexMap;
 use itertools::Itertools;
 use num::BigInt;
 
@@ -265,8 +266,6 @@ pub fn resolve_call_expr(
     };
 
     let function = ctx.resolved_ast.functions.get(callee.function).unwrap();
-    let return_type = function.return_type.clone();
-
     let num_required = function.parameters.required.len();
 
     for (i, argument) in arguments.iter_mut().enumerate() {
@@ -329,6 +328,8 @@ pub fn resolve_call_expr(
         }
     }
 
+    let return_type = resolve_polymorphs(&callee.recipe, &function.return_type)?;
+
     if let Some(required_ty) = &call.expected_to_return {
         let resolved_required_ty = ctx.type_ctx().resolve(required_ty)?;
 
@@ -355,3 +356,48 @@ pub fn resolve_call_expr(
         ),
     ))
 }
+
+pub fn resolve_polymorphs<'a>(
+    polymorphs: &IndexMap<String, PolyValue>,
+    ty: &resolved::Type,
+) -> Result<resolved::Type, ResolveError> {
+    Ok(match &ty.kind {
+        resolved::TypeKind::Unresolved => panic!(),
+        resolved::TypeKind::Boolean
+        | resolved::TypeKind::Integer(_, _)
+        | resolved::TypeKind::CInteger(_, _)
+        | resolved::TypeKind::IntegerLiteral(_)
+        | resolved::TypeKind::FloatLiteral(_)
+        | resolved::TypeKind::Void
+        | resolved::TypeKind::Floating(_) => ty.clone(),
+        resolved::TypeKind::Pointer(inner) => {
+            resolved::TypeKind::Pointer(Box::new(resolve_polymorphs(polymorphs, inner)?))
+                .at(ty.source)
+        }
+        resolved::TypeKind::AnonymousStruct() => todo!(),
+        resolved::TypeKind::AnonymousUnion() => todo!(),
+        resolved::TypeKind::AnonymousEnum(_) => todo!(),
+        resolved::TypeKind::FixedArray(fixed_array) => {
+            resolved::TypeKind::FixedArray(Box::new(resolved::FixedArray {
+                size: fixed_array.size,
+                inner: resolve_polymorphs(polymorphs, &fixed_array.inner)?,
+            }))
+            .at(ty.source)
+        }
+        resolved::TypeKind::FunctionPointer(_) => todo!(),
+        resolved::TypeKind::Enum(_, _) => todo!(),
+        resolved::TypeKind::Structure(_, _) => todo!(),
+        resolved::TypeKind::TypeAlias(_, _) => todo!(),
+        resolved::TypeKind::Polymorph(name, _) => {
+            let Some(value) = polymorphs.get(name) else {
+                return Err(ResolveErrorKind::NonExistentPolymorph(name.clone()).at(ty.source));
+            };
+
+            let PolyValue::PolyType(poly_type) = value else {
+                return Err(ResolveErrorKind::PolymorphIsNotAType(name.clone()).at(ty.source));
+            };
+
+            poly_type.resolved_type.clone()
+        }
+    })
+}

src/resolved/polymorph.rs

@@ -112,3 +112,4 @@ impl PolyCatalog {
         self.polymorphs.get(name)
     }
 }
+