cleanup

Author: yglukhov

compiler/closureiters.nim

@@ -846,56 +846,12 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
 
 proc newEndFinallyNode(ctx: var Ctx, info: TLineInfo): PNode =
   # Generate the following code:
-  #   if :unrollFinally:
-  #       if :curExc.isNil:
-  #         WHEN nearestFinally == 0:
-  #           return :tmpResult
-  #         else:
-  #           :state = nearestFinally # bubble up
-  #       else:
-  #         raise
-
-  # let curExc = ctx.newCurExcAccess()
-  # let nilnode = newNode(nkNilLit)
-  # nilnode.typ() = curExc.typ
-  # let cmp = newTree(nkCall, newSymNode(ctx.g.getSysMagic(info, "==", mEqRef), info), curExc, nilnode)
-  # cmp.typ() = ctx.g.getSysType(info, tyBool)
-
-  # let retStmt =
-  #   if ctx.nearestFinally == 0:
-  #     # last finally, we can return
-  #     let retValue = if ctx.fn.typ.returnType.isNil:
-  #                  ctx.g.emptyNode
-  #                else:
-  #                  newTree(nkFastAsgn,
-  #                          newSymNode(getClosureIterResult(ctx.g, ctx.fn, ctx.idgen), info),
-  #                          ctx.newTmpResultAccess())
-  #     newTree(nkReturnStmt, retValue)
+  # if :finallyPath[FINALLY_LEVEL] == 0:
+  #   if :curExcLevel == 0:
+  #     :state = -1
+  #     return result = :tmpResult
   #   else:
-  #     # bubble up to next finally
-  #     newTree(nkGotoState, ctx.g.newIntLit(info, ctx.nearestFinally))
-
-  # let branch = newTree(nkElifBranch, cmp, retStmt)
-
-  # let nullifyExc = newTree(nkCall, newSymNode(ctx.g.getCompilerProc("closureIterSetupExc")), nilnode)
-  # nullifyExc.info = info
-  # let raiseStmt = newTree(nkRaiseStmt, curExc)
-  # raiseStmt.info = info
-  # let elseBranch = newTree(nkElse, newTree(nkStmtList, nullifyExc, raiseStmt))
-
-  # let ifBody = newTree(nkIfStmt, branch, elseBranch)
-  # let elifBranch = newTree(nkElifBranch, ctx.newUnrollFinallyAccess(info), ifBody)
-  # elifBranch.info = info
-  # result = newTree(nkIfStmt, elifBranch)
-
-  # Generate the following code:
-  #   if :env.finallyPath[curFinallyLevel_const] == 0
-  #     if :curExc.isNil:
-  #       return :tmpResult
-  #     else:
-  #       raise
-  #   else:
-  #     :state = :env.finallyPath[curFinallyLevel_const]
+  #     raise
 
   let nextState = ctx.newFinallyPathAccess(ctx.curFinallyLevel, info)
   let exitFinally = newTree(nkGotoState, nextState)
@@ -907,7 +863,6 @@ proc newEndFinallyNode(ctx: var Ctx, info: TLineInfo): PNode =
                           ctx.g.newIntLit(info, 0))
 
   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, "==", mEqI), info),
@@ -925,7 +880,6 @@ proc newEndFinallyNode(ctx: var Ctx, info: TLineInfo): PNode =
       newTree(nkReturnStmt, retValue)
   retStmt.flags.incl(nfNoRewrite)
 
-
   let ifBody = newTree(nkIfStmt,
                        newTree(nkElifBranch, excNilCmp, retStmt),
                        newTree(nkElse,
@@ -934,9 +888,7 @@ proc newEndFinallyNode(ctx: var Ctx, info: TLineInfo): PNode =
                                    newTreeI(nkRaiseStmt, info, ctx.g.emptyNode))))
 
   result = newTree(nkIfStmt,
-                   newTreeI(nkElifBranch, info, cmpStateToZero, ifBody),
-                   # newTreeI(nkElse, info, exitFinally)
-  )
+                   newTreeI(nkElifBranch, info, cmpStateToZero, ifBody))
 
 
 proc newJumpAlongFinallyChain(ctx: var Ctx, finallyChain: seq[PNode], info: TLineInfo): PNode =
@@ -961,10 +913,7 @@ proc transformBreakStmt(ctx: var Ctx, n: PNode): PNode =
   # unnamed blocks is forbidden). Thus the break target is a named nkBlock with corresponding
   # name. Let's find it in finallyTarget stack, and remember all finallies on the way to it.
 
