Merge pull request #82 from Quickfall/feat/enum-decls

Feat/enum decls

Author: Zffu

compiler/ast/src/tree.rs

@@ -51,6 +51,9 @@ pub enum ASTTreeNodeKind {
 	ArrayIndexAccess { val: Box<ASTTreeNode>, index: Box<ASTTreeNode> },
 	ArrayIndexModifiy { array: Box<ASTTreeNode>, index: Box<ASTTreeNode>, val: Box<ASTTreeNode> },
 
+	EnumDeclaration { name: HashedString, entries: Vec<Box<ASTTreeNode>>, functions: Vec<Box<ASTTreeNode>>, type_params: TypeParameterContainer },
+	EnumEntryDeclaration { name: HashedString, fields: Vec<Box<ASTTreeNode>> },
+
 	StructLayoutDeclaration { name: HashedString, layout: bool, members: Vec<Box<ASTTreeNode>>, type_params: TypeParameterContainer },
 	StructFieldMember { name: HashedString, member_type: ASTType },
 
@@ -88,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> {
@@ -113,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
 		}
 	}
@@ -188,7 +195,9 @@ impl Display for ASTTreeNodeKind {
 			Self::StructLRFunction { .. } => "struct LRU function usage",
 			Self::StructLRVariable { .. } => "struct LRU variable usage",
 			Self::StructLayoutDeclaration { .. } => "struct / layout declaration",
-			Self::StructFieldMember { .. } => "struct field"
+			Self::StructFieldMember { .. } => "struct field",
+			Self::EnumDeclaration { .. } => "enum declaration",
+			Self::EnumEntryDeclaration { .. } => "enum entry declaration",
 		};
 
 		write!(f, "{}", s)?;

compiler/ast_parser/src/parser.rs

@@ -3,7 +3,7 @@ use compiler_utils::hash::HashedString;
 use diagnostics::{DiagnosticResult, builders::{make_unexpected_simple_error, make_unused_variable}};
 use lexer::token::{LexerToken, LexerTokenType};
 
-use crate::{control::{for_loop::parse_for_loop, if_else::parse_if_statement, while_block::parse_while_block}, functions::{parse_function_call, parse_function_declaraction, returns::parse_function_return_statement, shadow::parse_shadow_function_declaration}, structs::parse_type_declaration, value::parse_ast_value_post_l, variables::{decl::parse_variable_declaration, static_decl::parse_static_variable_declaration}};
+use crate::{control::{for_loop::parse_for_loop, if_else::parse_if_statement, while_block::parse_while_block}, functions::{parse_function_call, parse_function_declaraction, returns::parse_function_return_statement, shadow::parse_shadow_function_declaration}, structs::{enums::parse_enum_declaration, parse_type_declaration}, value::parse_ast_value_post_l, variables::{decl::parse_variable_declaration, static_decl::parse_static_variable_declaration}};
 
 /// Parses an AST node outside of any other node.
 /// 
@@ -34,6 +34,10 @@ pub fn parse_ast_node(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticRe
 			return parse_type_declaration(tokens, ind, true);
 		},
 
+		LexerTokenType::Enum => {
+			return parse_enum_declaration(tokens, ind);
+		},
+
 		_ => return Err(make_unexpected_simple_error(&tokens[*ind], &tokens[*ind].tok_type).into())
 	}	
 }

compiler/ast_parser/src/structs/enums.rs

