Fixes #21235, fixes #23602, fixes #24978, fixes #25018

Author: yglukhov

compiler/closureiters.nim

@@ -159,7 +159,7 @@ type
     fn: PSym
     tmpResultSym: PSym # Used when we return, but finally has to interfere
     finallyPathSym: PSym
-    curExcSym: PSym # Current exception
+    curExcLevelSym: PSym # Current exception
 
     # states: seq[tuple[label: PNode, body: PNode, inlinable: bool]] # The resulting states. Label is int literal.
     states: seq[State] # The resulting states. Label is int literal.
@@ -246,10 +246,10 @@ proc newFinallyPathAssign(ctx: var Ctx, level: int, label: PNode, info: TLineInf
   let fp = newFinallyPathAccess(ctx, level, info)
   result = newTree(nkAsgn, fp, label)
 
-proc newCurExcAccess(ctx: var Ctx): PNode =
-  if ctx.curExcSym.isNil:
-    ctx.curExcSym = ctx.newEnvVar(":curExc", ctx.g.callCodegenProc("getCurrentException").typ)
-  ctx.newEnvVarAccess(ctx.curExcSym)
+proc newCurExcLevelAccess(ctx: var Ctx): PNode =
+  if ctx.curExcLevelSym.isNil:
+    ctx.curExcLevelSym = ctx.newEnvVar(":curExcLevel", ctx.g.getSysType(ctx.fn.info, tyInt16))
+  ctx.newEnvVarAccess(ctx.curExcLevelSym)
 
 proc newStateLabel(ctx: Ctx): PNode =
   ctx.g.newIntLit(TLineInfo(), 0)
@@ -310,13 +310,24 @@ proc hasYields(n: PNode): bool =
         result = true
         break
 
-proc newNullifyCurExc(ctx: var Ctx, info: TLineInfo): PNode =
-  # :curEcx = nil
-  let curExc = ctx.newCurExcAccess()
+proc newNullifyCurExcLevel(ctx: var Ctx, info: TLineInfo, decrement = false): PNode =
+  # :curEcx = 0
+  let curExc = ctx.newCurExcLevelAccess()
   curExc.info = info
-  let nilnode = newNodeIT(nkNilLit, info, curExc.typ)
+  let nilnode = ctx.g.newIntLit(info, 0)
   result = newTree(nkAsgn, curExc, nilnode)
 
+proc newChangeCurExcLevel(ctx: var Ctx, info: TLineInfo, by: int): PNode =
+  # inc :curEcx
+  let curExc = ctx.newCurExcLevelAccess()
+  curExc.info = info
+  # let nilnode = newNodeIT(nkNilLit, info, curExc.typ)
+  # result = newTree(nkAsgn, curExc, nilnode)
+
+  result = newTreeIT(nkCall, info, ctx.g.getSysType(info, tyVoid),
+                     newSymNode(ctx.g.getSysMagic(info, "inc", mInc)), curExc,
+                     ctx.g.newIntLit(info, by))
+
 proc newOr(g: ModuleGraph, a, b: PNode): PNode {.inline.} =
   result = newTreeIT(nkCall, a.info, g.getSysType(a.info, tyBool),
                      newSymNode(g.getSysMagic(a.info, "or", mOr)), a, b)
@@ -389,7 +400,7 @@ proc addElseToExcept(ctx: var Ctx, n, gotoOut: PNode) =
 
     n.add newTree(nkCall,
       newSymNode(ctx.g.getCompilerProc("popCurrentException")))
-    n.add(ctx.newNullifyCurExc(n.info))
+    n.add(ctx.newChangeCurExcLevel(n.info, -1))
     if gotoOut != nil:
       n.add(ctx.newFinallyPathAssign(ctx.curFinallyLevel - 1, gotoOut[0], n.info))
 
@@ -891,13 +902,13 @@ proc newEndFinallyNode(ctx: var Ctx, info: TLineInfo): PNode =
                           nextState,
                           ctx.g.newIntLit(info, 0))
 