-  # echo "BREAAAAKKKK: "
-  # debug(n[0])
   let targetName = if n[0].kind == nkSym: n[0].sym else: nil
-
   var finallyChain = newSeq[PNode]()
 
   for i in countdown(ctx.finallyPathStack.high, 0):
@@ -984,24 +933,6 @@ proc transformBreakStmt(ctx: var Ctx, n: PNode): PNode =
   else:
     result = n
 
-proc transformContinueStmt(ctx: var Ctx, n: PNode): PNode =
-  # "Continuing" involves finding the corresponding target state in finallyPathStack,
-  # setting finallyPath so that it chains to the target state and jumping to nearest finally.
-  # If there are no finallies on the way, then jump to the target block right away
-  var finallyChain = newSeq[PNode]()
-
-  for i in countdown(ctx.finallyPathStack.high, 0):
-    let b = ctx.finallyPathStack[i].n
-    if b.kind == nkWhileStmt:
-      finallyChain.add(ctx.finallyPathStack[i].enterLabel)
-      break
-    elif b.kind == nkFinally:
-      finallyChain.add(ctx.finallyPathStack[i].enterLabel)
-
-  doAssert(false, "CONTINUE")
-  result = ctx.newJumpAlongFinallyChain(finallyChain, n.info)
-  echo "CONTINUE ", renderTree(result)
-
 proc transformReturnStmt(ctx: var Ctx, n: PNode): PNode =
   # "Breaking" involves finding the corresponding target state in finallyPathStack,
   # setting finallyPath so that it chains to the target state and jumping to nearest finally.
@@ -1012,9 +943,6 @@ proc transformReturnStmt(ctx: var Ctx, n: PNode): PNode =
   # unnamed blocks is forbidden). Thus the break target is a named nkBlock with corresponding
   # name. Let's find it in finallyTarget stack, and remember all finallies on the way to it.
 
-  # echo "BREAAAAKKKK: "
-  # debug(n[0])
-
   result = newNodeI(nkStmtList, n.info)
   result.add(ctx.newNullifyCurExcLevel(n.info))
 
@@ -1027,8 +955,6 @@ proc transformReturnStmt(ctx: var Ctx, n: PNode): PNode =
       finallyChain.add(ctx.finallyPathStack[i].enterLabel)
 
   if finallyChain.len > 0:
-  # assert(finallyChain.len > 0)
-
     # Add proc exit state
     finallyChain.add(ctx.g.newIntLit(n.info, 0))
 
@@ -1043,14 +969,13 @@ proc transformReturnStmt(ctx: var Ctx, n: PNode): PNode =
   else:
     result.add(n)
 
-  # echo "RETUUUURNM: ", result
-
 proc transformBreaksContinuesAndReturns(ctx: var Ctx, n: PNode): PNode =
   result = n
   case n.kind
   of nkSkip: discard
   of nkBreakStmt: result = ctx.transformBreakStmt(n)
-  # of nkContinueStmt: result = ctx.transformContinueStmt(n)
+  of nkContinueStmt:
+    internalError(ctx.g.config, n.info, "Continue not lowered")
   of nkReturnStmt:
     if ctx.curFinallyLevel > 0 and nfNoRewrite notin n.flags:
       result = ctx.transformReturnStmt(n)
@@ -1086,9 +1011,6 @@ proc transformClosureIteratorBody(ctx: var Ctx, n: PNode, gotoOut: PNode): PNode
 
   of nkYieldStmt:
     result = addGotoOut(result, gotoOut)
-    # result = newNodeI(nkStmtList, n.info)
-    # result.add(n)
-    # result.add(gotoOut)
 
   of nkElse, nkElseExpr:
     result[0] = addGotoOut(result[0], gotoOut)
@@ -1159,10 +1081,8 @@ proc transformClosureIteratorBody(ctx: var Ctx, n: PNode, gotoOut: PNode): PNode
     result.add(tryLabel)
     var tryBody = toStmtList(n[0])
 
-    var exceptBody = ctx.collectExceptState(n)
+    let exceptBody = ctx.collectExceptState(n)
     var finallyBody = ctx.getFinallyNode(n)
-    # var finallyBody = newTree(nkStmtList, getFinallyNode(ctx, n))
-    # finallyBody = ctx.transformReturnsInTry(finallyBody)
     var exceptLabel, finallyLabel = ctx.g.emptyNode
 
     if exceptBody.kind != nkEmpty:
@@ -1187,17 +1107,14 @@ proc transformClosureIteratorBody(ctx: var Ctx, n: PNode, gotoOut: PNode): PNode
 
       tryOut = newNodeI(nkGotoState, finallyBody.info)
       tryOut.add(finallyLabel)
