feat: added enum declaration parsing

Author: Zffu

compiler/astoir_hir_lowering/src/enums.rs

@@ -0,0 +1,42 @@
+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 crate::types::{lower_ast_type_struct};
+
+pub fn lower_ast_enum_entry(context: &mut HIRContext, node: Box<ASTTreeNode>, container: &mut RawEnumTypeContainer) -> MaybeDiagnostic {
+	if let ASTTreeNodeKind::EnumEntryDeclaration { name, fields } = node.kind.clone() {
+		let mut hir_fields = vec![];
+
+		for f in fields {
+			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))
+			}	
+
+			panic!("Invalid field node type!");
+		}
+
+		container.append_entry(name, hir_fields);
+	}
+
+	panic!("Invalid node")
+}
+
+pub fn lower_ast_enum(context: &mut HIRContext, node: Box<ASTTreeNode>) -> DiagnosticResult<Box<HIRNode>> {
+	if let ASTTreeNodeKind::EnumDeclaration { name, entries, functions, type_params } = node.kind.clone() {
+		let mut container = RawEnumTypeContainer::new(context.type_storage.types.vals.len(), type_params);
+
+		for entry in entries {
+			lower_ast_enum_entry(context, entry, &mut container)?;
+		}
+
+		let ind = context.type_storage.append_with_hash(name.hash, RawType::Enum(container.clone()))?;
+
+		return Ok(Box::new(HIRNode::new(HIRNodeKind::EnumDeclaration { type_name: ind, container }, &node.start, &node.end)))
+	}	
+
+	panic!("Invalid node")
+}

compiler/astoir_hir_lowering/src/lib.rs

@@ -2,7 +2,7 @@ use ast::{ctx::ParserCtx, tree::{ASTTreeNode, ASTTreeNodeKind}};
 use astoir_hir::{ctx::{HIRBranchedContext, HIRContext}, nodes::{HIRNode, HIRNodeKind}};
 use diagnostics::{DiagnosticResult, DiagnosticSpanOrigin, move_current_diagnostic_pos};
 
-use crate::{arrays::lower_ast_array_modify, control::{lower_ast_for_block, lower_ast_if_statement, lower_ast_while_block}, func::{lower_ast_function_call, lower_ast_function_declaration, lower_ast_shadow_function_declaration}, math::lower_ast_math_operation, structs::lower_ast_struct_declaration, values::lower_ast_value, var::{lower_ast_variable_assign, lower_ast_variable_declaration}};
+use crate::{arrays::lower_ast_array_modify, control::{lower_ast_for_block, lower_ast_if_statement, lower_ast_while_block}, enums::lower_ast_enum, func::{lower_ast_function_call, lower_ast_function_declaration, lower_ast_shadow_function_declaration}, math::lower_ast_math_operation, structs::lower_ast_struct_declaration, values::lower_ast_value, var::{lower_ast_variable_assign, lower_ast_variable_declaration}};
 
 pub mod literals;
 pub mod var;
@@ -93,6 +93,12 @@ pub fn lower_ast_toplevel(context: &mut HIRContext, node: Box<ASTTreeNode>) -> D
 			return Ok(true)
 		},
 
+		ASTTreeNodeKind::EnumDeclaration { .. } => {
+			lower_ast_enum(context, node)?;
+
+			return Ok(true)
+		}
+
 		_ => panic!("Invalid node type")
 	}
 } 

compiler/astoir_hir_lowering/src/types.rs

@@ -1,6 +1,6 @@
 use ast::types::ASTType;
 use astoir_hir::ctx::HIRContext;
-use compiler_typing::{raw::RawType, references::TypeReference, structs::RawStructTypeContainer, tree::Type};
+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}};
 
@@ -59,12 +59,12 @@ pub fn lower_ast_type<K: DiagnosticSpanOrigin>(context: &mut HIRContext, t: ASTT
 	};
 }
 
-pub fn lower_ast_type_struct<K: DiagnosticSpanOrigin>(context: &mut HIRContext, t: ASTType, struct_container: &RawStructTypeContainer, origin: &K) -> DiagnosticResult<TypeReference> {
+pub fn lower_ast_type_struct<K: DiagnosticSpanOrigin, T: TypeParamType>(context: &mut HIRContext, t: ASTType, container: &T, origin: &K) -> DiagnosticResult<TypeReference> {
 	if let ASTType::Generic(id, _, _, _) = &t {
 		let key = HashedString::new(id.clone());
 
-		if struct_container.type_params.contains_key(&key) {
-			return Ok(TypeReference::Unresolved(struct_container.type_params[&key]));
+		if container.has_type_param(&key) {
+			return Ok(TypeReference::Unresolved(container.get_type_param_ind(&key)));
 		}
 	}