feat: added enum parsing

Author: Zffu

compiler/ast/src/tree.rs

@@ -91,7 +91,7 @@ impl ASTTreeNodeKind {
 	}
 
 	pub fn is_tree_permissible(&self) -> bool {
-		return matches!(self, ASTTreeNodeKind::FunctionDeclaration { .. } | ASTTreeNodeKind::StaticVariableDeclaration { .. } | ASTTreeNodeKind::ShadowFunctionDeclaration { .. }| ASTTreeNodeKind::StructLayoutDeclaration { .. })
+		return matches!(self, ASTTreeNodeKind::FunctionDeclaration { .. } | ASTTreeNodeKind::EnumDeclaration { .. } | ASTTreeNodeKind::StaticVariableDeclaration { .. } | ASTTreeNodeKind::ShadowFunctionDeclaration { .. }| ASTTreeNodeKind::StructLayoutDeclaration { .. })
 	}
 
 	pub fn get_tree_name(&self) -> Option<HashedString> {
@@ -116,6 +116,10 @@ impl ASTTreeNodeKind {
 				return Some(HashedString::new(var_name.val.to_string()));
 			},
 
+			ASTTreeNodeKind::EnumDeclaration { name, entries: _, functions: _, type_params: _ } => {
+				return Some(name.clone())
+			}
+
 			_ => return None
 		}
 	}

compiler/ast_parser/src/types.rs

@@ -206,13 +206,15 @@ pub fn parse_type_parameters_declaration(tokens: &Vec<LexerToken>, ind: &mut usi
 
 		*ind += 1;
 
-		if tokens[*ind].tok_type == LexerTokenType::AngelBracketClose {
+		if tokens[*ind].is_angel_bracket_close() {
 			break;
 		}
 
 		tokens[*ind].expects(LexerTokenType::Comma)?;
 		*ind += 1;
 	}
 
+	*ind += 1;
+
 	return Ok(container);
 }

compiler/astoir/src/lib.rs

@@ -16,5 +16,7 @@ pub fn run_astoir_hir(ctx: ParserCtx) -> DiagnosticResult<HIRContext> {
 }
 
 pub fn run_astoir_mir(ctx: ParserCtx) -> DiagnosticResult<MIRContext> {
-	return lower_hir(run_astoir_hir(ctx)?);
+	let hir = run_astoir_hir(ctx)?;
+
+	return lower_hir(hir);
 }

compiler/astoir_hir_lowering/src/enums.rs

@@ -1,7 +1,7 @@
 use ast::tree::{ASTTreeNode, ASTTreeNodeKind};
 use astoir_hir::{ctx::HIRContext, nodes::{HIRNode, HIRNodeKind}};
 use compiler_typing::{enums::{RawEnumTypeContainer}, raw::RawType};
-use diagnostics::{DiagnosticResult, MaybeDiagnostic};
+use diagnostics::{DiagnosticResult, MaybeDiagnostic, builders::make_already_in_scope};
 
 use crate::types::{lower_ast_type_struct};
 
@@ -13,15 +13,18 @@ pub fn lower_ast_enum_entry(context: &mut HIRContext, node: Box<ASTTreeNode>, co
 			if let ASTTreeNodeKind::StructFieldMember { name, member_type } = f.kind {
 				let t = lower_ast_type_struct(context, member_type, container, &*node)?;
 
-				hir_fields.push((name.hash, t))
+				hir_fields.push((name.hash, t));
+				continue;
 			}	
 
 			panic!("Invalid field node type!");
 		}
 
 		container.append_entry(name, hir_fields);
+		return Ok(())
 	}
 
+
 	panic!("Invalid node")
 }
 
@@ -33,7 +36,10 @@ pub fn lower_ast_enum(context: &mut HIRContext, node: Box<ASTTreeNode>) -> Diagn
 			lower_ast_enum_entry(context, entry, &mut container)?;
 		}
 
-		let ind = context.type_storage.append_with_hash(name.hash, RawType::Enum(container.clone()))?;
+		let ind = match context.type_storage.append_with_hash(name.hash, RawType::Enum(container.clone())) {
+			Ok(v) => v,
+			Err(_) => return Err(make_already_in_scope(&*node, &name.val).into())
+		};
 
 		return Ok(Box::new(HIRNode::new(HIRNodeKind::EnumDeclaration { type_name: ind, container }, &node.start, &node.end)))
 	}	

compiler/astoir_hir_lowering/src/types.rs

@@ -2,7 +2,7 @@ use ast::types::ASTType;
 use astoir_hir::ctx::HIRContext;
 use compiler_typing::{TypeParamType, raw::RawType, references::TypeReference, structs::RawStructTypeContainer, tree::Type};
 use compiler_utils::hash::HashedString;