-    # let outToFinally = newNodeI(nkGotoState, finallyBody.info)
-    # outToFinally.add(finallyLabel)
 
     block: # Process the states
       let oldExcLandingState = ctx.curExcLandingState
       ctx.curExcLandingState = if exceptBody.kind != nkEmpty: exceptLabel
                              elif finallyBody.kind != nkEmpty: finallyLabel
                              else: oldExcLandingState
-      # ctx.curExcHandlingState = exceptIdx
+
       discard ctx.newState(tryBody, false, tryLabel)
-      # assert(realTryIdx.intVal == tryIdx)
 
       if finallyBody.kind != nkEmpty:
         inc ctx.curFinallyLevel
@@ -1210,7 +1127,6 @@ proc transformClosureIteratorBody(ctx: var Ctx, n: PNode, gotoOut: PNode): PNode
         ctx.curExcLandingState = if finallyBody.kind != nkEmpty: finallyLabel
                                  else: oldExcLandingState
         discard ctx.newState(exceptBody, false, exceptLabel)
-        # assert(realExceptIdx.intVal == -exceptIdx)
 
         let normalOut = if finallyBody.kind != nkEmpty: gotoOut else: nil
         ctx.addElseToExcept(exceptBody, normalOut)
@@ -1228,32 +1144,6 @@ proc transformClosureIteratorBody(ctx: var Ctx, n: PNode, gotoOut: PNode): PNode
           internalError(ctx.g.config, "transformClosureIteratorBody != finallyBody")
         dec ctx.curFinallyLevel
 
-      # assert(finallyLabel.intVal == finallyIdx)
-
-    # block: # Subdivide the states
-    #   let oldNearestFinally = ctx.nearestFinally
-    #   ctx.nearestFinally = finallyIdx
-
-    #   let oldExcLandingState = ctx.curExcHandlingState
-
-    #   ctx.curExcHandlingState = exceptIdx
-
-    #   if ctx.transformReturnsInTry(tryBody) != tryBody:
-    #     internalError(ctx.g.config, "transformReturnsInTry != tryBody")
-    #   if ctx.transformClosureIteratorBody(tryBody, tryOut) != tryBody:
-    #     internalError(ctx.g.config, "transformClosureIteratorBody != tryBody")
-
-    #   ctx.curExcHandlingState = finallyIdx
-    #   ctx.addElseToExcept(exceptBody)
-    #   if ctx.transformReturnsInTry(exceptBody) != exceptBody:
-    #     internalError(ctx.g.config, "transformReturnsInTry != exceptBody")
-    #   if ctx.transformClosureIteratorBody(exceptBody, outToFinally) != exceptBody:
-    #     internalError(ctx.g.config, "transformClosureIteratorBody != exceptBody")
-
-    #   ctx.nearestFinally = oldNearestFinally
-    #   if ctx.transformClosureIteratorBody(finallyBody, gotoOut) != finallyBody:
-    #     internalError(ctx.g.config, "transformClosureIteratorBody != finallyBody")
-
   of nkGotoState, nkForStmt:
     internalError(ctx.g.config, "closure iter " & $n.kind)
 
@@ -1263,7 +1153,6 @@ proc transformClosureIteratorBody(ctx: var Ctx, n: PNode, gotoOut: PNode): PNode
 
 proc stateFromGotoState(n: PNode): PNode =
   assert(n.kind == nkGotoState)
-  # result = n[0].intVal.int
   result = n[0]
 
 proc transformStateAssignments(ctx: var Ctx, n: PNode): PNode =
@@ -1330,47 +1219,6 @@ proc transformStateAssignments(ctx: var Ctx, n: PNode): PNode =
     for i in 0..<n.len:
       n[i] = ctx.transformStateAssignments(n[i])
 
