feat: made enum casting work

Author: Zffu

compiler/astoir_hir/src/nodes.rs

@@ -152,8 +152,6 @@ impl HIRNode {
 		}
 
 		if self_type.can_transmute(&t, &context.type_storage) {
-			println!("Can transmute {:#?} -> {:#?}", t, self);
-
 			match &self.kind {
 				HIRNodeKind::IntegerLiteral { value, int_type: _ } => {
 					return Ok(self.with(HIRNodeKind::IntegerLiteral { value: *value, int_type: t }));

compiler/astoir_hir_lowering/src/unwraps.rs

@@ -2,11 +2,11 @@ use ast::tree::{ASTTreeNode, ASTTreeNodeKind};
 use astoir_hir::{ctx::{HIRBranchedContext, HIRContext}, nodes::{HIRNode, HIRNodeKind}};
 use diagnostics::DiagnosticResult;
 
-use crate::{types::lower_ast_type, values::lower_ast_value};
+use crate::{types::lower_ast_type, values::lower_ast_value, var::lower_ast_variable_reference};
 
 pub fn lower_ast_condition_unwrap(context: &mut HIRContext, curr_ctx: &mut HIRBranchedContext, node: Box<ASTTreeNode>) -> DiagnosticResult<Box<HIRNode>> {
 	if let ASTTreeNodeKind::UnwrapCondition { original, target_type, unsafe_unwrap, target_var } = node.clone().kind {
-		let original = lower_ast_value(context, curr_ctx, original)?;
+		let original = lower_ast_variable_reference(context, curr_ctx, original, true)?;
 		let target_type = lower_ast_type(context, target_type, &*node)?;
 
 		if target_var.is_none() {

compiler/astoir_mir/src/vals/refer.rs

@@ -1,3 +1,4 @@
+use compiler_typing::storage::TypeStorage;
 use diagnostics::{DiagnosticResult, builders::make_invalid_assign_diff_type_ir, unsure_panic};
 
 use crate::{blocks::refer::MIRBlockReference, builder::{build_load, build_store}, ctx::MIRContext, vals::{base::BaseMIRValue, ptr::{MIRPointerValue}}};
@@ -39,7 +40,7 @@ impl MIRVariableReference {
 		}
 	}
 
-	pub fn write(&self, block: MIRBlockReference, ctx: &mut MIRContext, val: BaseMIRValue) -> DiagnosticResult<bool> {
+	pub fn write(&self, block: MIRBlockReference, ctx: &mut MIRContext, val: BaseMIRValue, storage: &TypeStorage) -> DiagnosticResult<bool> {
 		if self.is_pointer_ref() {
 			let mut ptr_ref = self.as_pointer_ref()?;	
 			let hint = ctx.ssa_hints.get_hint(BaseMIRValue::from(ptr_ref.clone().into()).get_ssa_index());
@@ -48,7 +49,7 @@ impl MIRVariableReference {
 				ptr_ref = build_load(ctx, ptr_ref)?.as_ptr()?;
 			}
 
-			build_store(ctx, ptr_ref, val)?;
+			build_store(ctx, storage, ptr_ref, val)?;
 
 			return Ok(true);
 		}

compiler/astoir_mir_lowering/src/arrays.rs

@@ -30,7 +30,7 @@ pub fn lower_hir_array_modify(block: MIRBlockReference, node: Box<HIRNode>, ctx:
 
 		let index_pointer = build_index_pointer(&mut ctx.mir_ctx, array, index)?;
 
-		build_store(&mut ctx.mir_ctx, index_pointer, val)?;
+		build_store(&mut ctx.mir_ctx,  &ctx.hir_ctx.type_storage, index_pointer, val)?;
 
 		return Ok(true);
 	}

compiler/astoir_mir_lowering/src/casts.rs

@@ -9,10 +9,7 @@ pub fn lower_cast(block: MIRBlockReference, node: Box<HIRNode>, ctx: &mut MIRLow
 		let value = lower_hir_value(block, value, ctx)?;
 		let old_type = lower_hir_type(ctx, old_type)?;
 
-		println!("Old: {:#?}", old_type);
-
 		let new_type = lower_hir_type(ctx, new_type)?;
-		println!("New: {:#?}", new_type);
 
 		if old_type.get_generic(&ctx.hir_ctx.type_storage).is_enum_child() && new_type.get_generic(&ctx.hir_ctx.type_storage).is_enum_parent() {
 			match ctx.mir_ctx.ssa_hints.vec[value.get_ssa_index()] {

compiler/astoir_mir_lowering/src/introductions.rs

@@ -21,9 +21,10 @@ pub fn handle_var_introduction_queue(block: MIRBlockReference, node: Box<HIRNode
 			let ptr = build_stack_alloc(&mut ctx.mir_ctx, new_type.get_size(&new_type, false, &ctx .hir_ctx.type_storage), new_type)?;
 
 			ctx.mir_ctx.blocks[block].variables.insert(new_var, MIRBlockVariableSSAHint { kind: MIRBlockVariableType::Pointer, hint: Some(ptr.clone().into()) });
-			build_store(&mut ctx.mir_ctx, ptr.clone(), casted)?;
+			build_store(&mut ctx.mir_ctx, &ctx.hir_ctx.type_storage, ptr.clone(), casted)?;
 		}
 
+		return Ok(())
 	}
 
 	panic!("Invalid node")

compiler/astoir_mir_lowering/src/math.rs

@@ -34,7 +34,7 @@ pub fn lower_hir_math_operation(block: MIRBlockReference, node: Box<HIRNode>, ct
 		if assignment {
 			let v = ptr.unwrap();
 
-			v.write(block, &mut ctx.mir_ctx, val.clone())?;
+			v.write(block, &mut ctx.mir_ctx, val.clone(), &ctx.hir_ctx.type_storage)?;
 		}
 
 		return Ok(val)

compiler/astoir_mir_lowering/src/type_tools.rs

@@ -5,7 +5,7 @@ use astoir_mir::{blocks::refer::MIRBlockReference, builder::{build_comp_eq, buil
 use compiler_typing::{SizedType, raw::RawType, tree::Type};
 use diagnostics::{DiagnosticResult, DiagnosticSpanOrigin, builders::{make_req_type_kind, make_type_not_partof}};
 
-use crate::{MIRLoweringContext, lower_hir_type, values::lower_hir_value};
+use crate::{MIRLoweringContext, lower_hir_type, values::lower_hir_value, vars::lower_hir_variable_reference};
 
 pub fn is_enum_value_of_kind<K: DiagnosticSpanOrigin>(block: MIRBlockReference, val: BaseMIRValue, enum_entry: RawType, ctx: &mut MIRLoweringContext, origin: &K) -> DiagnosticResult<MIRIntValue> {
 	let enum_type = match ctx.mir_ctx.ssa_hints.get_hint(val.get_ssa_index()).get_type().as_generic_lowered_safe(origin)? {
@@ -51,11 +51,26 @@ pub fn is_enum_value_of_kind<K: DiagnosticSpanOrigin>(block: MIRBlockReference,
 pub fn cast_to_enum_child<K: DiagnosticSpanOrigin>(block: MIRBlockReference, val: BaseMIRValue, enum_entry: RawType, ctx: &mut MIRLoweringContext, origin: &K) -> DiagnosticResult<BaseMIRValue> {
 	let enum_type = match ctx.mir_ctx.ssa_hints.get_hint(val.get_ssa_index()).get_type().as_generic_lowered_safe(origin)? {
 		RawType::Enum(v) => v,
+		RawType::LoweredStruct(_, container) => {
+			if !container.is_lowered_enum_parent {
+				return Err(make_req_type_kind(origin, &"enum parent".to_string()).into())
+			}
+
+			container.lowered_enum_parent.unwrap()
+		},
+		
 		_ => return Err(make_req_type_kind(origin, &"enum parent".to_string()).into())
 	};
 
 	let enum_entry_container = match &enum_entry {
 		RawType::EnumEntry(v) => v,
+		RawType::LoweredStruct(_, container) => {
+			if !container.is_lowered_enum_child {
+				return Err(make_req_type_kind(origin, &"enum parent".to_string()).into())
+			}
+
+			container.lowered_enum_child.as_ref().unwrap()
+		},
 		_ => return Err(make_req_type_kind(origin, &"enum child".to_string()).into())
 	};
 
@@ -68,7 +83,7 @@ pub fn cast_to_enum_child<K: DiagnosticSpanOrigin>(block: MIRBlockReference, val
 
 pub fn lower_hir_unwrap_cond(block: MIRBlockReference, node: Box<HIRNode>, ctx: &mut MIRLoweringContext) -> DiagnosticResult<BaseMIRValue> {
 	if let HIRNodeKind::UnwrapCondition { original, new_type, new_var, unsafe_unwrap } = node.kind.clone() {
-		let original = lower_hir_value(block, original, ctx)?;
+		let original = lower_hir_variable_reference(block, &original, ctx)?.as_pointer_ref()?.into();
 		let new_type = lower_hir_type(ctx, new_type)?;
 
 		let cond;

compiler/astoir_mir_lowering/src/vars.rs

@@ -30,7 +30,7 @@ pub fn lower_hir_variable_declaration(block_id: MIRBlockReference, node: Box<HIR
 			if default_val.is_some() {
 				let val = lower_hir_value(block_id, default_val.unwrap(), ctx)?;
 
-				build_store(&mut ctx.mir_ctx, ptr.clone(), val)?;
+				build_store(&mut ctx.mir_ctx, &ctx.hir_ctx.type_storage, ptr.clone(), val)?;
 			}
 		}
 
@@ -64,7 +64,7 @@ pub fn lower_hir_variable_assignment(block: MIRBlockReference, node: Box<HIRNode
 
 		let val = lower_hir_value(block, val, ctx)?;
 
-		variable_ref.write(block, &mut ctx.mir_ctx, val)?;
+		variable_ref.write(block, &mut ctx.mir_ctx, val, &ctx.hir_ctx.type_storage)?;
 		return Ok(true);
 	}