-use diagnostics::{DiagnosticResult, DiagnosticSpanOrigin, builders::{make_cannot_find_type, make_diff_size_specifiers, make_req_type_kind}};
+use diagnostics::{DiagnosticResult, DiagnosticSpanOrigin, builders::{make_cannot_find_type, make_diff_size_specifiers, make_diff_type_specifiers, make_req_type_kind}};
 
 pub fn lower_ast_type<K: DiagnosticSpanOrigin>(context: &mut HIRContext, t: ASTType, origin: &K) -> DiagnosticResult<Type> {
 	return match t {
@@ -24,7 +24,7 @@ pub fn lower_ast_type<K: DiagnosticSpanOrigin>(context: &mut HIRContext, t: ASTT
 			}
 
 			if t.get_type_params_count(&context.type_storage) != type_params.len() {
-				return Err(make_diff_size_specifiers(origin, &type_params.len(), &t.get_type_params_count(&context.type_storage)).into())
+				return Err(make_diff_type_specifiers(origin, &type_params.len(), &t.get_type_params_count(&context.type_storage)).into())
 			}
 
 			let mut t_params = vec![];

compiler/compiler_typing/src/raw.rs

@@ -309,6 +309,11 @@ impl Hash for RawType {
 				for function in &b.functions.vals {
 					hasher.write_usize(*function);
 				}
+			},
+
+			RawType::Enum(container) => {
+				hasher.write_usize(7);
+				hasher.write_usize(container.self_ref);
 			}
 
 			_ => panic!("Unhashable type {:#?}", self)

compiler/diagnostics/src/builders.rs

@@ -1,6 +1,6 @@
 use std::{fmt::Display};
 
-use crate::{DiagnosticSpanOrigin, diagnostic::{Diagnostic, Level, Span, SpanKind, SpanPosition}, errors::{ALREADY_IN_SCOPE, ASSIGN_DIFF_TYPE_IR, BOUND_MISSING, DIFF_SIZE_SPECIFIERS, ENUM_PARENT_FIELDS, ERA_NOT_EXIST, EXPECTED_FREE, EXPECTED_TOKEN, EXPECTED_TYPE, FIELD_MISSING, FIELD_STRUCT_INIT, FIND_TYPE, FIND_TYPE_FIELD, FIND_TYPE_FUNCTION, FIND_VAR, FUNC_MISSING, INDEX_USAGE, INVALID_POINTING, INVALID_TYPE_REQ, IR_CAST, IR_INSTRUCTION_HELD_VAL, MATH_OPERATION_ASSIGNS, TRAIT_MISSING, TYPE_NOT_PART, UNEXPECTED_TOKEN, VARIABLE_UNINIT}, get_current_diagnostic_pos, warnings::UNUSED_VAR};
+use crate::{DiagnosticSpanOrigin, diagnostic::{Diagnostic, Level, Span, SpanKind, SpanPosition}, errors::{ALREADY_IN_SCOPE, ASSIGN_DIFF_TYPE_IR, BOUND_MISSING, DIFF_SIZE_SPECIFIERS, DIFF_TYPE_SPECIFIERS, ENUM_PARENT_FIELDS, ERA_NOT_EXIST, EXPECTED_FREE, EXPECTED_TOKEN, EXPECTED_TYPE, FIELD_MISSING, FIELD_STRUCT_INIT, FIND_TYPE, FIND_TYPE_FIELD, FIND_TYPE_FUNCTION, FIND_VAR, FUNC_MISSING, INDEX_USAGE, INVALID_POINTING, INVALID_TYPE_REQ, IR_CAST, IR_INSTRUCTION_HELD_VAL, MATH_OPERATION_ASSIGNS, TRAIT_MISSING, TYPE_NOT_PART, UNEXPECTED_TOKEN, VARIABLE_UNINIT}, get_current_diagnostic_pos, warnings::UNUSED_VAR};
 
 pub fn make_expected_simple_error<K: DiagnosticSpanOrigin, E: Display, G: Display>(origin: &K, expected: &E, got: &G) -> Diagnostic {
 	origin.make_simple_diagnostic(EXPECTED_TOKEN.0, Level::Error, format!("expected {} but got {}", expected, got), None, vec![], vec![], vec![])
@@ -61,7 +61,11 @@ pub fn make_cannot_find_type_field<F: Display, T: Display>(field: &F, t: &T) ->
 }
 
 pub fn make_diff_size_specifiers<K: DiagnosticSpanOrigin, A: Display, B: Display>(origin: &K, a: &A, b: &B) -> Diagnostic {
-	origin.make_simple_diagnostic(DIFF_SIZE_SPECIFIERS.0, Level::Error, format!("expected {} size specifiers on this type, got {}", a, b), None, vec![], vec![], vec![])
+	origin.make_simple_diagnostic(DIFF_SIZE_SPECIFIERS.0, Level::Error, format!("expected {} size specifiers on this type, got {}", b, a), None, vec![], vec![], vec![])
+}
+
+pub fn make_diff_type_specifiers<K: DiagnosticSpanOrigin, A: Display, B: Display>(origin: &K, a: &A, b: &B) -> Diagnostic {
+	origin.make_simple_diagnostic(DIFF_TYPE_SPECIFIERS.0, Level::Error, format!("expected {} type specifiers on this type, got {}", b, a), None, vec![], vec![], vec![])
 }
 
 pub fn make_diff_type<K: DiagnosticSpanOrigin, V: Display, T: Display, A: Display>(origin: &K, var_name: &V, req_type: &T, got: &A, var_origin: &K) -> Diagnostic {