Implemented initial parsing for polymorph constraints

IsaacShelton · Oct 30, 2024 · f3aa9bf · f3aa9bf
1 parent 1e8a2e9
commit f3aa9bf
Show file tree

Hide file tree

Showing 4 changed files with 36 additions and 4 deletions.
diff --git a/src/ast/datatype/kind/display.rs b/src/ast/datatype/kind/display.rs
@@ -3,6 +3,7 @@ use crate::{
     ast::{fmt_c_integer, FloatSize, IntegerBits},
     ir::IntegerSign,
 };
+use itertools::Itertools;
 use std::fmt::Display;
 
 impl Display for &TypeKind {
@@ -48,8 +49,13 @@ impl Display for &TypeKind {
             TypeKind::FunctionPointer(_function) => {
                 write!(f, "(function pointer type)")?;
             }
-            TypeKind::Polymorph(polymorph) => {
+            TypeKind::Polymorph(polymorph, constraints) => {
                 write!(f, "${}", polymorph)?;
+
+                if !constraints.is_empty() {
+                    write!(f, ": ")?;
+                    write!(f, "{}", constraints.iter().map(|x| x.to_string()).join("+"))?;
+                }
             }
         }
 

diff --git a/src/ast/datatype/kind/mod.rs b/src/ast/datatype/kind/mod.rs
@@ -21,7 +21,7 @@ pub enum TypeKind {
     AnonymousUnion(AnoymousUnion),
     AnonymousEnum(AnonymousEnum),
     FunctionPointer(FunctionPointer),
-    Polymorph(String),
+    Polymorph(String, Vec<Type>),
 }
 
 impl TypeKind {

diff --git a/src/parser/parse_type.rs b/src/parser/parse_type.rs
@@ -31,7 +31,29 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                 });
             }
 
-            return Ok(TypeKind::Polymorph(token.kind.unwrap_polymorph()).at(source));
+            let polymorph = token.kind.unwrap_polymorph();
+            let mut constraints = vec![];
+
+            if self.input.eat(TokenKind::Colon) {
+                loop {
+                    constraints
+                        .push(self.parse_type(None::<&str>, Some("for polymorph constraint"))?);
+
+                    // TODO: CLEANUP: Clean this code up
+                    if let TypeKind::Polymorph(..) = constraints.last().unwrap().kind {
+                        return Err(ParseErrorKind::Other {
+                            message: "Polymorphs cannot be used as constraints".into(),
+                        }
+                        .at(constraints.last().unwrap().source));
+                    }
+
+                    if !self.input.eat(TokenKind::Add) {
+                        break;
+                    }
+                }
+            }
+
+            return Ok(TypeKind::Polymorph(polymorph, constraints).at(source));
         };
 
         let generics = self.parse_generics()?;

diff --git a/src/resolve/type_ctx/resolve_type.rs b/src/resolve/type_ctx/resolve_type.rs
@@ -93,7 +93,11 @@ impl<'a> ResolveTypeCtx<'a> {
                     },
                 ))
             }
-            ast::TypeKind::Polymorph(polymorph) => {
+            ast::TypeKind::Polymorph(polymorph, constaints) => {
+                if !constaints.is_empty() {
+                    todo!("resolve polymorph constaints");
+                }
+
                 Ok(resolved::TypeKind::Polymorph(polymorph.clone()))
             }
         }