Merge pull request #76 from Quickfall/feat/type-utils

[feat] Type utils

Author: Zffu

compiler/ast/src/tree.rs

@@ -31,6 +31,9 @@ pub enum ASTTreeNodeKind {
 
 	ThisStructParam,
 
+	UnwrapCondition { original: Box<ASTTreeNode>, target_type: ASTType, unsafe_unwrap: bool, target_var: Option<HashedString> },
+	UnwrapValue { original: Box<ASTTreeNode>, target_type: ASTType, unsafe_unwrap: bool },
+
 	OperatorBasedConditionMember { lval: Box<ASTTreeNode>, rval: Box<ASTTreeNode>, operator: ComparingOperator },
 	BooleanBasedConditionMember { val: Box<ASTTreeNode>, negate: bool },
 
@@ -156,6 +159,7 @@ impl Display for ASTTreeNode {
 impl Display for ASTTreeNodeKind {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		let s = match self {
+			Self::UnwrapCondition { .. } | Self::UnwrapValue { .. } => "unwrap",
 			Self::IntegerLit { .. } => "integer literal",
 			Self::StringLit(_) => "string literal",
 			Self::ThisStructParam => "this reference",

compiler/ast/src/types.rs

@@ -18,7 +18,8 @@ pub enum ASTType {
 	/// 0: The raw type name
 	/// 1: The type parameters
 	/// 2: The size specifiers
-	Generic(String, Vec<Box<ASTType>>, Vec<usize>), // Potential lowering to base-sized
+	/// 3: enum specifier
+	Generic(String, Vec<Box<ASTType>>, Vec<usize>, Option<String>), // Potential lowering to base-sized
 
 	/// A pointer type node. Represents a pointer version
 	/// 0: Is the pointer a poiner of arrays
@@ -36,7 +37,7 @@ pub enum ASTType {
 impl ASTType {
 	pub fn get_generic_name(&self) -> String {
 		match self {
-			Self::Generic(s, _, _) => s.clone(),
+			Self::Generic(s, _, _, _) => s.clone(),
 			Self::Pointer(_, inner) => inner.get_generic_name(),
 			Self::Reference(inner) => inner.get_generic_name(),
  			Self::Array(_, inner) => inner.get_generic_name()

compiler/ast_parser/src/control/if_else.rs

@@ -7,13 +7,13 @@ use lexer::token::{LexerToken, LexerTokenType};
 
 use ast::{tree::{ASTTreeNode, ASTTreeNodeKind}};
 
-use crate::{functions::parse_node_body, value::parse_ast_value};
+use crate::{functions::parse_node_body, value::{parse_ast_condition_if_statement_value}};
 
 pub fn parse_condition_member(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticResult<Box<ASTTreeNode>> {
 	tokens[*ind].expects(LexerTokenType::ParenOpen)?;
 
 	*ind += 1;
-	let cond = parse_ast_value(tokens, ind)?;
+	let cond = parse_ast_condition_if_statement_value(tokens, ind)?;
 
 	tokens[*ind].expects(LexerTokenType::ParenClose)?;
 

compiler/ast_parser/src/lib.rs

@@ -18,6 +18,7 @@ pub mod control;
 pub mod variables;
 pub mod types;
 pub mod arrays;
+pub mod unwraps;
 
 pub fn parse_ast_ctx(tokens: &Vec<LexerToken>) -> DiagnosticResult<ParserCtx> {
 	let mut ind = 0;

compiler/ast_parser/src/structs/mod.rs

@@ -26,7 +26,7 @@ pub fn parse_type_declaration(tokens: &Vec<LexerToken>, ind: &mut usize, layout:
 
 	let mut members: Vec<Box<ASTTreeNode>> = Vec::new();	
 
-	let temp_type = ASTType::Generic(type_name.0.clone(), vec![], vec![]);
+	let temp_type = ASTType::Generic(type_name.0.clone(), vec![], vec![], None);
 
 	while tokens[*ind].tok_type != LexerTokenType::BracketClose {
 		if tokens[*ind].tok_type == LexerTokenType::Function {

compiler/ast_parser/src/types.rs

@@ -8,7 +8,7 @@ use lexer::{token::{LexerToken, LexerTokenType}};
 
 #[derive(Clone, Debug)]
 pub enum ParsingASTTypeMember {
-	Generic(String, Vec<Box<ASTType>>, Vec<usize>),
+	Generic(String, Vec<Box<ASTType>>, Vec<usize>, Option<String>),
 	Pointer(bool),
 	Reference,
 	Array(usize)	
@@ -47,7 +47,7 @@ pub fn parse_type_type_parameters(tokens: &Vec<LexerToken>, ind: &mut usize) ->
 
 		types.push(parsed_type);
 
-		if tokens[*ind].tok_type == LexerTokenType::AngelBracketClose {
+		if tokens[*ind].is_angel_bracket_close() {
 			break;
 		}
 
@@ -65,10 +65,26 @@ pub fn parse_type_generic(tokens: &Vec<LexerToken>, ind: &mut usize) -> Diagnost
 
 	*ind += 1;
 
+	let specifier;
+
+	if tokens[*ind].tok_type == LexerTokenType::Collon {
+		*ind += 1;
+
+		tokens[*ind].expects(LexerTokenType::Collon)?;
+		*ind += 1;
+		
+		specifier = Some(tokens[*ind].expects_keyword()?.0);
+		*ind += 1;
+	} else {
+		specifier = None;
+	}
+
+	println!("{:#?}", specifier.clone());
+
 	let sizes = parse_type_size_specifiers(tokens, ind)?;
 	let types = parse_type_type_parameters(tokens, ind)?;
 
-	return Ok(ParsingASTTypeMember::Generic(type_name.0, types, sizes))
+	return Ok(ParsingASTTypeMember::Generic(type_name.0, types, sizes, specifier))
 }
 
 pub fn parse_type_member(tokens: &Vec<LexerToken>, ind: &mut usize, took_generic: bool) -> DiagnosticResult<Option<ParsingASTTypeMember>> {
@@ -147,7 +163,7 @@ pub fn parse_type(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticResult
 		let parsed_member = parse_type_member(tokens, ind, took_generic)?;
 
 		if let Some(value) = parsed_member {
-			if let ParsingASTTypeMember::Generic(_, _, _) = &value {
+			if let ParsingASTTypeMember::Generic(_, _, _, _) = &value {
 				took_generic = true;
 			}
 
@@ -161,7 +177,7 @@ pub fn parse_type(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticResult
 
 	for i in 0..members.len() {
 		let converted_member = match members[i].clone() {
-			ParsingASTTypeMember::Generic(t, types, sizes) => ASTType::Generic(t, types, sizes),
+			ParsingASTTypeMember::Generic(t, types, sizes, specifier) => ASTType::Generic(t, types, sizes, specifier),
 			ParsingASTTypeMember::Pointer(array) => ASTType::Pointer(array, child.unwrap()),
 			ParsingASTTypeMember::Reference => ASTType::Reference(child.unwrap()),
 			ParsingASTTypeMember::Array(size) => ASTType::Array(size, child.unwrap())

compiler/ast_parser/src/unwraps.rs

@@ -0,0 +1,63 @@
+use ast::tree::{ASTTreeNode, ASTTreeNodeKind};
+use compiler_utils::hash::HashedString;
+use diagnostics::{DiagnosticResult};
+use lexer::token::{LexerToken, LexerTokenType};
+
+use crate::{types::parse_type, value::parse_ast_value};
+
+pub fn parse_unwrap_condition(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticResult<Box<ASTTreeNode>> {
+	let start = tokens[*ind].pos.clone();
+
+	let unsafe_unwrap = tokens[*ind].tok_type == LexerTokenType::UnwrapUnsafe;
+	*ind += 1;
+
+	tokens[*ind].expects(LexerTokenType::AngelBracketOpen)?;
+	*ind += 1;
+
+	let original = parse_ast_value(tokens, ind)?;
+
+	tokens[*ind].expects(LexerTokenType::Comma)?;
+	*ind += 1;
+
+	let new_type = parse_type(tokens, ind)?;
+
+	let new_var: Option<HashedString>;
+	if tokens[*ind].tok_type == LexerTokenType::AngelBracketClose {
+		new_var = None;
+	} else {
+		tokens[*ind].expects(LexerTokenType::Comma)?;
+		*ind += 1;
+
+		let kwd = tokens[*ind].expects_keyword()?;
+
+		new_var = Some(HashedString::new(kwd.0));
+
+		*ind += 1;
+		tokens[*ind].expects(LexerTokenType::AngelBracketClose)?;
+	}
+
+	*ind += 1;
+	return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::UnwrapCondition { original, target_type: new_type, unsafe_unwrap, target_var: new_var }, start, tokens[*ind].get_end_pos())))
+}
+
+pub fn parse_unwrap_value(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticResult<Box<ASTTreeNode>> {
+	let start = tokens[*ind].pos.clone();
+
+	let unsafe_unwrap = tokens[*ind].tok_type == LexerTokenType::UnwrapUnsafe;
+	*ind += 1;
+
+	tokens[*ind].expects(LexerTokenType::AngelBracketOpen)?;
+	*ind += 1;
+
+	let original = parse_ast_value(tokens, ind)?;
+
+	tokens[*ind].expects(LexerTokenType::Comma)?;
+	*ind += 1;
+
+	let new_type = parse_type(tokens, ind)?;
+
+	tokens[*ind].expects(LexerTokenType::AngelBracketClose)?;
+
+	*ind += 1;
+	return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::UnwrapValue { original, target_type: new_type, unsafe_unwrap }, start, tokens[*ind].get_end_pos())))
+}

compiler/ast_parser/src/value.rs

@@ -4,7 +4,7 @@ use ast::{make_node, tree::{ASTTreeNode, ASTTreeNodeKind}};
 use diagnostics::{DiagnosticResult, builders::{make_expected_simple_error, make_unexpected_simple_error}};
 use lexer::token::{LexerToken, LexerTokenType};
 
-use crate::{arrays::parse_array_access, functions::parse_function_call, structs::val::parse_struct_initialize};
+use crate::{arrays::parse_array_access, functions::parse_function_call, structs::val::parse_struct_initialize, unwraps::{parse_unwrap_condition, parse_unwrap_value}};
 use crate::literals::{parse_integer_literal, parse_string_literal};
 use crate::math::parse_math_operation;
 
@@ -137,6 +137,13 @@ pub fn parse_ast_value_post_l(tokens: &Vec<LexerToken>, ind: &mut usize, origina
 	}
 }
 
+pub fn parse_ast_condition_if_statement_value(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticResult<Box<ASTTreeNode>> {
+	match &tokens[*ind].tok_type {
+		LexerTokenType::Unwrap | LexerTokenType::UnwrapUnsafe => parse_unwrap_condition(tokens, ind),
+		_ => parse_ast_value(tokens, ind)
+	}
+}
+
 /// Parses an AST node that can and WILL be intrepreted as a value
 /// 
 /// # Parsing Layout 
@@ -204,7 +211,9 @@ pub fn parse_ast_value(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticR
 			let chain = parse_ast_value_dotacess(tokens, ind, n);
 
 			return parse_ast_value_post_l(tokens, ind, chain, false);
-		}
+		},
+
+		LexerTokenType::Unwrap | LexerTokenType::UnwrapUnsafe => parse_unwrap_value(tokens, ind),
 
 		_=> return Err(make_unexpected_simple_error(&tokens[*ind], &tokens[*ind].tok_type).into())
 	}	

compiler/astoir_hir/src/ctx.rs

@@ -61,6 +61,30 @@ impl HIRBranchedContext {
 		return self.current_branch;
 	}
 
+	/// Introduces a new variable in the next branch era
+	pub fn introduce_variable_next_era(&mut self, hash: u64, t: Type, has_default: bool) -> Result<usize, ()> {
+		let identity = SelfHash { hash };
+
+		if self.hash_to_ind.contains_key(&identity) {
+			return Err(());
+		}
+
+		let mut var: HIRBranchedVariable = HIRBranchedVariable { introduced_in_era: self.current_branch + 1, variable_type: t, has_default, introduced_values: HashSet::new(), requires_address: false, mutation_count: 0 };
+				
+		if has_default {
+			var.mutation_count += 1;
+		}
+
+		self.variables.push(var);
+
+		let ind: usize = self.current_element_index;
+		self.current_element_index += 1;
+
+		self.hash_to_ind.insert(identity, ind);
+
+		return Ok(ind);
+	} 
+
 	/// Introduces a new variable in the current branch era.
 	pub fn introduce_variable(&mut self, hash: u64, t: Type, has_default: bool) -> Result<usize, ()> {
 		let identity = SelfHash { hash };

compiler/astoir_hir/src/nodes.rs

@@ -1,6 +1,6 @@
 //! The nodes inside of the AstoIR HIR. 
 
-use compiler_typing::{references::TypeReference, storage::{BOOLEAN_TYPE, STATIC_STR}, structs::RawStructTypeContainer, transmutation::array::can_transmute_inner, tree::Type};
+use compiler_typing::{raw::RawType, references::TypeReference, storage::{BOOLEAN_TYPE, STATIC_STR}, structs::RawStructTypeContainer, transmutation::array::can_transmute_inner, tree::Type};
 use compiler_utils::Position;
 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};
@@ -51,6 +51,9 @@ pub enum HIRNodeKind {
 
 	MathOperation { left:  Box<HIRNode>, right: Box<HIRNode>, operation: MathOperator, assignment: bool },
 
+	UnwrapCondition { original: Box<HIRNode>, new_type: Type, new_var: Option<usize>, unsafe_unwrap: bool },
+	UnwrapValue { original: Box<HIRNode>, new_type: Type, unsafe_unwrap: bool },
+
 	VariableReference { index: usize, is_static: bool },
 	FunctionReference { index: usize },
 
@@ -172,10 +175,10 @@ impl HIRNode {
 		}
 
 		if let Some(v) = var_origin {
-			return Err(make_diff_type(origin, &"unnamed".to_string(), &t, &self.get_node_type(context, curr_ctx).unwrap(), v).into())
+			return Err(make_diff_type(origin, &"unnamed".to_string(), &t.faulty_lowering_generic(&context.type_storage), &self.get_node_type(context, curr_ctx).unwrap().faulty_lowering_generic(&context.type_storage), v).into())
 		}
 
-		return Err(make_diff_type_val(origin, &t, &self.get_node_type(context, curr_ctx).unwrap()).into())
+		return Err(make_diff_type_val(origin, &t.faulty_lowering_generic(&context.type_storage), &self.get_node_type(context, curr_ctx).unwrap().faulty_lowering_generic(&context.type_storage)).into())
 	}	
 
 	pub fn get_node_type(&self, context: &HIRContext, curr_ctx: &HIRBranchedContext) -> Option<Type> {
@@ -196,6 +199,14 @@ impl HIRNode {
 				return Some(Type::Reference(Box::new(val.get_node_type(context, curr_ctx).unwrap())))
 			}
 
+			HIRNodeKind::UnwrapCondition { .. } => {
+				return Some(Type::Generic(RawType::Boolean, vec![], vec![]))
+			},
+
+			HIRNodeKind::UnwrapValue { original: _, new_type, unsafe_unwrap: _ } => {
+				return Some(new_type.clone())
+			},
+
 			HIRNodeKind::ArrayIndexAccess { val, index: _ } => {
 				let t = val.get_node_type(context, curr_ctx).unwrap();
 
@@ -212,7 +223,7 @@ impl HIRNode {
 					None => return None
 				};
 
-				return Some(Type::Generic(ind, vec![], vec![]))
+				return Some(Type::Generic(RawType::Boolean, vec![], vec![]))
 			},
 
 			HIRNodeKind::ArrayVariableInitializerValue { vals } => return Some(Type::Array(vals.len(), Box::new(vals[0].get_node_type(context, curr_ctx).unwrap()))),
@@ -227,12 +238,7 @@ impl HIRNode {
 			},
 
 			HIRNodeKind::BooleanOperator { .. } | HIRNodeKind::BooleanCondition { .. } => {
-				let t = match context.type_storage.types.get_index(BOOLEAN_TYPE) {
-					Some(v) => v,
-					None => return None
-				};
-
-				return Some(Type::Generic(t, vec![], vec![]))
+				return Some(Type::Generic(RawType::Boolean, vec![], vec![]))
 			},
 
 			HIRNodeKind::StructVariableInitializerValue { t, fields: _ } => {