ok

Author: yglukhov

compiler/closureiters.nim

@@ -108,14 +108,16 @@
 #   yield 0
 #   raise ...
 #   :finallyPath[LEVEL] = 3 # Exception did not happen. Our finally can continue to state 3
-#   :state = 2             # And we continue to our finally
+#   :state = 2              # And we continue to our finally
 #   break :stateLoop
 # of 1: # Except
+#   inc(:curExcLevel, -1)    # Exception is caught
 #   yield 1
 #   :tmpResult = 3           # Return
 #   :finalyPath[LEVEL] = 0   # Configure finally path.
 #   :state = 2 # Goto Finally
 #   break :stateLoop
+#   popCurrentException()    # XXX: This is likely wrong, see #25031
 #   :state = 2 # What would happen should we not return
 #   break :stateLoop
 # of 2: # Finally
@@ -140,8 +142,6 @@ import
   renderer, magicsys, lowerings, lambdalifting, modulegraphs, lineinfos,
   options
 
-import astalgo
-
 import std/tables
 
 when defined(nimPreviewSlimSystem):
@@ -344,12 +344,10 @@ proc collectExceptState(ctx: var Ctx, n: PNode): PNode {.inline.} =
         else:
           ifBranch = newNodeI(nkElse, c.info)
 
-      ifBranch.add(c[^1])
+      ifBranch.add(newTreeI(nkStmtList, c.info, ctx.newChangeCurExcLevel(c.info, -1), c[^1]))
       ifStmt.add(ifBranch)
 
   if ifStmt.len != 0:
-    # let setupExc = newTree(nkCall, newSymNode(ctx.g.getCompilerProc("pushCurrentException")), ctx.newCurExcAccess())
-    # result = newTree(nkStmtList, ctx.newNullifyCurExc(n.info), ifStmt)
     result = newTree(nkStmtList, ifStmt)
   else:
     result = ctx.g.emptyNode
@@ -361,14 +359,24 @@ proc addElseToExcept(ctx: var Ctx, n, gotoOut: PNode) =
     if n[0].kind == nkIfStmt and n[0][^1].kind != nkElse:
       # Not all cases are covered, which means exception is not handled
       # and we should go to parent exception landing state
+      let action =
+        if ctx.curFinallyLevel == 0:
+          # There is no suitable finally around. We must reraise.
+          newTreeI(nkRaiseStmt, n.info, ctx.g.emptyNode)
+        else:
+          # Jump to finally.
+          newTree(nkGotoState, ctx.curExcLandingState)
+
       n[0].add(newTree(nkElse,
-                       newTreeI(nkStmtList, n.info,
-                                newTree(nkGotoState, ctx.curExcLandingState))))
+                       newTreeI(nkStmtList, n.info, action)))
 
     # Exception is handled
+    # XXX: This is likely wrong. See #25031. We must clear exception not only here
+    # at the end of except but also when except flow is interrupted with break or return
+    # and if there's a raise in except flow, current exception must be replaced with the
+    # raised one.
     n.add newTree(nkCall,
       newSymNode(ctx.g.getCompilerProc("popCurrentException")))
-    n.add(ctx.newChangeCurExcLevel(n.info, -1))
     if gotoOut != nil:
       # We have a finally node following this except block, and exception is handled
       # Configure its path to continue normally
@@ -848,7 +856,6 @@ proc newEndFinallyNode(ctx: var Ctx, info: TLineInfo): PNode =
                        newTree(nkElifBranch, excNilCmp, retStmt),
                        newTree(nkElse,
                            newTree(nkStmtList,
-                                   # newTreeI(nkCall, info, newSymNode(ctx.g.getCompilerProc("closureIterSetupExc")), nilnode),
                                    newTreeI(nkRaiseStmt, info, ctx.g.emptyNode))))
 
   result = newTree(nkIfStmt,
@@ -1496,7 +1503,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/iter/tyieldintry.nim

@@ -182,21 +182,56 @@ block:
 
   test(it, 0, 1, 2, 3)
 
-# block: # Return in except with no finallies around
-#   iterator it(): int {.closure.} =
-#     try:
-#       try:
-#         yield 0
-#         raiseTestError()
-#       finally:
-#         checkpoint(1)
-#     except ValueError:
-#       yield 2
-#       return
-
-#     checkpoint(123)
-
-#   test(it, 0, 1, 2)
+block: # Wrong except
+  iterator it(): int {.closure.} =
+    try:
+      try:
+        yield 0
+        raiseTestError()
+      except ValueError:
+        doAssert(false, "Unreachable")
+      finally:
+        checkpoint(1)
+    except ValueError:
+      yield 123
+      return
+
+    checkpoint(123)
+
+  testExc(it, 0, 1)
+
+block: # Nexted except without finally
+  iterator it(): int {.closure.} =
+    try:
+      try:
+        yield 0
+        raiseTestError()
+      except ValueError:
+        doAssert(false, "Unreachable")
+    except ValueError:
+      yield 123
+
+    checkpoint(123)
+
+  testExc(it, 0)
+
+block: # Return in except with no finallies around
+  iterator it(): int {.closure.} =
+    try:
+      try:
+        yield 0
+        raiseTestError()
+      except ValueError:
+        doAssert(false, "Unreachable")
+      finally:
+        checkpoint(1)
+    except TestError:
+      yield 2
+      return
+
+    checkpoint(123)
+
+  test(it, 0, 1, 2)
 
 block:
   iterator it(): int {.closure.} =