-  let curExc = ctx.newCurExcAccess()
-  let nilnode = newNodeIT(nkNilLit, info, curExc.typ)
+  let curExc = ctx.newCurExcLevelAccess()
+  # let nilnode = newNodeIT(nkNilLit, info, curExc.typ)
   let excNilCmp = newTreeIT(nkCall,
                       info, ctx.g.getSysType(info, tyBool),
-                      newSymNode(ctx.g.getSysMagic(info, "==", mEqRef), info),
+                      newSymNode(ctx.g.getSysMagic(info, "==", mEqI), info),
                       curExc,
-                      nilnode)
+                      ctx.g.newIntLit(info, 0))
 
   let retStmt =
     block:
@@ -917,7 +928,7 @@ proc newEndFinallyNode(ctx: var Ctx, info: TLineInfo): PNode =
                        newTree(nkElse,
                            newTree(nkStmtList,
                                    # newTreeI(nkCall, info, newSymNode(ctx.g.getCompilerProc("closureIterSetupExc")), nilnode),
-                                   newTreeI(nkRaiseStmt, info, curExc))))
+                                   newTreeI(nkRaiseStmt, info, ctx.g.emptyNode))))
 
   result = newTree(nkIfStmt,
                    newTreeI(nkElifBranch, info, cmpStateToZero, ifBody),
@@ -1000,7 +1011,7 @@ proc transformReturnStmt(ctx: var Ctx, n: PNode): PNode =
   # debug(n[0])
 
   result = newNodeI(nkStmtList, n.info)
-  result.add(ctx.newNullifyCurExc(n.info))
+  result.add(ctx.newNullifyCurExcLevel(n.info))
 
   var finallyChain = newSeq[PNode]()
 
@@ -1428,10 +1439,10 @@ proc newCatchBody(ctx: var Ctx, info: TLineInfo): PNode {.inline.} =
   #   result.add(ifStmt)
 
   # :curExc = getCurrentException()
-  block:
-    result.add(newTree(nkAsgn,
-      ctx.newCurExcAccess(),
-      ctx.g.callCodegenProc("getCurrentException")))
+  # block:
+  #   result.add(newTree(nkAsgn,
+  #     ctx.newCurExcAccess(),
+  #     ctx.g.callCodegenProc("getCurrentException")))
 
 proc wrapIntoTryExcept(ctx: var Ctx, n: PNode): PNode {.inline.} =
   # let setupExc = newTree(nkCall,
@@ -1454,6 +1465,8 @@ proc wrapIntoTryExcept(ctx: var Ctx, n: PNode): PNode {.inline.} =
   exceptBody.add ctx.newTempVarAsgn(tempExc, getCurExc)
 
   result.add newTree(nkCall, newSymNode(ctx.g.getCompilerProc("pushCurrentException")), ctx.newTempVarAccess(tempExc))
+  result.add ctx.newChangeCurExcLevel(n.info, 1)
+
   # result = newTree(nkTryStmt, tryBody, exceptBranch)
 
 proc wrapIntoStateLoop(ctx: var Ctx, n: PNode): PNode =
@@ -1648,7 +1661,7 @@ proc transformClosureIterator*(g: ModuleGraph; idgen: IdGenerator; fn: PSym, n:
   result = wrapIntoStateLoop(ctx, caseDispatcher)
   result = liftLocals(ctx, result)
 
-  when true:
+  when false:
     echo "TRANSFORM TO STATES: "
     echo renderTree(result)
 

tests/async/t23602.nim

@@ -0,0 +1,27 @@
+import std/asyncdispatch
+
+proc errval {.async.} =
+  raise newException(ValueError, "err")
+  
+proc err {.async.} =
+  try:
+    doAssert false
+  finally:
+    echo "finally"
+    # removing the following code will propagate the AssertionDefect
+    try:
+      await errval()
+    except ValueError:
+      echo "valueError"
+
+proc main {.async.} =
+  let errFut = err()
+  await errFut
+
+var ok = false
+try:
+  waitFor main()
+except AssertionDefect:
+  ok = true
+
+doAssert(ok)