IC: move to BIF / nifcore APIs (#25943)

compiler/ast.nim

@@ -546,12 +546,30 @@ proc idGeneratorForPackage*(nextIdWillBe: int32): IdGenerator =
 
 proc nextSymId(x: IdGenerator): ItemId {.inline.} =
   assert(not x.sealed)
+  when not defined(nimKochBootstrap):
+    if x.backendMinted:
+      # Share the loader's per-module backend counter so a freshly-minted
+      # backend sym never collides with an `@bk` sym loaded from the module's
+      # `.t.bif` (see ast2nif.nextBackendSymItem).
+      let it = nextBackendSymItem(program, x.module)
+      if it >= 0'i32:
+        return backendItemId(x.module, it)
   inc x.symId
   result = if x.backendMinted: backendItemId(x.module, x.symId)
            else: itemId(x.module, x.symId)
 
 proc nextTypeId*(x: IdGenerator): ItemId {.inline.} =
   assert(not x.sealed)
+  when not defined(nimKochBootstrap):
+    if x.backendMinted:
+      # Share the loader's per-module backend TYPE counter (seeded from the
+      # module's `(unusedid)`) so a freshly-minted backend type sits ABOVE every
+      # loaded type — never colliding with a frontend type's `toId` (the bug that
+      # crashed cgen's `getTypeDescAux` cycle check on `AsyncBufferRef`). Mirrors
+      # `nextSymId` (see ast2nif.nextBackendTypeItem).
+      let it = nextBackendTypeItem(program, x.module)
+      if it >= 0'i32:
+        return backendItemId(x.module, it)
   inc x.typeId
   result = if x.backendMinted: backendItemId(x.module, x.typeId)
            else: itemId(x.module, x.typeId)

compiler/ccgexprs.nim

@@ -1071,7 +1071,7 @@ proc genRecordField(p: BProc, e: PNode, d: var TLoc) =
 
 proc genInExprAux(p: BProc, e: PNode, a, b, d: var TLoc)
 
-proc genFieldCheck(p: BProc, e: PNode, obj: Rope, field: PSym) =
+proc genFieldCheck(p: BProc, e: PNode, obj: Rope, field: PSym, ty: PType) =
   var test, u, v: TLoc
   for i in 1..<e.len:
     var it = e[i]
@@ -1081,10 +1081,17 @@ proc genFieldCheck(p: BProc, e: PNode, obj: Rope, field: PSym) =
     if op.magic == mNot: it = it[1]
     let disc = it[2].skipConv
     assert(disc.kind == nkSym)
+    # Re-navigate the discriminant in the object type: under `nim ic` `disc.sym` is
+    # a field-use stub whose `loc.snippet` is empty (the backend fills it on the
+    # canonical reclist field, not on per-use leaves). Look up the canonical field
+    # for the C member name; `disc`'s own node still supplies its type (TLoc.t).
+    # Byte-neutral for non-IC, where re-navigation returns the same field.
+    var rr = obj
+    let dfield = lookupFieldAgain(p, ty, disc.sym, rr)
     test = initLoc(locNone, it, OnStack)
     u = initLocExpr(p, it[1])
     v = initLoc(locExpr, disc, OnUnknown)
-    v.snippet = dotField(obj, disc.sym.loc.snippet)
+    v.snippet = dotField(obj, dfield.loc.snippet)
     genInExprAux(p, it, u, v, test)
     var msg = ""
     if optDeclaredLocs in p.config.globalOptions:
@@ -1094,7 +1101,7 @@ proc genFieldCheck(p: BProc, e: PNode, obj: Rope, field: PSym) =
       # by encoding the file names separately from `file(line:col)`, essentially
       # passing around `TLineInfo` + the set of files in the project.
       msg.add toFileLineCol(p.config, e.info) & " "
-    msg.add genFieldDefect(p.config, field.name.s, disc.sym)
+    msg.add genFieldDefect(p.config, field.name.s, dfield)
     var strLitBuilder = newBuilder("")
     genStringLiteral(p.module, newStrNode(nkStrLit, msg), strLitBuilder)
     let strLit = extract(strLitBuilder)
@@ -1158,7 +1165,7 @@ proc genCheckedRecordField(p: BProc, e: PNode, d: var TLoc) =
     if field.loc.snippet == "": fillObjectFields(p.module, ty)
     if field.loc.snippet == "":
       internalError(p.config, e.info, "genCheckedRecordField") # generate the checks:
-    genFieldCheck(p, e, r, field)
+    genFieldCheck(p, e, r, field, ty)
     r = dotField(r, field.loc.snippet)
     putIntoDest(p, d, e[0], r, a.storage)
     r.freeze
@@ -1858,7 +1865,7 @@ proc genFieldObjConstr(p: BProc; ty: PType; useTemp, isRef: bool; nField, val, c
   if field.loc.snippet == "": fillObjectFields(p.module, ty)
   if field.loc.snippet == "": internalError(p.config, info, "genFieldObjConstr")
   if check != nil and optFieldCheck in p.options:
-    genFieldCheck(p, check, r, field)
+    genFieldCheck(p, check, r, field, ty)
   tmp2.snippet = dotField(tmp2.snippet, field.loc.snippet)
   if useTemp:
     tmp2.k = locTemp

compiler/ccgtypes.nim

@@ -1807,6 +1807,16 @@ proc generateRttiDestructor(g: ModuleGraph; typ: PType; owner: PSym; kind: TType
 
   incl result.flagsImpl, sfFromGeneric
   incl result.flagsImpl, sfGeneratedOp
+  # Under IC the `rttiDestroy` wrapper is generated independently in every cg
+  # process that emits `typ`'s RTTI (the type-info is emit-everywhere). A plain
+  # counter `disamb` renumbers per process, so the RTTI table baked in module A
+  # references `rttiDestroy_c<n>` while module B (the =destroy owner) defines a
+  # different number → undefined at link. Give it a content-derived `disamb`
+  # (stable across processes) + `HookDisambBit`, exactly like `symPrototype` does
+  # for the hook itself: same `typ` ⇒ same C name everywhere, and the bit makes
+  # `emitsBodyInThisModule` emit the body in every demander (merge dedups). The
+  # `"rttiDestroy"` op-name keeps its key disjoint from the real `=destroy` hook's.
+  setHookDisamb(g, result, "rttiDestroy", typ)
 
 proc genHook(m: BModule; t: PType; info: TLineInfo; op: TTypeAttachedOp; result: var Builder) =
   let theProc = getAttachedOp(m.g.graph, t, op)

compiler/ccgutils.nim

@@ -11,7 +11,7 @@
 
 import
   ast, types, msgs, wordrecg,
-  platform, trees, options, cgendata, mangleutils, renderer
+  platform, trees, options, cgendata, mangleutils, renderer, modulegraphs
 
 import std/[hashes, strutils, formatfloat]
 
@@ -116,7 +116,17 @@ proc makeUnique(m: BModule; s: PSym, name: string = ""): string =
   # restarts at 0 and would collide with loaded symbols' ids
   if s.itemId.isBackendMinted:
     result.add "_c"
-    result.add $s.itemId.item
+    if (s.disamb and HookDisambBit) != 0'i32:
+      # A backend-minted sym whose `disamb` is content-derived (setHookDisamb gave
+      # it HookDisambBit) — e.g. the `rttiDestroy` wrapper. Its `itemId.item` is a
+      # PER-PROCESS backend counter, so using it makes the C name diverge across
+      # the emit-everywhere processes: the type's RTTI table (emit-everywhere,
+      # merge-deduped) ends up referencing one process's `_c<item>` while the
+      # wrapper is defined with another's -> undefined at link (`rttiDestroy_c23`).
+      # The content-derived disamb is stable across processes, so use it.
+      result.add $s.disamb
+    else:
+      result.add $s.itemId.item
   else:
     result.add "_u"
     # Mirror `mangleProcNameExt`: use the per-(module,name) `disamb`, NOT

compiler/cgen.nim

@@ -185,9 +185,13 @@ proc fillLoc(a: var TLoc, k: TLocKind, lode: PNode, s: TStorageLoc) {.inline.} =
     a.storage = s
 
 proc t(a: TLoc): PType {.inline.} =
-  if a.lode.kind == nkSym:
+  if a.lode.kind == nkSym and a.lode.sym.typ != nil:
     result = a.lode.sym.typ
   else:
+    # Under `nim ic` an object-field reference is a typeless leaf stub (its def
+    # lives in another seek; see ast2nif `FieldMarker`) that carries its type on
+    # the NODE instead. Fall back to the node type. Byte-neutral for non-IC, where
+    # a real sym always has a type.
     result = a.lode.typ
 
 proc lodeTyp(t: PType): PNode =
@@ -1218,8 +1222,17 @@ proc closeNamespaceNim(result: var Builder) =
 
 proc closureSetup(p: BProc, prc: PSym) =
   if tfCapturesEnv notin prc.typ.flags: return
-  # prc.ast[paramsPos].last contains the type we're after:
-  var ls = lastSon(prc.ast[paramsPos])
+  # prc.ast[paramsPos].last contains the type we're after — BUT a closure loaded
+  # from a `.t.bif` (a lambda-lifted nested proc / generic instance the `lower`
+  # stage transformed) can arrive with an EMPTY AST param node: the lifted hidden
+  # `:env` param lives in `typ.n`, the authoritative signature (`genProc` already
+  # reads `typ.n`, not the AST). The two param nodes diverge across the NIF
+  # boundary; fall back to `typ.n` so the env param resolves instead of indexing
+  # an empty container.
+  var params = prc.ast[paramsPos]
+  if params.safeLen == 0 and prc.typ.n != nil and prc.typ.n.kind == nkFormalParams:
+    params = prc.typ.n
+  var ls = lastSon(params)
   if ls.kind != nkSym:
     internalError(p.config, prc.info, "closure generation failed")
   var env = ls.sym
@@ -1464,8 +1477,21 @@ proc genProcLvl3*(m: BModule, prc: PSym) =
   var returnStmt: Snippet = ""
   assert(prc.ast != nil)
 
+  # A body LOADED from `.t.bif` was already FULLY lowered by the `lower` stage —
+  # transformed AND destructor-injected (see nifbackend.generateLowerStage). The
+  # `.t.bif` is the authoritative backend artifact; re-injecting here would lower
+  # it twice (double `=destroy` calls) and, worse, re-lift the env hooks per cg
+  # process (owned by nobody → undefined at link). So inject ONLY when the body
+  # was re-derived in this process (`wasLoaded == false`). Capture before
+  # `transformBody`, which returns the cached body (non-nil) when it was loaded.
+  # ONLY under IC: in a normal `nim c` build `transformedBody` is the ordinary
+  # transform cache (set whenever `transformBody` already ran for `prc`, e.g. a
+  # CT-evaluated or earlier-referenced routine), NOT a `.t.bif` load — gating on
+  # it there would WRONGLY skip destructor injection and miscompile (orc
+  # decref-on-freed). The `.t.bif`-loaded-body concept exists only under cmdNifC.
+  let wasLoaded = m.config.cmd == cmdNifC and prc.transformedBody != nil
   var procBody = transformBody(m.g.graph, m.idgen, prc, {})
-  if sfInjectDestructors in prc.flags:
+  if sfInjectDestructors in prc.flags and not wasLoaded:
     procBody = injectDestructorCalls(m.g.graph, m.idgen, prc, procBody)
 
   let tmpInfo = prc.info
@@ -1525,6 +1551,17 @@ proc genProcLvl3*(m: BModule, prc: PSym) =
   for i in 1..<prc.typ.n.len:
     let param = prc.typ.n[i].sym
     if param.typ.isCompileTimeOnly: continue
+    if prc.typ.callConv == ccClosure and param.name.s == ":envP":
+      # The hidden closure-env param is materialised by `closureSetup`, never a
+      # normal C parameter (`genProcParams` omits it from the signature). In a
+      # from-source build it lives only in the routine's AST params and never in
+      # `typ.n`, so this loop never reaches it. Under IC `closureParams` leaks it
+      # into `typ.n`; for a LOADED closure it is already present at header time
+      # (`genProcParams` fills its loc), but for a RE-DERIVED closure
+      # (`wasLoaded == false`) `transformBody` appends it only AFTER
+      # `genProcHeader` ran, so its `loc.snippet` is still empty here. Skip it to
+      # match the from-source invariant — `closureSetup` assigns its local below.
+      continue
     assignParam(p, param, prc.typ.returnType)
   closureSetup(p, prc)
   genProcBody(p, procBody)

compiler/deps.nim

@@ -16,6 +16,7 @@ import options, msgs, lineinfos, pathutils, condsyms,
 
 import "../dist/nimony/src/lib" / [nifstreams, bitabs, nifreader, nifbuilder]
 import "../dist/nimony/src/gear2" / modnames
+import icnifcore
 
 type
   FilePair = object
@@ -51,24 +52,24 @@ proc parsedFile(c: DepContext; f: FilePair): string =
   getNimcacheDir(c.config).string / f.modname & ".p.nif"
 
 proc semmedFile(c: DepContext; f: FilePair): string =
-  getNimcacheDir(c.config).string / f.modname & ".s.nif"
+  getNimcacheDir(c.config).string / f.modname & ".s.bif"
 
 proc ifaceFile(c: DepContext; f: FilePair): string =
   ## Interface-cookie sidecar written by `nim m` (ast2nif.writeIfaceCookie,
   ## OnlyIfChanged). Dependents' nim_m rules use it as their input instead of
   ## the semmed NIF: a body-only change in a dependency then keeps the sidecar
   ## mtime and nifmake prunes the whole re-sem cascade behind it.
-  getNimcacheDir(c.config).string / f.modname & ".iface.nif"
+  getNimcacheDir(c.config).string / f.modname & ".iface.bif"
 
 proc implFile(c: DepContext; suffix: string): string =
   ## Implementation-cookie sidecar (ast2nif.writeImplCookie): flips on ANY
   ## content change of the module (private bodies included; supersedes the
   ## iface cookie). Used as the edge for dependents that consumed the
   ## module's bodies at compile time (NeedsImpl edges).
-  getNimcacheDir(c.config).string / suffix & ".impl.nif"
+  getNimcacheDir(c.config).string / suffix & ".impl.bif"
 
 proc edgesFile(c: DepContext; f: FilePair): string =
-  getNimcacheDir(c.config).string / f.modname & ".edges.nif"
+  getNimcacheDir(c.config).string / f.modname & ".edges.bif"
 
 proc readNeedsImpl(c: DepContext; f: FilePair): seq[string] =
   ## Reads the module's recorded NeedsImpl edge set (module suffixes whose
@@ -79,19 +80,10 @@ proc readNeedsImpl(c: DepContext; f: FilePair): seq[string] =
   ## gated input of its rule, so the rule re-fires and re-records.
   result = @[]
   if fileExists(c.edgesFile(f)):
-    var s = nifstreams.open(c.edgesFile(f))
-    try:
-      discard processDirectives(s.r)
-      while true:
-        let t = next(s)
-        if t.kind == EofToken: break
-        if t.kind == StringLit:
-          result.add pool.strings[t.litId]
-    finally:
-      close s
+    result = collectBifStrLits(c.edgesFile(f))
 
 proc semDepsFile(c: DepContext; f: FilePair): string =
-  getNimcacheDir(c.config).string / f.modname & ".s.deps.nif"
+  getNimcacheDir(c.config).string / f.modname & ".s.deps.bif"
 
 proc readSemDeps(c: DepContext; f: FilePair): seq[string] =
   ## The module's REAL direct imports (full source paths) as sem resolved them,
@@ -99,16 +91,7 @@ proc readSemDeps(c: DepContext; f: FilePair): seq[string] =
   ## (ast2nif.writeSemDeps). Missing file (not yet semmed) -> empty.
   result = @[]
   if fileExists(c.semDepsFile(f)):
-    var s = nifstreams.open(c.semDepsFile(f))
-    try:
-      discard processDirectives(s.r)
-      while true:
-        let t = next(s)
-        if t.kind == EofToken: break
-        if t.kind == StringLit:
-          result.add pool.strings[t.litId]
-    finally:
-      close s
+    result = collectBifStrLits(c.semDepsFile(f))
 
 proc findNifler(): string =
   # Look for nifler in common locations
@@ -981,12 +964,12 @@ proc generateBackendBuildFile(c: DepContext; forwardedArgs: seq[string]): string
   var cFiles = newSeq[string](c.nodes.len)
   var tFiles = newSeq[string](c.nodes.len)
   # The `lower` stage writes a PROPER module NIF the cg/emit stages load via
-  # `toNifFilename` (a `.s.nif` sibling), so its `.t.nif` lives at the suffix base
+  # `toNifFilename` (a `.s.bif` sibling), so its `.t.bif` lives at the suffix base
   # (mirroring `semmedFile`), not next to the throwaway `.c`.
   for i, node in c.nodes:
     cFiles[i] = backendCFile(c, node)
     cnifFiles[i] = cFiles[i] & ".nif"
-    tFiles[i] = nimcache / node.files[0].modname & ".t.nif"
+    tFiles[i] = nimcache / node.files[0].modname & ".t.bif"
 
   # Only code-generate modules the real program actually reaches; statically
   # over-approximated nodes (e.g. `winlean` on Linux) are sem'd but not emitted.

compiler/icnifcore.nim

@@ -0,0 +1,242 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2026 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## nifcore-based IC serialization helpers — Stage 1 of porting the IC backend
+## from the old `nifstreams`/`nifcursors` NIF stack to `nifcore` (see
+## `doc/ic_nifcore_port.md`).
+##
+## It hosts:
+## * the process-wide shared `Pool`/`TagPool` that stands in for the old global
+##   `nifstreams.pool`,
+## * `writeFileStable`, the content-stable file writer mirroring
+##   `nifcursors.writeFile(..., OnlyIfChanged)`,
+## * the first ported writer (`writeSemDeps`), used as the migration spike.
+##
+## No `nifstreams`/`nifcursors` types cross this module's boundary: callers pass
+## plain Nim values (config, ids, string lists), so it can coexist with the
+## still-old-API `ast2nif.nim` during the migration.
+
+import std / [syncio, algorithm]
+from std / os import removeFile, moveFile
+import options, pathutils, typekeys
+import "../dist/nimony/src/lib" / [nifcore, nifcoreparse, nifreader, bif]
+
+# One shared literals pool + tag pool for the whole process — the nifcore
+# analogue of the old global `nifstreams.pool`. A single shared pool keeps
+# string/symbol/file ids stable across every TokenBuf the IC backend builds,
+# preserving the old global-pool semantics during the migration. (Stage 6 may
+# move to fresh per-file pools for bif's fast path; see doc/ic_nifcore_port.md.)
+let icPool* = newPool()
+let icTags* = newTagPool()
+
+proc createIcBuf*(cap = 16): TokenBuf {.inline.} =
+  ## A `TokenBuf` bound to the shared IC pools.
+  createTokenBuf(cap, icPool, icTags)
+
+proc tagId*(s: string): TagId {.inline.} =
+  ## Intern a tag name in the shared tag pool.
+  icTags.registerTag(s)
+
+type
+  IcBuilder* = object
+    ## A thin nifcore `TokenBuf` builder whose surface is *primitive types only*
+    ## (strings/ints/floats). It lets the still-old-API `ast2nif.nim` drive a
+    ## nifcore buffer without any nifcore type crossing the module boundary —
+    ## the bridge that routes IC output onto the nifcore serializer (Stage 2).
+    buf*: TokenBuf
+
+proc newIcBuilder*(cap = 16): IcBuilder = IcBuilder(buf: createIcBuf(cap))
+
+proc openTag*(b: var IcBuilder; tag: string) {.inline.} = b.buf.openTag(tagId(tag))
+proc closeTag*(b: var IcBuilder) {.inline.} = b.buf.closeTag()
+proc addSymUse*(b: var IcBuilder; s: string) {.inline.} = b.buf.addSymUse(s)
+proc addSymDef*(b: var IcBuilder; s: string) {.inline.} = b.buf.addSymDef(s)
+proc addIdent*(b: var IcBuilder; s: string) {.inline.} = b.buf.addIdent(s)
+proc addStrLit*(b: var IcBuilder; s: string) {.inline.} = b.buf.addStrLit(s)
+proc addIntLit*(b: var IcBuilder; v: int64) {.inline.} = b.buf.addIntLit(v)
+proc addUIntLit*(b: var IcBuilder; v: uint64) {.inline.} = b.buf.addUIntLit(v)
+proc addFloatLit*(b: var IcBuilder; v: float64) {.inline.} = b.buf.addFloatLit(v)
+proc addCharLit*(b: var IcBuilder; c: char) {.inline.} = b.buf.addCharLit(c)
+proc addDotToken*(b: var IcBuilder) {.inline.} = b.buf.addDotToken()
+
+proc lineInfo*(b: var IcBuilder; file: string; line, col: int32; comment = "") =
+  ## Attach line info (+ optional `#comment#`) to the head just emitted. No-op
+  ## when `file` is empty (matches the old "emit only when info is valid").
+  ## Strings are interned in the shared pools; the file/comment ids reproduce
+  ## the old `pool.files`/`pool.strings` entries by string value.
+  if file.len == 0: return
+  let fid = icPool.filenames.getOrIncl(file)
+  let cid = if comment.len > 0: icPool.strings.getOrIncl(comment) else: StrId(0)
+  b.buf.appendLineInfo(fid, line, col, cid)
+
+proc writeFileStable*(b: var TokenBuf; path: string; onlyIfChanged = false) =
+  ## Serialize `b` to canonical module NIF text and write it. Mirrors
+  ## `nifcursors.writeFile`: the module suffix is derived from `path`
+  ## (`"." & extractModuleSuffix`), and `onlyIfChanged` skips the write when the
+  ## on-disk bytes already match — the content-stability nifmake's incremental
+  ## rebuild depends on.
+  let content = toModuleString(b, "." & extractModuleSuffix(path))
+  if onlyIfChanged:
+    let existing =
+      try: readFile(path)
+      except CatchableError: ""
+    if existing == content: return
+  writeFile(path, content)
+
+proc writeStable*(b: var IcBuilder; path: string; onlyIfChanged = false) {.inline.} =
+  writeFileStable(b.buf, path, onlyIfChanged)
+
+proc cursorPool*(c: Cursor): Pool {.inline.} = nifcore.pool(c)
+  ## The literals pool the cursor's buffer was built against. `ast2nif.nim`
+  ## imports `nifcore` with `except pool` (to keep nifstreams' global `pool`
+  ## var the writer uses), so the reader reaches a cursor's pool through here —
+  ## needed once `bif`-loaded buffers carry their OWN fresh pool rather than the
+  ## shared `icPool`.
+
+proc freshModuleCopy(b: var IcBuilder): TokenBuf =
+  ## Re-home `b.buf` into a PRIVATE, module-local pool via `addSubtree` (which
+  ## re-interns only the literals/tags this buffer actually uses). `b.buf` is bound
+  ## to the process-wide shared `icPool`/`icTags`; storing it directly would embed
+  ## the WHOLE shared pool (correct but huge — see `bif.storeToFile`). The copy's
+  ## fresh-pool reload reproduces ids verbatim (the bif fresh-pool INVARIANT).
+  result = createTokenBuf(b.buf.len, newPool(), newTagPool())
+  var c = b.buf.beginRead()
+  while c.hasMore:
+    addSubtree(result, c)
+    skip c
+
+proc storeBif*(b: var IcBuilder; path: string; dottedSuffix: string) =
+  ## Persist the buffer as a compact, self-contained binary NIF (`.bif`).
+  var fresh = freshModuleCopy(b)
+  bif.store(fresh, path, dottedSuffix)
+
+proc storeBifStable*(b: var IcBuilder; path: string; dottedSuffix: string) =
+  ## Content-stable `bif` write — the binary analogue of `writeFileStable`'s
+  ## `onlyIfChanged`: only replace `path` when the encoded bytes differ, so an
+  ## unchanged sidecar keeps its mtime and nifmake prunes the dependent rebuild
+  ## cascade. Used for the iface/impl cookies + dep sidecars whose byte-stability
+  ## gates incremental builds. (bif encoding is deterministic for a given buffer
+  ## under fresh pools, so equal content ⇒ equal bytes.)
+  var fresh = freshModuleCopy(b)
+  let tmp = path & ".tmp"
+  bif.store(fresh, tmp, dottedSuffix)
+  let newBytes = readFile(tmp)
+  let oldBytes =
+    try: readFile(path)
+    except CatchableError: ""
+  if newBytes == oldBytes:
+    removeFile(tmp)
+  else:
+    moveFile(tmp, path)
+
+# --- subtree splicing (shared pool, so a raw subtree copy is exact) ----------
+
+proc addAll*(dest: var IcBuilder; src: var IcBuilder) =
+  ## Append every top-level subtree of `src` into `dest` — the nifcore analogue
+  ## of the old `dest.add wholeBuffer` splice.
+  var c = src.buf.beginRead()
+  while c.hasMore:
+    addSubtree(dest.buf, c)
+    skip c
+
+proc addStmtsBody*(dest: var IcBuilder; src: var IcBuilder) =
+  ## Append the BODY of a `(stmts . . <body> )` builder into `dest`, dropping the
+  ## wrapper tag and its two leading dot slots (flags/type) — the nifcore
+  ## analogue of the old `for i in 3 ..< content.len-1: dest.add content[i]`.
+  var c = src.buf.beginRead()   # at (stmts
+  c.into:
+    skip c   # flags dot
+    skip c   # type dot
+    while c.hasMore:
+      addSubtree(dest.buf, c)
+      skip c
+
+# --- cookie input: a line-info-free logical token list of the module ---------
+# The cookie hashers (ast2nif) need a flat, ParRi-bearing, index-addressable
+# view of the serialized module. nifcore has no ParRi kind and variable-width
+# tokens, so we flatten the buffer here (in the clean nifcore world) into a
+# neutral `CookieTok` list — no nifcore type crosses into ast2nif.
+
+type
+  CookieKind* = enum
+    ckParLe, ckParRi, ckSym, ckSymDef, ckIdent, ckStr, ckInt, ckUInt, ckFloat, ckChar, ckDot
+  CookieTok* = object
+    kind*: CookieKind
+    tag*: string       # ckParLe
+    name*: string      # ckSym / ckSymDef
+    sym*: uint32       # ckSym / ckSymDef id (identity key)
+    str*: string       # ckIdent / ckStr
+    ival*: int64
+    uval*: uint64
+    fval*: float64
+    cval*: uint32
+
+proc flattenGo(c: var Cursor; b: TokenBuf; acc: var seq[CookieTok]) =
+  while c.hasMore:
+    case c.kind
+    of TagLit:
+      acc.add CookieTok(kind: ckParLe, tag: b.tags.tagName(c.cursorTagId))
+      c.into:
+        flattenGo(c, b, acc)
+      acc.add CookieTok(kind: ckParRi)
+    of Symbol:
+      acc.add CookieTok(kind: ckSym, name: symName(c, b.pool), sym: uint32(symId(c, b.pool)))
+      skip c
+    of SymbolDef:
+      acc.add CookieTok(kind: ckSymDef, name: symName(c, b.pool), sym: uint32(symId(c, b.pool)))
+      skip c
+    of Ident:
+      acc.add CookieTok(kind: ckIdent, str: strVal(c, b.pool)); skip c
+    of StrLit:
+      acc.add CookieTok(kind: ckStr, str: strVal(c, b.pool)); skip c
+    of IntLit:
+      acc.add CookieTok(kind: ckInt, ival: intVal(c)); skip c
+    of UIntLit:
+      acc.add CookieTok(kind: ckUInt, uval: uintVal(c)); skip c
+    of FloatLit:
+      acc.add CookieTok(kind: ckFloat, fval: floatVal(c)); skip c
+    of CharLit:
+      acc.add CookieTok(kind: ckChar, cval: uint32(ord(charLit(c)))); skip c
+    of DotToken:
+      acc.add CookieTok(kind: ckDot); skip c
+    else:
+      skip c   # LineInfoLit / ExtendedSuffix ride on heads, never standalone
+
+proc flattenForCookie*(b: var IcBuilder): seq[CookieTok] =
+  ## Flatten the nifcore module buffer to the cookie hashers' flat token list.
+  result = newSeqOfCap[CookieTok](b.buf.len)
+  var cur = b.buf.beginRead()
+  flattenGo(cur, b.buf, result)
+
+proc collectBifStrLits*(path: string): seq[string] =
+  ## Read a small `(tag "s" "s" …)` bif sidecar (`semdeps`/`edges`) and return every
+  ## string literal it holds, in order — the binary analogue of the old nifstreams
+  ## scan that collected `StrLit`s. Keeps nifcore types out of `deps.nim`, which
+  ## only needs the recorded string list.
+  result = @[]
+  var m = bif.load(path)
+  var c = m.buf.beginRead()
+  while c.hasMore:
+    if c.kind == StrLit: result.add strVal(c)
+    inc c
+
+proc writeSemDeps*(config: ConfigRef; thisModule: int32; importPaths: seq[string]) =
+  ## Stage 1 spike: the nifcore port of `ast2nif.writeSemDeps`. Serializes the
+  ## module's resolved direct imports as `(semdeps "path" ...)`. Byte-identical
+  ## to the old writer (verified), so `nim ic` build graphs are unaffected.
+  let selfSuffix = modname(thisModule, config)
+  var paths = importPaths
+  sort paths
+  var dest = newIcBuilder(4 + 2*paths.len)
+  dest.openTag "semdeps"
+  for p in paths:
+    dest.addStrLit p
+  dest.closeTag()
+  let path = toGeneratedFile(config, AbsoluteFile(selfSuffix), ".s.deps.bif").string
+  storeBifStable(dest, path, "." & extractModuleSuffix(path))

compiler/lambdalifting.nim

@@ -309,6 +309,25 @@ proc markAsClosure(g: ModuleGraph; owner: PSym; n: PNode) =
       [s.name.s, owner.name.s, $owner.typ.callConv])
   unsealForTransform(owner.typ)
   incl(owner.typ, tfCapturesEnv)
+  # A closure proc type that captures an env owns a REF to it: copying the closure
+  # value must incref the env and destroying it must decref. That is exactly what
+  # `tfHasAsgn` signals to `injectDestructorCalls` (so a closure assignment becomes
+  # `=copy`, not a raw field store).
+  #
+  # Set it HERE (closure-type creation) so the flag is DETERMINISTIC and serializes
+  # with the type — but ONLY under `nim ic`. The per-module `lower` stage is a
+  # separate process that lowers routines in index order; if a consumer (e.g.
+  # `workNimAsyncContinue`) was lowered before the closure type's ops were lifted,
+  # its env store emitted a RAW assign with no incref → freed env → async
+  # "yielded `nil`". A normal single-process `nim c` build does NOT need this —
+  # `createTypeBoundOps` sets the flag lazily, in lift order, before it matters
+  # (the old `liftdestructors ~1498` "XXX Breaks IC!" side effect) — and setting it
+  # eagerly there REGRESSES codegen: a `=destroy` hook gets generated against the
+  # bare `void(*)(void)` proc representation but is then called with closure structs
+  # (`eqdestroy__u2__stdZtypedthreads` type mismatch — broke megatest). So gate on
+  # `cmdNifC`; normal builds keep the lazy (devel) behavior.
+  if g.config.cmd == cmdNifC:
+    incl(owner.typ, tfHasAsgn)
   if not isEnv:
     owner.typ.callConv = ccClosure
 

compiler/mangleutils.nim

@@ -61,12 +61,22 @@ proc mangleProcNameExt*(graph: ModuleGraph, s: PSym): string =
     # starts with an EMPTY per-name disamb table, so its `disamb` restarts at 0
     # and collides with same-named sem-time symbols loaded from NIFs (two
     # `=destroy` hooks both mangling to `_u2` → "conflicting types for ..." in
-    # the generated C). These symbols never cross a process boundary (nifc
+    # the generated C). Most such symbols never cross a process boundary (nifc
     # lifts, emits and compiles them in one run), so the per-module-unique
     # item id is a safe and deterministic discriminator; the `_c` marker keeps
     # the namespace disjoint from `_u<disamb>`.
     result = "_c"
-    result.addInt s.itemId.item
+    if (s.disamb and HookDisambBit) != 0'i32:
+      # EXCEPTION: a backend-minted sym whose `disamb` is content-derived
+      # (setHookDisamb gave it HookDisambBit) — e.g. the `rttiDestroy` wrapper —
+      # DOES cross process boundaries: its C name is baked into the type's RTTI
+      # table, which is emit-everywhere and merge-deduped, so one process's
+      # `_c<item>` (a per-process backend counter) ends up referenced while the
+      # wrapper is defined with another's → undefined at link (`rttiDestroy_c23`).
+      # The content-derived disamb is stable across processes; use it.
+      result.addInt s.disamb
+    else:
+      result.addInt s.itemId.item
   else:
     result = "_u"
     # Use `disamb` rather than `itemId.item`: under incremental compilation a

compiler/nifbackend.nim

@@ -27,6 +27,7 @@ import ast, options, lineinfos, modulegraphs, cgendata, cgen,
   cnif
 from cgmeth import generateIfMethodDispatchers
 from transf import transformBody
+from injectdestructors import injectDestructorCalls
 import ic / replayer
 
 proc loadModuleDependencies(g: ModuleGraph; mainFileIdx: FileIndex;
@@ -178,6 +179,15 @@ proc ownsRuntimeRoutine(s: PSym; modPos: int): bool =
   ## A `{.closure.}` iterator IS a standalone runtime routine (unlike an inline
   ## iterator, which is expanded at each call site) and must be emitted by its
   ## owner — else a cross-module `for` over it links to nothing.
+  ##
+  ## Generic INSTANCES (`sfFromGeneric`) are NEVER an owned runtime routine — not
+  ## in `cg` and not in the `lower` stage. They are demanded by the backend's
+  ## emit-everywhere path and deduped by `merge` (content C name); the frontend
+  ## materialises them through the `(offer)` mechanism. The `lower` stage must
+  ## not transform an instance: a not-fully-concrete instance (a closure factory
+  ## over a `static` param, or a `$`/`=` op instance whose body resolves only at
+  ## its further-specialised use sites) still carries unresolved overload choices
+  ## and crashes `transformBody` (empty-`namePos` lambda, nil-typed const-fold).
   s.itemId.module == modPos and
   (s.kind in {skProc, skFunc, skConverter, skMethod} or
    (s.kind == skIterator and s.typ != nil and s.typ.callConv == ccClosure)) and
@@ -367,12 +377,34 @@ proc setNestedClosureBodies(g: ModuleGraph; idgen: IdGenerator; n: PNode;
   if n.kind == nkSym:
     let s = n.sym
     if s != nil and s.kind in routineKinds and s != owner and
+        s.skipGenericOwner != nil and s.skipGenericOwner.kind != skModule and
         not seen.containsOrIncl(s.id):
-      if s.ast != nil and getBody(g, s).kind != nkEmpty and
-          s.typ != nil and s.typ.callConv == ccClosure:
-        if s.transformedBody == nil:
+      # Covers ALL nested routines, not only ccClosure ones. A NIMCALL nested proc
+      # the async transform mints (e.g. workNimAsyncContinue) already has its
+      # lifted body set by the OWNER's transformBody, but it is NOT in the owned
+      # loop (owner is a proc, not the module). Without injecting it HERE it is
+      # serialized transform-only; cg loads it (wasLoaded) and skips injection, so
+      # a closure-env store stays a raw field assign with no incref -> the env is
+      # freed before the async callback runs -> "yielded nil". `seen` (shared
+      # across the owned loop) injects each routine exactly once.
+      if s.ast != nil and getBody(g, s).kind != nkEmpty:
+        # Only ccClosure routines are safe to `transformBody` standalone here; a
+        # nimcall nested proc already has its lifted body from the owner's lift,
+        # and transforming an arbitrary nested routine with no cached body crashes
+        # (not in a standalone-transformable state).
+        let weTransformed = s.transformedBody == nil and
+                            s.typ != nil and s.typ.callConv == ccClosure
+        if weTransformed:
           s.transformedBody = transformBody(g, idgen, s, {})
-        setNestedClosureBodies(g, idgen, s.transformedBody, s, seen)
+        if s.transformedBody != nil:
+          # Inject destructors so cg loads a fully-lowered body and never rebuilds
+          # (mirrors non-IC, which injects every nested proc separately). The
+          # importer `n2` skField collision this used to trigger is fixed at the
+          # NIF-naming layer (toNifSymName gives derived env fields a unique
+          # disamb), so injecting ccClosure nested procs here is safe.
+          if sfInjectDestructors in s.flags:
+            s.transformedBody = injectDestructorCalls(g, idgen, s, s.transformedBody)
+          setNestedClosureBodies(g, idgen, s.transformedBody, s, seen)
   else:
     for i in 0 ..< n.safeLen:
       setNestedClosureBodies(g, idgen, n[i], owner, seen)
@@ -448,12 +480,19 @@ proc generateLowerStage(g: ModuleGraph; mainFileIdx: FileIndex) =
   # (`=destroy` etc.) into `g.opsLog`; snapshot its length so we serialize exactly
   # the ops THIS stage created (not those loaded from `.s.nif`).
   let opsLogStart = g.opsLog.len
+  # Shared across the owned loop so a nested routine reachable from more than one
+  # owner is transformed + destructor-injected EXACTLY once (double injection
+  # would emit two `=destroy`/`=copy` runs).
+  var seenNested = initIntSet()
   for s in moduleSymbolStubs(ast.program, FileIndex modPos):
     if ownsRuntimeRoutine(s, modPos):
-      # `.s.nif` wins: a routine already transformed during sem (CT eval / macro /
-      # VM transform) carries its lowered body in the `.s.nif` slot — don't
-      # re-transform it here.
-      if s.transformedBody != nil: continue
+      # REUSE path (`icReuseSemLowering` ON): a routine already transformed during
+      # sem (CT eval / macro / VM transform) carries its lowered body in the
+      # `.s.nif` slot (loaded into `transformedBody`) — don't re-transform it.
+      # Default OFF: the slot is never loaded (see loadSymFromCursor), so
+      # `transformedBody` is nil here and we always re-derive below. See
+      # doc/ic_backend_simplify.md §6a/§6b.
+      if icReuseSemLowering(g.config) and s.transformedBody != nil: continue
       # A routine serialized as a forward-decl + impl pair (writeSymDef's
       # "separate forward declaration and implementation") loads as TWO syms; the
       # impl `s` we transform here can carry body entities (`result`, locals,
@@ -469,9 +508,19 @@ proc generateLowerStage(g: ModuleGraph; mainFileIdx: FileIndex) =
       # Retain the transformed body on the sym so `writeSymDef` serializes it in
       # the routine's `(sd)` 2-way-body slot.
       s.transformedBody = transformBody(g, tb.idgen, s, {})
-      # Cache the lifted body on nested ccClosure routines too, so a module-indexed
-      # nested closure serializes its lifted (capture-rewritten) body.
-      var seenNested = initIntSet()
+      # Run the destructor injection HERE so the `.t.bif` body is FULLY lowered:
+      # `injectDestructorCalls` is demand-driven (it decides where destructors go
+      # by move analysis) and LIFTS the type-bound ops it needs (e.g. a nested
+      # closure env's `=destroy`) into `g.opsLog` — which the `hooks` collection
+      # below then serializes. Done in `cg` instead, those ops were lifted per-cg
+      # process, owned by nobody, and emitted as a prototype-only → undefined at
+      # link (the `eqdestroy__c<n>` gap). cg must NOT re-inject a loaded body
+      # (see genProcLvl3's `wasLoaded` gate) so this stays the single injection.
+      if sfInjectDestructors in s.flags:
+        s.transformedBody = injectDestructorCalls(g, tb.idgen, s, s.transformedBody)
+      # Cache the lifted+injected body on nested ccClosure routines too, so a
+      # module-indexed nested closure serializes its lifted (capture-rewritten,
+      # destructor-injected) body.
       setNestedClosureBodies(g, tb.idgen, s.transformedBody, s, seenNested)
   # Collect the hooks this stage lifted, and transform each hook ROUTINE's body
   # too (it is itself lowered into NIFC). The hooks' `(sd)` + transformed body go
@@ -487,14 +536,18 @@ proc generateLowerStage(g: ModuleGraph; mainFileIdx: FileIndex) =
       hooks.add e
       # Transform the hook routine's body and cache it on the sym so `writeSymDef`
       # serializes it in the hook's `(sd)` transformed-body slot (`transformBody
-      # {}` returns the body but does not cache it).
+      # {}` returns the body but does not cache it). Inject the hook's own
+      # destructors here too (it can destroy fields/temporaries) so cg loads a
+      # fully-lowered hook and never re-injects.
       e.sym.transformedBody = transformBody(g, tb.idgen, e.sym, {})
+      if sfInjectDestructors in e.sym.flags:
+        e.sym.transformedBody = injectDestructorCalls(g, tb.idgen, e.sym, e.sym.transformedBody)
     inc i
   # Re-serialize the whole module to its suffix-based `.t.nif` (the path
   # `toNifFilename` resolves for the cg/emit stages). `writeLoweredModule` seals
   # routines itself.
   let suffix = cachedModuleSuffix(g.config, FileIndex modPos)
-  let wholeArtifact = toGeneratedFile(g.config, AbsoluteFile(suffix), ".t.nif").string
+  let wholeArtifact = toGeneratedFile(g.config, AbsoluteFile(suffix), ".t.bif").string
   writeLoweredModule(ast.program, g.config, target, hooks, wholeArtifact)
   if isDefined(g.config, "icDceCheck"):
     stderr.writeLine "[icLower] " & extractFilename(wholeArtifact) & " " &

compiler/nim.cfg

@@ -14,6 +14,10 @@ define:nimPreviewAsmSemSymbol
 define:nimPreviewCStringComparisons
 #define:nimPreviewDuplicateModuleError
 # Incompatible with Nimony's compat2.nim for now
+# NOTE: `-d:virtualParRi` (jump-encoded ParLe + elided ParRi) is NOT yet enabled:
+# the IC writer assembles buffers by raw token splicing (`dest.add content[i]`),
+# which does not seal scopes the way `addParRi` does, so sealed `(stmts)` get
+# jump=0 and serialize empty. Enabling it needs writer buffer-sealing work first.
 
 threads:off
 

compiler/options.nim

@@ -29,7 +29,7 @@ const
 
   nimEnableCovariance* = defined(nimEnableCovariance)
 
-  icFormatVersion* = "21"
+  icFormatVersion* = "25"
     ## Version of the IC cache format (the sem-NIF module layout written by
     ## ast2nif.nim plus the iface/impl/edges side files). Bump it whenever
     ## that layout changes: `commandIc` wipes a nimcache whose `ic.version`
@@ -793,6 +793,17 @@ template quitOrRaise*(conf: ConfigRef, msg = "") =
   else:
     quit(msg) # quits with QuitFailure
 
+proc icReuseSemLowering*(conf: ConfigRef): bool {.inline.} =
+  ## When ON, the per-module `lower` backend stage REUSES the VM/CT lowering that
+  ## sem cached in the `.s.nif` 2-way-body slot (the non-IC single-lowering
+  ## semantics) instead of re-deriving the transform. Default OFF: the backend
+  ## re-derives every body from the pristine semchecked body (simpler; allowed by
+  ## the 2026-06-27 spec that VM-requested frontend transforms need not influence
+  ## the backend). The switch exists so caching can be restored if a target (e.g.
+  ## Nimbus) depends on the cached lowering being reused, not re-derived. See
+  ## doc/ic_backend_simplify.md §6b.
+  isDefined(conf, "icReuseSemLowering")
+
 proc importantComments*(conf: ConfigRef): bool {.inline.} = conf.ideActive or conf.cmd in cmdDocLike
 proc usesWriteBarrier*(conf: ConfigRef): bool {.inline.} = conf.selectedGC >= gcRefc
 proc usesSso*(conf: ConfigRef): bool {.inline.} = conf.selectedStrings == stringSso

compiler/pipelines.nim

@@ -313,9 +313,13 @@ proc processPipelineModule*(graph: ModuleGraph; module: PSym; idgen: IdGenerator
       # NIF `deps` section is complete (the backend closure walk needs it), and
       # reused below for the `.s.deps` sidecar (frontend graph re-derivation).
       let resolvedImportDeps = graph.importDeps.getOrDefault(module.position.FileIndex, @[])
+      # The frontend's highest used itemId (max of the sym and type counters):
+      # the backend seeds its id minting ABOVE this so closure envs / RTTI hooks
+      # never share a `toId` with a frontend sym/type. See ast2nif `(unusedid)`.
+      let firstUnusedId = max(idgen.symId, idgen.typeId)
       writeNifModule(graph.config, module.position.int32, topLevelStmts, graph.opsLog,
                      replayActions, implDeps, reexportedModuleSyms(graph, module),
-                     genericOffers, typeOffers, resolvedImportDeps)
+                     genericOffers, typeOffers, resolvedImportDeps, firstUnusedId)
       # The module's REAL direct imports (incl. macro-generated) for `nim ic`'s
       # graph re-derivation; see ast2nif.writeSemDeps / semdata.addImportFileDep.
       var semDepPaths: seq[string] = @[]

koch.nim

@@ -16,11 +16,11 @@ const
   ChecksumsStableCommit = "0b8e46379c5bc1bf73d8b3011908389c60fb9b98" # 2.0.1
   SatStableCommit = "e63eaea8baf00bed8bcd5a29ffd8823abb265b39"
 
-  NimonyStableCommit = "5fa72628a6867f8ca09f8955a493749cf65f006a" # unversioned \
+  NimonyStableCommit = "030fb8a132d29bb58b6db4d329647ab4bc512fd2" # unversioned \
     # Note that Nimony uses Nim as a git submodule but we don't want to install
     # Nimony's dependency to Nim as we are Nim. So a `git clone` without --recursive
     # is **required** here.
-    # Commit from 2026-06-14
+    # Commit from 2026-06-27
 
   # examples of possible values for fusion: #head, #ea82b54, 1.2.3
   FusionStableHash = "#562467452b32cb7a97410ea177f083e6d8405734"