@@ -0,0 +1,68 @@
+use ast::{tree::{ASTTreeNode, ASTTreeNodeKind}, types::ASTType};
+use compiler_utils::hash::HashedString;
+use diagnostics::{DiagnosticResult, diagnostic::Diagnostic};
+use lexer::token::{LexerToken, LexerTokenType};
+
+use crate::{functions::parse_function_declaraction, structs::members::parse_types_field_member, types::{parse_type_generic, parse_type_parameters_declaration}};
+
+pub fn parse_enum_entry(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticResult<Box<ASTTreeNode>> {
+	let start = tokens[*ind].pos.clone();
+
+	let name = tokens[*ind].expects_keyword()?;
+	*ind += 1;
+
+	let mut fields = vec![];
+
+	tokens[*ind].expects(LexerTokenType::ParenOpen)?;	
+	*ind += 1;
+
+	loop {
+		fields.push(parse_types_field_member(tokens, ind)?);
+
+		if tokens[*ind].tok_type == LexerTokenType::ParenClose {
+			break;
+		}
+
+		tokens[*ind].expects(LexerTokenType::Comma)?;
+	}
+
+	*ind += 1;
+
+	return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::EnumEntryDeclaration { name: HashedString::new(name.0), fields }, start, tokens[*ind].get_end_pos())))
+}
+
+pub fn parse_enum_declaration(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticResult<Box<ASTTreeNode>> {
+	let start = tokens[*ind].pos.clone();
+
+	*ind += 1;
+
+	let name = tokens[*ind].expects_keyword()?;
+	*ind += 1;
+
+	let t = parse_type_parameters_declaration(tokens, ind)?;
+
+	tokens[*ind].expects(LexerTokenType::BracketOpen)?;
+	*ind += 1;
+
+	let mut entries = vec![];
+	let mut functions = vec![];
+
+	let temp_type = ASTType::Generic(name.0.clone(), vec![], vec![], None);
+
+	loop {
+		if tokens[*ind].is_keyword() {
+			entries.push(parse_enum_entry(tokens, ind)?);
+		} else {
+			tokens[*ind].expects(LexerTokenType::Function)?;
+
+			functions.push(parse_function_declaraction(tokens, ind, Some(temp_type.clone()))?)
+		}
+
+		if tokens[*ind].tok_type == LexerTokenType::BracketClose {
+			break;
+		}
+	}
+	*ind += 1;
+
+	return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::EnumDeclaration { name: HashedString::new(name.0), entries, functions, type_params: t }, start, tokens[*ind].get_end_pos())))
+}

compiler/ast_parser/src/structs/mod.rs

@@ -8,6 +8,7 @@ use crate::{functions::parse_function_declaraction, structs::members::parse_type
 
 pub mod members;
 pub mod val;
+pub mod enums;
 
 pub fn parse_type_declaration(tokens: &Vec<LexerToken>, ind: &mut usize, layout: bool) -> DiagnosticResult<Box<ASTTreeNode>> {
 	let start = tokens[*ind].pos.clone();

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/src/nodes.rs

@@ -2,7 +2,7 @@
 
 use std::collections::HashMap;
 
-use compiler_typing::{raw::RawType, references::TypeReference, storage::{BOOLEAN_TYPE, STATIC_STR}, structs::RawStructTypeContainer, transmutation::array::can_transmute_inner, tree::Type};
+use compiler_typing::{enums::{RawEnumEntryContainer, RawEnumTypeContainer}, raw::RawType, references::TypeReference, storage::{BOOLEAN_TYPE, STATIC_STR}, structs::RawStructTypeContainer, transmutation::array::can_transmute_inner, tree::Type};
 use compiler_utils::{Position, hash::SelfHash};
 use diagnostics::{DiagnosticSpanOrigin, builders::{make_diff_type, make_diff_type_val}, diagnostic::{Diagnostic, Span, SpanKind, SpanPosition}, unsure_panic};
 use lexer::toks::{comp::ComparingOperator, math::MathOperator};
@@ -66,6 +66,8 @@ pub enum HIRNodeKind {
 
 	EnumParentCast { val: Box<HIRNode>, parent: Type },
 
+	EnumDeclaration { type_name: usize, container: RawEnumTypeContainer },
+ 
 	StructDeclaration { type_name: usize, container: RawStructTypeContainer, layout: bool },
 	StructFunctionDeclaration { func_name: usize, arguments: Vec<(u64, TypeReference)>, return_type: Option<TypeReference>, body: Vec<Box<HIRNode>>, ctx: HIRBranchedContext, requires_this: bool },
 

compiler/astoir_hir_lowering/src/enums.rs

@@ -0,0 +1,48 @@
+use ast::tree::{ASTTreeNode, ASTTreeNodeKind};
+use astoir_hir::{ctx::HIRContext, nodes::{HIRNode, HIRNodeKind}};
+use compiler_typing::{enums::{RawEnumTypeContainer}, raw::RawType};
+use diagnostics::{DiagnosticResult, MaybeDiagnostic, builders::make_already_in_scope};
+
+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));
+				continue;
+			}	
+
+			panic!("Invalid field node type!");
+		}
+
+		container.append_entry(name, hir_fields);
+		return Ok(())
+	}
+
+
+	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 = 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)))
+	}	
+
+	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;
@@ -15,6 +15,7 @@ pub mod control;
 pub mod structs;
 pub mod arrays;
 pub mod unwraps;
+pub mod enums;
 
 pub fn lower_ast_body_node(context: &mut HIRContext, curr_ctx: &mut HIRBranchedContext, node: Box<ASTTreeNode>) -> DiagnosticResult<Box<HIRNode>> {
 	move_current_diagnostic_pos(node.get_pos());
@@ -92,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,8 +1,8 @@
 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}};
+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![];
@@ -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)));
 		}
 	}