compiler: fix deferred calls may not be executed before optimized exceptional forwarding

Author: mertcandav

src/julec/obj/cxx/scope.jule

@@ -1783,8 +1783,22 @@ impl scopeCoder {
 	}
 
 	fn exceptionalForwarding(mut &self, mut m: &opt::ExceptionalForwardingExpr) {
-		self.oc.write("return ")
+		hasDefer := m.Func.Decl != nil && m.Func.Decl.HasDefer
+		if !hasDefer {
+			self.oc.write("return ")
+			self.oc.ec.pureFuncCall(m.Expr)
+			ret
+		}
+		if m.Func.Decl.IsVoid() {
+			self.oc.write("__jule_VoidExceptional")
+		} else {
+			self.oc.write("__jule_Exceptional<")
+			self.oc.tc.rc.codeMut1(&self.oc.Buf, m.Func.Result)
+			self.oc.write(">")
+		}
+		self.oc.write(" __result = ")
 		self.oc.ec.pureFuncCall(m.Expr)
+		self.oc.write("; " + deferStackName + ".call(); return __result;")
 	}
 
 	// Generates C++ code of statement.

src/julec/opt/expr.jule

@@ -809,12 +809,12 @@ impl exprOptimizer {
 	// Tries to optimize scope.
 	// If the |child| true and |self.scopeOpt| is not nil, calls the optimizeChildHard().
 	// Otherwise optimizes the scope with immutable copy of the data if exist.
-	fn scope(*self, mut s: &sema::Scope, child: bool) {
+	fn scope(*self, mut owner: &sema::FuncIns, mut s: &sema::Scope, child: bool) {
 		if child && self.scopeOpt != nil {
 			self.scopeOpt.optimizeChildHard(s)
 			ret
 		}
-		mut scopt := scopeOptimizer.new(s)
+		mut scopt := scopeOptimizer.new(owner, s)
 		if self.data != nil {
 			// If data exist, use it as immutable copy.
 			// Because this scope is not child.
@@ -932,7 +932,7 @@ impl exprOptimizer {
 			// Handle exceptional handler scope as child.
 			// Because it is actually a child scope.
 			const Child = true
-			self.scope(m.Except, Child)
+			self.scope(nil, m.Except, Child)
 		}
 		match {
 		| StdStrings && meta::Program.StrBuilder != nil:
@@ -994,7 +994,7 @@ impl exprOptimizer {
 		// It is possible with references, but it is unsafe operation.
 		// So optimizer is not have to thing such cases.
 		const Child = false
-		self.scope(m.Func.Scope, Child)
+		self.scope(m.Func, m.Func.Scope, Child)
 	}
 
 	fn inspectStep(*self, mut &m: *sema::Expr) {

src/julec/opt/model.jule

@@ -15,6 +15,7 @@ struct BytesFromStr {
 }
 
 struct ExceptionalForwardingExpr {
+	Func: &sema::FuncIns
 	Expr: &sema::FuncCallExpr
 }
 

src/julec/opt/optimizer.jule

@@ -39,7 +39,7 @@ impl Optimizer {
 			ret
 		}
 		for (_, mut ins) in func.Instances {
-			mut so := scopeOptimizer.new(ins.Scope)
+			mut so := scopeOptimizer.new(ins, ins.Scope)
 			so.optimize()
 		}
 	}

src/julec/opt/scope.jule

@@ -15,15 +15,17 @@ use "std/strings"
 
 // Scope optimizer that applies target-independent optimizations.
 struct scopeOptimizer {
+	owner:  &sema::FuncIns
 	parent: &scopeOptimizer
 	i:      int
 	scope:  &sema::Scope
 	data:   &data // Should be non-nil guaranteed.
 }
 
 impl scopeOptimizer {
-	fn new(mut scope: &sema::Scope): &scopeOptimizer {
+	fn new(mut owner: &sema::FuncIns, mut scope: &sema::Scope): &scopeOptimizer {
 		mut sc := &scopeOptimizer{
+			owner: owner,
 			scope: scope,
 			data: &data{
 				boundary: new(boundary),
@@ -34,6 +36,16 @@ impl scopeOptimizer {
 		ret sc
 	}
 
+	fn getOwner(mut &self): &sema::FuncIns {
+		mut s := self
+		for s != nil; s = s.parent {
+			if s.owner != nil {
+				ret s.owner
+			}
+		}
+		ret nil
+	}
+
 	fn setCurrentStmt(mut &self, mut stmt: any) {
 		self.scope.Stmts[self.i] = unsafe { *(*sema::Stmt)(&stmt) }
 	}
@@ -925,7 +937,11 @@ impl scopeOptimizer {
 			!obj::IsForwarded(fc.Except) {
 			ret
 		}
-		self.setCurrentStmt(&ExceptionalForwardingExpr{Expr: fc})
+		mut owner := self.getOwner()
+		if owner == nil {
+			panic("unreachable")
+		}
+		self.setCurrentStmt(&ExceptionalForwardingExpr{Func: owner, Expr: fc})
 	}
 
 	// Like optimizeStmt, but handles independent statement from the scope.
@@ -946,7 +962,7 @@ impl scopeOptimizer {
 		//	`x = 10; y = 20`, after optimization.
 		mut scope := new(sema::Scope)
 		scope.Stmts = append(scope.Stmts, *stmt)
-		mut opt := scopeOptimizer.new(scope)
+		mut opt := scopeOptimizer.new(nil, scope)
 		opt.optimize()
 		*stmt = scope
 	}
@@ -988,7 +1004,7 @@ impl scopeOptimizer {
 
 	// Optimizes child scope using mutable data.
 	fn optimizeChild(mut &self, mut child: &sema::Scope) {
-		mut so := scopeOptimizer.new(child)
+		mut so := scopeOptimizer.new(nil, child)
 		so.parent = self
 		so.data = self.data
 		so.optimize()