feat: added ending point enforcment

Author: Zffu

compiler/astoir_hir/src/ctx.rs

@@ -184,6 +184,13 @@ impl HIRBranchedContext {
         return true;
     }
 
+    pub fn introduce_ending_point(&mut self, kind: EndingPointKind) {
+        self.ending_points.push(HIRBranchedEndingPoint {
+            introduced_in_era: self.current_branch,
+            kind,
+        })
+    }
+
     /// Determines if the element with the given index is still alive in the current branch.
     pub fn is_alive(&self, ind: usize) -> bool {
         let start_branch = self.variables[ind].introduced_in_era;
@@ -215,7 +222,7 @@ impl HIRBranchedContext {
     /// Determines if the current function meets the ending point requirement.
     /// The requirement is that every single branch should have an ending point that affects it.
     /// This function uses `is_code_alive` to check if the code ended on each branch before the current branch.
-	/// This function should only be ran at the end of body parsing
+    /// This function should only be ran at the end of body parsing
     pub fn meets_ending_point(&self) -> bool {
         if !self.is_code_alive(self.current_branch) {
             return true;

compiler/astoir_hir/src/nodes.rs

@@ -270,6 +270,13 @@ impl HIRNode {
         return false;
     }
 
+    pub fn is_ending_point(&self) -> bool {
+        match self.kind {
+            HIRNodeKind::ReturnStatement { .. } => true,
+            _ => false,
+        }
+    }
+
     pub fn get_variable_represent(&self) -> (usize, bool) {
         match &self.kind {
             HIRNodeKind::VariableReference { index, is_static } => return (*index, *is_static),

compiler/astoir_hir_lowering/src/func.rs

@@ -5,7 +5,10 @@ use astoir_hir::{
 };
 use compiler_global_scope::key::EntryKey;
 use compiler_typing::TypedGlobalScopeEntry;
-use diagnostics::{DiagnosticResult, builders::make_already_in_scope};
+use diagnostics::{
+    DiagnosticResult,
+    builders::{make_already_in_scope, make_ending_point_missing},
+};
 
 use crate::{lower_ast_body, types::lower_ast_type, values::lower_ast_value};
 
@@ -115,6 +118,10 @@ pub fn lower_ast_function_declaration(
 
         curr_ctx.end_branch(branch);
 
+        if !curr_ctx.meets_ending_point() {
+            return Err(make_ending_point_missing(&*body[body.len() - 1]).into());
+        }
+
         let implementation = Box::new(HIRNode::new(
             HIRNodeKind::FunctionDeclaration {
                 func_name: ind,

compiler/astoir_hir_lowering/src/lib.rs

@@ -3,10 +3,14 @@ use ast::{
     tree::{ASTTreeNode, ASTTreeNodeKind},
 };
 use astoir_hir::{
-    ctx::{HIRBranchedContext, HIRContext},
+    ctx::{EndingPointKind, HIRBranchedContext, HIRContext},
     nodes::{HIRNode, HIRNodeKind},
 };
-use diagnostics::{DiagnosticResult, DiagnosticSpanOrigin, move_current_diagnostic_pos};
+use diagnostics::{
+    DiagnosticResult, DiagnosticSpanOrigin,
+    builders::{make_ret_type_kind, make_unreachable_code},
+    move_current_diagnostic_pos,
+};
 use prelude::apply_prelude;
 
 use crate::{
@@ -68,20 +72,24 @@ pub fn lower_ast_body_node(
         ASTTreeNodeKind::ReturnStatement { val } => {
             let v;
 
+            if val.is_none() != curr_ctx.return_type.is_none() {
+                return Err(make_ret_type_kind(&*node).into());
+            }
+
             if val.is_none() {
+                curr_ctx.introduce_ending_point(EndingPointKind::NoneReturn);
+
                 v = None;
             } else {
-                let mut k = lower_ast_value(context, curr_ctx, val.unwrap())?;
-
-                if curr_ctx.return_type.is_some() {
-                    k = Box::new(k.use_as(
-                        context,
-                        curr_ctx,
-                        curr_ctx.return_type.clone().unwrap(),
-                        &*node,
-                        None,
-                    )?);
-                }
+                curr_ctx.introduce_ending_point(EndingPointKind::Return);
+
+                let k = Box::new(lower_ast_value(context, curr_ctx, val.unwrap())?.use_as(
+                    context,
+                    curr_ctx,
+                    curr_ctx.return_type.clone().unwrap(),
+                    &*node,
+                    None,
+                )?);
 
                 v = Some(k)
             }
@@ -129,7 +137,17 @@ pub fn lower_ast_body(
     }
 
     for n in nodes {
-        hir_nodes.push(lower_ast_body_node(context, curr_ctx, n)?);
+        let is_code_dead_pre = !curr_ctx.is_code_alive(curr_ctx.current_branch);
+
+        let node = lower_ast_body_node(context, curr_ctx, n)?;
+
+        if !curr_ctx.is_code_alive(curr_ctx.current_branch) {
+            if is_code_dead_pre || !node.is_ending_point() {
+                return Err(make_unreachable_code(&*node).into());
+            }
+        }
+
+        hir_nodes.push(node);
     }
 
     if introduce_era {

compiler/diagnostics/src/builders.rs

@@ -9,8 +9,8 @@ use crate::{
         ERA_NOT_EXIST, EXPECTED_FREE, EXPECTED_TOKEN, EXPECTED_TYPE, FIELD_MISSING,
         FIELD_STRUCT_INIT, FIND_TYPE, FIND_TYPE_FIELD, FIND_TYPE_FUNCTION, FIND_VAR, FUNC_MISSING,
         INDEX_USAGE, INVALID_POINTING, INVALID_TYPE_REQ, IR_CAST, IR_INSTRUCTION_HELD_VAL,
-        MATH_OPERATION_ASSIGNS, NOT_FOUND_USE, TRAIT_MISSING, TYPE_NOT_PART, UNEXPECTED_TOKEN,
-        VARIABLE_UNINIT,
+        MATH_OPERATION_ASSIGNS, NOT_FOUND_USE, RET_TYPE_NOT_MATCH, TRAIT_MISSING, TYPE_NOT_PART,
+        UNEXPECTED_TOKEN, VARIABLE_UNINIT,
     },
     get_current_diagnostic_pos,
     warnings::UNUSED_VAR,
@@ -669,3 +669,15 @@ pub fn make_unreachable_code<K: DiagnosticSpanOrigin>(origin: &K) -> Diagnostic
         vec!["move this code before the ending point".to_string()],
     )
 }
+
+pub fn make_ret_type_kind<K: DiagnosticSpanOrigin>(origin: &K) -> Diagnostic {
+    origin.make_simple_diagnostic(
+        RET_TYPE_NOT_MATCH.0,
+        Level::Error,
+        RET_TYPE_NOT_MATCH.1.to_string(),
+        None,
+        vec![],
+        vec![],
+        vec![],
+    )
+}

compiler/diagnostics/src/errors.rs

@@ -105,3 +105,8 @@ declare_error!(NOT_FOUND_USE, 32, "element {} was not found in {}");
 declare_error!(CANNOT_FIND, 33, "cannot find {} in the current scope");
 declare_error!(ENDING_POINT_MISSING, 34, "missing ending point.");
 declare_error!(CODE_UNREACHABLE, 35, "unreachable code.");
+declare_error!(
+    RET_TYPE_NOT_MATCH,
+    36,
+    "different return type kinds. one is empty and one is not."
+);