feat: defer statement support in both compilers

- Add statement for function-level deferred execution - Deferred expressions run in LIFO order on function exit (return or implicit) - Bootstrap: desugar defers in hir_lower.nim (inject before return + end of func) - Selfhost: emit defers in c_backend.bux via CEmitter defer stack - Both: add tkDefer token, skDefer AST node, hDefer HIR node - Parser, lexer, sema, token files updated in both bootstrap/ and src/
2026-06-08 20:59:27 +03:00
parent cf92b63ba6
commit a67271b08c
15 changed files with 385 additions and 4 deletions
@@ -238,6 +238,7 @@ type
    skStaticAssert
    skComptime
    skEmit
+    skDefer
    skDecl

  ElseIf* = object
@@ -298,6 +299,8 @@ type
    of skEmit:
      stmtEmitExpr*: Expr
      stmtEmitEvaluated*: string  ## filled by sema CTFE
+    of skDefer:
+      stmtDeferBody*: Expr
    of skDecl:
      stmtDecl*: Decl

@@ -8,6 +8,7 @@ type
    varCounter*: int
    declaredVars*: seq[string]
    sliceTypeDefs*: seq[tuple[name: string, elem: string]]  ## Generated Slice_<T> typedefs
+    deferStack*: seq[seq[string]]  ## Function-level deferred statements (LIFO)

 proc cEscape(s: string): string =
  ## Escape a string for use as a C string literal.
@@ -45,6 +46,28 @@ proc freshVar(be: var CBackend): string =
  inc be.varCounter
  result = &"__tmp_{be.varCounter}"

+# ---------------------------------------------------------------------------
+# Defer helpers
+# ---------------------------------------------------------------------------
+proc pushDeferScope(be: var CBackend) =
+  be.deferStack.add(@[])
+
+proc popDeferScope(be: var CBackend) =
+  if be.deferStack.len > 0:
+    be.deferStack.setLen(be.deferStack.len - 1)
+
+proc emitCurrentDefers(be: var CBackend) =
+  ## Emit all deferred statements in current scope, LIFO order
+  if be.deferStack.len == 0: return
+  let idx = be.deferStack.len - 1
+  for i in countdown(be.deferStack[idx].len - 1, 0):
+    be.emitLine(be.deferStack[idx][i])
+
+proc clearCurrentDefers(be: var CBackend) =
+  if be.deferStack.len > 0:
+    let idx = be.deferStack.len - 1
+    be.deferStack[idx].setLen(0)
+
 # Type conversion: Bux Type → C type string
 proc typeToC*(be: var CBackend, typ: Type): string =
  if typ == nil: return "void"
@@ -358,7 +381,14 @@ proc emitExpr(be: var CBackend, node: HirNode): string =
 proc emitStmt(be: var CBackend, node: HirNode) =
  if node == nil: return
  case node.kind
+  of hDefer:
+    let expr = be.emitExpr(node.deferBody)
+    if be.deferStack.len > 0:
+      let idx = be.deferStack.len - 1
+      be.deferStack[idx].add(expr & ";")
+
  of hReturn:
+    be.emitCurrentDefers()
    if node.returnValue != nil:
      let val = be.emitExpr(node.returnValue)
      be.emitLine(&"return {val};")
@@ -394,9 +424,11 @@ proc emitStmt(be: var CBackend, node: HirNode) =
    be.emitLine("}")

  of hBreak:
+    be.emitCurrentDefers()
    be.emitLine("break;")

  of hContinue:
+    be.emitCurrentDefers()
    be.emitLine("continue;")

  of hEmit:
@@ -453,15 +485,23 @@ proc emitFunc*(be: var CBackend, hfunc: HirFunc) =
  let paramsStr = params.join(", ")
  be.emitLine(&"{retType} {hfunc.name}({paramsStr}) {{")
  inc be.indent
+  be.pushDeferScope()
  if hfunc.body != nil:
    if hfunc.body.kind == hBlock:
      for stmt in hfunc.body.blockStmts:
        be.emitStmt(stmt)
      if hfunc.body.blockExpr != nil and hfunc.retType.kind != tkVoid:
