refactor: improve control flow analysis and error handling in functions

Author: itsfuad

app/cmd/if_test.fer

@@ -55,6 +55,9 @@ fn isEven(number: i32) -> bool {
     } else {
         return false;
     }
+
+    // unreachable code
+    let unreachableVar := 100;
 }
 
 fn classify(score: i32) -> i32 {
@@ -80,12 +83,15 @@ fn complexLogic(x: i32, y: i32, z: i32) -> i32 {
             } else {
                 return 2; // x and y positive, z non-positive
             }
+            return 0;
         } else {
             return 3; // x positive, y non-positive
         }
     } else {
         return 4; // x non-positive
     }
+
+    return 0;
 }
 
 // Function that uses other functions

app/cmd/proposal.fer

@@ -0,0 +1,32 @@
+
+// fetch returns a string or an error
+fn fetchData() -> str, error {
+
+    // dummy variable "dataAvailable" to simulate data availability
+    if !dataAvailable {
+        return Error("network down", 500)!; // "!" suffix indicates an error message
+    }
+
+    return "payload"; // successful return
+}
+
+fn main() {
+
+    // | value | { ... } is a closure that handles the error case for possible error return from functions
+    let data, _ := fetchData()
+
+
+
+
+    
+
+    print("Got: " + data);
+
+    // Optional types use Type? syntax. Value can be of the type or None.
+    // None is a constant representing absence of value.
+    let maybeUser: str? = None;
+    let name: str = maybeUser ?? "Guest"; // "??" operator provides a default value if the variable is None
+    print("Hello, " + name);
+}
+
+

app/cmd/start.fer

@@ -32,14 +32,21 @@ geometry::area_circle(3.0);
 
 fn doSomething() {
     // This function does something
+    add(1, 5, voidfn);
+    //myfunc();
 }
 
-fn add(a: i32, b: i32) -> i32 {
+fn add(a: i32, b: i32, callback: fn()) -> i32 {
+
+    callback();
     return a + b;
 }
 
 let value := 10;
 
+// let myfunc := fn() {
+
+// };
 
 let myname := "Ferret";
 let byt := myname[0];

app/cmd/test.fer

@@ -25,3 +25,51 @@ const later := fn() -> i32 {
 
 // comment
 //let x := a + ;
+
+
+// type Point struct {
+//     .x: i32,
+//     .y: i32
+// };
+
+// let p := Point { .x = 12, .y = 38 };
+
+// print(p.x)
+
+// -------------------
+
+// type Point struct {
+//     x: i32,
+//     y: i32
+// };
+
+// let p := @Point { x: 12, y: 29 };
+
+
+// // Optional types
+
+// let res : str?; // string or None
+// res = "hello"; // valid
+// res = None; // valid
+
+// let data: str = res ?? "No value"; // if res is None, assign "No value" to data
+
+// // if res != None {
+// //     print(res);
+// // } else {
+// //     print("no value");
+// // }
+
+// // Error return from functions
+// fn mayFail() -> str ! {
+//     if dataAvalable {
+//         return "Data";
+//     } else {
+//         return "Error occurred"!;
+//     }
+// }
+
+// let result: str = mayFail() | error | {
+//     print("Handling error: " + error);
+//     return;
+// }

app/fer.ret

@@ -4,7 +4,7 @@ name = "demo-app"
 version = "0.0.2"
 
 [build]
-entry = "cmd/start.fer"
+entry = "cmd/if_test.fer"
 output = "bin"
 
 [cache]

compiler/internal/semantic/typecheck/control_flow.go

@@ -161,8 +161,8 @@ func analyzeControlFlow(r *analyzer.AnalyzerNode, block *ast.Block, cm *modules.
 	hasConditionals := false
 
 	// Process all nodes in the block
-	earlyReturn, hasConditionals := processBlockNodes(r, block, cm, expectedReturnType, &result, &conditionalResults, hasConditionals)
-	if earlyReturn {
+	foundReturn, hasConditionals := processBlockNodes(r, block, cm, expectedReturnType, &result, &conditionalResults, hasConditionals)
+	if foundReturn {
 		return result
 	}
 
@@ -179,15 +179,20 @@ func createEmptyControlFlowResult() ControlFlowResult {
 	}
 }
 
-// processBlockNodes processes all nodes in a block and returns early if return found
+// processBlockNodes processes all nodes in a block and detects unreachable code
 func processBlockNodes(r *analyzer.AnalyzerNode, block *ast.Block, cm *modules.Module, expectedReturnType stype.Type,
 	result *ControlFlowResult, conditionalResults *[]ControlFlowResult, hasConditionals bool) (bool, bool) {
 
 	reachable := true
+	foundReturn := false
+	var unreachableStart *source.Location
 
 	for _, node := range block.Nodes {
 		if !reachable {
-			reportUnreachableCode(r, node)
+			// Mark the start of unreachable section on first unreachable node
+			if unreachableStart == nil {
+				unreachableStart = node.Loc()
+			}
 			continue
 		}
 
@@ -198,28 +203,35 @@ func processBlockNodes(r *analyzer.AnalyzerNode, block *ast.Block, cm *modules.M
 			if !hasConditionals {
 				result.HasFallbackReturn = true
 			}
-			return true, hasConditionals // Early return found
+			reachable = false // Mark subsequent code as unreachable
+			foundReturn = true
 		case *ast.IfStmt:
 			hasConditionals = true
 			ifResult := analyzeIfStatement(r, n, cm, expectedReturnType)
 			*conditionalResults = append(*conditionalResults, ifResult)
 			if ifResult.AllPathsReturn {
 				result.AllPathsReturn = true
-				return true, hasConditionals // All paths in if statement return
+				reachable = false // Mark subsequent code as unreachable
+				foundReturn = true
 			}
 		default:
 			checkNode(r, node, cm)
 		}
 	}
 
-	return false, hasConditionals
+	// Report unreachable section once if any was found
+	if unreachableStart != nil {
+		reportUnreachableSection(r, unreachableStart)
+	}
+
+	return foundReturn, hasConditionals
 }
 
-// reportUnreachableCode reports unreachable code after return
-func reportUnreachableCode(r *analyzer.AnalyzerNode, node ast.Node) {
+// reportUnreachableSection reports a section of unreachable code after return
+func reportUnreachableSection(r *analyzer.AnalyzerNode, startLoc *source.Location) {
 	r.Ctx.Reports.AddSemanticError(
 		r.Program.FullPath,
-		node.Loc(),
+		startLoc,
 		"unreachable code after return statement",
 		report.TYPECHECK_PHASE,
 	)