Merge pull request #77 from Quickfall/feat/uniform-struct-decls

[feat] Uniform struct declarations

Author: Zffu

.gitignore

@@ -2,4 +2,9 @@ target/
 *.ll
 
 out
-out.*
+out.*
+
+*.qf
+*.qfmir
+
+!examples/**.qf

compiler/ast/src/tree.rs

@@ -44,7 +44,7 @@ pub enum ASTTreeNodeKind {
 	PointerGrab(Box<ASTTreeNode>),
 	ReferenceGrab(Box<ASTTreeNode>),
 
-	StructVariableInitializerValue { struct_type: ASTType, map: HashMap<SelfHash, Box<ASTTreeNode>> },
+	StructInitializer { map: HashMap<SelfHash, Box<ASTTreeNode>> },
 	ArrayVariableInitializerValueSameValue { size: usize, v: Box<ASTTreeNode> },
 	ArrayVariableInitializerValue { vals: Vec<Box<ASTTreeNode>> },
 
@@ -169,7 +169,7 @@ impl Display for ASTTreeNodeKind {
 			Self::VariableReference(_) => "variable reference",
 			Self::PointerGrab(_) => "pointer grabbing",
 			Self::ReferenceGrab(_) => "reference",
-			Self::StructVariableInitializerValue { .. } => "struct value initializer",
+			Self::StructInitializer { .. } => "struct value initializer",
 			Self::ArrayVariableInitializerValue { .. } | Self::ArrayVariableInitializerValueSameValue { .. } => "array value initializer",
 			Self::ArrayIndexAccess { .. } | Self::ArrayIndexModifiy { .. } => "index access",
 			Self::VarDeclaration { .. } => "variable declaration",

compiler/ast_parser/src/structs/val.rs

@@ -5,15 +5,9 @@ use compiler_utils::hash::{HashedString, SelfHash};
 use diagnostics::DiagnosticResult;
 use lexer::token::{LexerToken, LexerTokenType};
 
-use crate::{types::parse_type, value::parse_ast_value};
+use crate::{value::parse_ast_value};
 
 pub fn parse_struct_initialize(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticResult<Box<ASTTreeNode>> {
-	*ind += 1;
-
-	let t = parse_type(tokens, ind)?;
-
-	tokens[*ind].expects(LexerTokenType::BracketOpen)?;
-
 	let start = tokens[*ind].pos.clone();
 
 	*ind += 1;
@@ -24,8 +18,13 @@ pub fn parse_struct_initialize(tokens: &Vec<LexerToken>, ind: &mut usize) -> Dia
 		let field_name = tokens[*ind].expects_keyword()?;
 		*ind += 1;
 
+		tokens[*ind].expects(LexerTokenType::Collon)?;
+		*ind += 1;
+
+
 		let value = parse_ast_value(tokens, ind)?;
 
+
 		map.insert(SelfHash { hash: HashedString::new(field_name.0).hash }, value);
 
 		//*ind += 1;
@@ -40,5 +39,5 @@ pub fn parse_struct_initialize(tokens: &Vec<LexerToken>, ind: &mut usize) -> Dia
 
 	*ind += 1;
 
-	return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::StructVariableInitializerValue { struct_type: t, map }, start, tokens[*ind].get_end_pos())))
+	return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::StructInitializer { map }, start, tokens[*ind].get_end_pos())))
 }

compiler/ast_parser/src/types.rs

@@ -79,8 +79,6 @@ pub fn parse_type_generic(tokens: &Vec<LexerToken>, ind: &mut usize) -> Diagnost
 		specifier = None;
 	}
 
-	println!("{:#?}", specifier.clone());
-
 	let sizes = parse_type_size_specifiers(tokens, ind)?;
 	let types = parse_type_type_parameters(tokens, ind)?;
 

compiler/ast_parser/src/value.rs

@@ -177,7 +177,7 @@ pub fn parse_ast_value(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticR
 			return Err(make_expected_simple_error(&tokens[*ind], &"function call or variable access".to_string(),&ast).into());
 		},
 
-		LexerTokenType::BracketOpen | LexerTokenType::ArrayOpen => {
+		LexerTokenType::ArrayOpen => {
 			return parse_ast_array_init(tokens, ind);
 		}
 
@@ -194,7 +194,7 @@ pub fn parse_ast_value(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticR
 			return parse_ast_value_post_l(tokens, ind, str, false);
 		},
 
-		LexerTokenType::New => {
+		LexerTokenType::BracketOpen => {
 			return parse_struct_initialize(tokens, ind);
 		}
 
@@ -221,46 +221,36 @@ pub fn parse_ast_value(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticR
 
 pub fn parse_ast_array_init(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticResult<Box<ASTTreeNode>> {
 	let start = tokens[*ind].pos.clone();
+	*ind += 1;
 
-	if tokens[*ind].tok_type == LexerTokenType::BracketOpen {
-		*ind += 1;
-
-		let int_lit = tokens[*ind].expects_int_lit()?;
-
-		*ind += 1;
-
-		tokens[*ind].expects(LexerTokenType::Dot)?;
-
-		*ind += 1;
-
+	if tokens[*ind + 1].tok_type == LexerTokenType::Comma {
 		let val = parse_ast_value(tokens, ind)?;
 
-		tokens[*ind].expects(LexerTokenType::BracketClose)?;
-
+		tokens[*ind].expects(LexerTokenType::Comma)?;
 		*ind += 1;
 
-		return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::ArrayVariableInitializerValueSameValue { size: int_lit.0 as usize, v: val }, start, tokens[*ind].get_end_pos())));
-	}
+		let count = tokens[*ind].expects_int_lit()?;
 
-	tokens[*ind].expects(LexerTokenType::ArrayOpen)?;
-	*ind += 1;
+		return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::ArrayVariableInitializerValueSameValue { size: count.0 as usize, v: val }, start, tokens[*ind].get_end_pos())))
+	}
 
 	let mut vals = vec![];
 
 	loop {
-		vals.push(parse_ast_value(tokens, ind)?);
+		let val = parse_ast_value(tokens, ind)?;
 
 		if tokens[*ind].tok_type == LexerTokenType::ArrayClose {
 			break;
 		}
 
 		tokens[*ind].expects(LexerTokenType::Comma)?;
 		*ind += 1;
-	}
 
-	*ind += 1;
+		vals.push(val);
+	}
 
 	return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::ArrayVariableInitializerValue { vals }, start, tokens[*ind].get_end_pos())))
+
 }
 
 pub fn parse_ast_pointer(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticResult<Box<ASTTreeNode>> {

compiler/astoir_hir/src/ctx.rs

@@ -207,7 +207,7 @@ impl HIRBranchedContext {
 	pub fn is_eligible_for_ssa(&self, ind: usize) -> bool {
 		let var = &self.variables[ind];
 
-		return !var.requires_address && var.mutation_count <= 1 && !var.variable_type.can_use_index_access()
+		return !var.requires_address && var.mutation_count <= 1 && !var.variable_type.can_use_index_access() && false
 	}
 
 }

compiler/astoir_hir/src/lib.rs

@@ -3,4 +3,5 @@
 
 pub mod ctx;
 pub mod nodes;
-pub mod structs;
+pub mod structs;
+pub mod resolve;

compiler/astoir_hir/src/nodes.rs

@@ -1,11 +1,13 @@
 //! The nodes inside of the AstoIR HIR. 
 
+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_utils::Position;
+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};
 
-use crate::{ctx::{HIRBranchedContext, HIRContext}, structs::{HIRIfBranch, StructLRUStep}};
+use crate::{ctx::{HIRBranchedContext, HIRContext}, resolve::resolve_to_type, structs::{HIRIfBranch, StructLRUStep}};
 
 #[derive(Debug, Clone)]
 pub struct HIRNode {	
@@ -62,6 +64,8 @@ pub enum HIRNodeKind {
 
 	StructLRU { steps: Vec<StructLRUStep>, last: Type },
 
+	EnumParentCast { val: Box<HIRNode>, parent: Type },
+
 	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 },
 
@@ -71,7 +75,9 @@ pub enum HIRNodeKind {
 	ArrayIndexAccess { val: Box<HIRNode>, index: Box<HIRNode> },
 	ArrayIndexModify { array: Box<HIRNode>, index: Box<HIRNode>, new_val : Box<HIRNode> },
 
-	StructVariableInitializerValue { t: Type, fields: Vec<Box<HIRNode>> },
+	/// Before transmutation
+	StructInitializer { fields: HashMap<SelfHash, Box<HIRNode>> },
+	StructInitializerTyped { t: Type, fields: Vec<Box<HIRNode>> },
 
 	FunctionDeclaration { func_name: usize, arguments: Vec<(u64, Type)>, return_type: Option<Type>, body: Vec<Box<HIRNode>>, ctx: HIRBranchedContext, requires_this: bool },
 
@@ -132,6 +138,10 @@ impl HIRNode {
 	}
 
 	pub fn use_as<K: DiagnosticSpanOrigin>(&self, context: &HIRContext, curr_ctx: &HIRBranchedContext, t: Type, origin: &K, var_origin: Option<&K>) -> Result<HIRNode, ()> {
+		if self.is_intederminately_typed() {
+			return Ok(resolve_to_type(Box::new(self.clone()), t.clone(), context, curr_ctx, origin)?.use_as(context, curr_ctx, t, origin, var_origin)?);
+		}
+
 		let self_type = match self.get_node_type(context, curr_ctx) {
 			Some(v) => v,
 			_ => panic!("Tried using a typeless node in use_as: {:#?}", self)
@@ -146,7 +156,7 @@ impl HIRNode {
 				HIRNodeKind::IntegerLiteral { value, int_type: _ } => {
 					return Ok(self.with(HIRNodeKind::IntegerLiteral { value: *value, int_type: t }));
 				},
-
+				
 				HIRNodeKind::ArrayVariableInitializerValue { vals } => {
 					if can_transmute_inner(&self_type, &t, &context.type_storage) {
 						let mut new_vals = vec![];
@@ -181,6 +191,14 @@ impl HIRNode {
 		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 is_intederminately_typed(&self) -> bool {
+		match self.kind {
+			HIRNodeKind::StructInitializer { .. } => true,
+
+			_ => false
+		}
+	}
+
 	pub fn get_node_type(&self, context: &HIRContext, curr_ctx: &HIRBranchedContext) -> Option<Type> {
 		match &self.kind {
 			HIRNodeKind::VariableReference { index, is_static } => {
@@ -218,12 +236,7 @@ impl HIRNode {
 			},
 
 			HIRNodeKind::StringLiteral { value: _ } => {
-				let ind = match context.type_storage.types.get_index(STATIC_STR) {
-					Some(v) => v,
-					None => return None
-				};
-
-				return Some(Type::Generic(RawType::Boolean, vec![], vec![]))
+				return Some(Type::Generic(RawType::StaticString, vec![], vec![]))
 			},
 
 			HIRNodeKind::ArrayVariableInitializerValue { vals } => return Some(Type::Array(vals.len(), Box::new(vals[0].get_node_type(context, curr_ctx).unwrap()))),
@@ -241,9 +254,7 @@ impl HIRNode {
 				return Some(Type::Generic(RawType::Boolean, vec![], vec![]))
 			},
 
-			HIRNodeKind::StructVariableInitializerValue { t, fields: _ } => {
-				return Some(t.clone())
-			}
+			HIRNodeKind::StructInitializerTyped { t, fields: _ } => Some(t.clone()),
 
 			HIRNodeKind::FunctionCall { func_name, arguments: _ } => {
 				let f = context.functions.vals[*func_name].0.clone();

compiler/astoir_hir/src/resolve.rs

@@ -0,0 +1,41 @@
+//! Used to resolve incomplete HIR nodes like initializers
+
+use compiler_typing::tree::Type;
+use compiler_utils::hash::SelfHash;
+use diagnostics::{DiagnosticResult, DiagnosticSpanOrigin, builders::{make_req_type_kind, make_struct_init_missing_field}};
+
+use crate::{ctx::{HIRBranchedContext, HIRContext}, nodes::{HIRNode, HIRNodeKind}};
+
+/// Resolves incomplete HIR nodes into complete nodes
+pub fn resolve_to_type<K: DiagnosticSpanOrigin>(node: Box<HIRNode>, destination: Type, context: &HIRContext, curr_ctx: &HIRBranchedContext, origin: &K) -> DiagnosticResult<Box<HIRNode>> {
+	match node.kind {
+		HIRNodeKind::StructInitializer { fields } => {
+			let generic = destination.as_generic_safe(origin)?;
+			let mut new_fields = vec![];
+
+			if !generic.is_field_based() {
+				return Err(make_req_type_kind(origin, &"field-having".to_string()).into())
+			}
+
+			for field in destination.get_fields(&context.type_storage) {
+				let identity = SelfHash { hash: field };
+
+				if !fields.contains_key(&identity) {
+					return Err(make_struct_init_missing_field(origin, &destination, &field).into())
+				}
+
+				let val = fields[&identity].clone();
+
+				let field_data = destination.get_field(&context.type_storage, field)?.1.resolve(&destination);
+
+				let val = Box::new(val.use_as(context, curr_ctx, field_data, origin, None)?);
+
+				new_fields.push(val);
+			}
+
+			return Ok(Box::new(HIRNode::new(HIRNodeKind::StructInitializerTyped { t: destination, fields: new_fields }, &node.start, &node.end)))
+		},
+
+		_ => panic!("Invalid node")
+	}
+} 

compiler/astoir_hir_lowering/src/structs.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use ast::tree::{ASTTreeNode, ASTTreeNodeKind};
 use astoir_hir::{ctx::{HIRBranchedContext, HIRContext}, nodes::{HIRNode, HIRNodeKind}, structs::HIRStructContainer};
 use compiler_typing::{raw::RawType, structs::RawStructTypeContainer, tree::Type};
@@ -89,40 +91,14 @@ pub fn lower_ast_struct_declaration(context: &mut HIRContext, node: Box<ASTTreeN
 }
 
 pub fn lower_ast_struct_initializer(context: &mut HIRContext, curr_ctx: &mut HIRBranchedContext, node: Box<ASTTreeNode>) -> DiagnosticResult<Box<HIRNode>> {
-	if let ASTTreeNodeKind::StructVariableInitializerValue { struct_type, map } = node.kind.clone() {
-		let raw = match context.type_storage.get_type(HashedString::new(struct_type.get_generic_name()).hash) {
-			Ok(v) => Type::GenericLowered(v),
-			Err(_) => return Err(make_cannot_find_type(&*node, &struct_type.get_generic_name()).into())
-		};
-
-		let hir_type = lower_ast_type(context, struct_type, &*node)?;
-
-		let fields = raw.get_fields(&context.type_storage);
-
-		let mut vals = vec![];
-
-		for field in fields {
-			let id = SelfHash { hash: field };
-
-			if !map.contains_key(&id) {
-				return Err(make_struct_init_missing_field(&*node, &hir_type, &field).into())
-			}
-
-			let field = match raw.get_field(&context.type_storage, field) {
-				Ok(v) => v,
-				Err(_) => return Err(make_struct_missing_field(&*node, &hir_type, &id.hash).into())
-			};
-
-			let tt = field.1.resolve(&hir_type);
-
-			let val = lower_ast_value(context, curr_ctx, map[&id].clone())?;
-
-			let val = Box::new(val.use_as(context, curr_ctx, tt.clone(), &*node, None)?);
+	if let ASTTreeNodeKind::StructInitializer { map } = node.kind.clone() {
+		let mut new_map = HashMap::new();
 
-			vals.push(val)
+		for (k, v) in map {
+			new_map.insert(k, lower_ast_value(context, curr_ctx, v)?);
 		}
 
-		return Ok(Box::new(HIRNode::new(HIRNodeKind::StructVariableInitializerValue { t: hir_type, fields: vals }, &node.start, &node.end)))
+		return Ok(Box::new(HIRNode::new(HIRNodeKind::StructInitializer { fields: new_map }, &node.start, &node.end)))
 	}
 
 	panic!("Invalid node type")