+        be.emitCurrentDefers()
        let val = be.emitExpr(hfunc.body.blockExpr)
        be.emitLine(&"return {val};")
+      else:
+        be.emitCurrentDefers()
    else:
      be.emitStmt(hfunc.body)
+      be.emitCurrentDefers()
+  else:
+    be.emitCurrentDefers()
+  be.popDeferScope()
  dec be.indent
  be.emitLine("}")
  be.emitLine("")
@@ -17,6 +17,7 @@ type
    hBreak
    hContinue
    hReturn
+    hDefer
    # Memory
    hAlloca
    hLoad
@@ -84,6 +85,8 @@ type
      continueLabel*: string
    of hReturn:
      returnValue*: HirNode
+    of hDefer:
+      deferBody*: HirNode
    of hAlloca:
      allocaType*: Type
      allocaName*: string
@@ -200,6 +203,9 @@ proc hirCall*(callee: string, args: seq[HirNode], typ: Type, loc: SourceLocation
 proc hirReturn*(value: HirNode, loc: SourceLocation): HirNode =
  HirNode(kind: hReturn, returnValue: value, typ: makeVoid(), loc: loc)

+proc hirDefer*(body: HirNode, loc: SourceLocation): HirNode =
+  HirNode(kind: hDefer, deferBody: body, typ: makeVoid(), loc: loc)
+
 proc hirBlock*(stmts: seq[HirNode], expr: HirNode, typ: Type, loc: SourceLocation, isScope: bool = false): HirNode =
  HirNode(kind: hBlock, blockStmts: stmts, blockExpr: expr, typ: typ, loc: loc, isScope: isScope)

@@ -11,6 +11,7 @@ type
    varCounter*: int
    tryCounter*: int
    pendingStmts*: seq[HirNode]
+    deferStmts*: seq[HirNode]
    typeSubst*: Table[string, Type]  # Type parameter substitution for generics
    importTable*: Table[string, string]  # Local name → fully qualified name for imports
    genericStructs*: Table[string, Decl]  # Generic struct declarations
@@ -1005,7 +1006,13 @@ proc lowerStmt(ctx: var LowerCtx, stmt: Stmt): HirNode =

  of skReturn:
    let value = if stmt.stmtReturnValue != nil: ctx.lowerExpr(stmt.stmtReturnValue) else: nil
-    return ctx.flushPending(hirReturn(value, loc))
+    var stmts = ctx.pendingStmts
+    ctx.pendingStmts = @[]
+    # Add defers in reverse order (LIFO)
+    for i in countdown(ctx.deferStmts.len - 1, 0):
+      stmts.add(ctx.deferStmts[i])
+    stmts.add(hirReturn(value, loc))
+    return hirBlock(stmts, nil, makeVoid(), loc)

  of skIf:
    let cond = ctx.lowerExpr(stmt.stmtIfCond)
@@ -1120,6 +1127,11 @@ proc lowerStmt(ctx: var LowerCtx, stmt: Stmt): HirNode =
    return ctx.flushPending(HirNode(kind: hMatch, matchSubject: subject, matchArms: arms,
                   typ: makeVoid(), loc: loc))

+  of skDefer:
+    let body = ctx.lowerExpr(stmt.stmtDeferBody)
+    ctx.deferStmts.add(body)
+    return nil
+
  of skDecl:
    return HirNode(kind: hLit, litToken: Token(kind: tkIntLiteral, text: "0", loc: loc),
                   typ: makeVoid(), loc: loc)
@@ -1188,7 +1200,24 @@ proc lowerFunc*(ctx: var LowerCtx, decl: Decl): HirFunc =
  ctx.currentFuncRetType = retType
  ctx.currentFuncDecl = decl
  ctx.varTypeExprs = initTable[string, TypeExpr]()  # Clear local vars for new function
-  let body = if funcBody != nil: ctx.lowerBlock(funcBody) else: nil
+  var body = if funcBody != nil: ctx.lowerBlock(funcBody) else: nil
+  
+  # Inject remaining defers at end of function (for implicit return)
+  if ctx.deferStmts.len > 0 and body != nil and body.kind == hBlock:
+    # Only add if last statement is not already a return (defers already injected there)
+    var hasReturn = false
+    if body.blockStmts.len > 0 and body.blockStmts[^1].kind == hReturn:
+      hasReturn = true
+    elif body.blockStmts.len > 0 and body.blockStmts[^1].kind == hBlock:
+      # Check nested block's last statement
+      let last = body.blockStmts[^1]
+      if last.blockStmts.len > 0 and last.blockStmts[^1].kind == hReturn:
+        hasReturn = true
+    if not hasReturn:
+      for i in countdown(ctx.deferStmts.len - 1, 0):
+        body.blockStmts.add(ctx.deferStmts[i])
+    ctx.deferStmts = @[]
+  
  ctx.currentFuncDecl = oldFuncDecl
  ctx.currentFuncRetType = oldFuncRetType
  ctx.varTypeExprs = oldVarTypeExprs
@@ -959,6 +959,12 @@ proc parseStmt(p: var Parser): Stmt =
      # No-op: emit literal 0 as expression statement
      let zeroTok = Token(kind: tkIntLiteral, text: "0", loc: loc)
      return Stmt(kind: skExpr, loc: loc, stmtExpr: Expr(kind: ekLiteral, loc: loc, exprLit: zeroTok))
+  of tkDefer:
+    discard p.advance()
+    let expr = p.parseExpr()
+    if p.check(tkSemicolon):
+      discard p.advance()
+    return Stmt(kind: skDefer, loc: loc, stmtDeferBody: expr)
  of tkFunc, tkStruct, tkEnum, tkUnion, tkInterface, tkExtend, tkModule,
     tkImport, tkConst, tkType, tkExtern, tkPub:
    # Local declaration
@@ -1335,6 +1335,9 @@ proc checkStmt(sema: var Sema, stmt: Stmt, scope: Scope): Type =
    elif not exprType.isUnknown and exprType.kind != tkStr:
      sema.emitError(stmt.loc, "#emit requires a string expression")
    return makeVoid()
+  of skDefer:
+    discard sema.checkExpr(stmt.stmtDeferBody, scope)
+    return makeVoid()
  of skDecl:
    # Local declaration inside block
    case stmt.stmtDecl.kind
@@ -59,6 +59,7 @@ type
    tkStaticAssert    # static_assert
    tkComptime        # comptime
    tkDyn             # dyn
+    tkDefer           # defer
    tkLifetime        # 'a (lifetime parameter)

    ##Punctuation
@@ -152,7 +153,7 @@ proc isKeyword*(kind: TokenKind): bool =
     tkBreak, tkContinue, tkReturn, tkMatch,
     tkFunc, tkLet, tkVar, tkConst, tkType, tkStruct, tkEnum,
     tkUnion, tkInterface, tkExtend, tkModule, tkImport,
-       tkPub, tkExtern, tkAs, tkIs, tkNull, tkSelf, tkSuper, tkOwn, tkMut, tkBorrow, tkDiscard, tkAsync, tkAwait, tkSpawn, tkStaticAssert, tkComptime, tkDyn:
+       tkPub, tkExtern, tkAs, tkIs, tkNull, tkSelf, tkSuper, tkOwn, tkMut, tkBorrow, tkDiscard, tkAsync, tkAwait, tkSpawn, tkStaticAssert, tkComptime, tkDyn, tkDefer:
    true
  else:
    false
@@ -216,6 +217,7 @@ proc keywordKind*(text: string): TokenKind =
  of "static_assert": tkStaticAssert
  of "comptime": tkComptime
  of "dyn": tkDyn
+  of "defer": tkDefer
  of "true", "false": tkBoolLiteral
  else: tkIdent

@@ -269,6 +271,7 @@ proc tokenKindName*(kind: TokenKind): string =
  of tkStaticAssert: "'static_assert'"
  of tkComptime: "'comptime'"
  of tkDyn: "'dyn'"
+  of tkDefer: "'defer'"
  of tkLifetime: "lifetime"
  of tkLParen: "'('"
  of tkRParen: "')'"