-# proc skipStmtList(ctx: Ctx; n: PNode): PNode =
-#   result = n
-#   while result.kind in {nkStmtList}:
-#     if result.len == 0: return ctx.g.emptyNode
-#     result = result[0]
-
-# proc skipEmptyStates(ctx: Ctx, stateIdx: int): int =
-#   # Returns first non-empty state idx for `stateIdx`. Returns `stateIdx` if
-#   # it is not empty
-#   var maxJumps = ctx.states.len # maxJumps used only for debugging purposes.
-#   var stateIdx = stateIdx
-#   while true:
-#     let label = stateIdx
-#     if label == ctx.exitStateIdx: break
-#     var newLabel = label
-#     if label == emptyStateLabel:
-#       newLabel = ctx.exitStateIdx
-#     else:
-#       let fs = skipStmtList(ctx, ctx.states[label].body)
-#       if fs.kind == nkGotoState:
-#         newLabel = fs[0].intVal.int
-#     if label == newLabel: break
-#     stateIdx = newLabel
-#     dec maxJumps
-#     if maxJumps == 0:
-#       assert(false, "Internal error")
-
-#   result = ctx.states[stateIdx].label
-
-# proc skipThroughEmptyStates(ctx: var Ctx, n: PNode): PNode=
-#   result = n
-#   case n.kind
-#   of nkSkip:
-#     discard
-#   of nkGotoState:
-#     result = copyTree(n)
-#     result[0].intVal = ctx.skipEmptyStates(result[0].intVal.int)
-#   else:
-#     for i in 0..<n.len:
-#       n[i] = ctx.skipThroughEmptyStates(n[i])
-
 proc createExceptionTable(ctx: var Ctx): PNode {.inline.} =
   let typ = ctx.g.newArrayType(ctx.g.newIntLit(ctx.fn.info, ctx.states.high),
                                ctx.g.getSysType(ctx.fn.info, tyInt16), ctx.idgen, ctx.fn)
@@ -1382,14 +1230,10 @@ proc createExceptionTable(ctx: var Ctx): PNode {.inline.} =
     result.add(elem)
 
 proc newCatchBody(ctx: var Ctx, info: TLineInfo): PNode {.inline.} =
-  # Generates the code:
-  # :state = exceptionTable[:state]
-  # if :state == 0: raise
-  # :unrollFinally = :state > 0
-  # if :state < 0:
-  #   :state = -:state
-  # :curExc = getCurrentException()
-
+  # Generates code:
+  #   :state = exceptionTable[:state]
+  #   if :state == 0:
+  #     raise
   result = newNodeI(nkStmtList, info)
 
   let intTyp = ctx.g.getSysType(info, tyInt)
@@ -1417,50 +1261,19 @@ proc newCatchBody(ctx: var Ctx, info: TLineInfo): PNode {.inline.} =
     let ifStmt = newTree(nkIfStmt, ifBranch)
     result.add(ifStmt)
 
-  # :unrollFinally = :state > 0
-  # block:
-  #   let cond = newTree(nkCall,
-  #     ctx.g.getSysMagic(info, "<", mLtI).newSymNode,
-  #     newIntTypeNode(0, intTyp),
-  #     ctx.newStateAccess())
-  #   cond.typ() = boolTyp
-
-  #   let asgn = newTree(nkAsgn, ctx.newUnrollFinallyAccess(info), cond)
-  #   result.add(asgn)
-
-  # if :state < 0: :state = -:state
-  # block:
-  #   let cond = newTree(nkCall,
-  #     ctx.g.getSysMagic(info, "<", mLtI).newSymNode,
-  #     ctx.newStateAccess(),
-  #     newIntTypeNode(0, intTyp))
-  #   cond.typ() = boolTyp
-
-  #   let negateState = newTree(nkCall,
-  #     ctx.g.getSysMagic(info, "-", mUnaryMinusI).newSymNode,
-  #     ctx.newStateAccess())
-  #   negateState.typ() = intTyp
-
-  #   let ifBranch = newTree(nkElifBranch, cond, ctx.newStateAssgn(negateState))
-  #   let ifStmt = newTree(nkIfStmt, ifBranch)
-  #   result.add(ifStmt)
-
-  # :curExc = 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,
-  #   newSymNode(ctx.g.getCompilerProc("closureIterSetupExc")),
-  #   ctx.newCurExcAccess())
-
-  # let printDebug = newTree(nkCall,
-  #   newSymNode(ctx.g.getCompilerProc("closureIterDebug")),
-  #   ctx.newStateAccess())
+  # Generates code:
+  # var :tmp = nil
+  # try:
+  #   body
+  # except:
+  #   :state = exceptionTable[:state]
+  #   if :state == 0:
+  #     raise
+  #   :tmp = getCurrentException()
+  #
+  # pushCurrentException(:tmp)
 
-  # let tryBody = newTree(nkStmtList, setupExc, n)
   let tryBody = newTree(nkStmtList, n)
   let exceptBody = ctx.newCatchBody(ctx.fn.info)
   let exceptBranch = newTree(nkExceptBranch, exceptBody)
@@ -1474,8 +1287,6 @@ proc wrapIntoTryExcept(ctx: var Ctx, n: PNode): PNode {.inline.} =
   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 =
   # while true:
   #   block :stateLoop: