Add all type parsing tests

src/parser/ast/typ.rs

@@ -1,8 +1,8 @@
-use std::fmt::Display;
+use std::{clone, collections::HashSet, fmt::Display};
 
 use anyhow::bail;
 
-use crate::{common::loc::LocBox, info, validator::predefined::{BuiltinType, get_builtin_from_name}};
+use crate::{common::loc::LocBox, error, info, validator::predefined::{BuiltinType, get_builtin_from_name}};
 
 use super::{expr::Expr, literal::Literal, Ident, Program};
 
@@ -75,6 +75,38 @@ impl Type {
 
         } 
     }
+    pub fn get_real_value_of_alias(&self, name: &Ident, program: &Program) -> anyhow::Result<Self> {
+        let mut used_types = HashSet::new();
+        used_types.insert(name.clone());
+        fn f(slf: &mut Type, program: &Program, used_types: &mut HashSet<Ident>) -> anyhow::Result<Type> {
+            match slf {
+                Type::Ref {inner, ..} => {
+                    f(inner, program, used_types)
+                }
+                Type::Owned(ident) => {
+                    if let Some(name) = used_types.get(ident) {
+                        error!("Recursive type alias: {name}");
+                        bail!("")
+                    }
+                    if let Some(t) = program.types.get(ident) {
+                        used_types.insert(ident.clone());
+                        let mut t = t.inner().clone();
+                        f(&mut t, program, used_types)
+                    } else {
+                        Ok(slf.clone())
+                    }
+                }
+                Type::SizedArray { inner, .. } |
+                Type::UnsizedArray { inner } => {
+                    f(inner, program, used_types)
+                }
+                Type::Builtin { .. } => Ok(slf.clone()),
+            } 
+        }
+        let mut t = self.clone();
+        f(&mut t, program, &mut used_types)
+    }
+
     pub fn get_absolute_value(&self, program: &Program) -> anyhow::Result<Self> {
         match self {
             Self::Ref { inner, .. } => inner.get_absolute_value(program),

src/parser/typ.rs

@@ -1,6 +1,6 @@
 use anyhow::{Result, bail};
 
-use crate::{cli::CliArgs, common::loc::LocBox, lerror, parser::{Delimiter, ast::{Program, expr::Expr, literal::Literal}}, tokeniser::Token, validator::predefined::get_builtin_from_name};
+use crate::{cli::CliArgs, common::loc::LocBox, lerror, parser::{Delimiter, ast::{Ident, Program, expr::Expr, literal::Literal}}, tokeniser::Token, validator::predefined::get_builtin_from_name};
 
 use super::{ast::{typ::Type, TokenType}, expr::parse_expr, utils, Keyword, Punctuation};
 

src/validator/mod.rs

@@ -2,7 +2,7 @@ use std::{collections::HashMap, panic};
 
 use anyhow::bail;
 
-use crate::{common::{Loc, loc::LocBox}, parser::ast::{Ast, Program, Punctuation, Scope, TokenType, expr::*, literal::Literal, statement::*, typ::Type}, validator::predefined::get_builtin_from_name};
+use crate::{common::{Loc, loc::LocBox}, parser::ast::{Ast, Ident, Program, Punctuation, Scope, TokenType, expr::*, literal::Literal, statement::*, typ::Type}, validator::predefined::get_builtin_from_name};
 
 pub mod predefined;
 
@@ -669,7 +669,7 @@ fn check_that_types_exist_for_items(prog: &mut Program, items: &Vec<Ast>) -> any
     Ok(())
 }
 
-fn validate_type(prog: &mut Program, typ: &LocBox<Type>) -> anyhow::Result<Type> {
+pub fn validate_type(prog: &mut Program, typ: &LocBox<Type>) -> anyhow::Result<Type> {
     fn f(prog: &mut Program, typ: &Type, loc: &Loc) -> anyhow::Result<Type> {
         match typ {
             Type::SizedArray { .. } |
@@ -691,7 +691,7 @@ fn validate_type(prog: &mut Program, typ: &LocBox<Type>) -> anyhow::Result<Type>
             Type::Builtin { .. } => Ok(typ.clone())
         }
     }
-    f(prog, typ.inner(), typ.loc())
+    f(prog, &typ.inner().get_real_value_of_alias(&Ident::new(""), prog)?, typ.loc())
 }