test

fixes #25566

.github/dependabot.yml

@@ -0,0 +1,11 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

.github/workflows/bisects.yml

@@ -15,7 +15,7 @@ jobs:
     name: ${{ matrix.platform }}-bisects
     runs-on: ${{ matrix.platform }}
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
 
       - name: Install OpenSSL (Windows)
         if: |

.github/workflows/ci_docs.yml

@@ -53,7 +53,7 @@ jobs:
 
     steps:
       - name: 'Checkout'
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           fetch-depth: 2
 

.github/workflows/ci_packages.yml

@@ -33,14 +33,14 @@ jobs:
       NIM_TESTAMENT_BATCH: ${{ matrix.batch }}
     steps:
       - name: 'Checkout'
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           fetch-depth: 2
 
-      - name: 'Install node.js 20.x'
-        uses: actions/setup-node@v4
+      - name: 'Install node.js'
+        uses: actions/setup-node@v6
         with:
-          node-version: '20.x'
+          node-version: 24
 
       - name: 'Install dependencies (Linux amd64)'
         if: runner.os == 'Linux' && matrix.cpu == 'amd64'

.github/workflows/ci_publish.yml

@@ -17,14 +17,14 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: 'Checkout'
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           fetch-depth: 2
 
       - name: 'Install node.js'
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
-          node-version: ''
+          node-version: 24
 
       - name: 'Install dependencies (Linux amd64)'
         if: runner.os == 'Linux' && matrix.cpu == 'amd64'
@@ -60,7 +60,7 @@ jobs:
         run: nim c -r -d:release ci/action.nim
 
       - name: 'Comment'
-        uses: actions/github-script@v7
+        uses: actions/github-script@v8
         with:
           script: |
             const fs = require('fs');

.github/workflows/stale.yml

@@ -9,7 +9,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v9
+      - uses: actions/stale@v10
         with:
           days-before-pr-stale:    365
           days-before-pr-close:    30

changelog.md

@@ -33,6 +33,8 @@ errors.
 
 - Bitshift operators (`shl`, `shr`, `ashr`) now apply bitmasking to the right operand in the C/C++/VM/JS backends.
 
+- Adds a new warning `--warning:ImplicitRangeConversion` that detects downsizing implicit conversions to range types (e.g., `int -> range[0..255]` or `range[1..256] -> range[0..255]`) that could cause runtime panics. Safe conversions like `range[0..255] -> range[0..65535]` and explicit casts do not trigger warnings. `int` to `Natural` and `Positive` conversions do not trigger warnings, which can be enabled with `--warning:systemRangeConversion`.
+
 ## Standard library additions and changes
 
 [//]: # "Additions:"
@@ -59,6 +61,10 @@ errors.
 
 - `system.setLenUninit` now supports refc, JS and VM backends.
 
+- `std/parseopt` now supports multiple parser modes via a `CliMode` enum.
+  Modes include `Nim` (default, fully compatible) and two new experimental modes:
+  `Lax` and `Gnu` for different option parsing behaviors.
+
 [//]: # "Changes:"
 
 - `std/math` The `^` symbol now supports floating-point as exponent in addition to the Natural type.
@@ -112,7 +118,9 @@ errors.
 
 ## Tool changes
 
+- Added `--raw` flag when generating JSON docs to not render markup.
 - Added `--stdinfile` flag to name of the file used when running program from stdin (defaults to `stdinfile.nim`)
+- Added `--styleCheck:warning` flag to treat style check violations as warnings.
 
 ## Documentation changes
 

compiler/ast.nim

@@ -501,6 +501,7 @@ const
 proc idGeneratorFromModule*(m: PSym): IdGenerator =
   assert m.kind == skModule
   result = IdGenerator(module: m.itemId.module, symId: m.itemId.item, typeId: 0, disambTable: initCountTable[PIdent]())
+  result.disambTable.inc m.name
 
 proc idGeneratorForPackage*(nextIdWillBe: int32): IdGenerator =
   result = IdGenerator(module: PackageModuleId, symId: nextIdWillBe - 1'i32, typeId: 0, disambTable: initCountTable[PIdent]())
@@ -549,22 +550,25 @@ proc addAllowNil*(father, son: PNode) {.inline.} =
   father.sons.add(son)
 
 proc add*(father, son: PType) =
+  ensureMutable father
   assert father.kind != tyProc or father.sonsImpl.len == 0
   assert son != nil
   father.sonsImpl.add son
 
 proc addAllowNil*(father, son: PType) {.inline.} =
+  ensureMutable father
   assert father.kind != tyProc or father.sonsImpl.len == 0
   father.sonsImpl.add son
 
-template `[]`*(n: PType, i: int): PType =
+proc `[]`*(n: PType, i: int): PType {.inline.} =
   if n.state == Partial: loadType(n)
   if n.kind == tyProc and i > 0:
     assert n.nImpl[i] != nil and n.nImpl[i].sym != nil
     n.nImpl[i].sym.typ
   else:
     n.sonsImpl[i]
-template `[]=`*(n: PType, i: int; x: PType) =
+
+proc `[]=`*(n: PType, i: int; x: PType) {.inline.} =
   if n.state == Partial: loadType(n)
   if n.kind == tyProc and i > 0:
     assert n.nImpl[i] != nil and n.nImpl[i].sym != nil
@@ -572,12 +576,13 @@ template `[]=`*(n: PType, i: int; x: PType) =
   else:
     n.sonsImpl[i] = x
 
-template `[]`*(n: PType, i: BackwardsIndex): PType =
+proc `[]`*(n: PType, i: BackwardsIndex): PType {.inline.} =
   if n.state == Partial: loadType(n)
-  n[n.len - i.int]
-template `[]=`*(n: PType, i: BackwardsIndex; x: PType) =
+  n[n.sonsImpl.len - i.int]
+
+proc `[]=`*(n: PType, i: BackwardsIndex; x: PType) {.inline.} =
   if n.state == Partial: loadType(n)
-  n[n.len - i.int] = x
+  n[n.sonsImpl.len - i.int] = x
 
 proc getDeclPragma*(n: PNode): PNode =
   ## return the `nkPragma` node for declaration `n`, or `nil` if no pragma was found.
@@ -930,6 +935,7 @@ proc `$`*(s: PSym): string =
     result = "<nil>"
 
 proc len*(n: PType): int {.inline.} =
+  if n.state == Partial: loadType(n)
   if n.kind == tyProc:
     result = if n.nImpl == nil: 0 else: n.nImpl.len
   else:
@@ -1168,6 +1174,7 @@ proc skipTypesOrNil*(t: PType, kinds: TTypeKinds): PType =
   ## same as skipTypes but handles 'nil'
   result = t
   while result != nil and result.kind in kinds:
+    if result.state == Partial: loadType(result)
     if result.sonsImpl.len == 0: return nil
     result = last(result)
 

compiler/ast2nif.nim

@@ -159,7 +159,6 @@ type
     inProc: int
     #writtenTypes: seq[PType]  # types written in this module, to be unloaded later
     #writtenSyms: seq[PSym]    # symbols written in this module, to be unloaded later
-    exports: Table[FileIndex, HashSet[string]]  # module -> specific symbol names (empty = all)
     writtenPackages: HashSet[string]
 
 const
@@ -253,6 +252,7 @@ proc writeLoc(w: var Writer; dest: var TokenBuf; loc: TLoc) =
 proc writeTypeDef(w: var Writer; dest: var TokenBuf; typ: PType) =
   dest.buildTree tdefTag:
     dest.addSymDef pool.syms.getOrIncl(typeToNifSym(typ, w.infos.config)), NoLineInfo
+    dest.addDotToken # always private for the index generator
 
     #dest.addIdent toNifTag(typ.kind)
     writeFlags(dest, typ.flagsImpl)
@@ -321,7 +321,7 @@ proc collectGenericParams(w: var Writer; n: PNode) =
 proc writeSymDef(w: var Writer; dest: var TokenBuf; sym: PSym) =
   dest.addParLe sdefTag, trLineInfo(w, sym.infoImpl)
   dest.addSymDef pool.syms.getOrIncl(w.toNifSymName(sym)), NoLineInfo
-  if sfExported in sym.flagsImpl:
+  if {sfExported, sfFromGeneric} * sym.flagsImpl == {sfExported}:
     dest.addIdent "x"
   else:
     dest.addDotToken
@@ -345,6 +345,8 @@ proc writeSymDef(w: var Writer; dest: var TokenBuf; sym: PSym) =
 
   if sym.kindImpl == skModule:
     dest.addDotToken() # position will be set by the loader!
+  elif sym.kindImpl in {skVar, skLet, skForVar, skResult}:
+    dest.addIntLit 0  # hack for the VM which uses this field to store information
   else:
     dest.addIntLit sym.positionImpl
 
@@ -474,6 +476,40 @@ proc trImport(w: var Writer; n: PNode) =
       w.deps.addStrLit fp  # raw string literal, no wrapper needed
       w.deps.addParRi
 
+proc trExport(w: var Writer; n: PNode) =
+  # Collect export information for the index
+  # nkExportStmt children are nkSym nodes
+  # When exporting a module (export dollars), the module symbol is a child
+  # followed by all symbols from that module - we use empty set to mean "export all"
+  # When exporting specific symbols (export foo, bar), we collect their names
+  w.deps.addParLe pool.tags.getOrIncl(toNifTag(n.kind)), trLineInfo(w, n.info)
+  w.deps.addDotToken # flags
+  w.deps.addDotToken # type
+  for child in n:
+    if child.kind == nkSym:
+      let s = child.sym
+      if s.kindImpl == skModule:
+        discard "do not write module syms here"
+      else:
+        w.deps.addSymUse pool.syms.getOrIncl(w.toNifSymName(s)), NoLineInfo
+  w.deps.addParRi
+
+let replayTag = registerTag("replay")
+let repConverterTag = registerTag("repconverter")
+let repDestroyTag = registerTag("repdestroy")
+let repWasMovedTag = registerTag("repwasmoved")
+let repCopyTag = registerTag("repcopy")
+let repSinkTag = registerTag("repsink")
+let repDupTag = registerTag("repdup")
+let repTraceTag = registerTag("reptrace")
+let repDeepCopyTag = registerTag("repdeepcopy")
+let repEnumToStrTag = registerTag("repenumtostr")
+let repMethodTag = registerTag("repmethod")
+#let repClassTag = registerTag("repclass")
+let includeTag = registerTag("include")
+let importTag = registerTag("import")
+let implTag = registerTag("implementation")
+
 proc writeNode(w: var Writer; dest: var TokenBuf; n: PNode; forAst = false) =
   if n == nil:
     dest.addDotToken
@@ -581,37 +617,9 @@ proc writeNode(w: var Writer; dest: var TokenBuf; n: PNode; forAst = false) =
     of nkIncludeStmt:
       trInclude w, n
     of nkExportStmt, nkExportExceptStmt:
-      # Collect export information for the index
-      # nkExportStmt children are nkSym nodes
-      # When exporting a module (export dollars), the module symbol is a child
-      # followed by all symbols from that module - we use empty set to mean "export all"
-      # When exporting specific symbols (export foo, bar), we collect their names
       # Note: nkExportExceptStmt is transformed to nkExportStmt by semExportExcept,
       # but we handle both just in case
-      var exportAllModules = initHashSet[FileIndex]()
-      for child in n:
-        if child.kind == nkSym:
-          let s = child.sym
-          if s.kindImpl == skModule:
-            # Export all from this module - use empty set
-            let modIdx = s.positionImpl.FileIndex
-            exportAllModules.incl modIdx
-            if modIdx notin w.exports:
-              w.exports[modIdx] = initHashSet[string]()  # empty means "export all"
-          else:
-            # Export specific symbol, but only if we're not already exporting all from this module
-            let modIdx = s.itemId.module.FileIndex
-            if modIdx notin exportAllModules:
-              if modIdx notin w.exports:
-                w.exports[modIdx] = initHashSet[string]()
-              w.exports[modIdx].incl s.name.s
-      # Write the export statement as a regular node
-      w.withNode dest, n:
-        for i in 0 ..< n.len:
-          if n[i].kind == nkSym and n[i].sym.kindImpl == skModule:
-            discard "do not write module syms here"
-          else:
-            writeNode(w, dest, n[i], forAst)
+      trExport w, n
     else:
       w.withNode dest, n:
         for i in 0 ..< n.len:
@@ -663,40 +671,6 @@ proc createStmtList(buf: var TokenBuf; info: PackedLineInfo) {.inline.} =
   buf.addDotToken # flags
   buf.addDotToken # type
 
-proc buildExportBuf(w: var Writer): TokenBuf =
-  ## Build the export section for the NIF index from collected exports
-  result = createTokenBuf(32)
-  for modIdx, names in w.exports:
-    let path = toFullPath(w.infos.config, modIdx)
-    if names.len == 0:
-      # Export all from this module
-      result.addParLe(TagId(ExportIdx), NoLineInfo)
-      result.add strToken(pool.strings.getOrIncl(path), NoLineInfo)
-      result.addParRi()
-    else:
-      # Export specific symbols
-      result.addParLe(TagId(FromexportIdx), NoLineInfo)
-      result.add strToken(pool.strings.getOrIncl(path), NoLineInfo)
-      for name in names:
-        result.add identToken(pool.strings.getOrIncl(name), NoLineInfo)
-      result.addParRi()
-
-let replayTag = registerTag("replay")
-let repConverterTag = registerTag("repconverter")
-let repDestroyTag = registerTag("repdestroy")
-let repWasMovedTag = registerTag("repwasmoved")
-let repCopyTag = registerTag("repcopy")
-let repSinkTag = registerTag("repsink")
-let repDupTag = registerTag("repdup")
-let repTraceTag = registerTag("reptrace")
-let repDeepCopyTag = registerTag("repdeepcopy")
-let repEnumToStrTag = registerTag("repenumtostr")
-let repMethodTag = registerTag("repmethod")
-#let repClassTag = registerTag("repclass")
-let includeTag = registerTag("include")
-let importTag = registerTag("import")
-let implTag = registerTag("implementation")
-
 proc writeOp(w: var Writer; content: var TokenBuf; op: LogEntry) =
   case op.kind
   of HookEntry:
@@ -784,10 +758,6 @@ proc writeNifModule*(config: ConfigRef; thisModule: int32; n: PNode;
 
   writeFile(dest, d)
 
-  let exportBuf = buildExportBuf(w)
-  createIndex(d, dest[0].info, false,
-    IndexSections(exportBuf: exportBuf))
-
 # --------------------------- Loader (lazy!) -----------------------------------------------
 
 proc nodeKind(n: Cursor): TNodeKind {.inline.} =
@@ -845,7 +815,7 @@ type
   NifModule = ref object
     stream: nifstreams.Stream
     symCounter: int32
-    index: NifIndex
+    index: Table[string, NifIndexEntry]  # Simple embedded index for offsets
     suffix: string
 
   DecodeContext* = object
@@ -871,25 +841,65 @@ type
   LoadFlag* = enum
     LoadFullAst, AlwaysLoadInterface
 
+proc readEmbeddedIndex(s: var Stream): Table[string, NifIndexEntry] =
+  ## Reads the simple embedded index (index (kv sym offset)...) from indexStartsAt position.
+  result = initTable[string, NifIndexEntry]()
+  let indexPos = indexStartsAt(s.r)
+  if indexPos <= 0:
+    return
+  let contentPos = offset(s.r)  # Save position
+  s.r.jumpTo(indexPos)
+
+  var previousOffset = 0
+  var t = next(s)
+  let exportedTagId = pool.tags.getOrIncl("x")
+  if t.kind == ParLe and pool.tags[t.tagId] == ".index":
+    t = next(s)
+    while t.kind != EofToken and t.kind != ParRi:
+      if t.kind == ParLe:
+        let vis = if t.tagId == exportedTagId: Exported else: Hidden
+        let info = t.info
+        t = next(s)  # skip (kv
+        var key = ""
+        if t.kind == Symbol:
+          key = pool.syms[t.symId]
+        elif t.kind == Ident:
+          key = pool.strings[t.litId]
+        t = next(s)  # skip symbol
+        if t.kind == IntLit:
+          let offset = int(pool.integers[t.intId]) + previousOffset
+          result[key] = NifIndexEntry(offset: offset, info: info, vis: vis)
+          previousOffset = offset
+        t = next(s)  # skip offset
+        if t.kind == ParRi:
+          t = next(s)  # skip )
+      else:
+        t = next(s)
+
+  s.r.jumpTo(contentPos)  # Restore position
+
 proc moduleId(c: var DecodeContext; suffix: string; flags: set[LoadFlag] = {}): FileIndex =
   var isKnownFile = false
   result = c.infos.config.registerNifSuffix(suffix, isKnownFile)
-  if not isKnownFile or AlwaysLoadInterface in flags:
+  # Always load the module's index if it's not already in c.mods
+  # This is needed when resolving symbols from modules that were registered elsewhere
+  # but haven't had their NIF index loaded yet
+  let hasEntry = c.mods.hasKey(result)
+  if not hasEntry or AlwaysLoadInterface in flags:
     let modFile = (getNimcacheDir(c.infos.config) / RelativeFile(suffix & ".nif")).string
-    let idxFile = (getNimcacheDir(c.infos.config) / RelativeFile(suffix & ".s.idx.nif")).string
     if not fileExists(modFile):
       raiseAssert "NIF file not found for module suffix '" & suffix & "': " & modFile &
         ". This can happen when loading a module from NIF that references another module " &
         "whose NIF file hasn't been written yet."
-    c.mods[result] = NifModule(stream: nifstreams.open(modFile), index: readIndex(idxFile), suffix: suffix)
+    var stream = nifstreams.open(modFile)
+    let index = readEmbeddedIndex(stream)
+    c.mods[result] = NifModule(stream: stream, index: index, suffix: suffix)
 
 proc getOffset(c: var DecodeContext; module: FileIndex; nifName: string): NifIndexEntry =
   let ii = addr c.mods[module].index
-  result = ii.public.getOrDefault(nifName)
+  result = ii[].getOrDefault(nifName)
   if result.offset == 0:
-    result = ii.private.getOrDefault(nifName)
-    if result.offset == 0:
-      raiseAssert "symbol has no offset: " & nifName
+    raiseAssert "symbol has no offset: " & nifName
 
 proc loadNode(c: var DecodeContext; n: var Cursor; thisModule: string;
               localSyms: var Table[string, PSym]): PNode
@@ -1081,6 +1091,8 @@ proc loadTypeFromCursor(c: var DecodeContext; n: var Cursor; t: PType; localSyms
   expect n, SymbolDef
   # ignore the type's name, we have already used it to create this PType's itemId!
   inc n
+  expect n, DotToken
+  inc n
   #loadField t.kind
   loadField t.flagsImpl
   loadField t.callConvImpl
@@ -1395,83 +1407,33 @@ proc extractBasename(nifName: string): string =
 proc populateInterfaceTablesFromIndex(c: var DecodeContext; module: FileIndex;
                                       interf, interfHidden: var TStrTable; thisModule: string) =
   ## Populates interface tables from the NIF index structure.
-  ## Uses the index's public/private tables instead of traversing AST.
+  ## Uses the simple embedded index for offsets, exports passed from processTopLevel.
 
-  # Move the public table and exports list out to avoid iterator invalidation
+  # Move the index table out to avoid iterator invalidation
   # (moduleId can add to c.mods which would invalidate Table iterators)
-  # We move them back after iteration.
-  var publicTab = move c.mods[module].index.public
-  var exportsList = move c.mods[module].index.exports
+  var indexTab = move c.mods[module].index
 
-  # Add all public symbols to interf (exported interface) and interfHidden
-  for nifName, entry in publicTab:
-    if not nifName.startsWith("`t"):
-      # do not load types, they are not part of an interface but an implementation detail!
-      #echo "LOADING SYM ", nifName, " ", entry.offset
+  # Add all symbols to interf (exported interface) and interfHidden
+  for nifName, entry in indexTab:
+    if entry.vis == Exported:
       let sym = loadSymFromIndexEntry(c, module, nifName, entry, thisModule)
       if sym != nil:
         strTableAdd(interf, sym)
         strTableAdd(interfHidden, sym)
-
-  # Move public table back
-  c.mods[module].index.public = move publicTab
-
-  # Process exports (re-exports from other modules)
-  for exp in exportsList:
-    let (path, kind, names) = exp
-    # Convert path to module suffix
-    let expSuffix = moduleSuffix(path, cast[seq[string]](c.infos.config.searchPaths))
-    # Load the exported module's index
-    let expModule = moduleId(c, expSuffix)
-
-    # Move the exported module's public table out to avoid iterator invalidation
-    var expPublicTab = move c.mods[expModule].index.public
-
-    # Build a set of names for filtering
-    var nameSet = initHashSet[string]()
-    for nameId in names:
-      nameSet.incl pool.strings[nameId]
-
-    # Add symbols based on export kind
-    for nifName, entry in expPublicTab:
-      if nifName.startsWith("`t"):
-        continue  # skip types
-
-      let basename = extractBasename(nifName)
-      let shouldInclude =
-        case kind
-        of ExportIdx: true  # export all
-        of FromexportIdx: basename in nameSet  # only specific names
-        of ExportexceptIdx: basename notin nameSet  # all except specific names
-        else: false
-
-      if shouldInclude:
-        let sym = loadSymFromIndexEntry(c, expModule, nifName, entry, expSuffix)
-        if sym != nil:
-          strTableAdd(interf, sym)
-          strTableAdd(interfHidden, sym)
-
-    # Move exported module's public table back
-    c.mods[expModule].index.public = move expPublicTab
-
-  # Move exports list back
-  c.mods[module].index.exports = move exportsList
-
-  when false:
-    # Add private symbols to interfHidden only
-    for nifName, entry in idx.private:
+    elif not nifName.startsWith("`t"):
+      # do not load types, they are not part of an interface but an implementation detail!
+      #echo "LOADING SYM ", nifName, " ", entry.offset
       let sym = loadSymFromIndexEntry(c, module, nifName, entry, thisModule)
       if sym != nil:
         strTableAdd(interfHidden, sym)
 
+  # Move index table back
+  c.mods[module].index = move indexTab
+
 proc toNifFilename*(conf: ConfigRef; f: FileIndex): string =
   let suffix = moduleSuffix(conf, f)
   result = toGeneratedFile(conf, AbsoluteFile(suffix), ".nif").string
 
-proc toNifIndexFilename*(conf: ConfigRef; f: FileIndex): string =
-  let suffix = moduleSuffix(conf, f)
-  result = toGeneratedFile(conf, AbsoluteFile(suffix), ".s.idx.nif").string
-
 proc resolveSym(c: var DecodeContext; symAsStr: string; alsoConsiderPrivate: bool): PSym =
   result = c.syms.getOrDefault(symAsStr)[0]
   if result != nil:
@@ -1482,14 +1444,17 @@ proc resolveSym(c: var DecodeContext; symAsStr: string; alsoConsiderPrivate: boo
     return nil  # Local symbols shouldn't be hooks
   let module = moduleId(c, sn.module)
   # Look up the symbol in the module's index
-  var offs = c.mods[module].index.public.getOrDefault(symAsStr)
+  # Try both formats: with module suffix (e.g., "foo.0.modulename") and without (e.g., "foo.0.")
+  # NIF spec allows local symbols to be stored without module suffix
+  var offs = c.mods[module].index.getOrDefault(symAsStr)
   if offs.offset == 0:
-    if alsoConsiderPrivate:
-      offs = c.mods[module].index.private.getOrDefault(symAsStr)
-      if offs.offset == 0:
-        return nil
-    else:
-      return nil
+    # Try the format without module suffix
+    let localKey = sn.name & "." & $sn.count & "."
+    offs = c.mods[module].index.getOrDefault(localKey)
+  if offs.offset == 0:
+    return nil
+  if not alsoConsiderPrivate and offs.vis == Hidden:
+    return nil
   # Create a stub symbol
   let val = addr c.mods[module].symCounter
   inc val[]
@@ -1581,12 +1546,14 @@ proc loadImport(c: var DecodeContext; s: var Stream; deps: var seq[ModuleSuffix]
   else:
     raiseAssert "expected ParRi but got " & $tok.kind
 
-proc processTopLevel(c: var DecodeContext; s: var Stream; flags: set[LoadFlag] = {}; suffix: string; module: int): PrecompiledModule =
+proc processTopLevel(c: var DecodeContext; s: var Stream; flags: set[LoadFlag];
+                     interf: var TStrTable; suffix: string; module: int): PrecompiledModule =
   result = PrecompiledModule(topLevel: newNode(nkStmtList))
   var localSyms = initTable[string, PSym]()
 
   var t = next(s) # skip dot
   var cont = true
+  let exportTag = pool.tags.getOrIncl"export"
   while cont and t.kind != EofToken:
     if t.kind == ParLe:
       if t.tagId == replayTag:
@@ -1627,6 +1594,24 @@ proc processTopLevel(c: var DecodeContext; s: var Stream; flags: set[LoadFlag] =
         t = loadLogOp(c, result.logOps, s, MethodEntry, attachedTrace, module)
         #elif t.tagId == repClassTag:
         #  t = loadLogOp(c, logOps, s, ClassEntry, attachedTrace, module)
+      elif t.tagId == exportTag:
+        t = next(s)  # skip (export
+        if t.kind == DotToken:
+          t = next(s) # skip dot
+          if t.kind == DotToken:
+            t = next(s) # skip dot
+        while true:
+          if t.kind == Symbol:
+            let symAsStr = pool.syms[t.symId]
+            let sym = resolveSym(c, symAsStr, false)
+            if sym != nil:
+              strTableAdd(interf, sym)
+            t = next(s)
+          elif t.kind == ParRi:
+            break
+          else:
+            raiseAssert "expected Symbol or ParRi but got " & $t.kind
+        t = next(s)
       elif t.tagId == includeTag:
         t = skipTree(s)
       elif t.tagId == importTag:
@@ -1649,25 +1634,25 @@ proc processTopLevel(c: var DecodeContext; s: var Stream; flags: set[LoadFlag] =
 
 proc loadNifModule*(c: var DecodeContext; suffix: ModuleSuffix; interf, interfHidden: var TStrTable;
                     flags: set[LoadFlag] = {}): PrecompiledModule =
-    # Ensure module index is loaded - moduleId returns the FileIndex for this suffix
+  # Ensure module index is loaded - moduleId returns the FileIndex for this suffix
   let module = moduleId(c, string(suffix), flags)
 
-  # Populate interface tables from the NIF index structure
-  # Symbols are created as stubs (Partial state) and will be loaded lazily via loadSym
-  populateInterfaceTablesFromIndex(c, module, interf, interfHidden, string(suffix))
-
   # Load the module AST (or just replay actions if loadFullAst is false)
+  # processTopLevel also collects export instructions
   let s = addr c.mods[module].stream
-  s.r.jumpTo 0  # Start from beginning
-  discard processDirectives(s.r)
   var t = next(s[])
   if t.kind == ParLe and pool.tags[t.tagId] == toNifTag(nkStmtList):
     t = next(s[])  # skip (stmts
     t = next(s[])  # skip flags
-    result = processTopLevel(c, s[], flags, string(suffix), module.int)
+    result = processTopLevel(c, s[], flags, interf, string(suffix), module.int)
   else:
     result = PrecompiledModule(topLevel: newNode(nkStmtList))
 
+  # Populate interface tables from the NIF index structure
+  # Symbols are created as stubs (Partial state) and will be loaded lazily via loadSym
+  # Use exports collected by processTopLevel
+  populateInterfaceTablesFromIndex(c, module, interf, interfHidden, string(suffix))
+
 proc loadNifModule*(c: var DecodeContext; f: FileIndex; interf, interfHidden: var TStrTable;
                     flags: set[LoadFlag] = {}): PrecompiledModule =
   let suffix = ModuleSuffix(moduleSuffix(c.infos.config, f))

compiler/astdef.nim

@@ -202,7 +202,11 @@ type
     tySequence,
     tyProc,
     tyPointer, tyOpenArray,
-    tyString, tyCstring, tyForward,
+    tyString, tyCstring,
+    tyForward,
+      # a type not yet semchecked
+      # When semcheck a type section, all types defined in it are initialized to tyForward
+
     tyInt, tyInt8, tyInt16, tyInt32, tyInt64, # signed integers
     tyFloat, tyFloat32, tyFloat64, tyFloat128,
     tyUInt, tyUInt8, tyUInt16, tyUInt32, tyUInt64,

compiler/btrees.nim

@@ -69,7 +69,7 @@ proc copyHalf[Key, Val](h, result: Node[Key, Val]) =
       result.links[j] = h.links[Mhalf + j]
   else:
     for j in 0..<Mhalf:
-      when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc):
+      when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc) or defined(gcYrc):
         result.vals[j] = move h.vals[Mhalf + j]
       else:
         shallowCopy(result.vals[j], h.vals[Mhalf + j])
@@ -92,7 +92,7 @@ proc insert[Key, Val](h: Node[Key, Val], key: Key, val: Val): Node[Key, Val] =
       if less(key, h.keys[j]): break
       inc j
     for i in countdown(h.entries, j+1):
-      when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc):
+      when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc) or defined(gcYrc):
         h.vals[i] = move h.vals[i-1]
       else:
         shallowCopy(h.vals[i], h.vals[i-1])

compiler/ccgcalls.nim

@@ -331,7 +331,7 @@ proc withTmpIfNeeded(p: BProc, a: TLoc, needsTmp: bool): TLoc =
   # Bug https://github.com/status-im/nimbus-eth2/issues/1549
   # Aliasing is preferred over stack overflows.
   # Also don't regress for non ARC-builds, too risky.
-  if needsTmp and a.lode.typ != nil and p.config.selectedGC in {gcArc, gcAtomicArc, gcOrc} and
+  if needsTmp and a.lode.typ != nil and p.config.selectedGC in {gcArc, gcAtomicArc, gcOrc, gcYrc} and
       getSize(p.config, a.lode.typ) < 1024:
     result = getTemp(p, a.lode.typ, needsInit=false)
     genAssignment(p, result, a, {})

compiler/ccgexprs.nim

@@ -416,7 +416,7 @@ proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) =
     else:
       simpleAsgn(p.s(cpsStmts), dest, src)
   of tyArray:
-    if containsGarbageCollectedRef(dest.t) and p.config.selectedGC notin {gcArc, gcAtomicArc, gcOrc, gcHooks}:
+    if containsGarbageCollectedRef(dest.t) and p.config.selectedGC notin {gcArc, gcAtomicArc, gcOrc, gcYrc, gcHooks}:
       genGenericAsgn(p, dest, src, flags)
     else:
       let rd = rdLoc(dest)
@@ -1832,7 +1832,7 @@ proc genObjConstr(p: BProc, e: PNode, d: var TLoc) =
 
   var tmp: TLoc = default(TLoc)
   var r: Rope
-  let needsZeroMem = p.config.selectedGC notin {gcArc, gcAtomicArc, gcOrc} or nfAllFieldsSet notin e.flags
+  let needsZeroMem = p.config.selectedGC notin {gcArc, gcAtomicArc, gcOrc, gcYrc} or nfAllFieldsSet notin e.flags
   if useTemp:
     tmp = getTemp(p, t)
     r = rdLoc(tmp)
@@ -2751,7 +2751,7 @@ proc genMove(p: BProc; n: PNode; d: var TLoc) =
     p.s(cpsStmts).addFieldAssignment(destVal, "p", dotField(srcVal, "p"))
   else:
     if d.k == locNone: d = getTemp(p, n.typ)
-    if p.config.selectedGC in {gcArc, gcAtomicArc, gcOrc}:
+    if p.config.selectedGC in {gcArc, gcAtomicArc, gcOrc, gcYrc}:
       genAssignment(p, d, a, {})
       var op = getAttachedOp(p.module.g.graph, n.typ, attachedWasMoved)
       if op == nil:
@@ -2835,7 +2835,7 @@ proc genSlice(p: BProc; e: PNode; d: var TLoc) =
   let (x, y) = genOpenArraySlice(p, e, e.typ, e.typ.elementType,
     prepareForMutation = e[1].kind == nkHiddenDeref and
                          e[1].typ.skipTypes(abstractInst).kind == tyString and
-                         p.config.selectedGC in {gcArc, gcAtomicArc, gcOrc})
+                         p.config.selectedGC in {gcArc, gcAtomicArc, gcOrc, gcYrc})
   if d.k == locNone: d = getTemp(p, e.typ)
   let dest = rdLoc(d)
   p.s(cpsStmts).addFieldAssignment(dest, "Field0", x)
@@ -3039,7 +3039,7 @@ proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
       let n = semparallel.liftParallel(p.module.g.graph, p.module.idgen, p.module.module, e)
       expr(p, n, d)
   of mDeepCopy:
-    if p.config.selectedGC in {gcArc, gcAtomicArc, gcOrc} and optEnableDeepCopy notin p.config.globalOptions:
+    if p.config.selectedGC in {gcArc, gcAtomicArc, gcOrc, gcYrc} and optEnableDeepCopy notin p.config.globalOptions:
       localError(p.config, e.info,
         "for --mm:arc|atomicArc|orc 'deepcopy' support has to be enabled with --deepcopy:on")
 
@@ -3271,7 +3271,11 @@ proc upConv(p: BProc, n: PNode, d: var TLoc) =
         p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "raiseObjectConversionError"))
         raiseInstr(p, p.s(cpsStmts))
 
-  if n[0].typ.kind != tyObject:
+  # skip cast when types map to the same C type
+  # this avoids invalid C code like `*(T*)&x` for types that can't have their address taken (e.g., WASM __externref_t)
+  if getTypeDesc(p.module, n.typ) == getTypeDesc(p.module, n[0].typ):
+    expr(p, n[0], d)
+  elif n[0].typ.kind != tyObject:
     let destTyp = getTypeDesc(p.module, n.typ)
     let val = rdLoc(a)
     if n.isLValue:
@@ -3317,7 +3321,7 @@ proc downConv(p: BProc, n: PNode, d: var TLoc) =
         cCast(ptrType(destType),
           wrapPar(cAddr(wrapPar(val))))),
       a.storage)
-  elif p.module.compileToCpp:
+  elif p.module.compileToCpp or isImportedType(src):
     # C++ implicitly downcasts for us
     expr(p, arg, d)
   else:

compiler/ccgliterals.nim

@@ -16,7 +16,7 @@
 ## implementation.
 
 template detectVersion(field, corename) =
-  if m.g.config.selectedGC in {gcArc, gcOrc, gcAtomicArc, gcHooks}:
+  if m.g.config.selectedGC in {gcArc, gcOrc, gcYrc, gcAtomicArc, gcHooks}:
     result = 2
   else:
     result = 1

compiler/ccgtypes.nim

@@ -277,7 +277,7 @@ proc isInvalidReturnType(conf: ConfigRef; typ: PType, isProc = true): bool =
     of ctStruct:
       let t = skipTypes(rettype, typedescInst)
       if rettype.isImportedCppType or t.isImportedCppType or
-          (typ.callConv == ccCDecl and conf.selectedGC in {gcArc, gcAtomicArc, gcOrc}):
+          (typ.callConv == ccCDecl and conf.selectedGC in {gcArc, gcAtomicArc, gcOrc, gcYrc}):
         # prevents nrvo for cdecl procs; # bug #23401
         result = false
       else:
@@ -294,7 +294,12 @@ proc cacheGetType(tab: TypeCache; sig: SigHash): Rope =
   result = tab.getOrDefault(sig)
 
 proc addAbiCheck(m: BModule; t: PType, name: Rope) =
-  if isDefined(m.config, "checkAbi") and (let size = getSize(m.config, t); size != szUnknownSize):
+  if isDefined(m.config, "checkAbi") and (let size = getSize(m.config, t); size != szUnknownSize) and
+    not (t.kind == tyObject and searchTypeFor(t, proc (t: PType): bool {.nimcall.} = t.kind == tyUncheckedArray)):
+    # `UncheckedArray`, not `ptr UncheckedArray` type field in object types is a flexible array.
+    # `sizeof` in C and Nim doesn't always return the same value for object types containing it.
+    # making `getSize` in Nim always returns the same value as `sizeof` in C from flexible arrays seems hard.
+    # See `SEQ_DECL_SIZE` in lib/nimbase.h
     var msg = "backend & Nim disagree on size for: "
     msg.addTypeHeader(m.config, t)
     var msg2 = ""
@@ -1067,6 +1072,7 @@ proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDes
                       else: getTupleDesc(m, t, result, check)
         if not isImportedType(t):
           m.s[cfsTypes].add(recdesc)
+          addAbiCheck(m, t, result)
         elif tfIncompleteStruct notin t.flags:
           discard # addAbiCheck(m, t, result) # already handled elsewhere
   of tySet:
@@ -1686,7 +1692,7 @@ proc genHook(m: BModule; t: PType; info: TLineInfo; op: TTypeAttachedOp; result:
         echo "ayclic but has this =trace ", t, " ", theProc.ast
   else:
     when false:
-      if op == attachedTrace and m.config.selectedGC == gcOrc and
+      if op == attachedTrace and m.config.selectedGC in {gcOrc, gcYrc} and
           containsGarbageCollectedRef(t):
         # unfortunately this check is wrong for an object type that only contains
         # .cursor fields like 'Node' inside 'cycleleak'.
@@ -1996,7 +2002,7 @@ proc genTypeInfoV1(m: BModule; t: PType; info: TLineInfo): Rope =
     owner = m.module.position.int32
 
   m.g.typeInfoMarker[sig] = (str: result, owner: owner)
-  rememberEmittedTypeInfo(m.g.graph, FileIndex(owner), $result)
+  #rememberEmittedTypeInfo(m.g.graph, FileIndex(owner), $result)
 
   case t.kind
   of tyEmpty, tyVoid: result = cIntValue(0)

compiler/cgen.nim

@@ -30,7 +30,6 @@ when not defined(leanCompiler):
 
 import std/strutils except `%`, addf # collides with ropes.`%`
 
-from ic / ic import ModuleBackendFlag
 import std/[dynlib, math, tables, sets, os, intsets, hashes]
 
 const
@@ -1333,7 +1332,7 @@ proc genProcLvl3*(m: BModule, prc: PSym) =
         # declare the result symbol:
         assignLocalVar(p, resNode)
         assert(res.loc.snippet != "")
-        if p.config.selectedGC in {gcArc, gcAtomicArc, gcOrc} and
+        if p.config.selectedGC in {gcArc, gcAtomicArc, gcOrc, gcYrc} and
             allPathsAsgnResult(p, procBody) == InitSkippable:
           # In an ideal world the codegen could rely on injectdestructors doing its job properly
           # and then the analysis step would not be required.
@@ -1688,7 +1687,7 @@ proc hcrGetProcLoadCode(builder: var Builder, m: BModule, sym, prefix, handle, g
 # prevents inlining of the NimMainInner function and dependent
 # functions, which might otherwise merge their stack frames.
 proc isInnerMainVolatile(m: BModule): bool =
-  m.config.selectedGC notin {gcNone, gcArc, gcAtomicArc, gcOrc}
+  m.config.selectedGC notin {gcNone, gcArc, gcAtomicArc, gcOrc, gcYrc}
 
 proc genPreMain(m: BModule) =
   m.s[cfsProcs].addDeclWithVisibility(Private):
@@ -1700,8 +1699,6 @@ proc genPreMain(m: BModule) =
       m.s[cfsProcs].addVar(name = "cmdCount", typ = CInt)
     m.s[cfsProcs].addDeclWithVisibility(Private):
       m.s[cfsProcs].addVar(name = "cmdLine", typ = ptrType(ptrType(CChar)))
-    m.s[cfsProcs].addDeclWithVisibility(Private):
-      m.s[cfsProcs].addVar(name = "gEnv", typ = ptrType(ptrType(CChar)))
   m.s[cfsProcs].addDeclWithVisibility(Private):
     m.s[cfsProcs].addProcHeader(m.config.nimMainPrefix & "PreMain", CVoid, cProcParams())
     m.s[cfsProcs].finishProcHeaderWithBody():
@@ -1735,7 +1732,7 @@ proc genNimMainInner(m: BModule) =
   m.s[cfsProcs].addNewline()
 
 proc initStackBottom(m: BModule): bool =
-  not (m.config.target.targetOS == osStandalone or m.config.selectedGC in {gcNone, gcArc, gcAtomicArc, gcOrc})
+  not (m.config.target.targetOS == osStandalone or m.config.selectedGC in {gcNone, gcArc, gcAtomicArc, gcOrc, gcYrc})
 
 proc genNimMainProc(m: BModule, preMainCode: Snippet) =
   m.s[cfsProcs].addProcHeader(ccCDecl, m.config.nimMainPrefix & "NimMain", CVoid, cProcParams())
@@ -1762,12 +1759,10 @@ proc genNimMainBody(m: BModule, preMainCode: Snippet) =
 proc genPosixCMain(m: BModule) =
   m.s[cfsProcs].addProcHeader("main", CInt, cProcParams(
     (name: "argc", typ: CInt),
-    (name: "args", typ: ptrType(ptrType(CChar))),
-    (name: "env", typ: ptrType(ptrType(CChar)))))
+    (name: "args", typ: ptrType(ptrType(CChar)))))
   m.s[cfsProcs].finishProcHeaderWithBody():
     m.s[cfsProcs].addAssignment("cmdLine", "args")
     m.s[cfsProcs].addAssignment("cmdCount", "argc")
-    m.s[cfsProcs].addAssignment("gEnv", "env")
     genMainProcsWithResult(m)
   m.s[cfsProcs].addNewline()
 
@@ -1865,7 +1860,7 @@ proc genMainProc(m: BModule) =
         builder.addCallStmt(cgsymValue(m, "nimLoadLibraryError"), strLit)
 
     loadLib(preMainBuilder, "hcr_handle", "hcrGetProc")
-    if m.config.selectedGC in {gcArc, gcAtomicArc, gcOrc}:
+    if m.config.selectedGC in {gcArc, gcAtomicArc, gcOrc, gcYrc}:
       preMainBuilder.addCallStmt(m.config.nimMainPrefix & "PreMain")
     else:
       preMainBuilder.addVar(name = "rtl_handle", typ = CPointer)
@@ -1926,36 +1921,6 @@ proc genMainProc(m: BModule) =
     if m.config.cppCustomNamespace.len > 0:
       openNamespaceNim(m.config.cppCustomNamespace, m.s[cfsProcs])
 
-proc registerInitProcs*(g: BModuleList; m: PSym; flags: set[ModuleBackendFlag]) =
-  ## Called from the IC backend.
-  if HasDatInitProc in flags:
-    let datInit = getSomeNameForModule(g.config, g.config.toFullPath(m.info.fileIndex).AbsoluteFile) & "DatInit000"
-    g.mainModProcs.addDeclWithVisibility(Private):
-      g.mainModProcs.addProcHeader(ccNimCall, datInit, CVoid, cProcParams())
-      g.mainModProcs.finishProcHeaderAsProto()
-    g.mainDatInit.addCallStmt(datInit)
-  if HasModuleInitProc in flags:
-    let init = getSomeNameForModule(g.config, g.config.toFullPath(m.info.fileIndex).AbsoluteFile) & "Init000"
-    g.mainModProcs.addDeclWithVisibility(Private):
-      g.mainModProcs.addProcHeader(ccNimCall, init, CVoid, cProcParams())
-      g.mainModProcs.finishProcHeaderAsProto()
-    if sfMainModule in m.flags:
-      g.mainModInit.addCallStmt(init)
-    elif sfSystemModule in m.flags:
-      g.mainDatInit.addCallStmt(init) # systemInit must called right after systemDatInit if any
-    else:
-      g.otherModsInit.addCallStmt(init)
-
-proc whichInitProcs*(m: BModule): set[ModuleBackendFlag] =
-  # called from IC.
-  result = {}
-  if m.hcrOn or m.preInitProc.s(cpsInit).buf.len > 0 or m.preInitProc.s(cpsStmts).buf.len > 0:
-    result.incl HasModuleInitProc
-  for i in cfsTypeInit1..cfsDynLibInit:
-    if m.s[i].buf.len != 0:
-      result.incl HasDatInitProc
-      break
-
 proc registerModuleToMain(g: BModuleList; m: BModule) =
   let
     init = m.getInitName
@@ -2065,7 +2030,7 @@ proc registerModuleToMain(g: BModuleList; m: BModule) =
   if sfSystemModule in m.module.flags:
     if emulatedThreadVars(m.config) and m.config.target.targetOS != osStandalone:
       g.mainDatInit.addCallStmt(cgsymValue(m, "initThreadVarsEmulation"))
-    if m.config.target.targetOS != osStandalone and m.config.selectedGC notin {gcNone, gcArc, gcAtomicArc, gcOrc}:
+    if m.config.target.targetOS != osStandalone and m.config.selectedGC notin {gcNone, gcArc, gcAtomicArc, gcOrc, gcYrc}:
       g.mainDatInit.addCallStmt(cgsymValue(m, "initStackBottomWith"),
         cCast(CPointer, cAddr("inner")))
 
@@ -2634,7 +2599,7 @@ proc finalCodegenActions*(graph: ModuleGraph; m: BModule; n: PNode) =
         cgsym(m, "rawWrite")
 
       # raise dependencies on behalf of genMainProc
-      if m.config.target.targetOS != osStandalone and m.config.selectedGC notin {gcNone, gcArc, gcAtomicArc, gcOrc}:
+      if m.config.target.targetOS != osStandalone and m.config.selectedGC notin {gcNone, gcArc, gcAtomicArc, gcOrc, gcYrc}:
         cgsym(m, "initStackBottomWith")
       if emulatedThreadVars(m.config) and m.config.target.targetOS != osStandalone:
         cgsym(m, "initThreadVarsEmulation")
@@ -2642,7 +2607,7 @@ proc finalCodegenActions*(graph: ModuleGraph; m: BModule; n: PNode) =
       if m.g.forwardedProcs.len == 0:
         incl m.flags, objHasKidsValid
       if optMultiMethods in m.g.config.globalOptions or
-          m.g.config.selectedGC notin {gcArc, gcOrc, gcAtomicArc} or
+          m.g.config.selectedGC notin {gcArc, gcOrc, gcAtomicArc, gcYrc} or
           vtables notin m.g.config.features:
         generateIfMethodDispatchers(graph, m.idgen)
 

compiler/closureiters.nim

@@ -727,7 +727,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
       n[0] = ex
       result.add(n)
 
-  of nkCast, nkHiddenStdConv, nkHiddenSubConv, nkConv, nkObjDownConv,
+  of nkCast, nkHiddenStdConv, nkHiddenSubConv, nkConv, nkObjDownConv, nkObjUpConv,
       nkDerefExpr, nkHiddenDeref:
     var ns = false
     for i in ord(n.kind == nkCast)..<n.len:

compiler/commands.nim

@@ -118,7 +118,7 @@ const
   errInvalidCmdLineOption = "invalid command line option: '$1'"
   errOnOrOffExpectedButXFound = "'on' or 'off' expected, but '$1' found"
   errOnOffOrListExpectedButXFound = "'on', 'off' or 'list' expected, but '$1' found"
-  errOffHintsError = "'off', 'hint', 'error' or 'usages' expected, but '$1' found"
+  errOffHintsError = "'off', 'hint', 'warning', 'error' or 'usages' expected, but '$1' found"
 
 proc invalidCmdLineOption(conf: ConfigRef; pass: TCmdLinePass, switch: string, info: TLineInfo) =
   if switch == " ": localError(conf, info, errInvalidCmdLineOption % "-")
@@ -245,7 +245,7 @@ proc processCompile(conf: ConfigRef; filename: string) =
   extccomp.addExternalFileToCompile(conf, found)
 
 const
-  errNoneBoehmRefcExpectedButXFound = "'arc', 'orc', 'atomicArc', 'markAndSweep', 'boehm', 'go', 'none', 'regions', or 'refc' expected, but '$1' found"
+  errNoneBoehmRefcExpectedButXFound = "'arc', 'orc', 'yrc', 'atomicArc', 'markAndSweep', 'boehm', 'go', 'none', 'regions', or 'refc' expected, but '$1' found"
   errNoneSpeedOrSizeExpectedButXFound = "'none', 'speed' or 'size' expected, but '$1' found"
   errGuiConsoleOrLibExpectedButXFound = "'gui', 'console', 'lib' or 'staticlib' expected, but '$1' found"
   errInvalidExceptionSystem = "'goto', 'setjmp', 'cpp' or 'quirky' expected, but '$1' found"
@@ -266,6 +266,7 @@ proc testCompileOptionArg*(conf: ConfigRef; switch, arg: string, info: TLineInfo
     of "markandsweep": result = conf.selectedGC == gcMarkAndSweep
     of "destructors", "arc": result = conf.selectedGC == gcArc
     of "orc": result = conf.selectedGC == gcOrc
+    of "yrc": result = conf.selectedGC == gcYrc
     of "hooks": result = conf.selectedGC == gcHooks
     of "go": result = conf.selectedGC == gcGo
     of "none": result = conf.selectedGC == gcNone
@@ -494,7 +495,6 @@ proc parseCommand*(command: string): Command =
   of "gendepend": cmdGendepend
   of "dump": cmdDump
   of "parse": cmdParse
-  of "rod": cmdRod
   of "secret": cmdInteractive
   of "nop", "help": cmdNop
   of "jsonscript": cmdJsonscript
@@ -571,6 +571,7 @@ proc unregisterArcOrc*(conf: ConfigRef) =
   undefSymbol(conf.symbols, "gcdestructors")
   undefSymbol(conf.symbols, "gcarc")
   undefSymbol(conf.symbols, "gcorc")
+  undefSymbol(conf.symbols, "gcyrc")
   undefSymbol(conf.symbols, "gcatomicarc")
   undefSymbol(conf.symbols, "nimSeqsV2")
   undefSymbol(conf.symbols, "nimV2")
@@ -604,6 +605,10 @@ proc processMemoryManagementOption(switch, arg: string, pass: TCmdLinePass,
       conf.selectedGC = gcOrc
       defineSymbol(conf.symbols, "gcorc")
       registerArcOrc(pass, conf)
+    of "yrc":
+      conf.selectedGC = gcYrc
+      defineSymbol(conf.symbols, "gcyrc")
+      registerArcOrc(pass, conf)
     of "atomicarc":
       conf.selectedGC = gcAtomicArc
       defineSymbol(conf.symbols, "gcatomicarc")
@@ -1109,6 +1114,9 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
   of "shownonexports":
     expectNoArg(conf, switch, arg, pass, info)
     showNonExportedFields(conf)
+  of "raw":
+    expectNoArg(conf, switch, arg, pass, info)
+    docRawOutput(conf)
   of "exceptions":
     case arg.normalize
     of "cpp": conf.exc = excCpp
@@ -1140,9 +1148,10 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
       defineSymbol(conf.symbols, "nimSeqsV2")
   of "stylecheck":
     case arg.normalize
-    of "off": conf.globalOptions = conf.globalOptions - {optStyleHint, optStyleError}
-    of "hint": conf.globalOptions = conf.globalOptions + {optStyleHint} - {optStyleError}
-    of "error": conf.globalOptions = conf.globalOptions + {optStyleError}
+    of "off": conf.globalOptions = conf.globalOptions - {optStyleHint, optStyleError, optStyleWarning}
+    of "hint": conf.globalOptions = conf.globalOptions + {optStyleHint} - {optStyleError, optStyleWarning}
+    of "warning": conf.globalOptions = conf.globalOptions + {optStyleWarning} - {optStyleHint, optStyleError}
+    of "error": conf.globalOptions = conf.globalOptions + {optStyleError} - {optStyleHint, optStyleWarning}
     of "usages": conf.globalOptions.incl optStyleUsages
     else: localError(conf, info, errOffHintsError % arg)
   of "showallmismatches":

compiler/condsyms.nim

@@ -175,3 +175,5 @@ proc initDefines*(symbols: StringTableRef) =
   defineSymbol("nimHasSetLengthSeqUninitMagic")
   defineSymbol("nimHasPreviewDuplicateModuleError")
 
+  defineSymbol("nimHasImplicitRangeConversion")
+

compiler/deps.nim

@@ -32,6 +32,7 @@ type
     nodes: seq[Node]
     processedModules: Table[string, int]  # modname -> node index
     includeStack: seq[string]
+    systemNodeId: int  # ID of the system.nim node
 
 proc toPair(c: DepContext; f: string): FilePair =
   FilePair(nimFile: f, modname: moduleSuffix(f, cast[seq[string]](c.config.searchPaths)))
@@ -128,6 +129,9 @@ proc processImport(c: var DepContext; importPath: string; current: Node) =
     # New module - create node and process it
     let newNode = Node(files: @[pair], id: c.nodes.len)
     current.deps.add newNode.id
+    # Every module depends on system.nim
+    if c.systemNodeId >= 0:
+      newNode.deps.add c.systemNodeId
     c.processedModules[pair.modname] = newNode.id
     c.nodes.add newNode
     traverseDeps(c, pair, newNode)
@@ -223,9 +227,9 @@ proc traverseDeps(c: var DepContext; pair: FilePair; current: Node) =
 
 proc generateBuildFile(c: DepContext): string =
   ## Generate the .build.nif file for nifmake
-  createDir("nifcache")
-  result = "nifcache" / c.nodes[0].files[0].modname & ".build.nif"
-  #getNimcacheDir(c.config).string / c.nodes[0].files[0].modname & ".build.nif"
+  let nimcache = getNimcacheDir(c.config).string
+  createDir(nimcache)
+  result = nimcache / c.nodes[0].files[0].modname & ".build.nif"
 
   var b = nifbuilder.open(result)
   defer: b.close()
@@ -250,7 +254,7 @@ proc generateBuildFile(c: DepContext): string =
   b.addSymbolDef "nim_m"
   b.addStrLit getAppFilename()
   b.addStrLit "m"
-  b.addStrLit "--nimcache:nifcache"
+  b.addStrLit "--nimcache:" & nimcache
   # Add search paths
   for p in c.config.searchPaths:
     b.addStrLit "--path:" & p.string
@@ -265,7 +269,7 @@ proc generateBuildFile(c: DepContext): string =
   b.addSymbolDef "nim_nifc"
   b.addStrLit getAppFilename()
   b.addStrLit "nifc"
-  b.addStrLit "--nimcache:nifcache"
+  b.addStrLit "--nimcache:" & nimcache
   # Add search paths
   for p in c.config.searchPaths:
     b.addStrLit "--path:" & p.string
@@ -354,7 +358,8 @@ proc commandIc*(conf: ConfigRef) =
       nifler: nifler,
       nodes: @[],
       processedModules: initTable[string, int](),
-      includeStack: @[]
+      includeStack: @[],
+      systemNodeId: -1
     )
 
     # Create root node for main project file
@@ -366,6 +371,7 @@ proc commandIc*(conf: ConfigRef) =
     # model the system.nim dependency:
     let sysNode = Node(files: @[toPair(c, (conf.libpath / RelativeFile"system.nim").string)], id: 1)
     c.nodes.add sysNode
+    c.systemNodeId = sysNode.id
     rootNode.deps.add sysNode.id
 
     # Process dependencies

compiler/dfa.nim

@@ -483,7 +483,7 @@ proc constructCfg*(s: PSym; body: PNode; root: PSym): ControlFlowGraph =
     gen(c, body)
     if root.kind == skResult:
       genImplicitReturn(c)
-  when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc):
+  when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc) or defined(gcYrc):
     result = c.code # will move
   else:
     shallowCopy(result, c.code)

compiler/docgen.nim

@@ -433,6 +433,9 @@ proc getVarIdx(varnames: openArray[string], id: string): int =
 
 proc genComment(d: PDoc, n: PNode): PRstNode =
   if n.comment.len > 0:
+    if optDocRaw in d.conf.globalOptions:
+      return newRstLeaf(n.comment)
+
     d.sharedState.currFileIdx = addRstFileIndex(d, n.info)
     try:
       result = parseRst(n.comment,
@@ -1176,8 +1179,12 @@ proc genJsonItem(d: PDoc, n, nameNode: PNode, k: TSymKind, nonExports = false):
                    "col": %n.info.col}
   )
   if comm != nil:
-    result.rst = comm
-    result.rstField = "description"
+    if optDocRaw in d.conf.globalOptions:
+      result.json["description"] = %comm.text
+    else:
+      result.rst = comm
+      result.rstField = "description"
+
   if r.buf.len > 0:
     result.json["code"] = %r.buf
   if k in routineKinds:
@@ -1418,7 +1425,7 @@ proc generateDoc*(d: PDoc, n, orig: PNode, config: ConfigRef, docFlags: DocFlags
   of nkExportExceptStmt: discard "transformed into nkExportStmt by semExportExcept"
   of nkFromStmt, nkImportExceptStmt: traceDeps(d, n[0])
   of nkCallKinds:
-    var comm: ItemPre = default(ItemPre)
+    var comm = default(ItemPre)
     getAllRunnableExamples(d, n, comm)
     if comm.len != 0: d.modDescPre.add(comm)
   else: discard

compiler/ic/bitabs.nim

@@ -1,178 +0,0 @@
-## A BiTable is a table that can be seen as an optimized pair
-## of `(Table[LitId, Val], Table[Val, LitId])`.
-
-import std/hashes
-import rodfiles
-
-when defined(nimPreviewSlimSystem):
-  import std/assertions
-
-type
-  LitId* = distinct uint32
-
-  BiTable*[T] = object
-    vals: seq[T] # indexed by LitId
-    keys: seq[LitId]  # indexed by hash(val)
-
-proc initBiTable*[T](): BiTable[T] = BiTable[T](vals: @[], keys: @[])
-
-proc nextTry(h, maxHash: Hash): Hash {.inline.} =
-  result = (h + 1) and maxHash
-
-template maxHash(t): untyped = high(t.keys)
-template isFilled(x: LitId): bool = x.uint32 > 0'u32
-
-proc `$`*(x: LitId): string {.borrow.}
-proc `<`*(x, y: LitId): bool {.borrow.}
-proc `<=`*(x, y: LitId): bool {.borrow.}
-proc `==`*(x, y: LitId): bool {.borrow.}
-proc hash*(x: LitId): Hash {.borrow.}
-
-
-proc len*[T](t: BiTable[T]): int = t.vals.len
-
-proc mustRehash(length, counter: int): bool {.inline.} =
-  assert(length > counter)
-  result = (length * 2 < counter * 3) or (length - counter < 4)
-
-const
-  idStart = 1
-
-template idToIdx(x: LitId): int = x.int - idStart
-
-proc hasLitId*[T](t: BiTable[T]; x: LitId): bool =
-  let idx = idToIdx(x)
-  result = idx >= 0 and idx < t.vals.len
-
-proc enlarge[T](t: var BiTable[T]) =
-  var n: seq[LitId]
-  newSeq(n, len(t.keys) * 2)
-  swap(t.keys, n)
-  for i in 0..high(n):
-    let eh = n[i]
-    if isFilled(eh):
-      var j = hash(t.vals[idToIdx eh]) and maxHash(t)
-      while isFilled(t.keys[j]):
-        j = nextTry(j, maxHash(t))
-      t.keys[j] = move n[i]
-
-proc getKeyId*[T](t: BiTable[T]; v: T): LitId =
-  let origH = hash(v)
-  var h = origH and maxHash(t)
-  if t.keys.len != 0:
-    while true:
-      let litId = t.keys[h]
-      if not isFilled(litId): break
-      if t.vals[idToIdx t.keys[h]] == v: return litId
-      h = nextTry(h, maxHash(t))
-  return LitId(0)
-
-proc getOrIncl*[T](t: var BiTable[T]; v: T): LitId =
-  let origH = hash(v)
-  var h = origH and maxHash(t)
-  if t.keys.len != 0:
-    while true:
-      let litId = t.keys[h]
-      if not isFilled(litId): break
-      if t.vals[idToIdx t.keys[h]] == v: return litId
-      h = nextTry(h, maxHash(t))
-    # not found, we need to insert it:
-    if mustRehash(t.keys.len, t.vals.len):
-      enlarge(t)
-      # recompute where to insert:
-      h = origH and maxHash(t)
-      while true:
-        let litId = t.keys[h]
-        if not isFilled(litId): break
-        h = nextTry(h, maxHash(t))
-  else:
-    setLen(t.keys, 16)
-    h = origH and maxHash(t)
-
-  result = LitId(t.vals.len + idStart)
-  t.keys[h] = result
-  t.vals.add v
-
-
-proc `[]`*[T](t: var BiTable[T]; litId: LitId): var T {.inline.} =
-  let idx = idToIdx litId
-  assert idx < t.vals.len
-  result = t.vals[idx]
-
-proc `[]`*[T](t: BiTable[T]; litId: LitId): lent T {.inline.} =
-  let idx = idToIdx litId
-  assert idx < t.vals.len
-  result = t.vals[idx]
-
-proc hash*[T](t: BiTable[T]): Hash =
-  ## as the keys are hashes of the values, we simply use them instead
-  var h: Hash = 0
-  for i, n in pairs t.keys:
-    h = h !& hash((i, n))
-  result = !$h
-
-proc store*[T](f: var RodFile; t: BiTable[T]) =
-  storeSeq(f, t.vals)
-  storeSeq(f, t.keys)
-
-proc load*[T](f: var RodFile; t: var BiTable[T]) =
-  loadSeq(f, t.vals)
-  loadSeq(f, t.keys)
-
-proc sizeOnDisc*(t: BiTable[string]): int =
-  result = 4
-  for x in t.vals:
-    result += x.len + 4
-  result += t.keys.len * sizeof(LitId)
-
-when isMainModule:
-
-  var t: BiTable[string]
-
-  echo getOrIncl(t, "hello")
-
-  echo getOrIncl(t, "hello")
-  echo getOrIncl(t, "hello3")
-  echo getOrIncl(t, "hello4")
-  echo getOrIncl(t, "helloasfasdfdsa")
-  echo getOrIncl(t, "hello")
-  echo getKeyId(t, "hello")
-  echo getKeyId(t, "none")
-
-  for i in 0 ..< 100_000:
-    discard t.getOrIncl($i & "___" & $i)
-
-  for i in 0 ..< 100_000:
-    assert t.getOrIncl($i & "___" & $i).idToIdx == i + 4
-  echo "begin"
-  echo t.vals.len
-
-  echo t.vals[0]
-  echo t.vals[1004]
-
-  echo "middle"
-
-  var tf: BiTable[float]
-
-  discard tf.getOrIncl(0.4)
-  discard tf.getOrIncl(16.4)
-  discard tf.getOrIncl(32.4)
-  echo getKeyId(tf, 32.4)
-
-  var f2 = open("testblah.bin", fmWrite)
-  echo store(f2, tf)
-  f2.close
-
-  var f1 = open("testblah.bin", fmRead)
-
-  var t2: BiTable[float]
-
-  echo f1.load(t2)
-  echo t2.vals.len
-
-  echo getKeyId(t2, 32.4)
-
-  echo "end"
-
-
-  f1.close

compiler/ic/cbackend.nim

@@ -1,179 +0,0 @@
-#
-#
-#           The Nim Compiler
-#        (c) Copyright 2021 Andreas Rumpf
-#
-#    See the file "copying.txt", included in this
-#    distribution, for details about the copyright.
-#
-
-## New entry point into our C/C++ code generator. Ideally
-## somebody would rewrite the old backend (which is 8000 lines of crufty Nim code)
-## to work on packed trees directly and produce the C code as an AST which can
-## then be rendered to text in a very simple manner. Unfortunately nobody wrote
-## this code. So instead we wrap the existing cgen.nim and its friends so that
-## we call directly into the existing code generation logic but avoiding the
-## naive, outdated `passes` design. Thus you will see some
-## `useAliveDataFromDce in flags` checks in the old code -- the old code is
-## also doing cross-module dependency tracking and DCE that we don't need
-## anymore. DCE is now done as prepass over the entire packed module graph.
-
-import std/[packedsets, algorithm, tables]
-
-when defined(nimPreviewSlimSystem):
-  import std/assertions
-
-import ".."/[ast, options, lineinfos, modulegraphs, cgendata, cgen,
-  pathutils, extccomp, msgs, modulepaths]
-
-import packed_ast, ic, dce, rodfiles
-
-proc unpackTree(g: ModuleGraph; thisModule: int;
-                tree: PackedTree; n: NodePos): PNode =
-  var decoder = initPackedDecoder(g.config, g.cache)
-  result = loadNodes(decoder, g.packed, thisModule, tree, n)
-
-proc setupBackendModule(g: ModuleGraph; m: var LoadedModule) =
-  if g.backend == nil:
-    g.backend = cgendata.newModuleList(g)
-  assert g.backend != nil
-  var bmod = cgen.newModule(BModuleList(g.backend), m.module, g.config, idgenFromLoadedModule(m))
-
-proc generateCodeForModule(g: ModuleGraph; m: var LoadedModule; alive: var AliveSyms) =
-  var bmod = BModuleList(g.backend).mods[m.module.position]
-  assert bmod != nil
-  bmod.flags.incl useAliveDataFromDce
-  bmod.alive = move alive[m.module.position]
-
-  for p in allNodes(m.fromDisk.topLevel):
-    let n = unpackTree(g, m.module.position, m.fromDisk.topLevel, p)
-    cgen.genTopLevelStmt(bmod, n)
-
-  finalCodegenActions(g, bmod, newNodeI(nkStmtList, m.module.info))
-  for disp in getDispatchers(g):
-    genProcLvl3(bmod, disp)
-  m.fromDisk.backendFlags = cgen.whichInitProcs(bmod)
-
-proc replayTypeInfo(g: ModuleGraph; m: var LoadedModule; origin: FileIndex) =
-  for x in mitems(m.fromDisk.emittedTypeInfo):
-    #echo "found type ", x, " for file ", int(origin)
-    g.emittedTypeInfo[x] = origin
-
-proc addFileToLink(config: ConfigRef; m: PSym) =
-  let filename = AbsoluteFile toFullPath(config, m.position.FileIndex)
-  let ext =
-      if config.backend == backendCpp: ".nim.cpp"
-      elif config.backend == backendObjc: ".nim.m"
-      else: ".nim.c"
-  let cfile = changeFileExt(completeCfilePath(config,
-                            mangleModuleName(config, filename).AbsoluteFile), ext)
-  let objFile = completeCfilePath(config, toObjFile(config, cfile))
-  if fileExists(objFile):
-    var cf = Cfile(nimname: m.name.s, cname: cfile,
-                   obj: objFile,
-                   flags: {CfileFlag.Cached})
-    addFileToCompile(config, cf)
-
-when defined(debugDce):
-  import os, std/packedsets
-
-proc storeAliveSymsImpl(asymFile: AbsoluteFile; s: seq[int32]) =
-  var f = rodfiles.create(asymFile.string)
-  f.storeHeader()
-  f.storeSection aliveSymsSection
-  f.storeSeq(s)
-  close f
-
-template prepare {.dirty.} =
-  let asymFile = toRodFile(config, AbsoluteFile toFullPath(config, position.FileIndex), ".alivesyms")
-  var s = newSeqOfCap[int32](alive[position].len)
-  for a in items(alive[position]): s.add int32(a)
-  sort(s)
-
-proc storeAliveSyms(config: ConfigRef; position: int; alive: AliveSyms) =
-  prepare()
-  storeAliveSymsImpl(asymFile, s)
-
-proc aliveSymsChanged(config: ConfigRef; position: int; alive: AliveSyms): bool =
-  prepare()
-  var f2 = rodfiles.open(asymFile.string)
-  f2.loadHeader()
-  f2.loadSection aliveSymsSection
-  var oldData: seq[int32] = @[]
-  f2.loadSeq(oldData)
-  f2.close
-  if f2.err == ok and oldData == s:
-    result = false
-  else:
-    when defined(debugDce):
-      let oldAsSet = toPackedSet[int32](oldData)
-      let newAsSet = toPackedSet[int32](s)
-      echo "set of live symbols changed ", asymFile.changeFileExt("rod"), " ", position, " ", f2.err
-      echo "in old but not in new ", oldAsSet.difference(newAsSet), " number of entries in old ", oldAsSet.len
-      echo "in new but not in old ", newAsSet.difference(oldAsSet), " number of entries in new ", newAsSet.len
-      #if execShellCmd(getAppFilename() & " rod " & quoteShell(asymFile.changeFileExt("rod"))) != 0:
-      #  echo "command failed"
-    result = true
-    storeAliveSymsImpl(asymFile, s)
-
-proc genPackedModule(g: ModuleGraph, i: int; alive: var AliveSyms) =
-  # case statement here to enforce exhaustive checks.
-  case g.packed[i].status
-  of undefined:
-    discard "nothing to do"
-  of loading, stored:
-    assert false
-  of storing, outdated:
-    storeAliveSyms(g.config, g.packed[i].module.position, alive)
-    generateCodeForModule(g, g.packed[i], alive)
-    closeRodFile(g, g.packed[i].module)
-  of loaded:
-    if g.packed[i].loadedButAliveSetChanged:
-      generateCodeForModule(g, g.packed[i], alive)
-    else:
-      addFileToLink(g.config, g.packed[i].module)
-      replayTypeInfo(g, g.packed[i], FileIndex(i))
-
-      if g.backend == nil:
-        g.backend = cgendata.newModuleList(g)
-      registerInitProcs(BModuleList(g.backend), g.packed[i].module, g.packed[i].fromDisk.backendFlags)
-
-proc generateCode*(g: ModuleGraph) =
-  ## The single entry point, generate C(++) code for the entire
-  ## Nim program aka `ModuleGraph`.
-  resetForBackend(g)
-  var alive = computeAliveSyms(g.packed, g.config)
-
-  when false:
-    for i in 0..<len(g.packed):
-      echo i, " is of status ", g.packed[i].status, " ", toFullPath(g.config, FileIndex(i))
-
-  # First pass: Setup all the backend modules for all the modules that have
-  # changed:
-  for i in 0..<len(g.packed):
-    # case statement here to enforce exhaustive checks.
-    case g.packed[i].status
-    of undefined:
-      discard "nothing to do"
-    of loading, stored:
-      assert false
-    of storing, outdated:
-      setupBackendModule(g, g.packed[i])
-    of loaded:
-      # Even though this module didn't change, DCE might trigger a change.
-      # Consider this case: Module A uses symbol S from B and B does not use
-      # S itself. A is then edited not to use S either. Thus we have to
-      # recompile B in order to remove S from the final result.
-      if aliveSymsChanged(g.config, g.packed[i].module.position, alive):
-        g.packed[i].loadedButAliveSetChanged = true
-        setupBackendModule(g, g.packed[i])
-
-  # Second pass: Code generation.
-  let mainModuleIdx = g.config.projectMainIdx2.int
-  # We need to generate the main module last, because only then
-  # all init procs have been registered:
-  for i in 0..<len(g.packed):
-    if i != mainModuleIdx:
-      genPackedModule(g, i, alive)
-  if mainModuleIdx >= 0:
-    genPackedModule(g, mainModuleIdx, alive)

compiler/ic/dce.nim

@@ -1,169 +0,0 @@
-#
-#
-#           The Nim Compiler
-#        (c) Copyright 2021 Andreas Rumpf
-#
-#    See the file "copying.txt", included in this
-#    distribution, for details about the copyright.
-#
-
-## Dead code elimination (=DCE) for IC.
-
-import std/[intsets, tables]
-
-when defined(nimPreviewSlimSystem):
-  import std/assertions
-
-import ".." / [ast, options, lineinfos, types]
-
-import packed_ast, ic, bitabs
-
-type
-  AliveSyms* = seq[IntSet]
-  AliveContext* = object ## Purpose is to fill the 'alive' field.
-    stack: seq[(int, TOptions, NodePos)] ## A stack for marking symbols as alive.
-    decoder: PackedDecoder ## We need a PackedDecoder for module ID address translations.
-    thisModule: int  ## The module we're currently analysing for DCE.
-    alive: AliveSyms ## The final result of our computation.
-    options: TOptions
-    compilerProcs: Table[string, (int, int32)]
-
-proc isExportedToC(c: var AliveContext; g: PackedModuleGraph; symId: int32): bool =
-  ## "Exported to C" procs are special (these are marked with '.exportc') because these
-  ## must not be optimized away!
-  let symPtr = unsafeAddr g[c.thisModule].fromDisk.syms[symId]
-  let flags = symPtr.flags
-  # due to a bug/limitation in the lambda lifting, unused inner procs
-  # are not transformed correctly; issue (#411). However, the whole purpose here
-  # is to eliminate unused procs. So there is no special logic required for this case.
-  if sfCompileTime notin flags:
-    if ({sfExportc, sfCompilerProc} * flags != {}) or
-        (symPtr.kind == skMethod):
-      result = true
-    else:
-      result = false
-      # XXX: This used to be a condition to:
-      #  (sfExportc in prc.flags and lfExportLib in prc.loc.flags) or
-    if sfCompilerProc in flags:
-      c.compilerProcs[g[c.thisModule].fromDisk.strings[symPtr.name]] = (c.thisModule, symId)
-  else:
-    result = false
-
-template isNotGeneric(n: NodePos): bool = ithSon(tree, n, genericParamsPos).kind == nkEmpty
-
-proc followLater(c: var AliveContext; g: PackedModuleGraph; module: int; item: int32) =
-  ## Marks a symbol 'item' as used and later in 'followNow' the symbol's body will
-  ## be analysed.
-  if not c.alive[module].containsOrIncl(item):
-    var body = g[module].fromDisk.syms[item].ast
-    if body != emptyNodeId:
-      let opt = g[module].fromDisk.syms[item].options
-      if g[module].fromDisk.syms[item].kind in routineKinds:
-        body = NodeId ithSon(g[module].fromDisk.bodies, NodePos body, bodyPos)
-      c.stack.add((module, opt, NodePos(body)))
-
-    when false:
-      let nid = g[module].fromDisk.syms[item].name
-      if nid != LitId(0):
-        let name = g[module].fromDisk.strings[nid]
-        if name in ["nimFrame", "callDepthLimitReached"]:
-          echo "I was called! ", name, " body exists: ", body != emptyNodeId, " ", module, " ", item
-
-proc requestCompilerProc(c: var AliveContext; g: PackedModuleGraph; name: string) =
-  let (module, item) = c.compilerProcs[name]
-  followLater(c, g, module, item)
-
-proc loadTypeKind(t: PackedItemId; c: AliveContext; g: PackedModuleGraph; toSkip: set[TTypeKind]): TTypeKind =
-  template kind(t: ItemId): TTypeKind = g[t.module].fromDisk.types[t.item].kind
-
-  var t2 = translateId(t, g, c.thisModule, c.decoder.config)
-  result = t2.kind
-  while result in toSkip:
-    t2 = translateId(g[t2.module].fromDisk.types[t2.item].types[^1], g, t2.module, c.decoder.config)
-    result = t2.kind
-
-proc rangeCheckAnalysis(c: var AliveContext; g: PackedModuleGraph; tree: PackedTree; n: NodePos) =
-  ## Replicates the logic of `ccgexprs.genRangeChck`.
-  ## XXX Refactor so that the duplicated logic is avoided. However, for now it's not clear
-  ## the approach has enough merit.
-  var dest = loadTypeKind(n.typ, c, g, abstractVar)
-  if optRangeCheck notin c.options or dest in {tyUInt..tyUInt64}:
-    discard "no need to generate a check because it was disabled"
-  else:
-    let n0t = loadTypeKind(n.firstSon.typ, c, g, {})
-    if n0t in {tyUInt, tyUInt64}:
-      c.requestCompilerProc(g, "raiseRangeErrorNoArgs")
-    else:
-      let raiser =
-        case loadTypeKind(n.typ, c, g, abstractVarRange)
-        of tyUInt..tyUInt64, tyChar: "raiseRangeErrorU"
-        of tyFloat..tyFloat128: "raiseRangeErrorF"
-        else: "raiseRangeErrorI"
-      c.requestCompilerProc(g, raiser)
-
-proc aliveCode(c: var AliveContext; g: PackedModuleGraph; tree: PackedTree; n: NodePos) =
-  ## Marks the symbols we encounter when we traverse the AST at `tree[n]` as alive, unless
-  ## it is purely in a declarative context (type section etc.).
-  case n.kind
-  of nkNone..pred(nkSym), succ(nkSym)..nkNilLit:
-    discard "ignore non-sym atoms"
-  of nkSym:
-    # This symbol is alive and everything its body references.
-    followLater(c, g, c.thisModule, tree[n].soperand)
-  of nkModuleRef:
-    let (n1, n2) = sons2(tree, n)
-    assert n1.kind == nkNone
-    assert n2.kind == nkNone
-    let m = n1.litId
-    let item = tree[n2].soperand
-    let otherModule = toFileIndexCached(c.decoder, g, c.thisModule, m).int
-    followLater(c, g, otherModule, item)
-  of nkMacroDef, nkTemplateDef, nkTypeSection, nkTypeOfExpr,
-     nkCommentStmt, nkIncludeStmt,
-     nkImportStmt, nkImportExceptStmt, nkExportStmt, nkExportExceptStmt,
-     nkFromStmt, nkStaticStmt:
-    discard
-  of nkVarSection, nkLetSection, nkConstSection:
-    # XXX ignore the defining local variable name?
-    for son in sonsReadonly(tree, n):
-      aliveCode(c, g, tree, son)
-  of nkChckRangeF, nkChckRange64, nkChckRange:
-    rangeCheckAnalysis(c, g, tree, n)
-  of nkProcDef, nkConverterDef, nkMethodDef, nkFuncDef, nkIteratorDef:
-    if n.firstSon.kind == nkSym and isNotGeneric(n):
-      let item = tree[n.firstSon].soperand
-      if isExportedToC(c, g, item):
-        # This symbol is alive and everything its body references.
-        followLater(c, g, c.thisModule, item)
-  else:
-    for son in sonsReadonly(tree, n):
-      aliveCode(c, g, tree, son)
-
-proc followNow(c: var AliveContext; g: PackedModuleGraph) =
-  ## Mark all entries in the stack. Marking can add more entries
-  ## to the stack but eventually we have looked at every alive symbol.
-  while c.stack.len > 0:
-    let (modId, opt, ast) = c.stack.pop()
-    c.thisModule = modId
-    c.options = opt
-    aliveCode(c, g, g[modId].fromDisk.bodies, ast)
-
-proc computeAliveSyms*(g: PackedModuleGraph; conf: ConfigRef): AliveSyms =
-  ## Entry point for our DCE algorithm.
-  var c = AliveContext(stack: @[], decoder: PackedDecoder(config: conf),
-                       thisModule: -1, alive: newSeq[IntSet](g.len),
-                       options: conf.options)
-  for i in countdown(len(g)-1, 0):
-    if g[i].status != undefined:
-      c.thisModule = i
-      for p in allNodes(g[i].fromDisk.topLevel):
-        aliveCode(c, g, g[i].fromDisk.topLevel, p)
-
-  followNow(c, g)
-  result = move(c.alive)
-
-proc isAlive*(a: AliveSyms; module: int, item: int32): bool =
-  ## Backends use this to query if a symbol is `alive` which means
-  ## we need to produce (C/C++/etc) code for it.
-  result = a[module].contains(item)
-

compiler/ic/design.rst

@@ -1,56 +0,0 @@
-====================================
-  Incremental Recompilations
-====================================
-
-We split the Nim compiler into a frontend and a backend.
-The frontend produces a set of `.rod` files. Every `.nim` module
-produces its own `.rod` file.
-
-- The IR must be a faithful representation of the AST in memory.
-- The backend can do its own caching but doesn't have to. In the
-  current implementation the backend also caches its results.
-
-Advantage of the "set of files" vs the previous global database:
-- By construction, we either read from the `.rod` file or from the
-  `.nim` file, there can be no inconsistency. There can also be no
-  partial updates.
-- No dependency to external packages (SQLite). SQLite simply is too
-  slow and the old way of serialization was too slow too. We use a
-  format designed for Nim and expect to base further tools on this
-  file format.
-
-References to external modules must be (moduleId, symId) pairs.
-The symbol IDs are module specific. This way no global ID increment
-mechanism needs to be implemented that we could get wrong. ModuleIds
-are rod-file specific too.
-
-
-
-Global state
-------------
-
-There is no global state.
-
-Rod File Format
----------------
-
-It's a simple binary file format. `rodfiles.nim` contains some details.
-
-
-Backend
--------
-
-Nim programmers have to come to enjoy whole-program dead code elimination,
-by default. Since this is a "whole program" optimization, it does break
-modularity. However, thanks to the packed AST representation we can perform
-this global analysis without having to unpack anything. This is basically
-a mark&sweep GC algorithm:
-
-- Start with the top level statements. Every symbol that is referenced
-  from a top level statement is not "dead" and needs to be compiled by
-  the backend.
-- Every symbol referenced from a referenced symbol also has to be
-  compiled.
-
-Caching logic: Only if the set of alive symbols is different from the
-last run, the module has to be regenerated.

compiler/ic/iclineinfos.nim

@@ -1,84 +0,0 @@
-#
-#
-#           The Nim Compiler
-#        (c) Copyright 2024 Andreas Rumpf
-#
-#    See the file "copying.txt", included in this
-#    distribution, for details about the copyright.
-#
-
-# For the line information we use 32 bits. They are used as follows:
-# Bit 0 (AsideBit): If we have inline line information or not. If not, the
-# remaining 31 bits are used as an index into a seq[(LitId, int, int)].
-#
-# We use 10 bits for the "file ID", this means a program can consist of as much
-# as 1024 different files. (If it uses more files than that, the overflow bit
-# would be set.)
-# This means we have 21 bits left to encode the (line, col) pair. We use 7 bits for the column
-# so 128 is the limit and 14 bits for the line number.
-# The packed representation supports files with up to 16384 lines.
-# Keep in mind that whenever any limit is reached the AsideBit is set and the real line
-# information is kept in a side channel.
-
-import std / assertions
-
-const
-  AsideBit = 1
-  FileBits = 10
-  LineBits = 14
-  ColBits = 7
-  FileMax = (1 shl FileBits) - 1
-  LineMax = (1 shl LineBits) - 1
-  ColMax = (1 shl ColBits) - 1
-
-static:
-  assert AsideBit + FileBits + LineBits + ColBits == 32
-
-import .. / ic / [bitabs, rodfiles] # for LitId
-
-type
-  PackedLineInfo* = distinct uint32
-
-  LineInfoManager* = object
-    aside: seq[(LitId, int32, int32)]
-
-const
-  NoLineInfo* = PackedLineInfo(0'u32)
-
-proc pack*(m: var LineInfoManager; file: LitId; line, col: int32): PackedLineInfo =
-  if file.uint32 <= FileMax.uint32 and line <= LineMax and col <= ColMax:
-    let col = if col < 0'i32: 0'u32 else: col.uint32
-    let line = if line < 0'i32: 0'u32 else: line.uint32
-    # use inline representation:
-    result = PackedLineInfo((file.uint32 shl 1'u32) or (line shl uint32(AsideBit + FileBits)) or
-      (col shl uint32(AsideBit + FileBits + LineBits)))
-  else:
-    result = PackedLineInfo((m.aside.len shl 1) or AsideBit)
-    m.aside.add (file, line, col)
-
-proc unpack*(m: LineInfoManager; i: PackedLineInfo): (LitId, int32, int32) =
-  let i = i.uint32
-  if (i and 1'u32) == 0'u32:
-    # inline representation:
-    result = (LitId((i shr 1'u32) and FileMax.uint32),
-      int32((i shr uint32(AsideBit + FileBits)) and LineMax.uint32),
-      int32((i shr uint32(AsideBit + FileBits + LineBits)) and ColMax.uint32))
-  else:
-    result = m.aside[int(i shr 1'u32)]
-
-proc getFileId*(m: LineInfoManager; i: PackedLineInfo): LitId =
-  result = unpack(m, i)[0]
-
-proc store*(r: var RodFile; m: LineInfoManager) = storeSeq(r, m.aside)
-proc load*(r: var RodFile; m: var LineInfoManager) = loadSeq(r, m.aside)
-
-when isMainModule:
-  var m = LineInfoManager(aside: @[])
-  for i in 0'i32..<16388'i32:
-    for col in 0'i32..<100'i32:
-      let packed = pack(m, LitId(1023), i, col)
-      let u = unpack(m, packed)
-      assert u[0] == LitId(1023)
-      assert u[1] == i
-      assert u[2] == col
-  echo m.aside.len

compiler/ic/integrity.nim

@@ -1,155 +0,0 @@
-#
-#
-#           The Nim Compiler
-#        (c) Copyright 2021 Andreas Rumpf
-#
-#    See the file "copying.txt", included in this
-#    distribution, for details about the copyright.
-#
-
-## Integrity checking for a set of .rod files.
-## The set must cover a complete Nim project.
-
-import std/[sets, tables]
-
-when defined(nimPreviewSlimSystem):
-  import std/assertions
-
-import ".." / [ast, modulegraphs]
-import packed_ast, bitabs, ic
-
-type
-  CheckedContext = object
-    g: ModuleGraph
-    thisModule: int32
-    checkedSyms: HashSet[ItemId]
-    checkedTypes: HashSet[ItemId]
-
-proc checkType(c: var CheckedContext; typeId: PackedItemId)
-proc checkForeignSym(c: var CheckedContext; symId: PackedItemId)
-proc checkNode(c: var CheckedContext; tree: PackedTree; n: NodePos)
-
-proc checkTypeObj(c: var CheckedContext; typ: PackedType) =
-  for child in typ.types:
-    checkType(c, child)
-  if typ.n != emptyNodeId:
-    checkNode(c, c.g.packed[c.thisModule].fromDisk.bodies, NodePos typ.n)
-  if typ.sym != nilItemId:
-    checkForeignSym(c, typ.sym)
-  if typ.owner != nilItemId:
-    checkForeignSym(c, typ.owner)
-  checkType(c, typ.typeInst)
-
-proc checkType(c: var CheckedContext; typeId: PackedItemId) =
-  if typeId == nilItemId: return
-  let itemId = translateId(typeId, c.g.packed, c.thisModule, c.g.config)
-  if not c.checkedTypes.containsOrIncl(itemId):
-    let oldThisModule = c.thisModule
-    c.thisModule = itemId.module
-    checkTypeObj c, c.g.packed[itemId.module].fromDisk.types[itemId.item]
-    c.thisModule = oldThisModule
-
-proc checkSym(c: var CheckedContext; s: PackedSym) =
-  if s.name != LitId(0):
-    assert c.g.packed[c.thisModule].fromDisk.strings.hasLitId s.name
-  checkType c, s.typ
-  if s.ast != emptyNodeId:
-    checkNode(c, c.g.packed[c.thisModule].fromDisk.bodies, NodePos s.ast)
-  if s.owner != nilItemId:
-    checkForeignSym(c, s.owner)
-
-proc checkLocalSym(c: var CheckedContext; item: int32) =
-  let itemId = ItemId(module: c.thisModule, item: item)
-  if not c.checkedSyms.containsOrIncl(itemId):
-    checkSym c, c.g.packed[c.thisModule].fromDisk.syms[item]
-
-proc checkForeignSym(c: var CheckedContext; symId: PackedItemId) =
-  let itemId = translateId(symId, c.g.packed, c.thisModule, c.g.config)
-  if not c.checkedSyms.containsOrIncl(itemId):
-    let oldThisModule = c.thisModule
-    c.thisModule = itemId.module
-    checkSym c, c.g.packed[itemId.module].fromDisk.syms[itemId.item]
-    c.thisModule = oldThisModule
-
-proc checkNode(c: var CheckedContext; tree: PackedTree; n: NodePos) =
-  let t = findType(tree, n)
-  if t != nilItemId:
-    checkType(c, t)
-  case n.kind
-  of nkEmpty, nkNilLit, nkType, nkNilRodNode:
-    discard
-  of nkIdent:
-    assert c.g.packed[c.thisModule].fromDisk.strings.hasLitId n.litId
-  of nkSym:
-    checkLocalSym(c, tree[n].soperand)
-  of directIntLit:
-    discard
-  of externIntLit, nkFloatLit..nkFloat128Lit:
-    assert c.g.packed[c.thisModule].fromDisk.numbers.hasLitId n.litId
-  of nkStrLit..nkTripleStrLit:
-    assert c.g.packed[c.thisModule].fromDisk.strings.hasLitId n.litId
-  of nkModuleRef:
-    let (n1, n2) = sons2(tree, n)
-    assert n1.kind == nkNone
-    assert n2.kind == nkNone
-    checkForeignSym(c, PackedItemId(module: n1.litId, item: tree[n2].soperand))
-  else:
-    for n0 in sonsReadonly(tree, n):
-      checkNode(c, tree, n0)
-
-proc checkTree(c: var CheckedContext; t: PackedTree) =
-  for p in allNodes(t): checkNode(c, t, p)
-
-proc checkLocalSymIds(c: var CheckedContext; m: PackedModule; symIds: seq[int32]) =
-  for symId in symIds:
-    assert symId >= 0 and symId < m.syms.len, $symId & " " & $m.syms.len
-
-proc checkModule(c: var CheckedContext; m: PackedModule) =
-  # We check that:
-  # - Every symbol references existing types and symbols.
-  # - Every tree node references existing types and symbols.
-  for _, v in pairs(m.syms):
-    checkLocalSym c, v.id
-
-  checkTree c, m.toReplay
-  checkTree c, m.topLevel
-
-  for e in m.exports:
-    #assert e[1] >= 0 and e[1] < m.syms.len
-    assert e[0] == m.syms[e[1]].name
-
-  for e in m.compilerProcs:
-    #assert e[1] >= 0 and e[1] < m.syms.len
-    assert e[0] == m.syms[e[1]].name
-
-  checkLocalSymIds c, m, m.converters
-  checkLocalSymIds c, m, m.methods
-  checkLocalSymIds c, m, m.trmacros
-  checkLocalSymIds c, m, m.pureEnums
-  #[
-    To do: Check all these fields:
-
-    reexports*: seq[(LitId, PackedItemId)]
-    macroUsages*: seq[(PackedItemId, PackedLineInfo)]
-
-    typeInstCache*: seq[(PackedItemId, PackedItemId)]
-    procInstCache*: seq[PackedInstantiation]
-    attachedOps*: seq[(TTypeAttachedOp, PackedItemId, PackedItemId)]
-    methodsPerGenericType*: seq[(PackedItemId, int, PackedItemId)]
-    enumToStringProcs*: seq[(PackedItemId, PackedItemId)]
-    methodsPerType*: seq[(PackedItemId, PackedItemId)]
-    dispatchers*: seq[PackedItemId]
-  ]#
-
-proc checkIntegrity*(g: ModuleGraph) =
-  var c = CheckedContext(g: g)
-  for i in 0..<len(g.packed):
-    # case statement here to enforce exhaustive checks.
-    case g.packed[i].status
-    of undefined:
-      discard "nothing to do"
-    of loading:
-      assert false, "cannot check integrity: Module still loading"
-    of stored, storing, outdated, loaded:
-      c.thisModule = int32 i
-      checkModule(c, g.packed[i].fromDisk)

compiler/ic/navigator.nim

@@ -1,183 +0,0 @@
-#
-#
-#           The Nim Compiler
-#        (c) Copyright 2021 Andreas Rumpf
-#
-#    See the file "copying.txt", included in this
-#    distribution, for details about the copyright.
-#
-
-## Supports the "nim check --ic:legacy --defusages:FILE,LINE,COL"
-## IDE-like features. It uses the set of .rod files to accomplish
-## its task. The set must cover a complete Nim project.
-
-import std/[sets, tables]
-
-from std/os import nil
-from std/private/miscdollars import toLocation
-
-when defined(nimPreviewSlimSystem):
-  import std/assertions
-
-import ".." / [ast, modulegraphs, msgs, options]
-import iclineinfos
-import packed_ast, bitabs, ic
-
-type
-  UnpackedLineInfo = object
-    file: LitId
-    line, col: int
-  NavContext = object
-    g: ModuleGraph
-    thisModule: int32
-    trackPos: UnpackedLineInfo
-    alreadyEmitted: HashSet[string]
-    outputSep: char # for easier testing, use short filenames and spaces instead of tabs.
-
-proc isTracked(man: LineInfoManager; current: PackedLineInfo, trackPos: UnpackedLineInfo, tokenLen: int): bool =
-  let (currentFile, currentLine, currentCol) = man.unpack(current)
-  if currentFile == trackPos.file and currentLine == trackPos.line:
-    let col = trackPos.col
-    if col >= currentCol and col < currentCol+tokenLen:
-      result = true
-    else:
-      result = false
-  else:
-    result = false
-
-proc searchLocalSym(c: var NavContext; s: PackedSym; info: PackedLineInfo): bool =
-  result = s.name != LitId(0) and
-    isTracked(c.g.packed[c.thisModule].fromDisk.man, info, c.trackPos, c.g.packed[c.thisModule].fromDisk.strings[s.name].len)
-
-proc searchForeignSym(c: var NavContext; s: ItemId; info: PackedLineInfo): bool =
-  let name = c.g.packed[s.module].fromDisk.syms[s.item].name
-  result = name != LitId(0) and
-    isTracked(c.g.packed[c.thisModule].fromDisk.man, info, c.trackPos, c.g.packed[s.module].fromDisk.strings[name].len)
-
-const
-  EmptyItemId = ItemId(module: -1'i32, item: -1'i32)
-
-proc search(c: var NavContext; tree: PackedTree): ItemId =
-  # We use the linear representation here directly:
-  for i in 0..<len(tree):
-    let i = NodePos(i)
-    case tree[i].kind
-    of nkSym:
-      let item = tree[i].soperand
-      if searchLocalSym(c, c.g.packed[c.thisModule].fromDisk.syms[item], tree[i].info):
-        return ItemId(module: c.thisModule, item: item)
-    of nkModuleRef:
-      let (currentFile, currentLine, currentCol) = c.g.packed[c.thisModule].fromDisk.man.unpack(tree[i].info)
-      if currentLine == c.trackPos.line and currentFile == c.trackPos.file:
-        let (n1, n2) = sons2(tree, i)
-        assert n1.kind == nkInt32Lit
-        assert n2.kind == nkInt32Lit
-        let pId = PackedItemId(module: n1.litId, item: tree[n2].soperand)
-        let itemId = translateId(pId, c.g.packed, c.thisModule, c.g.config)
-        if searchForeignSym(c, itemId, tree[i].info):
-          return itemId
-    else: discard
-  return EmptyItemId
-
-proc isDecl(tree: PackedTree; n: NodePos): bool =
-  # XXX This is not correct yet.
-  const declarativeNodes = procDefs + {nkMacroDef, nkTemplateDef,
-    nkLetSection, nkVarSection, nkUsingStmt, nkConstSection, nkTypeSection,
-    nkIdentDefs, nkEnumTy, nkVarTuple}
-  result = n.int >= 0 and tree[n].kind in declarativeNodes
-
-proc usage(c: var NavContext; info: PackedLineInfo; isDecl: bool) =
-  let (fileId, line, col) = unpack(c.g.packed[c.thisModule].fromDisk.man, info)
-  var m = ""
-  var file = c.g.packed[c.thisModule].fromDisk.strings[fileId]
-  if c.outputSep == ' ':
-    file = os.extractFilename file
-  toLocation(m, file, line, col + ColOffset)
-  if not c.alreadyEmitted.containsOrIncl(m):
-    msgWriteln c.g.config, (if isDecl: "def" else: "usage") & c.outputSep & m
-
-proc list(c: var NavContext; tree: PackedTree; sym: ItemId) =
-  for i in 0..<len(tree):
-    let i = NodePos(i)
-    case tree[i].kind
-    of nkSym:
-      let item = tree[i].soperand
-      if sym.item == item and sym.module == c.thisModule:
-        usage(c, tree[i].info, isDecl(tree, parent(i)))
-    of nkModuleRef:
-      let (n1, n2) = sons2(tree, i)
-      assert n1.kind == nkNone
-      assert n2.kind == nkNone
-      let pId = PackedItemId(module: n1.litId, item: tree[n2].soperand)
-      let itemId = translateId(pId, c.g.packed, c.thisModule, c.g.config)
-      if itemId.item == sym.item and sym.module == itemId.module:
-        usage(c, tree[i].info, isDecl(tree, parent(i)))
-    else: discard
-
-proc searchForIncludeFile(g: ModuleGraph; fullPath: string): int =
-  for i in 0..<len(g.packed):
-    for k in 1..high(g.packed[i].fromDisk.includes):
-      # we start from 1 because the first "include" file is
-      # the module's filename.
-      if os.cmpPaths(g.packed[i].fromDisk.strings[g.packed[i].fromDisk.includes[k][0]], fullPath) == 0:
-        return i
-  return -1
-
-proc nav(g: ModuleGraph) =
-  # translate the track position to a packed position:
-  let unpacked = g.config.m.trackPos
-  var mid = unpacked.fileIndex.int
-
-  let fullPath = toFullPath(g.config, unpacked.fileIndex)
-
-  if g.packed[mid].status == undefined:
-    # check if 'mid' is an include file of some other module:
-    mid = searchForIncludeFile(g, fullPath)
-
-  if mid < 0:
-    localError(g.config, unpacked, "unknown file name: " & fullPath)
-    return
-
-  let fileId = g.packed[mid].fromDisk.strings.getKeyId(fullPath)
-
-  if fileId == LitId(0):
-    internalError(g.config, unpacked, "cannot find a valid file ID")
-    return
-
-  var c = NavContext(
-    g: g,
-    thisModule: int32 mid,
-    trackPos: UnpackedLineInfo(line: unpacked.line.int, col: unpacked.col.int, file: fileId),
-    outputSep: if isDefined(g.config, "nimIcNavigatorTests"): ' ' else: '\t'
-  )
-  var symId = search(c, g.packed[mid].fromDisk.topLevel)
-  if symId == EmptyItemId:
-    symId = search(c, g.packed[mid].fromDisk.bodies)
-
-  if symId == EmptyItemId:
-    localError(g.config, unpacked, "no symbol at this position")
-    return
-
-  for i in 0..<len(g.packed):
-    # case statement here to enforce exhaustive checks.
-    case g.packed[i].status
-    of undefined:
-      discard "nothing to do"
-    of loading:
-      assert false, "cannot check integrity: Module still loading"
-    of stored, storing, outdated, loaded:
-      c.thisModule = int32 i
-      list(c, g.packed[i].fromDisk.topLevel, symId)
-      list(c, g.packed[i].fromDisk.bodies, symId)
-
-proc navDefinition*(g: ModuleGraph) = nav(g)
-proc navUsages*(g: ModuleGraph) = nav(g)
-proc navDefusages*(g: ModuleGraph) = nav(g)
-
-proc writeRodFiles*(g: ModuleGraph) =
-  for i in 0..<len(g.packed):
-    case g.packed[i].status
-    of undefined, loading, stored, loaded:
-      discard "nothing to do"
-    of storing, outdated:
-      closeRodFile(g, g.packed[i].module)

compiler/ic/packed_ast.nim

@@ -1,367 +0,0 @@
-#
-#
-#           The Nim Compiler
-#        (c) Copyright 2020 Andreas Rumpf
-#
-#    See the file "copying.txt", included in this
-#    distribution, for details about the copyright.
-#
-
-## Packed AST representation, mostly based on a seq of nodes.
-## For IC support. Far future: Rewrite the compiler passes to
-## use this representation directly in all the transformations,
-## it is superior.
-
-import std/[hashes, tables, strtabs]
-import bitabs, rodfiles
-import ".." / [ast, options]
-
-import iclineinfos
-
-when defined(nimPreviewSlimSystem):
-  import std/assertions
-
-type
-  SymId* = distinct int32
-  ModuleId* = distinct int32
-  NodePos* = distinct int
-
-  NodeId* = distinct int32
-
-  PackedItemId* = object
-    module*: LitId       # 0 if it's this module
-    item*: int32         # same as the in-memory representation
-
-const
-  nilItemId* = PackedItemId(module: LitId(0), item: 0.int32)
-
-const
-  emptyNodeId* = NodeId(-1)
-
-type
-  PackedLib* = object
-    kind*: TLibKind
-    generated*: bool
-    isOverridden*: bool
-    name*: LitId
-    path*: NodeId
-
-  PackedSym* = object
-    id*: int32
-    kind*: TSymKind
-    name*: LitId
-    typ*: PackedItemId
-    flags*: TSymFlags
-    magic*: TMagic
-    info*: PackedLineInfo
-    ast*: NodeId
-    owner*: PackedItemId
-    guard*: PackedItemId
-    bitsize*: int
-    alignment*: int # for alignment
-    options*: TOptions
-    position*: int
-    offset*: int32
-    disamb*: int32
-    externalName*: LitId # instead of TLoc
-    locFlags*: TLocFlags
-    annex*: PackedLib
-    when hasFFI:
-      cname*: LitId
-    constraint*: NodeId
-    instantiatedFrom*: PackedItemId
-
-  PackedType* = object
-    id*: int32
-    kind*: TTypeKind
-    callConv*: TCallingConvention
-    #nodekind*: TNodeKind
-    flags*: TTypeFlags
-    types*: seq[PackedItemId]
-    n*: NodeId
-    #nodeflags*: TNodeFlags
-    sym*: PackedItemId
-    owner*: PackedItemId
-    size*: BiggestInt
-    align*: int16
-    paddingAtEnd*: int16
-    # not serialized: loc*: TLoc because it is backend-specific
-    typeInst*: PackedItemId
-    nonUniqueId*: int32
-
-  PackedNode* = object     # 8 bytes
-    x: uint32
-    info*: PackedLineInfo
-
-  PackedTree* = object ## usually represents a full Nim module
-    nodes: seq[PackedNode]
-    withFlags: seq[(int32, TNodeFlags)]
-    withTypes: seq[(int32, PackedItemId)]
-
-  PackedInstantiation* = object
-    key*, sym*: PackedItemId
-    concreteTypes*: seq[PackedItemId]
-
-const
-  NodeKindBits = 8'u32
-  NodeKindMask = (1'u32 shl NodeKindBits) - 1'u32
-
-template kind*(n: PackedNode): TNodeKind = TNodeKind(n.x and NodeKindMask)
-template uoperand*(n: PackedNode): uint32 = (n.x shr NodeKindBits)
-template soperand*(n: PackedNode): int32 = int32(uoperand(n))
-
-template toX(k: TNodeKind; operand: uint32): uint32 =
-  uint32(k) or (operand shl NodeKindBits)
-
-template toX(k: TNodeKind; operand: LitId): uint32 =
-  uint32(k) or (operand.uint32 shl NodeKindBits)
-
-template typeId*(n: PackedNode): PackedItemId = n.typ
-
-proc `==`*(a, b: SymId): bool {.borrow.}
-proc hash*(a: SymId): Hash {.borrow.}
-
-proc `==`*(a, b: NodePos): bool {.borrow.}
-#proc `==`*(a, b: PackedItemId): bool {.borrow.}
-proc `==`*(a, b: NodeId): bool {.borrow.}
-
-proc newTreeFrom*(old: PackedTree): PackedTree =
-  result = PackedTree(nodes: @[])
-  when false: result.sh = old.sh
-
-proc addIdent*(tree: var PackedTree; s: LitId; info: PackedLineInfo) =
-  tree.nodes.add PackedNode(x: toX(nkIdent, uint32(s)), info: info)
-
-proc addSym*(tree: var PackedTree; s: int32; info: PackedLineInfo) =
-  tree.nodes.add PackedNode(x: toX(nkSym, cast[uint32](s)), info: info)
-
-proc addSymDef*(tree: var PackedTree; s: SymId; info: PackedLineInfo) =
-  tree.nodes.add PackedNode(x: toX(nkSym, cast[uint32](s)), info: info)
-
-proc isAtom*(tree: PackedTree; pos: int): bool {.inline.} = tree.nodes[pos].kind <= nkNilLit
-
-type
-  PatchPos = distinct int
-
-proc addNode*(t: var PackedTree; kind: TNodeKind; operand: int32;
-              typeId: PackedItemId = nilItemId; info: PackedLineInfo;
-              flags: TNodeFlags = {}) =
-  t.nodes.add PackedNode(x: toX(kind, cast[uint32](operand)), info: info)
-  if flags != {}:
-    t.withFlags.add (t.nodes.len.int32 - 1, flags)
-  if typeId != nilItemId:
-    t.withTypes.add (t.nodes.len.int32 - 1, typeId)
-
-proc prepare*(tree: var PackedTree; kind: TNodeKind; flags: TNodeFlags; typeId: PackedItemId; info: PackedLineInfo): PatchPos =
-  result = PatchPos tree.nodes.len
-  tree.addNode(kind = kind, flags = flags, operand = 0, info = info, typeId = typeId)
-
-proc prepare*(dest: var PackedTree; source: PackedTree; sourcePos: NodePos): PatchPos =
-  result = PatchPos dest.nodes.len
-  dest.nodes.add source.nodes[sourcePos.int]
-
-proc patch*(tree: var PackedTree; pos: PatchPos) =
-  let pos = pos.int
-  let k = tree.nodes[pos].kind
-  assert k > nkNilLit
-  let distance = int32(tree.nodes.len - pos)
-  assert distance > 0
-  tree.nodes[pos].x = toX(k, cast[uint32](distance))
-
-proc len*(tree: PackedTree): int {.inline.} = tree.nodes.len
-
-proc `[]`*(tree: PackedTree; i: NodePos): lent PackedNode {.inline.} =
-  tree.nodes[i.int]
-
-template rawSpan(n: PackedNode): int = int(uoperand(n))
-
-proc nextChild(tree: PackedTree; pos: var int) {.inline.} =
-  if tree.nodes[pos].kind > nkNilLit:
-    assert tree.nodes[pos].uoperand > 0
-    inc pos, tree.nodes[pos].rawSpan
-  else:
-    inc pos
-
-iterator sonsReadonly*(tree: PackedTree; n: NodePos): NodePos =
-  var pos = n.int
-  assert tree.nodes[pos].kind > nkNilLit
-  let last = pos + tree.nodes[pos].rawSpan
-  inc pos
-  while pos < last:
-    yield NodePos pos
-    nextChild tree, pos
-
-iterator sons*(dest: var PackedTree; tree: PackedTree; n: NodePos): NodePos =
-  let patchPos = prepare(dest, tree, n)
-  for x in sonsReadonly(tree, n): yield x
-  patch dest, patchPos
-
-iterator isons*(dest: var PackedTree; tree: PackedTree;
-                n: NodePos): (int, NodePos) =
-  var i = 0
-  for ch0 in sons(dest, tree, n):
-    yield (i, ch0)
-    inc i
-
-iterator sonsFrom1*(tree: PackedTree; n: NodePos): NodePos =
-  var pos = n.int
-  assert tree.nodes[pos].kind > nkNilLit
-  let last = pos + tree.nodes[pos].rawSpan
-  inc pos
-  if pos < last:
-    nextChild tree, pos
-  while pos < last:
-    yield NodePos pos
-    nextChild tree, pos
-
-iterator sonsWithoutLast2*(tree: PackedTree; n: NodePos): NodePos =
-  var count = 0
-  for child in sonsReadonly(tree, n):
-    inc count
-  var pos = n.int
-  assert tree.nodes[pos].kind > nkNilLit
-  let last = pos + tree.nodes[pos].rawSpan
-  inc pos
-  while pos < last and count > 2:
-    yield NodePos pos
-    dec count
-    nextChild tree, pos
-
-proc parentImpl(tree: PackedTree; n: NodePos): NodePos =
-  # finding the parent of a node is rather easy:
-  var pos = n.int - 1
-  while pos >= 0 and (isAtom(tree, pos) or (pos + tree.nodes[pos].rawSpan - 1 < n.int)):
-    dec pos
-  #assert pos >= 0, "node has no parent"
-  result = NodePos(pos)
-
-template parent*(n: NodePos): NodePos = parentImpl(tree, n)
-
-proc hasXsons*(tree: PackedTree; n: NodePos; x: int): bool =
-  var count = 0
-  if tree.nodes[n.int].kind > nkNilLit:
-    for child in sonsReadonly(tree, n): inc count
-  result = count == x
-
-proc hasAtLeastXsons*(tree: PackedTree; n: NodePos; x: int): bool =
-  if tree.nodes[n.int].kind > nkNilLit:
-    var count = 0
-    for child in sonsReadonly(tree, n):
-      inc count
-      if count >= x: return true
-  return false
-
-proc firstSon*(tree: PackedTree; n: NodePos): NodePos {.inline.} =
-  NodePos(n.int+1)
-proc kind*(tree: PackedTree; n: NodePos): TNodeKind {.inline.} =
-  tree.nodes[n.int].kind
-proc litId*(tree: PackedTree; n: NodePos): LitId {.inline.} =
-  LitId tree.nodes[n.int].uoperand
-proc info*(tree: PackedTree; n: NodePos): PackedLineInfo {.inline.} =
-  tree.nodes[n.int].info
-
-proc findType*(tree: PackedTree; n: NodePos): PackedItemId =
-  for x in tree.withTypes:
-    if x[0] == int32(n): return x[1]
-    if x[0] > int32(n): return nilItemId
-  return nilItemId
-
-proc findFlags*(tree: PackedTree; n: NodePos): TNodeFlags =
-  for x in tree.withFlags:
-    if x[0] == int32(n): return x[1]
-    if x[0] > int32(n): return {}
-  return {}
-
-template typ*(n: NodePos): PackedItemId =
-  tree.findType(n)
-template flags*(n: NodePos): TNodeFlags =
-  tree.findFlags(n)
-
-template uoperand*(n: NodePos): uint32 =
-  tree.nodes[n.int].uoperand
-
-proc span*(tree: PackedTree; pos: int): int {.inline.} =
-  if isAtom(tree, pos): 1 else: tree.nodes[pos].rawSpan
-
-proc sons2*(tree: PackedTree; n: NodePos): (NodePos, NodePos) =
-  assert(not isAtom(tree, n.int))
-  let a = n.int+1
-  let b = a + span(tree, a)
-  result = (NodePos a, NodePos b)
-
-proc sons3*(tree: PackedTree; n: NodePos): (NodePos, NodePos, NodePos) =
-  assert(not isAtom(tree, n.int))
-  let a = n.int+1
-  let b = a + span(tree, a)
-  let c = b + span(tree, b)
-  result = (NodePos a, NodePos b, NodePos c)
-
-proc ithSon*(tree: PackedTree; n: NodePos; i: int): NodePos =
-  result = default(NodePos)
-  if tree.nodes[n.int].kind > nkNilLit:
-    var count = 0
-    for child in sonsReadonly(tree, n):
-      if count == i: return child
-      inc count
-  assert false, "node has no i-th child"
-
-when false:
-  proc `@`*(tree: PackedTree; lit: LitId): lent string {.inline.} =
-    tree.sh.strings[lit]
-
-template kind*(n: NodePos): TNodeKind = tree.nodes[n.int].kind
-template info*(n: NodePos): PackedLineInfo = tree.nodes[n.int].info
-template litId*(n: NodePos): LitId = LitId tree.nodes[n.int].uoperand
-
-template symId*(n: NodePos): SymId = SymId tree.nodes[n.int].soperand
-
-proc firstSon*(n: NodePos): NodePos {.inline.} = NodePos(n.int+1)
-
-const
-  externIntLit* = {nkCharLit,
-    nkIntLit,
-    nkInt8Lit,
-    nkInt16Lit,
-    nkInt32Lit,
-    nkInt64Lit,
-    nkUIntLit,
-    nkUInt8Lit,
-    nkUInt16Lit,
-    nkUInt32Lit,
-    nkUInt64Lit}
-
-  externSIntLit* = {nkIntLit, nkInt8Lit, nkInt16Lit, nkInt32Lit, nkInt64Lit}
-  externUIntLit* = {nkUIntLit, nkUInt8Lit, nkUInt16Lit, nkUInt32Lit, nkUInt64Lit}
-  directIntLit* = nkNone
-
-template copyInto*(dest, n, body) =
-  let patchPos = prepare(dest, tree, n)
-  body
-  patch dest, patchPos
-
-template copyIntoKind*(dest, kind, info, body) =
-  let patchPos = prepare(dest, kind, info)
-  body
-  patch dest, patchPos
-
-proc getNodeId*(tree: PackedTree): NodeId {.inline.} = NodeId tree.nodes.len
-
-iterator allNodes*(tree: PackedTree): NodePos =
-  var p = 0
-  while p < tree.len:
-    yield NodePos(p)
-    let s = span(tree, p)
-    inc p, s
-
-proc toPackedItemId*(item: int32): PackedItemId {.inline.} =
-  PackedItemId(module: LitId(0), item: item)
-
-proc load*(f: var RodFile; t: var PackedTree) =
-  loadSeq f, t.nodes
-  loadSeq f, t.withFlags
-  loadSeq f, t.withTypes
-
-proc store*(f: var RodFile; t: PackedTree) =
-  storeSeq f, t.nodes
-  storeSeq f, t.withFlags
-  storeSeq f, t.withTypes

compiler/ic/replayer.nim

@@ -19,8 +19,6 @@ import std/tables
 when defined(nimPreviewSlimSystem):
   import std/assertions
 
-import packed_ast, ic, bitabs
-
 proc replayStateChanges*(module: PSym; g: ModuleGraph) =
   let list = module.ast
   assert list != nil
@@ -88,84 +86,3 @@ proc replayStateChanges*(module: PSym; g: ModuleGraph) =
           g.cacheSeqs[destKey].add val
       else:
         internalAssert g.config, false
-
-proc replayBackendProcs*(g: ModuleGraph; module: int) =
-  for it in mitems(g.packed[module].fromDisk.attachedOps):
-    let key = translateId(it[0], g.packed, module, g.config)
-    let op = it[1]
-    let tmp = translateId(it[2], g.packed, module, g.config)
-    let symId = FullId(module: tmp.module, packed: it[2])
-    g.attachedOps[op][key] = LazySym(id: symId, sym: nil)
-
-  for it in mitems(g.packed[module].fromDisk.enumToStringProcs):
-    let key = translateId(it[0], g.packed, module, g.config)
-    let tmp = translateId(it[1], g.packed, module, g.config)
-    let symId = FullId(module: tmp.module, packed: it[1])
-    g.enumToStringProcs[key] = LazySym(id: symId, sym: nil)
-
-  for it in mitems(g.packed[module].fromDisk.methodsPerType):
-    let key = translateId(it[0], g.packed, module, g.config)
-    let tmp = translateId(it[1], g.packed, module, g.config)
-    let symId = FullId(module: tmp.module, packed: it[1])
-    g.methodsPerType.mgetOrPut(key, @[]).add LazySym(id: symId, sym: nil)
-
-  for it in mitems(g.packed[module].fromDisk.dispatchers):
-    let tmp = translateId(it, g.packed, module, g.config)
-    let symId = FullId(module: tmp.module, packed: it)
-    g.dispatchers.add LazySym(id: symId, sym: nil)
-
-proc replayGenericCacheInformation*(g: ModuleGraph; module: int) =
-  ## We remember the generic instantiations a module performed
-  ## in order to to avoid the code bloat that generic code tends
-  ## to imply. This is cheaper than deduplication of identical
-  ## generic instantiations. However, deduplication is more
-  ## powerful and general and I hope to implement it soon too
-  ## (famous last words).
-  assert g.packed[module].status == loaded
-  for it in g.packed[module].fromDisk.typeInstCache:
-    let key = translateId(it[0], g.packed, module, g.config)
-    g.typeInstCache.mgetOrPut(key, @[]).add LazyType(id: FullId(module: module, packed: it[1]), typ: nil)
-
-  for it in mitems(g.packed[module].fromDisk.procInstCache):
-    let key = translateId(it.key, g.packed, module, g.config)
-    let sym = translateId(it.sym, g.packed, module, g.config)
-    var concreteTypes = newSeq[FullId](it.concreteTypes.len)
-    for i in 0..high(it.concreteTypes):
-      let tmp = translateId(it.concreteTypes[i], g.packed, module, g.config)
-      concreteTypes[i] = FullId(module: tmp.module, packed: it.concreteTypes[i])
-
-    g.procInstCache.mgetOrPut(key, @[]).add LazyInstantiation(
-      module: module, sym: FullId(module: sym.module, packed: it.sym),
-      concreteTypes: concreteTypes, inst: nil)
-
-  for it in mitems(g.packed[module].fromDisk.methodsPerGenericType):
-    let key = translateId(it[0], g.packed, module, g.config)
-    let col = it[1]
-    let tmp = translateId(it[2], g.packed, module, g.config)
-    let symId = FullId(module: tmp.module, packed: it[2])
-    g.methodsPerGenericType.mgetOrPut(key, @[]).add (col, LazySym(id: symId, sym: nil))
-
-  replayBackendProcs(g, module)
-
-  for it in mitems(g.packed[module].fromDisk.methods):
-    let sym = loadSymFromId(g.config, g.cache, g.packed, module,
-                            PackedItemId(module: LitId(0), item: it))
-    methodDef(g, g.idgen, sym)
-
-  when false:
-    # not used anymore:
-    for it in mitems(g.packed[module].fromDisk.compilerProcs):
-      let symId = FullId(module: module, packed: PackedItemId(module: LitId(0), item: it[1]))
-      g.lazyCompilerprocs[g.packed[module].fromDisk.sh.strings[it[0]]] = symId
-
-  for it in mitems(g.packed[module].fromDisk.converters):
-    let symId = FullId(module: module, packed: PackedItemId(module: LitId(0), item: it))
-    g.ifaces[module].converters.add LazySym(id: symId, sym: nil)
-
-  for it in mitems(g.packed[module].fromDisk.trmacros):
-    let symId = FullId(module: module, packed: PackedItemId(module: LitId(0), item: it))
-    g.ifaces[module].patterns.add LazySym(id: symId, sym: nil)
-
-  for it in mitems(g.packed[module].fromDisk.pureEnums):
-    let symId = FullId(module: module, packed: PackedItemId(module: LitId(0), item: it))
-    g.ifaces[module].pureEnums.add LazySym(id: symId, sym: nil)

compiler/ic/rodfiles.nim

@@ -1,283 +0,0 @@
-#
-#
-#           The Nim Compiler
-#        (c) Copyright 2020 Andreas Rumpf
-#
-#    See the file "copying.txt", included in this
-#    distribution, for details about the copyright.
-#
-
-## Low level binary format used by the compiler to store and load various AST
-## and related data.
-##
-## NB: this is incredibly low level and if you're interested in how the
-##     compiler works and less a storage format, you're probably looking for
-##     the `ic` or `packed_ast` modules to understand the logical format.
-
-from std/typetraits import supportsCopyMem
-
-when defined(nimPreviewSlimSystem):
-  import std/[syncio, assertions]
-
-import std / tables
-
-## Overview
-## ========
-## `RodFile` represents a Rod File (versioned binary format), and the
-## associated data for common interactions such as IO and error tracking
-## (`RodFileError`). The file format broken up into sections (`RodSection`)
-## and preceded by a header (see: `cookie`). The precise layout, section
-## ordering and data following the section are determined by the user. See
-## `ic.loadRodFile`.
-##
-## A basic but "wrong" example of the lifecycle:
-## ---------------------------------------------
-## 1. `create` or `open`        - create a new one or open an existing
-## 2. `storeHeader`             - header info
-## 3. `storePrim` or `storeSeq` - save your stuff
-## 4. `close`                   - and we're done
-##
-## Now read the bits below to understand what's missing.
-##
-## ### Issues with the Example
-## Missing Sections:
-## This is a low level API, so headers and sections need to be stored and
-## loaded by the user, see `storeHeader` & `loadHeader` and `storeSection` &
-## `loadSection`, respectively.
-##
-## No Error Handling:
-## The API is centered around IO and prone to error, each operation checks or
-## sets the `RodFile.err` field. A user of this API needs to handle these
-## appropriately.
-##
-## API Notes
-## =========
-##
-## Valid inputs for Rod files
-## --------------------------
-## ASTs, hopes, dreams, and anything as long as it and any children it may have
-## support `copyMem`. This means anything that is not a pointer and that does not contain a pointer. At a glance these are:
-## * string
-## * objects & tuples (fields are recursed)
-## * sequences AKA `seq[T]`
-##
-## Note on error handling style
-## ----------------------------
-## A flag based approach is used where operations no-op in case of a
-## preexisting error and set the flag if they encounter one.
-##
-## Misc
-## ----
-## * 'Prim' is short for 'primitive', as in a non-sequence type
-
-type
-  RodSection* = enum
-    versionSection
-    configSection
-    stringsSection
-    checkSumsSection
-    depsSection
-    numbersSection
-    exportsSection
-    hiddenSection
-    reexportsSection
-    compilerProcsSection
-    trmacrosSection
-    convertersSection
-    methodsSection
-    pureEnumsSection
-    toReplaySection
-    topLevelSection
-    bodiesSection
-    symsSection
-    typesSection
-    typeInstCacheSection
-    procInstCacheSection
-    attachedOpsSection
-    methodsPerGenericTypeSection
-    enumToStringProcsSection
-    methodsPerTypeSection
-    dispatchersSection
-    typeInfoSection  # required by the backend
-    backendFlagsSection
-    aliveSymsSection # beware, this is stored in a `.alivesyms` file.
-    sideChannelSection
-    namespaceSection
-    symnamesSection
-
-  RodFileError* = enum
-    ok, tooBig, cannotOpen, ioFailure, wrongHeader, wrongSection, configMismatch,
-    includeFileChanged
-
-  RodFile* = object
-    f*: File
-    currentSection*: RodSection # for error checking
-    err*: RodFileError # little experiment to see if this works
-                       # better than exceptions.
-
-const
-  RodVersion = 2
-  defaultCookie = [byte(0), byte('R'), byte('O'), byte('D'),
-            byte(sizeof(int)*8), byte(system.cpuEndian), byte(0), byte(RodVersion)]
-
-proc setError(f: var RodFile; err: RodFileError) {.inline.} =
-  f.err = err
-  #raise newException(IOError, "IO error")
-
-proc storePrim*(f: var RodFile; s: string) =
-  ## Stores a string.
-  ## The len is prefixed to allow for later retreival.
-  if f.err != ok: return
-  if s.len >= high(int32):
-    setError f, tooBig
-    return
-  var lenPrefix = int32(s.len)
-  if writeBuffer(f.f, addr lenPrefix, sizeof(lenPrefix)) != sizeof(lenPrefix):
-    setError f, ioFailure
-  else:
-    if s.len != 0:
-      if writeBuffer(f.f, unsafeAddr(s[0]), s.len) != s.len:
-        setError f, ioFailure
-
-proc storePrim*[T](f: var RodFile; x: T) =
-  ## Stores a non-sequence/string `T`.
-  ## If `T` doesn't support `copyMem` and is an object or tuple then the fields
-  ## are written -- the user from context will need to know which `T` to load.
-  if f.err != ok: return
-  when supportsCopyMem(T):
-    if writeBuffer(f.f, unsafeAddr(x), sizeof(x)) != sizeof(x):
-      setError f, ioFailure
-  elif T is tuple:
-    for y in fields(x):
-      storePrim(f, y)
-  elif T is object:
-    for y in fields(x):
-      when y is seq:
-        storeSeq(f, y)
-      else:
-        storePrim(f, y)
-  else:
-    {.error: "unsupported type for 'storePrim'".}
-
-proc storeSeq*[T](f: var RodFile; s: seq[T]) =
-  ## Stores a sequence of `T`s, with the len as a prefix for later retrieval.
-  if f.err != ok: return
-  if s.len >= high(int32):
-    setError f, tooBig
-    return
-  var lenPrefix = int32(s.len)
-  if writeBuffer(f.f, addr lenPrefix, sizeof(lenPrefix)) != sizeof(lenPrefix):
-    setError f, ioFailure
-  else:
-    for i in 0..<s.len:
-      storePrim(f, s[i])
-
-proc storeOrderedTable*[K, T](f: var RodFile; s: OrderedTable[K, T]) =
-  if f.err != ok: return
-  if s.len >= high(int32):
-    setError f, tooBig
-    return
-  var lenPrefix = int32(s.len)
-  if writeBuffer(f.f, addr lenPrefix, sizeof(lenPrefix)) != sizeof(lenPrefix):
-    setError f, ioFailure
-  else:
-    for _, v in s:
-      storePrim(f, v)
-
-proc loadPrim*(f: var RodFile; s: var string) =
-  ## Read a string, the length was stored as a prefix
-  if f.err != ok: return
-  var lenPrefix = int32(0)
-  if readBuffer(f.f, addr lenPrefix, sizeof(lenPrefix)) != sizeof(lenPrefix):
-    setError f, ioFailure
-  else:
-    s = newString(lenPrefix)
-    if lenPrefix > 0:
-      if readBuffer(f.f, unsafeAddr(s[0]), s.len) != s.len:
-        setError f, ioFailure
-
-proc loadPrim*[T](f: var RodFile; x: var T) =
-  ## Load a non-sequence/string `T`.
-  if f.err != ok: return
-  when supportsCopyMem(T):
-    if readBuffer(f.f, unsafeAddr(x), sizeof(x)) != sizeof(x):
-      setError f, ioFailure
-  elif T is tuple:
-    for y in fields(x):
-      loadPrim(f, y)
-  elif T is object:
-    for y in fields(x):
-      when y is seq:
-        loadSeq(f, y)
-      else:
-        loadPrim(f, y)
-  else:
-    {.error: "unsupported type for 'loadPrim'".}
-
-proc loadSeq*[T](f: var RodFile; s: var seq[T]) =
-  ## `T` must be compatible with `copyMem`, see `loadPrim`
-  if f.err != ok: return
-  var lenPrefix = int32(0)
-  if readBuffer(f.f, addr lenPrefix, sizeof(lenPrefix)) != sizeof(lenPrefix):
-    setError f, ioFailure
-  else:
-    s = newSeq[T](lenPrefix)
-    for i in 0..<lenPrefix:
-      loadPrim(f, s[i])
-
-proc loadOrderedTable*[K, T](f: var RodFile; s: var OrderedTable[K, T]) =
-  ## `T` must be compatible with `copyMem`, see `loadPrim`
-  if f.err != ok: return
-  var lenPrefix = int32(0)
-  if readBuffer(f.f, addr lenPrefix, sizeof(lenPrefix)) != sizeof(lenPrefix):
-    setError f, ioFailure
-  else:
-    s = initOrderedTable[K, T](lenPrefix)
-    for i in 0..<lenPrefix:
-      var x = default T
-      loadPrim(f, x)
-      s[x.id] = x
-
-proc storeHeader*(f: var RodFile; cookie = defaultCookie) =
-  ## stores the header which is described by `cookie`.
-  if f.err != ok: return
-  if f.f.writeBytes(cookie, 0, cookie.len) != cookie.len:
-    setError f, ioFailure
-
-proc loadHeader*(f: var RodFile; cookie = defaultCookie) =
-  ## Loads the header which is described by `cookie`.
-  if f.err != ok: return
-  var thisCookie: array[cookie.len, byte] = default(array[cookie.len, byte])
-  if f.f.readBytes(thisCookie, 0, thisCookie.len) != thisCookie.len:
-    setError f, ioFailure
-  elif thisCookie != cookie:
-    setError f, wrongHeader
-
-proc storeSection*(f: var RodFile; s: RodSection) =
-  ## update `currentSection` and writes the bytes value of s.
-  if f.err != ok: return
-  assert f.currentSection < s
-  f.currentSection = s
-  storePrim(f, s)
-
-proc loadSection*(f: var RodFile; expected: RodSection) =
-  ## read the bytes value of s, sets and error if the section is incorrect.
-  if f.err != ok: return
-  var s: RodSection = default(RodSection)
-  loadPrim(f, s)
-  if expected != s and f.err == ok:
-    setError f, wrongSection
-
-proc create*(filename: string): RodFile =
-  ## create the file and open it for writing
-  result = default(RodFile)
-  if not open(result.f, filename, fmWrite):
-    setError result, cannotOpen
-
-proc close*(f: var RodFile) = close(f.f)
-
-proc open*(filename: string): RodFile =
-  ## open the file for reading
-  result = default(RodFile)
-  if not open(result.f, filename, fmRead):
-    setError result, cannotOpen

compiler/importer.nim

@@ -108,8 +108,8 @@ proc rawImportSymbol(c: PContext, s, origin: PSym; importSet: var IntSet) =
           else:
             importPureEnumField(c, e)
   else:
-    if s.kind == skConverter: addConverter(c, LazySym(sym: s))
-    if hasPattern(s): addPattern(c, LazySym(sym: s))
+    if s.kind == skConverter: addConverter(c, s)
+    if hasPattern(s): addPattern(c, s)
   if s.owner != origin:
     c.exportIndirections.incl((origin.id, s.id))
 
@@ -190,22 +190,19 @@ proc addImport(c: PContext; im: sink ImportedModule) =
 template addUnnamedIt(c: PContext, fromMod: PSym; filter: untyped) {.dirty.} =
   for it in mitems c.graph.ifaces[fromMod.position].converters:
     if filter:
-      loadPackedSym(c.graph, it)
-      if sfExported in it.sym.flags:
+      if sfExported in it.flags:
         addConverter(c, it)
   for it in mitems c.graph.ifaces[fromMod.position].patterns:
     if filter:
-      loadPackedSym(c.graph, it)
-      if sfExported in it.sym.flags:
+      if sfExported in it.flags:
         addPattern(c, it)
   for it in mitems c.graph.ifaces[fromMod.position].pureEnums:
     if filter:
-      loadPackedSym(c.graph, it)
-      importPureEnumFields(c, it.sym, it.sym.typ)
+      importPureEnumFields(c, it, it.typ)
 
 proc importAllSymbolsExcept(c: PContext, fromMod: PSym, exceptSet: IntSet) =
   c.addImport ImportedModule(m: fromMod, mode: importExcept, exceptSet: exceptSet)
-  addUnnamedIt(c, fromMod, it.sym.name.id notin exceptSet)
+  addUnnamedIt(c, fromMod, it.name.id notin exceptSet)
 
 proc importAllSymbols*(c: PContext, fromMod: PSym) =
   c.addImport ImportedModule(m: fromMod, mode: importAll)
@@ -292,9 +289,8 @@ proc myImportModule(c: PContext, n: var PNode, importStmtResult: PNode): PSym =
       c.recursiveDep = err
 
     let trackUnusedImport = warnUnusedImportX in c.config.notes
-    var realModule: PSym
     discard pushOptionEntry(c)
-    realModule = c.graph.importModuleCallback(c.graph, c.module, f)
+    let realModule = c.graph.importModuleCallback(c.graph, c.module, f)
     result = importModuleAs(c, n, realModule, transf.importHidden, trackUnusedImport)
     popOptionEntry(c)
 

compiler/injectdestructors.nim

@@ -69,7 +69,7 @@ proc hasDestructor(c: Con; t: PType): bool {.inline.} =
   result = ast.hasDestructor(t)
   when toDebug.len > 0:
     # for more effective debugging
-    if not result and c.graph.config.selectedGC in {gcArc, gcOrc, gcAtomicArc}:
+    if not result and c.graph.config.selectedGC in {gcArc, gcOrc, gcYrc, gcAtomicArc}:
       assert(not containsGarbageCollectedRef(t))
 
 proc getTemp(c: var Con; s: var Scope; typ: PType; info: TLineInfo): PNode =
@@ -165,7 +165,7 @@ proc isLastReadImpl(n: PNode; c: var Con; scope: var Scope): bool =
 
 template hasDestructorOrAsgn(c: var Con, typ: PType): bool =
   # bug #23354; an object type could have a non-trivial assignements when it is passed to a sink parameter
-  hasDestructor(c, typ) or (c.graph.config.selectedGC in {gcArc, gcOrc, gcAtomicArc} and
+  hasDestructor(c, typ) or (c.graph.config.selectedGC in {gcArc, gcOrc, gcYrc, gcAtomicArc} and
         typ.kind == tyObject and not isTrivial(getAttachedOp(c.graph, typ, attachedAsgn)))
 
 proc isLastRead(n: PNode; c: var Con; s: var Scope): bool =
@@ -329,14 +329,14 @@ proc isCriticalLink(dest: PNode): bool {.inline.} =
   result = dest.kind != nkSym
 
 proc finishCopy(c: var Con; result, dest: PNode; flags: set[MoveOrCopyFlag]; isFromSink: bool) =
-  if c.graph.config.selectedGC == gcOrc and IsExplicitSink notin flags:
+  if c.graph.config.selectedGC in {gcOrc, gcYrc} and IsExplicitSink notin flags:
     # add cyclic flag, but not to sink calls, which IsExplicitSink generates
     let t = dest.typ.skipTypes(tyUserTypeClasses + {tyGenericInst, tyAlias, tySink, tyDistinct})
     if cyclicType(c.graph, t):
       result.add boolLit(c.graph, result.info, isFromSink or isCriticalLink(dest))
 
 proc genMarkCyclic(c: var Con; result, dest: PNode) =
-  if c.graph.config.selectedGC == gcOrc:
+  if c.graph.config.selectedGC in {gcOrc, gcYrc}:
     let t = dest.typ.skipTypes({tyGenericInst, tyAlias, tySink, tyDistinct})
     if cyclicType(c.graph, t):
       if t.kind == tyRef:
@@ -457,10 +457,10 @@ proc isCapturedVar(n: PNode): bool =
   else: result = false
 
 proc passCopyToSink(n: PNode; c: var Con; s: var Scope): PNode =
-  result = newNodeIT(nkStmtListExpr, n.info, n.typ)
   let nTyp = n.typ.skipTypes(tyUserTypeClasses)
-  let tmp = c.getTemp(s, nTyp, n.info)
   if hasDestructorOrAsgn(c, nTyp):
+    result = newNodeIT(nkStmtListExpr, n.info, n.typ)
+    let tmp = c.getTemp(s, nTyp, n.info)
     let typ = nTyp.skipTypes({tyGenericInst, tyAlias, tySink})
     let op = getAttachedOp(c.graph, typ, attachedDup)
     if op != nil and tfHasOwned notin typ.flags:
@@ -494,15 +494,15 @@ proc passCopyToSink(n: PNode; c: var Con; s: var Scope): PNode =
     if c.inEnsureMove > 0:
       localError(c.graph.config, n.info, errFailedMove,
         ("cannot move '$1', passing '$1' to a sink parameter introduces an implicit copy") % $n)
+    # Since we know somebody will take over the produced copy, there is
+    # no need to destroy it.
+    result.add tmp
   else:
-    if c.graph.config.selectedGC in {gcArc, gcOrc, gcAtomicArc}:
+    if c.graph.config.selectedGC in {gcArc, gcOrc, gcYrc, gcAtomicArc}:
       assert(not containsManagedMemory(nTyp))
     if nTyp.skipTypes(abstractInst).kind in {tyOpenArray, tyVarargs}:
       localError(c.graph.config, n.info, "cannot create an implicit openArray copy to be passed to a sink parameter")
-    result.add newTree(nkAsgn, tmp, p(n, c, s, normal))
-  # Since we know somebody will take over the produced copy, there is
-  # no need to destroy it.
-  result.add tmp
+    result = p(n, c, s, normal)
 
 proc isDangerousSeq(t: PType): bool {.inline.} =
   let t = t.skipTypes(abstractInst)
@@ -926,7 +926,7 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
 
       if n[0].kind == nkSym and n[0].sym.magic in {mNew, mNewFinalize}:
         result[0] = copyTree(n[0])
-        if c.graph.config.selectedGC in {gcHooks, gcArc, gcAtomicArc, gcOrc}:
+        if c.graph.config.selectedGC in {gcHooks, gcArc, gcAtomicArc, gcOrc, gcYrc}:
           let destroyOld = c.genDestroy(result[1])
           result = newTree(nkStmtList, destroyOld, result)
       else:

compiler/lexer.nim

@@ -316,6 +316,28 @@ proc getNumber(L: var Lexer, result: var Token) =
     L.bufpos = msgPos
     lexMessage(L, msgKind, msg % t.literal)
 
+  proc checkBitWidth(L: var Lexer, base: NumericalBase, tokType: TokType, 
+                     numDigits: int, startpos: int) =
+    # Check bit width for non-base-10 literals
+    # Warn if the digit count exceeds what can fit in the target type
+    let bitsPerDigit = case base
+      of base2: 1
+      of base8: 3
+      of base16: 4
+      else: raiseAssert "unreachable"
+    let bitWidth = case tokType
+      of tkInt8Lit, tkUInt8Lit: 8
+      of tkInt16Lit, tkUInt16Lit: 16
+      of tkInt32Lit, tkUInt32Lit: 32
+      of tkInt64Lit, tkUIntLit, tkIntLit, tkUInt64Lit: 64
+      else: raiseAssert "unreachable"
+    # Maximum digits = ceil(bitWidth / bitsPerDigit) = (bitWidth + bitsPerDigit - 1) div bitsPerDigit
+    let maxDigits = (bitWidth + bitsPerDigit - 1) div bitsPerDigit
+    if numDigits > maxDigits:
+      lexMessageLitNum(L,
+        "number has " & $numDigits & " digits but type only supports " &
+        $maxDigits & " digits: '$1'", startpos, warnLongLiterals)
+
   var
     xi: BiggestInt
     isBase10 = true
@@ -491,6 +513,11 @@ proc getNumber(L: var Lexer, result: var Token) =
           setNumber result.fNumber, (cast[ptr float64](addr(xi)))[]
         else: internalError(L.config, getLineInfo(L), "getNumber")
 
+        # Check bit width for non-base-10 literals
+        # Warn if the digit count exceeds what can fit in the target type
+        if result.base != base10 and result.tokType in {tkIntLit..tkUInt64Lit} and numDigits > 0:
+          checkBitWidth(L, result.base, result.tokType, numDigits, startpos)
+
         # Bounds checks. Non decimal literals are allowed to overflow the range of
         # the datatype as long as their pattern don't overflow _bitwise_, hence
         # below checks of signed sizes against uint*.high is deliberate:
@@ -896,7 +923,7 @@ proc getSymbol(L: var Lexer, tok: var Token) =
     tok.tokType = tkSymbol
   else:
     tok.tokType = TokType(tok.ident.id + ord(tkSymbol))
-    if suspicious and {optStyleHint, optStyleError} * L.config.globalOptions != {}:
+    if suspicious and {optStyleHint, optStyleError, optStyleWarning} * L.config.globalOptions != {}:
       lintReport(L.config, getLineInfo(L), tok.ident.s.normalize, tok.ident.s)
   L.bufpos = pos
 

compiler/liftdestructors.nim

@@ -163,7 +163,7 @@ proc fillBodyObj(c: var TLiftCtx; n, body, x, y: PNode; enforceDefaultOp: bool,
     if c.filterDiscriminator != nil: return
     let f = n.sym
     let b = if c.kind == attachedTrace: y else: y.dotField(f)
-    if (sfCursor in f.flags and c.g.config.selectedGC in {gcArc, gcAtomicArc, gcOrc, gcHooks}) or
+    if (sfCursor in f.flags and c.g.config.selectedGC in {gcArc, gcAtomicArc, gcOrc, gcYrc, gcHooks}) or
         enforceDefaultOp:
       defaultOp(c, f.typ, body, x.dotField(f), b)
     else:
@@ -558,6 +558,22 @@ proc declareTempOf(c: var TLiftCtx; body: PNode; value: PNode): PNode =
   v.addVar(result, value)
   body.add v
 
+proc considerInferDupFromCopy(c: var TLiftCtx; t: PType; body, x, y: PNode): bool =
+  ## For `=dup`, if no explicit hook exists, try to infer from `=copy` hook
+  ## to maintain backward compatibility. Returns true if inference was applied.
+  if c.kind == attachedDup:
+    var op2 = getAttachedOp(c.g, t, attachedAsgn)
+    if op2 != nil and sfOverridden in op2.flags:
+      #markUsed(c.g.config, c.info, op, c.g.usageSym)
+      onUse(c.info, op2)
+      body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+      body.add newHookCall(c, op2, x, y)
+      result = true
+    else:
+      result = false
+  else:
+    result = false
+
 proc addIncStmt(c: var TLiftCtx; body, i: PNode) =
   let incCall = genBuiltin(c, mInc, "inc", i)
   incCall.add lowerings.newIntLit(c.g, c.info, 1)
@@ -721,14 +737,43 @@ proc atomicRefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     dest[] = source
     decRef tmp
 
+  For YRC the write barrier is more complicated still and must be:
+
+    let tmp = dest
+    # assignment must come first so that the collector sees the most-recent graph:
+    atomic: dest[] = source
+    # Then teach the cycle collector about the changes edge (these use locks, see yrc.nim):
+    incRef source
+    decRef tmp
+
+  This is implemented as a single runtime call (nimAsgnYrc / nimSinkYrc).
   ]#
   var actions = newNodeI(nkStmtList, c.info)
   let elemType = t.elementType
 
   createTypeBoundOps(c.g, c.c, elemType, c.info, c.idgen)
-  let isCyclic = c.g.config.selectedGC == gcOrc and types.canFormAcycle(c.g, elemType)
 
-  let isInheritableAcyclicRef = c.g.config.selectedGC == gcOrc and
+  # YRC uses dedicated runtime procs for the entire write barrier:
+  if c.g.config.selectedGC == gcYrc:
+    let desc =
+      if isFinal(elemType):
+        let ti = genBuiltin(c, mGetTypeInfoV2, "getTypeInfoV2", newNodeIT(nkType, x.info, elemType))
+        ti.typ = getSysType(c.g, c.info, tyPointer)
+        ti
+      else:
+        newNodeIT(nkNilLit, c.info, getSysType(c.g, c.info, tyPointer))
+    case c.kind
+    of attachedAsgn, attachedDup:
+      body.add callCodegenProc(c.g, "nimAsgnYrc", c.info, genAddr(c, x), y, desc)
+      return
+    of attachedSink:
+      body.add callCodegenProc(c.g, "nimSinkYrc", c.info, genAddr(c, x), y, desc)
+      return
+    else: discard # fall through for destructor, trace, wasMoved
+
+  let isCyclic = c.g.config.selectedGC in {gcOrc, gcYrc} and types.canFormAcycle(c.g, elemType)
+
+  let isInheritableAcyclicRef = c.g.config.selectedGC in {gcOrc, gcYrc} and
                       (not isPureObject(elemType)) and
                       tfAcyclic in skipTypes(elemType, abstractInst+{tyOwned}-{tyTypeDesc}).flags
   # dynamic Acyclic refs need to use dyn decRef
@@ -810,7 +855,26 @@ proc atomicClosureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   let xenv = genBuiltin(c, mAccessEnv, "accessEnv", x)
   xenv.typ = getSysType(c.g, c.info, tyPointer)
 
-  let isCyclic = c.g.config.selectedGC == gcOrc
+  # Closures are (fnPtr, env) pairs. nimAsgnYrc/nimSinkYrc handle the env pointer
+  # (atomic store + buffered inc/dec). We also need newAsgnStmt to copy the fnPtr.
+  if c.g.config.selectedGC == gcYrc:
+    let nilDesc = newNodeIT(nkNilLit, c.info, getSysType(c.g, c.info, tyPointer))
+    let yenv = genBuiltin(c, mAccessEnv, "accessEnv", y)
+    yenv.typ = getSysType(c.g, c.info, tyPointer)
+    case c.kind
+    of attachedAsgn, attachedDup:
+      # nimAsgnYrc: save old env, atomic store new env, inc new env, dec old env
+      body.add callCodegenProc(c.g, "nimAsgnYrc", c.info, genAddr(c, xenv), yenv, nilDesc)
+      # Raw struct copy to also update the function pointer (env write is redundant but benign)
+      body.add newAsgnStmt(x, y)
+      return
+    of attachedSink:
+      body.add callCodegenProc(c.g, "nimSinkYrc", c.info, genAddr(c, xenv), yenv, nilDesc)
+      body.add newAsgnStmt(x, y)
+      return
+    else: discard # fall through for destructor, trace, wasMoved
+
+  let isCyclic = c.g.config.selectedGC in {gcOrc, gcYrc}
   let tmp =
     if isCyclic and c.kind in {attachedAsgn, attachedSink, attachedDup}:
       declareTempOf(c, body, xenv)
@@ -843,7 +907,6 @@ proc atomicClosureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
       body.add genIf(c, cond, actions)
     else:
       body.add genIf(c, yenv, callCodegenProc(c.g, "nimIncRef", c.info, yenv))
-
       body.add genIf(c, cond, actions)
       body.add newAsgnStmt(x, y)
   of attachedDup:
@@ -928,7 +991,7 @@ proc closureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     call[1] = y
     body.add newAsgnStmt(x, call)
   elif (optOwnedRefs in c.g.config.globalOptions and
-      optRefCheck in c.g.config.options) or c.g.config.selectedGC in {gcArc, gcAtomicArc, gcOrc}:
+      optRefCheck in c.g.config.options) or c.g.config.selectedGC in {gcArc, gcAtomicArc, gcOrc, gcYrc}:
     let xx = genBuiltin(c, mAccessEnv, "accessEnv", x)
     xx.typ = getSysType(c.g, c.info, tyPointer)
     case c.kind
@@ -983,7 +1046,7 @@ proc fillBody(c: var TLiftCtx; t: PType; body, x, y: PNode) =
       tyPtr, tyUncheckedArray, tyVar, tyLent:
     defaultOp(c, t, body, x, y)
   of tyRef:
-    if c.g.config.selectedGC in {gcArc, gcOrc, gcAtomicArc}:
+    if c.g.config.selectedGC in {gcArc, gcOrc, gcYrc, gcAtomicArc}:
       atomicRefOp(c, t, body, x, y)
     elif (optOwnedRefs in c.g.config.globalOptions and
         optRefCheck in c.g.config.options):
@@ -992,7 +1055,7 @@ proc fillBody(c: var TLiftCtx; t: PType; body, x, y: PNode) =
       defaultOp(c, t, body, x, y)
   of tyProc:
     if t.callConv == ccClosure:
-      if c.g.config.selectedGC in {gcArc, gcOrc, gcAtomicArc}:
+      if c.g.config.selectedGC in {gcArc, gcOrc, gcYrc, gcAtomicArc}:
         atomicClosureOp(c, t, body, x, y)
       else:
         closureOp(c, t, body, x, y)
@@ -1053,19 +1116,12 @@ proc fillBody(c: var TLiftCtx; t: PType; body, x, y: PNode) =
       elif tfUnion in t.flags: # bug #25236
         defaultOp(c, t, body, x, y)
       else:
-        if c.kind == attachedDup:
-          var op2 = getAttachedOp(c.g, t, attachedAsgn)
-          if op2 != nil and sfOverridden in op2.flags:
-            #markUsed(c.g.config, c.info, op, c.g.usageSym)
-            onUse(c.info, op2)
-            body.add newHookCall(c, t.assignment, x, y)
-          else:
-            fillBodyObjT(c, t, body, x, y)
-        else:
+        if not considerInferDupFromCopy(c, t, body, x, y):
           fillBodyObjT(c, t, body, x, y)
   of tyDistinct:
     if not considerUserDefinedOp(c, t, body, x, y):
-      fillBody(c, t.elementType, body, x, y)
+      if not considerInferDupFromCopy(c, t, body, x, y):
+        fillBody(c, t.elementType, body, x, y)
   of tyTuple:
     fillBodyTup(c, t, body, x, y)
   of tyVarargs, tyOpenArray:
@@ -1112,7 +1168,7 @@ proc symDupPrototype(g: ModuleGraph; typ: PType; owner: PSym; kind: TTypeAttache
 
   result.typ.addParam src
 
-  if g.config.selectedGC == gcOrc and
+  if g.config.selectedGC in {gcOrc, gcYrc} and
     cyclicType(g, typ.skipTypes(abstractInst)):
     let cycleParam = newSym(skParam, getIdent(g.cache, "cyclic"),
                             idgen, result, info)
@@ -1139,7 +1195,7 @@ proc symPrototype(g: ModuleGraph; typ: PType; owner: PSym; kind: TTypeAttachedOp
   let src = newSym(skParam, getIdent(g.cache, if kind == attachedTrace: "env" else: "src"),
                    idgen, result, info)
 
-  if kind == attachedDestructor and g.config.selectedGC in {gcArc, gcOrc, gcAtomicArc} and
+  if kind == attachedDestructor and g.config.selectedGC in {gcArc, gcOrc, gcYrc, gcAtomicArc} and
      ((g.config.isDefined("nimPreviewNonVarDestructor") and not isDiscriminant) or (typ.kind in {tyRef, tyString, tySequence})):
     dest.typ = typ
   else:
@@ -1155,7 +1211,7 @@ proc symPrototype(g: ModuleGraph; typ: PType; owner: PSym; kind: TTypeAttachedOp
   if kind notin {attachedDestructor, attachedWasMoved}:
     result.typ.addParam src
 
-  if kind == attachedAsgn and g.config.selectedGC == gcOrc and
+  if kind == attachedAsgn and g.config.selectedGC in {gcOrc, gcYrc} and
       cyclicType(g, typ.skipTypes(abstractInst)):
     let cycleParam = newSym(skParam, getIdent(g.cache, "cyclic"),
                             idgen, result, info)
@@ -1184,7 +1240,17 @@ proc genTypeFieldCopy(c: var TLiftCtx; t: PType; body, x, y: PNode) =
 proc produceSym(g: ModuleGraph; c: PContext; typ: PType; kind: TTypeAttachedOp;
               info: TLineInfo; idgen: IdGenerator): PSym =
   if typ.kind == tyDistinct:
-    return produceSymDistinctType(g, c, typ, kind, info, idgen)
+    # For =dup, if the distinct type has a user-defined =copy, don't delegate
+    # to the base type. Instead fall through to the normal produceSym logic
+    # so that fillBody -> considerInferDupFromCopy can synthesize =dup from =copy.
+    if kind == attachedDup:
+      let copyOp = getAttachedOp(g, typ, attachedAsgn)
+      if copyOp != nil and sfOverridden in copyOp.flags:
+        discard "fall through to normal produceSym logic"
+      else:
+        return produceSymDistinctType(g, c, typ, kind, info, idgen)
+    else:
+      return produceSymDistinctType(g, c, typ, kind, info, idgen)
 
   result = getAttachedOp(g, typ, kind)
   if result == nil:
@@ -1213,14 +1279,22 @@ proc produceSym(g: ModuleGraph; c: PContext; typ: PType; kind: TTypeAttachedOp;
   else:
     var tk: TTypeKind
     var skipped: PType = nil
-    if g.config.selectedGC in {gcArc, gcOrc, gcHooks, gcAtomicArc}:
+    if g.config.selectedGC in {gcArc, gcOrc, gcYrc, gcHooks, gcAtomicArc}:
       skipped = skipTypes(typ, {tyOrdinal, tyRange, tyInferred, tyGenericInst, tyStatic, tyAlias, tySink})
       tk = skipped.kind
     else:
       tk = tyNone # no special casing for strings and seqs
     case tk
     of tySequence:
+      let needsYrcLock = g.config.selectedGC == gcYrc and
+         kind in {attachedDestructor, attachedSink, attachedAsgn, attachedDeepCopy, attachedDup} and
+         types.canFormAcycle(g, skipped.elementType)
+      # YRC: topology-changing seq ops must hold the mutator (read) lock
+      if needsYrcLock:
+        result.ast[bodyPos].add callCodegenProc(g, "acquireMutatorLock", info)
       fillSeqOp(a, typ, result.ast[bodyPos], d, src)
+      if needsYrcLock:
+        result.ast[bodyPos].add callCodegenProc(g, "releaseMutatorLock", info)
     of tyString:
       fillStrOp(a, typ, result.ast[bodyPos], d, src)
     else:
@@ -1335,7 +1409,7 @@ proc createTypeBoundOps(g: ModuleGraph; c: PContext; orig: PType; info: TLineInf
 
   # we do not generate '=trace' procs if we
   # have the cycle detection disabled, saves code size.
-  let lastAttached = if g.config.selectedGC == gcOrc: attachedTrace
+  let lastAttached = if g.config.selectedGC in {gcOrc, gcYrc}: attachedTrace
                      else: attachedSink
 
   # bug #15122: We need to produce all prototypes before entering the

compiler/lineinfos.nim

@@ -93,10 +93,13 @@ type
     warnBareExcept = "BareExcept",
     warnImplicitDefaultValue = "ImplicitDefaultValue",
     warnIgnoredSymbolInjection = "IgnoredSymbolInjection",
-    warnStdPrefix = "StdPrefix"
-    warnUnknownNotes = "UnknownNotes"
+    warnStdPrefix = "StdPrefix",
+    warnUnknownNotes = "UnknownNotes",
+    warnLongLiterals = "LongLiterals",
     warnUser = "User",
     warnGlobalVarConstructorTemporary = "GlobalVarConstructorTemporary",
+    warnImplicitRangeConversion = "ImplicitRangeConversion",
+    warnSystemRangeConversion = "SystemRangeConversion",
     # hints
     hintSuccess = "Success", hintSuccessX = "SuccessX",
     hintCC = "CC",
@@ -202,8 +205,11 @@ const
     warnIgnoredSymbolInjection: "$1",
     warnStdPrefix: "$1 needs the 'std' prefix",
     warnUnknownNotes: "$1",
+    warnLongLiterals: "$1",
     warnUser: "$1",
     warnGlobalVarConstructorTemporary: "global variable '$1' initialization requires a temporary variable",
+    warnImplicitRangeConversion: "implicit range conversion $1",
+    warnSystemRangeConversion: "implicit range conversion $1",
     hintSuccess: "operation successful: $#",
     # keep in sync with `testament.isSuccess`
     hintSuccessX: "$build\n$loc lines; ${sec}s; $mem; proj: $project; out: $output",
@@ -258,7 +264,7 @@ type
 
 proc computeNotesVerbosity(): array[0..3, TNoteKinds] =
   result = default(array[0..3, TNoteKinds])
-  result[3] = {low(TNoteKind)..high(TNoteKind)} - {warnObservableStores, warnResultUsed, warnAnyEnumConv, warnBareExcept, warnStdPrefix}
+  result[3] = {low(TNoteKind)..high(TNoteKind)} - {warnObservableStores, warnResultUsed, warnAnyEnumConv, warnBareExcept, warnStdPrefix, warnSystemRangeConversion}
   result[2] = result[3] - {hintStackTrace, hintExtendedContext, hintDeclaredLoc, hintProcessingStmt}
   result[1] = result[2] - {warnProveField, warnProveIndex,
     warnGcUnsafe, hintPath, hintDependency, hintCodeBegin, hintCodeEnd,

compiler/linter.nim

@@ -95,7 +95,7 @@ proc nep1CheckDefImpl(conf: ConfigRef; info: TLineInfo; s: PSym; k: TSymKind) =
 template styleCheckDef*(ctx: PContext; info: TLineInfo; sym: PSym; k: TSymKind) =
   ## Check symbol definitions adhere to NEP1 style rules.
   if optStyleCheck in ctx.config.options and # ignore if styleChecks are off
-     {optStyleHint, optStyleError} * ctx.config.globalOptions != {} and # check only if hint/error is enabled
+     {optStyleHint, optStyleError, optStyleWarning} * ctx.config.globalOptions != {} and # check only if hint/error/warning is enabled
      hintName in ctx.config.notes and # ignore if name checks are not requested
      ctx.config.belongsToProjectPackageMaybeNil(getModule(ctx.graph, info.fileIndex)) and # ignore foreign packages
      optStyleUsages notin ctx.config.globalOptions and # ignore if requested to only check name usage
@@ -136,7 +136,7 @@ proc styleCheckUseImpl(conf: ConfigRef; info: TLineInfo; s: PSym) =
 
 template styleCheckUse*(ctx: PContext; info: TLineInfo; sym: PSym) =
   ## Check symbol uses match their definition's style.
-  if {optStyleHint, optStyleError} * ctx.config.globalOptions != {} and # ignore if styleChecks are off
+  if {optStyleHint, optStyleError, optStyleWarning} * ctx.config.globalOptions != {} and # ignore if styleChecks are off
      hintName in ctx.config.notes and # ignore if name checks are not requested
      ctx.config.belongsToProjectPackageMaybeNil(getModule(ctx.graph, info.fileIndex)) and # ignore foreign packages
      sym.kind != skTemp and # ignore temporary variables created by the compiler
@@ -152,7 +152,7 @@ proc checkPragmaUseImpl(conf: ConfigRef; info: TLineInfo; w: TSpecialWord; pragm
 template checkPragmaUse*(ctx: PContext; info: TLineInfo; w: TSpecialWord; pragmaName: string, sym: PSym) =
   ## Check builtin pragma uses match their definition's style.
   ## Note: This only applies to builtin pragmas, not user pragmas.
-  if {optStyleHint, optStyleError} * ctx.config.globalOptions != {} and # ignore if styleChecks are off
+  if {optStyleHint, optStyleError, optStyleWarning} * ctx.config.globalOptions != {} and # ignore if styleChecks are off
      hintName in ctx.config.notes and # ignore if name checks are not requested
      ctx.config.belongsToProjectPackageMaybeNil(getModule(ctx.graph, info.fileIndex)): # ignore foreign packages
     checkPragmaUseImpl(ctx.config, info, w, pragmaName)

compiler/lookups.nim

@@ -412,8 +412,6 @@ proc addDecl*(c: PContext, sym: PSym) {.inline.} =
 proc addPrelimDecl*(c: PContext, sym: PSym) =
   discard c.currentScope.addUniqueSym(sym)
 
-from ic / ic import addHidden
-
 proc addInterfaceDeclAux(c: PContext, sym: PSym) =
   ## adds symbol to the module for either private or public access.
   if sfExported in sym.flags:
@@ -422,8 +420,6 @@ proc addInterfaceDeclAux(c: PContext, sym: PSym) =
     else: internalError(c.config, sym.info, "addInterfaceDeclAux")
   elif sym.kind in ExportableSymKinds and c.module != nil and isTopLevelInsideDeclaration(c, sym):
     strTableAdd(semtabAll(c.graph, c.module), sym)
-    if c.config.symbolFiles != disabledSf:
-      addHidden(c.encoder, c.packedRepr, sym)
 
 proc addInterfaceDeclAt*(c: PContext, scope: PScope, sym: PSym) =
   ## adds a symbol on the scope and the interface if appropriate

compiler/main.nim

@@ -26,8 +26,6 @@ import
 when defined(nimPreviewSlimSystem):
   import std/[syncio, assertions]
 
-import ic / [cbackend, integrity, navigator, ic]
-
 import ../dist/checksums/src/checksums/sha1
 
 import pipelines
@@ -99,14 +97,6 @@ proc commandCheck(graph: ModuleGraph) =
   setPipeLinePass(graph, SemPass)
   compilePipelineProject(graph)
 
-  if conf.symbolFiles != disabledSf:
-    case conf.ideCmd
-    of ideDef: navDefinition(graph)
-    of ideUse: navUsages(graph)
-    of ideDus: navDefusages(graph)
-    else: discard
-    writeRodFiles(graph)
-
 when not defined(leanCompiler):
   proc commandDoc2(graph: ModuleGraph; ext: string) =
     handleDocOutputOptions graph.config
@@ -173,15 +163,7 @@ proc commandCompileToC(graph: ModuleGraph) =
   compilePipelineProject(graph)
   if graph.config.errorCounter > 0:
     return # issue #9933
-  if conf.symbolFiles == disabledSf:
-    cgenWriteModules(graph.backend, conf)
-  else:
-    if isDefined(conf, "nimIcIntegrityChecks"):
-      checkIntegrity(graph)
-    generateCode(graph)
-    # graph.backend can be nil under IC when nothing changed at all:
-    if graph.backend != nil:
-      cgenWriteModules(graph.backend, conf)
+  cgenWriteModules(graph.backend, conf)
   if conf.cmd != cmdTcc and graph.backend != nil:
     extccomp.callCCompiler(conf)
     # for now we do not support writing out a .json file with the build instructions when HCR is on
@@ -241,10 +223,6 @@ proc commandScan(cache: IdentCache, config: ConfigRef) =
   else:
     rawMessage(config, errGenerated, "cannot open file: " & f.string)
 
-proc commandView(graph: ModuleGraph) =
-  let f = toAbsolute(mainCommandArg(graph.config), AbsoluteDir getCurrentDir()).addFileExt(RodExt)
-  rodViewer(f, graph.config, graph.cache)
-
 const
   PrintRopeCacheStats = false
 
@@ -342,8 +320,6 @@ proc mainCommand*(graph: ModuleGraph) =
   case conf.cmd
   of cmdBackends:
     compileToBackend()
-    when BenchIC:
-      echoTimes graph.packed
   of cmdTcc:
     when hasTinyCBackend:
       extccomp.setCC(conf, "tcc", unknownLineInfo)
@@ -461,10 +437,6 @@ proc mainCommand*(graph: ModuleGraph) =
   of cmdParse:
     wantMainModule(conf)
     discard parseFile(conf.projectMainIdx, cache, conf)
-  of cmdRod:
-    wantMainModule(conf)
-    commandView(graph)
-    #msgWriteln(conf, "Beware: Indentation tokens depend on the parser's state!")
   of cmdInteractive: commandInteractive(graph)
   of cmdNimscript:
     if conf.projectIsCmd or conf.projectIsStdin: discard

compiler/modulegraphs.nim

@@ -14,7 +14,6 @@
 import std/[intsets, tables, hashes, strtabs, os, strutils, parseutils]
 import ../dist/checksums/src/checksums/md5
 import ast, astalgo, options, lineinfos,idents, btrees, ropes, msgs, pathutils, packages, suggestsymdb
-import ic / [packed_ast, ic]
 
 when not defined(nimKochBootstrap):
   import ast2nif
@@ -28,16 +27,12 @@ when defined(nimPreviewSlimSystem):
 type
   SigHash* = distinct MD5Digest
 
-  LazySym* = object
-    id*: FullId
-    sym*: PSym
-
   Iface* = object       ## data we don't want to store directly in the
                         ## ast.PSym type for s.kind == skModule
     module*: PSym       ## module this "Iface" belongs to
-    converters*: seq[LazySym]
-    patterns*: seq[LazySym]
-    pureEnums*: seq[LazySym]
+    converters*: seq[PSym]
+    patterns*: seq[PSym]
+    pureEnums*: seq[PSym]
     interf: TStrTable
     interfHidden: TStrTable
     uniqueName*: Rope
@@ -46,20 +41,6 @@ type
     opNot*, opContains*, opLe*, opLt*, opAnd*, opOr*, opIsNil*, opEq*: PSym
     opAdd*, opSub*, opMul*, opDiv*, opLen*: PSym
 
-  FullId* = object
-    module*: int
-    packed*: PackedItemId
-
-  LazyType* = object
-    id*: FullId
-    typ*: PType
-
-  LazyInstantiation* = object
-    module*: int
-    sym*: FullId
-    concreteTypes*: seq[FullId]
-    inst*: PInstantiation
-
   PipelinePass* = enum
     NonePass
     SemPass
@@ -75,21 +56,18 @@ type
 
   ModuleGraph* {.acyclic.} = ref object
     ifaces*: seq[Iface]  ## indexed by int32 fileIdx
-    packed*: PackedModuleGraph
-    encoders*: seq[PackedEncoder]
 
-    typeInstCache*: Table[ItemId, seq[LazyType]] # A symbol's ItemId.
-    procInstCache*: Table[ItemId, seq[LazyInstantiation]] # A symbol's ItemId.
-    attachedOps*: array[TTypeAttachedOp, Table[ItemId, LazySym]] # Type ID, destructors, etc.
+    typeInstCache*: Table[ItemId, seq[PType]] # A symbol's ItemId.
+    procInstCache*: Table[ItemId, seq[PInstantiation]] # A symbol's ItemId.
+    attachedOps*: array[TTypeAttachedOp, Table[ItemId, PSym]] # Type ID, destructors, etc.
     loadedOps: array[TTypeAttachedOp, Table[string, PSym]] # This can later by unified with `attachedOps` once it's stable
     opsLog*: seq[LogEntry]
-    methodsPerGenericType*: Table[ItemId, seq[(int, LazySym)]] # Type ID, attached methods
+    methodsPerGenericType*: Table[ItemId, seq[(int, PSym)]] # Type ID, attached methods
     memberProcsPerType*: Table[ItemId, seq[PSym]] # Type ID, attached member procs (only c++, virtual,member and ctor so far).
     initializersPerType*: Table[ItemId, PNode] # Type ID, AST call to the default ctor (c++ only)
-    enumToStringProcs*: Table[ItemId, LazySym]
+    enumToStringProcs*: Table[ItemId, PSym]
     emittedTypeInfo*: Table[string, FileIndex]
 
-    startupPackedConfig*: PackedConfig
     packageSyms*: TStrTable
     deps*: IntSet # the dependency graph or potentially its transitive closure.
     importDeps*: Table[FileIndex, seq[FileIndex]] # explicit import module dependencies
@@ -115,8 +93,8 @@ type
     methods*: seq[tuple[methods: seq[PSym], dispatcher: PSym]] # needs serialization!
     bucketTable*: CountTable[ItemId]
     objectTree*: Table[ItemId, seq[tuple[depth: int, value: PType]]]
-    methodsPerType*: Table[ItemId, seq[LazySym]]
-    dispatchers*: seq[LazySym]
+    methodsPerType*: Table[ItemId, seq[PSym]]
+    dispatchers*: seq[PSym]
 
     systemModule*: PSym
     sysTypes*: array[TTypeKind, PType]
@@ -146,6 +124,7 @@ type
 
     procGlobals*: seq[PNode]
     nifReplayActions*: Table[int32, seq[PNode]]  # module position -> replay actions for NIF
+    cachedMods: IntSet
 
   TPassContext* = object of RootObj # the pass's context
     idgen*: IdGenerator
@@ -228,85 +207,43 @@ proc strTableAdds*(g: ModuleGraph, m: PSym, s: PSym) =
   strTableAdd(semtabAll(g, m), s)
 
 proc isCachedModule(g: ModuleGraph; module: int): bool {.inline.} =
-  result = module < g.packed.len and g.packed[module].status == loaded
+  result = module in g.cachedMods
 
 proc isCachedModule*(g: ModuleGraph; m: PSym): bool {.inline.} =
   isCachedModule(g, m.position)
 
-proc simulateCachedModule(g: ModuleGraph; moduleSym: PSym; m: PackedModule) =
-  when false:
-    echo "simulating ", moduleSym.name.s, " ", moduleSym.position
-  simulateLoadedModule(g.packed, g.config, g.cache, moduleSym, m)
-
-proc initEncoder*(g: ModuleGraph; module: PSym) =
-  let id = module.position
-  if id >= g.encoders.len:
-    setLen g.encoders, id+1
-  ic.initEncoder(g.encoders[id],
-    g.packed[id].fromDisk, module, g.config, g.startupPackedConfig)
-
 type
   ModuleIter* = object
-    fromRod: bool
     modIndex: int
     ti: TIdentIter
-    rodIt: RodIter
     importHidden: bool
 
 proc initModuleIter*(mi: var ModuleIter; g: ModuleGraph; m: PSym; name: PIdent): PSym =
   assert m.kind == skModule
   mi.modIndex = m.position
-  mi.fromRod = isCachedModule(g, mi.modIndex)
   mi.importHidden = optImportHidden in m.options
-  if mi.fromRod:
-    result = initRodIter(mi.rodIt, g.config, g.cache, g.packed, FileIndex mi.modIndex, name, mi.importHidden)
-  else:
-    result = initIdentIter(mi.ti, g.ifaces[mi.modIndex].interfSelect(mi.importHidden), name)
+  result = initIdentIter(mi.ti, g.ifaces[mi.modIndex].interfSelect(mi.importHidden), name)
 
 proc nextModuleIter*(mi: var ModuleIter; g: ModuleGraph): PSym =
-  if mi.fromRod:
-    result = nextRodIter(mi.rodIt, g.packed)
-  else:
-    result = nextIdentIter(mi.ti, g.ifaces[mi.modIndex].interfSelect(mi.importHidden))
+  result = nextIdentIter(mi.ti, g.ifaces[mi.modIndex].interfSelect(mi.importHidden))
 
 iterator allSyms*(g: ModuleGraph; m: PSym): PSym =
   let importHidden = optImportHidden in m.options
-  if isCachedModule(g, m):
-    var rodIt: RodIter = default(RodIter)
-    var r = initRodIterAllSyms(rodIt, g.config, g.cache, g.packed, FileIndex m.position, importHidden)
-    while r != nil:
-      yield r
-      r = nextRodIter(rodIt, g.packed)
-  else:
-    for s in g.ifaces[m.position].interfSelect(importHidden).data:
-      if s != nil:
-        yield s
+  for s in g.ifaces[m.position].interfSelect(importHidden).data:
+    if s != nil:
+      yield s
 
 proc someSym*(g: ModuleGraph; m: PSym; name: PIdent): PSym =
   let importHidden = optImportHidden in m.options
-  if isCachedModule(g, m):
-    result = interfaceSymbol(g.config, g.cache, g.packed, FileIndex(m.position), name, importHidden)
-  else:
-    result = strTableGet(g.ifaces[m.position].interfSelect(importHidden), name)
+  result = strTableGet(g.ifaces[m.position].interfSelect(importHidden), name)
 
 proc someSymAmb*(g: ModuleGraph; m: PSym; name: PIdent; amb: var bool): PSym =
   let importHidden = optImportHidden in m.options
-  if isCachedModule(g, m):
-    result = nil
-    for s in interfaceSymbols(g.config, g.cache, g.packed, FileIndex(m.position), name, importHidden):
-      if result == nil:
-        # set result to the first symbol
-        result = s
-      else:
-        # another symbol found
-        amb = true
-        break
-  else:
-    var ti: TIdentIter = default(TIdentIter)
-    result = initIdentIter(ti, g.ifaces[m.position].interfSelect(importHidden), name)
-    if result != nil and nextIdentIter(ti, g.ifaces[m.position].interfSelect(importHidden)) != nil:
-      # another symbol exists with same name
-      amb = true
+  var ti: TIdentIter = default(TIdentIter)
+  result = initIdentIter(ti, g.ifaces[m.position].interfSelect(importHidden), name)
+  if result != nil and nextIdentIter(ti, g.ifaces[m.position].interfSelect(importHidden)) != nil:
+    # another symbol exists with same name
+    amb = true
 
 proc systemModuleSym*(g: ModuleGraph; name: PIdent): PSym =
   result = someSym(g, g.systemModule, name)
@@ -318,56 +255,24 @@ iterator systemModuleSyms*(g: ModuleGraph; name: PIdent): PSym =
     yield r
     r = nextModuleIter(mi, g)
 
-proc resolveType(g: ModuleGraph; t: var LazyType): PType =
-  result = t.typ
-  if result == nil and isCachedModule(g, t.id.module):
-    result = loadTypeFromId(g.config, g.cache, g.packed, t.id.module, t.id.packed)
-    t.typ = result
-  assert result != nil
-
-proc resolveSym(g: ModuleGraph; t: var LazySym): PSym =
-  result = t.sym
-  if result == nil and isCachedModule(g, t.id.module):
-    result = loadSymFromId(g.config, g.cache, g.packed, t.id.module, t.id.packed)
-    t.sym = result
-  assert result != nil
-
-proc resolveInst(g: ModuleGraph; t: var LazyInstantiation): PInstantiation =
-  result = t.inst
-  if result == nil and isCachedModule(g, t.module):
-    result = PInstantiation(sym: loadSymFromId(g.config, g.cache, g.packed, t.sym.module, t.sym.packed))
-    result.concreteTypes = newSeq[PType](t.concreteTypes.len)
-    for i in 0..high(result.concreteTypes):
-      result.concreteTypes[i] = loadTypeFromId(g.config, g.cache, g.packed,
-          t.concreteTypes[i].module, t.concreteTypes[i].packed)
-    t.inst = result
-  assert result != nil
-
-proc resolveAttachedOp*(g: ModuleGraph; t: var LazySym): PSym =
-  result = t.sym
-  if result == nil:
-    result = loadSymFromId(g.config, g.cache, g.packed, t.id.module, t.id.packed)
-    t.sym = result
-  assert result != nil
-
 iterator typeInstCacheItems*(g: ModuleGraph; s: PSym): PType =
   if g.typeInstCache.contains(s.itemId):
     let x = addr(g.typeInstCache[s.itemId])
     for t in mitems(x[]):
-      yield resolveType(g, t)
+      yield t
 
 iterator procInstCacheItems*(g: ModuleGraph; s: PSym): PInstantiation =
   if g.procInstCache.contains(s.itemId):
     let x = addr(g.procInstCache[s.itemId])
     for t in mitems(x[]):
-      yield resolveInst(g, t)
+      yield t
 
 
 proc getAttachedOp*(g: ModuleGraph; t: PType; op: TTypeAttachedOp): PSym =
   ## returns the requested attached operation for type `t`. Can return nil
   ## if no such operation exists.
   if g.attachedOps[op].contains(t.itemId):
-    result = resolveAttachedOp(g, g.attachedOps[op][t.itemId])
+    result = g.attachedOps[op][t.itemId]
   elif g.config.cmd in {cmdNifC, cmdM}:
     # Fall back to key-based lookup for NIF-loaded hooks
     let key = typeKey(t, g.config, loadTypeCallback, loadSymCallback)
@@ -388,36 +293,32 @@ proc setAttachedOp*(g: ModuleGraph; module: int; t: PType; op: TTypeAttachedOp;
       let ownerModule = if t.sym != nil: t.sym.itemId.module.int else: module
       g.opsLog.add LogEntry(kind: HookEntry, op: op, module: ownerModule, key: key, sym: value)
       g.loadedOps[op][key] = value
-  g.attachedOps[op][t.itemId] = LazySym(sym: value)
+  g.attachedOps[op][t.itemId] = value
 
 proc setAttachedOp*(g: ModuleGraph; module: int; typeId: ItemId; op: TTypeAttachedOp; value: PSym) =
   ## Overload that takes ItemId directly, useful for registering hooks from NIF index.
-  g.attachedOps[op][typeId] = LazySym(sym: value)
+  g.attachedOps[op][typeId] = value
 
 proc setAttachedOpPartial*(g: ModuleGraph; module: int; t: PType; op: TTypeAttachedOp; value: PSym) =
   ## we also need to record this to the packed module.
-  g.attachedOps[op][t.itemId] = LazySym(sym: value)
+  g.attachedOps[op][t.itemId] = value
 
-proc completePartialOp*(g: ModuleGraph; module: int; t: PType; op: TTypeAttachedOp; value: PSym) =
-  if g.config.symbolFiles != disabledSf:
-    assert module < g.encoders.len
-    assert isActive(g.encoders[module])
-    toPackedGeneratedProcDef(value, g.encoders[module], g.packed[module].fromDisk)
-    #storeAttachedProcDef(t, op, value, g.encoders[module], g.packed[module].fromDisk)
+proc completePartialOp*(g: ModuleGraph; module: int; t: PType; op: TTypeAttachedOp; value: PSym) {.inline.} =
+  discard
 
 iterator getDispatchers*(g: ModuleGraph): PSym =
   for i in g.dispatchers.mitems:
-    yield resolveSym(g, i)
+    yield i
 
 proc addDispatchers*(g: ModuleGraph, value: PSym) =
   # TODO: add it for packed modules
-  g.dispatchers.add LazySym(sym: value)
+  g.dispatchers.add value
 
-iterator resolveLazySymSeq(g: ModuleGraph, list: var seq[LazySym]): PSym =
+iterator resolveLazySymSeq(g: ModuleGraph, list: var seq[PSym]): PSym =
   for it in list.mitems:
-    yield resolveSym(g, it)
+    yield it
 
-proc setMethodsPerType*(g: ModuleGraph; id: ItemId, methods: seq[LazySym]) =
+proc setMethodsPerType*(g: ModuleGraph; id: ItemId, methods: seq[PSym]) =
   # TODO: add it for packed modules
   g.methodsPerType[id] = methods
 
@@ -428,14 +329,14 @@ proc addNifReplayAction*(g: ModuleGraph; module: int32; n: PNode) =
 iterator getMethodsPerType*(g: ModuleGraph; t: PType): PSym =
   if g.methodsPerType.contains(t.itemId):
     for it in mitems g.methodsPerType[t.itemId]:
-      yield resolveSym(g, it)
+      yield it
 
 proc getToStringProc*(g: ModuleGraph; t: PType): PSym =
-  result = resolveSym(g, g.enumToStringProcs[t.itemId])
+  result = g.enumToStringProcs[t.itemId]
   assert result != nil
 
 proc setToStringProc*(g: ModuleGraph; t: PType; value: PSym) =
-  g.enumToStringProcs[t.itemId] = LazySym(sym: value)
+  g.enumToStringProcs[t.itemId] = value
   let key = typeKey(t, g.config, loadTypeCallback, loadSymCallback)
   let ownerModule = if t.sym != nil: t.sym.itemId.module.int else: value.itemId.module.int
   g.opsLog.add LogEntry(kind: EnumToStrEntry, module: ownerModule, key: key, sym: value)
@@ -443,10 +344,10 @@ proc setToStringProc*(g: ModuleGraph; t: PType; value: PSym) =
 iterator methodsForGeneric*(g: ModuleGraph; t: PType): (int, PSym) =
   if g.methodsPerGenericType.contains(t.itemId):
     for it in mitems g.methodsPerGenericType[t.itemId]:
-      yield (it[0], resolveSym(g, it[1]))
+      yield (it[0], it[1])
 
 proc addMethodToGeneric*(g: ModuleGraph; module: int; t: PType; col: int; m: PSym) =
-  g.methodsPerGenericType.mgetOrPut(t.itemId, @[]).add (col, LazySym(sym: m))
+  g.methodsPerGenericType.mgetOrPut(t.itemId, @[]).add (col, m)
   let key = typeKey(t, g.config, loadTypeCallback, loadSymCallback)
   let ownerModule = if t.sym != nil: t.sym.itemId.module.int else: module
   g.opsLog.add LogEntry(kind: MethodEntry, module: ownerModule, key: key, sym: m)
@@ -474,11 +375,12 @@ proc loadCompilerProc*(g: ModuleGraph; name: string): PSym =
   if g.config.symbolFiles == disabledSf and optWithinConfigSystem notin g.config.globalOptions:
     # For NIF-based compilation, search in loaded NIF modules
     when not defined(nimKochBootstrap):
-      # Only try to resolve from NIF if we're actually using NIF files (cmdNifC)
-      if g.config.cmd == cmdNifC:
+      # Try to resolve from NIF for both cmdNifC and cmdM (which uses NIF files)
+      if g.config.cmd in {cmdNifC, cmdM}:
         # First try system module (most compilerprocs are there)
         let systemFileIdx = g.config.m.systemFileIdx
-        if systemFileIdx != InvalidFileIdx:
+        if systemFileIdx != InvalidFileIdx and not g.withinSystem:
+          # Only try to load from NIF if the file exists (it may not during initial ic build)
           result = tryResolveCompilerProc(ast.program, name, systemFileIdx)
           if result != nil:
             strTableAdd(g.compilerprocs, result)
@@ -496,20 +398,6 @@ proc loadCompilerProc*(g: ModuleGraph; name: string): PSym =
               return result
     return nil
 
-  # slow, linear search, but the results are cached:
-  for module in 0..<len(g.packed):
-    #if isCachedModule(g, module):
-    let x = searchForCompilerproc(g.packed[module], name)
-    if x >= 0:
-      result = loadSymFromId(g.config, g.cache, g.packed, module, toPackedItemId(x))
-      if result != nil:
-        strTableAdd(g.compilerprocs, result)
-      return result
-
-proc loadPackedSym*(g: ModuleGraph; s: var LazySym) =
-  if s.sym == nil:
-    s.sym = loadSymFromId(g.config, g.cache, g.packed, s.id.module, s.id.packed)
-
 proc `$`*(u: SigHash): string =
   toBase64a(cast[cstring](unsafeAddr u), sizeof(u))
 
@@ -596,16 +484,13 @@ proc registerModule*(g: ModuleGraph; m: PSym) =
   if m.position >= g.ifaces.len:
     setLen(g.ifaces, m.position + 1)
 
-  if m.position >= g.packed.len:
-    setLen(g.packed.pm, m.position + 1)
-
   if g.ifaces[m.position].module == nil:
     g.ifaces[m.position] = Iface(module: m, converters: @[], patterns: @[],
                                 uniqueName: rope(uniqueModuleName(g.config, m)))
     initStrTables(g, m)
 
 proc registerModuleById*(g: ModuleGraph; m: FileIndex) =
-  registerModule(g, g.packed[int m].module)
+  registerModule(g, g.ifaces[int m].module)
 
 proc initOperators*(g: ModuleGraph): Operators =
   # These are safe for IC.
@@ -652,6 +537,7 @@ proc initModuleGraphFields(result: ModuleGraph) =
   result.operators = initOperators(result)
   result.emittedTypeInfo = initTable[string, FileIndex]()
   result.cachedFiles = newStringTable()
+  result.cachedMods = initIntSet()
 
 proc newModuleGraph*(cache: IdentCache; config: ConfigRef): ModuleGraph =
   result = ModuleGraph()
@@ -674,49 +560,13 @@ proc resetAllModules*(g: ModuleGraph) =
   initModuleGraphFields(g)
 
 proc getModule*(g: ModuleGraph; fileIdx: FileIndex): PSym =
-  result = nil
-  if fileIdx.int32 >= 0:
-    if isCachedModule(g, fileIdx.int32):
-      result = g.packed[fileIdx.int32].module
-    elif fileIdx.int32 < g.ifaces.len:
-      result = g.ifaces[fileIdx.int32].module
+  if fileIdx.int32 >= 0 and fileIdx.int32 < g.ifaces.len:
+    result = g.ifaces[fileIdx.int32].module
+  else:
+    result = nil
 
 proc moduleOpenForCodegen*(g: ModuleGraph; m: FileIndex): bool {.inline.} =
-  if g.config.symbolFiles == disabledSf:
-    result = true
-  else:
-    result = g.packed[m.int32].status notin {undefined, stored, loaded}
-
-proc rememberEmittedTypeInfo*(g: ModuleGraph; m: FileIndex; ti: string) =
-  #assert(not isCachedModule(g, m.int32))
-  if g.config.symbolFiles != disabledSf:
-    #assert g.encoders[m.int32].isActive
-    assert g.packed[m.int32].status != stored
-    g.packed[m.int32].fromDisk.emittedTypeInfo.add ti
-    #echo "added typeinfo ", m.int32, " ", ti, " suspicious ", not g.encoders[m.int32].isActive
-
-proc rememberFlag*(g: ModuleGraph; m: PSym; flag: ModuleBackendFlag) =
-  if g.config.symbolFiles != disabledSf:
-    #assert g.encoders[m.int32].isActive
-    assert g.packed[m.position].status != stored
-    g.packed[m.position].fromDisk.backendFlags.incl flag
-
-proc closeRodFile*(g: ModuleGraph; m: PSym) =
-  if g.config.symbolFiles in {readOnlySf, v2Sf}:
-    # For stress testing we seek to reload the symbols from memory. This
-    # way much of the logic is tested but the test is reproducible as it does
-    # not depend on the hard disk contents!
-    let mint = m.position
-    saveRodFile(toRodFile(g.config, AbsoluteFile toFullPath(g.config, FileIndex(mint))),
-                g.encoders[mint], g.packed[mint].fromDisk)
-    g.packed[mint].status = stored
-
-  elif g.config.symbolFiles == stressTest:
-    # debug code, but maybe a good idea for production? Could reduce the compiler's
-    # memory consumption considerably at the cost of more loads from disk.
-    let mint = m.position
-    simulateCachedModule(g, m, g.packed[mint].fromDisk)
-    g.packed[mint].status = loaded
+  result = true
 
 proc dependsOn(a, b: int): int {.inline.} = (a shl 15) + b
 
@@ -800,19 +650,8 @@ proc needsCompilation*(g: ModuleGraph, fileIdx: FileIndex): bool =
 
 proc getBody*(g: ModuleGraph; s: PSym): PNode {.inline.} =
   result = s.ast[bodyPos]
-  if result == nil and g.config.symbolFiles in {readOnlySf, v2Sf, stressTest}:
-    result = loadProcBody(g.config, g.cache, g.packed, s)
-    s.ast[bodyPos] = result
   assert result != nil
 
-proc moduleFromRodFile*(g: ModuleGraph; fileIdx: FileIndex;
-                        cachedModules: var seq[FileIndex]): PSym =
-  ## Returns 'nil' if the module needs to be recompiled.
-  if g.config.symbolFiles in {readOnlySf, v2Sf, stressTest}:
-    result = moduleFromRodFile(g.packed, g.config, g.cache, fileIdx, cachedModules)
-  else:
-    result = nil
-
 when not defined(nimKochBootstrap):
   proc moduleFromNifFile*(g: ModuleGraph; fileIdx: FileIndex;
                           flags: set[LoadFlag] = {}): PrecompiledModule =
@@ -840,13 +679,16 @@ when not defined(nimKochBootstrap):
                            g.ifaces[fileIdx.int].interfHidden, flags)
     result.module = m
 
+    # Mark module as cached
+    g.cachedMods.incl fileIdx.int
+
     # Register hooks from NIF index with the module graph
     for x in result.logOps:
       case x.kind
       of HookEntry:
         g.loadedOps[x.op][x.key] = x.sym
       of ConverterEntry:
-        g.ifaces[fileIdx.int].converters.add LazySym(sym: x.sym)
+        g.ifaces[fileIdx.int].converters.add x.sym
       of MethodEntry:
         discard "todo"
       of EnumToStrEntry:
@@ -857,9 +699,10 @@ when not defined(nimKochBootstrap):
     discard "todo"
 
 proc configComplete*(g: ModuleGraph) =
-  rememberStartupConfig(g.startupPackedConfig, g.config)
+  #rememberStartupConfig(g.startupPackedConfig, g.config)
+  discard
 
-proc onProcessing*(graph: ModuleGraph, fileIdx: FileIndex, moduleStatus: string, fromModule: PSym, ) =
+proc onProcessing*(graph: ModuleGraph, fileIdx: FileIndex, moduleStatus: string, fromModule: PSym) =
   let conf = graph.config
   let isNimscript = conf.isDefined("nimscript")
   if (not isNimscript) or hintProcessing in conf.cmdlineNotes:

compiler/modulepaths.nim

@@ -109,9 +109,11 @@ proc mangleModuleName*(conf: ConfigRef; path: AbsoluteFile): string =
     of FromSearchPath: "@p"
     of FromNimblePath: "@n"
 
+  # Note: We encode ".." specially as "@d" to avoid issues with changeFileExt
+  # which would misinterpret ".." as "name.ext" and strip the second part.
   prefix & best.multiReplace(
-    {$os.DirSep: "@s", $os.AltSep: "@s", "#": "@h", "@": "@@", ":": "@c"})
+    {"..": "@d", $os.DirSep: "@s", $os.AltSep: "@s", "#": "@h", "@": "@@", ":": "@c"})
 
 proc demangleModuleName*(path: string): string =
   ## Demangle a relative module path.
-  result = path.multiReplace({"@@": "@", "@h": "#", "@s": "/", "@m": "", "@p": "", "@n": "", "@c": ":"})
+  result = path.multiReplace({"@@": "@", "@d": "..", "@h": "#", "@s": "/", "@m": "", "@p": "", "@n": "", "@c": ":"})

compiler/msgs.nim

@@ -240,7 +240,7 @@ proc setDirtyFile*(conf: ConfigRef; fileIdx: FileIndex; filename: AbsoluteFile)
 
 proc setHash*(conf: ConfigRef; fileIdx: FileIndex; hash: string) =
   assert fileIdx.int32 >= 0
-  when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc):
+  when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc) or defined(gcYrc):
     conf.m.fileInfos[fileIdx.int32].hash = hash
   else:
     shallowCopy(conf.m.fileInfos[fileIdx.int32].hash, hash)
@@ -248,7 +248,7 @@ proc setHash*(conf: ConfigRef; fileIdx: FileIndex; hash: string) =
 
 proc getHash*(conf: ConfigRef; fileIdx: FileIndex): string =
   assert fileIdx.int32 >= 0
-  when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc):
+  when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc) or defined(gcYrc):
     result = conf.m.fileInfos[fileIdx.int32].hash
   else:
     shallowCopy(result, conf.m.fileInfos[fileIdx.int32].hash)
@@ -664,7 +664,9 @@ template internalAssert*(conf: ConfigRef, e: bool) =
 
 template lintReport*(conf: ConfigRef; info: TLineInfo, beau, got: string, extraMsg = "") =
   let m = "'$1' should be: '$2'$3" % [got, beau, extraMsg]
-  let msg = if optStyleError in conf.globalOptions: errGenerated else: hintName
+  let msg = if optStyleError in conf.globalOptions: errGenerated
+            elif optStyleWarning in conf.globalOptions: warnUser
+            else: hintName
   liMessage(conf, info, msg, m, doNothing, instLoc())
 
 proc quotedFilename*(conf: ConfigRef; fi: FileIndex): Rope =

compiler/nifgen.nim

@@ -983,7 +983,7 @@ proc genericParamToNif(n: PNode; parent: PNode; c: var TranslationContext) =
     toNif n, parent, c
 
 proc addExternName(sym: PSym; c: var TranslationContext) =
-  if sym.loc.snippet != nil:
+  if sym.loc.snippet != "":
     c.b.addStrLit sym.loc.snippet
   else:
     c.b.addStrLit sym.name.s

compiler/nim.cfg

@@ -65,3 +65,7 @@ define:useStdoutAsStdmsg
 @if nimHasVtables:
   experimental:vtables
 @end
+
+@if nimHasImplicitRangeConversion:
+  warning[ImplicitRangeConversion]:off
+@end

compiler/options.nim

@@ -68,6 +68,7 @@ type                          # please make sure we have under 32 options
     optUseNimcache,           # save artifacts (including binary) in $nimcache
     optStyleHint,             # check that the names adhere to NEP-1
     optStyleError,            # enforce that the names adhere to NEP-1
+    optStyleWarning,          # emit style checks as warnings
     optStyleUsages,           # only enforce consistent **usages** of the symbol
     optSkipSystemConfigFile,  # skip the system's cfg/nims config file
     optSkipProjConfigFile,    # skip the project's cfg/nims config file
@@ -110,6 +111,7 @@ type                          # please make sure we have under 32 options
     optEnableDeepCopy         # ORC specific: enable 'deepcopy' for all types.
     optShowNonExportedFields  # for documentation: show fields that are not exported
     optJsBigInt64             # use bigints for 64-bit integers in JS
+    optDocRaw                 # for documentation: Don't render markdown for JSON output
     optItaniumMangle          # mangling follows the Itanium spec
     optCompress               # turn on AST compression by converting it to NIF
     optWithinConfigSystem     # we still compile within the configuration system
@@ -155,7 +157,6 @@ type
     cmdCheck # semantic checking for whole project
     cmdM     # only compile a single
     cmdParse # parse a single file (for debugging)
-    cmdRod # .rod to some text representation (for debugging)
     cmdIdeTools # ide tools (e.g. nimsuggest)
     cmdNimscript # evaluate nimscript
     cmdDoc0
@@ -194,6 +195,7 @@ type
     gcRegions = "regions"
     gcArc = "arc"
     gcOrc = "orc"
+    gcYrc = "yrc"       # thread-safe ORC (concurrent cycle collector)
     gcAtomicArc = "atomicArc"
     gcMarkAndSweep = "markAndSweep"
     gcHooks = "hooks"
@@ -1046,6 +1048,9 @@ proc isDynlibOverride*(conf: ConfigRef; lib: string): bool =
 proc showNonExportedFields*(conf: ConfigRef) =
   incl(conf.globalOptions, optShowNonExportedFields)
 
+proc docRawOutput*(conf: ConfigRef) =
+  incl(conf.globalOptions, optDocRaw)
+
 proc expandDone*(conf: ConfigRef): bool =
   result = conf.ideCmd == ideExpand and conf.expandLevels == 0 and conf.expandProgress
 

compiler/passes.nim

@@ -148,11 +148,6 @@ proc processModule*(graph: ModuleGraph; module: PSym; idgen: IdGenerator;
     closeParser(p)
     if s.kind != llsStdIn: break
   closePasses(graph, a)
-  if graph.config.backend notin {backendC, backendCpp, backendObjc}:
-    # We only write rod files here if no C-like backend is active.
-    # The C-like backends have been patched to support the IC mechanism.
-    # They are responsible for closing the rod files. See `cbackend.nim`.
-    closeRodFile(graph, module)
   result = true
 
 proc compileModule*(graph: ModuleGraph; fileIdx: FileIndex; flags: TSymFlags, fromModule: PSym = nil): PSym =
@@ -168,22 +163,10 @@ proc compileModule*(graph: ModuleGraph; fileIdx: FileIndex; flags: TSymFlags, fr
       elif graph.config.projectIsCmd: s = llStreamOpen(graph.config.cmdInput)
     discard processModule(graph, result, idGeneratorFromModule(result), s)
   if result == nil:
-    var cachedModules: seq[FileIndex] = @[]
-    result = moduleFromRodFile(graph, fileIdx, cachedModules)
-    let filename = AbsoluteFile toFullPath(graph.config, fileIdx)
-    if result == nil:
-      result = newModule(graph, fileIdx)
-      result.incl flags
-      registerModule(graph, result)
-      processModuleAux("import")
-    else:
-      if sfSystemModule in flags:
-        graph.systemModule = result
-      partialInitModule(result, graph, fileIdx, filename)
-    for m in cachedModules:
-      registerModuleById(graph, m)
-      replayStateChanges(graph.packed.pm[m.int].module, graph)
-      replayGenericCacheInformation(graph, m.int)
+    result = newModule(graph, fileIdx)
+    result.incl flags
+    registerModule(graph, result)
+    processModuleAux("import")
   elif graph.isDirty(result):
     result.excl sfDirty
     # reset module fields:

compiler/pipelines.nim

@@ -242,8 +242,11 @@ proc processPipelineModule*(graph: ModuleGraph; module: PSym; idgen: IdGenerator
     raiseAssert "use setPipeLinePass to set a proper PipelinePass"
 
   when not defined(nimKochBootstrap):
-    if (optCompress in graph.config.globalOptions or graph.config.cmd == cmdM) and
-       not graph.config.isDefined("nimscript"):
+    # For cmdM: only write NIF for the main module, not for imported modules
+    # (imported modules should be loaded from existing NIF files)
+    let shouldWriteNif = (optCompress in graph.config.globalOptions) or
+                         (graph.config.cmd == cmdM and sfMainModule in module.flags)
+    if shouldWriteNif and not graph.config.isDefined("nimscript"):
       topLevelStmts.add finalNode
       # Collect replay actions from both pragma computations and VM state diff
       var replayActions: seq[PNode] = @[]
@@ -258,12 +261,6 @@ proc processPipelineModule*(graph: ModuleGraph; module: PSym; idgen: IdGenerator
 
       writeNifModule(graph.config, module.position.int32, topLevelStmts, graph.opsLog, replayActions)
 
-  if graph.config.backend notin {backendC, backendCpp, backendObjc} and graph.config.cmd != cmdM:
-    # We only write rod files here if no C-like backend is active.
-    # The C-like backends have been patched to support the IC mechanism.
-    # They are responsible for closing the rod files. See `cbackend.nim`.
-    # cmdM uses NIF files only, not ROD files.
-    closeRodFile(graph, module)
   result = true
 
 proc compilePipelineModule*(graph: ModuleGraph; fileIdx: FileIndex; flags: TSymFlags; fromModule: PSym = nil): PSym =
@@ -279,7 +276,6 @@ proc compilePipelineModule*(graph: ModuleGraph; fileIdx: FileIndex; flags: TSymF
       elif graph.config.projectIsCmd: s = llStreamOpen(graph.config.cmdInput)
     discard processPipelineModule(graph, result, idGeneratorFromModule(result), s)
   if result == nil:
-    var cachedModules: seq[FileIndex] = @[]
     when not defined(nimKochBootstrap):
       # For cmdM: load imports from NIF files (but compile the main module from source)
       # Skip when withinSystem is true (compiling system.nim itself)
@@ -290,13 +286,20 @@ proc compilePipelineModule*(graph: ModuleGraph; fileIdx: FileIndex; flags: TSymF
         let precomp = moduleFromNifFile(graph, fileIdx)
         if precomp.module == nil:
           let nifPath = toNifFilename(graph.config, fileIdx)
-          localError(graph.config, unknownLineInfo,
+          globalError(graph.config, unknownLineInfo,
             "nim m requires precompiled NIF for import: " & toFullPath(graph.config, fileIdx) &
             " (expected: " & nifPath & ")")
           return nil  # Don't fall through to compile from source
-    if result == nil and graph.config.cmd != cmdM:
-      # Fall back to ROD file loading (not used for cmdM which uses NIF only)
-      result = moduleFromRodFile(graph, fileIdx, cachedModules)
+        else:
+          # Module successfully loaded from NIF file - use it and skip processing
+          result = precomp.module
+          if sfSystemModule in flags:
+            graph.systemModule = result
+          partialInitModule(result, graph, fileIdx, AbsoluteFile(toFullPath(graph.config, fileIdx)))
+          # Replay state changes from the loaded NIF module
+          if result.ast != nil:
+            replayStateChanges(result, graph)
+          return result  # Return early, don't process from source
     let path = toFullPath(graph.config, fileIdx)
     let filename = AbsoluteFile path
     # it could be a stdinfile/cmdfile
@@ -315,16 +318,6 @@ proc compilePipelineModule*(graph: ModuleGraph; fileIdx: FileIndex; flags: TSymF
         registerModule(graph, result)
         processModuleAux("import")
       partialInitModule(result, graph, fileIdx, filename)
-    for m in cachedModules:
-      registerModuleById(graph, m)
-      if graph.config.cmd == cmdM:
-        # cmdM uses NIF files - replay from module AST loaded by loadNifModule
-        let module = graph.getModule(m)
-        if module != nil and module.ast != nil:
-          replayStateChanges(module, graph)
-      else:
-        replayStateChanges(graph.packed.pm[m.int].module, graph)
-        replayGenericCacheInformation(graph, m.int)
   elif graph.isDirty(result):
     result.excl sfDirty
     # reset module fields:
@@ -384,7 +377,6 @@ proc compilePipelineProject*(graph: ModuleGraph; projectFileIdx = InvalidFileIdx
     connectPipelineCallbacks(graph)
     graph.config.m.systemFileIdx = fileInfoIdx(graph.config,
         graph.config.libpath / RelativeFile"system.nim")
-    var cachedModules: seq[FileIndex] = @[]
     when not defined(nimKochBootstrap):
       let precomp = moduleFromNifFile(graph, graph.config.m.systemFileIdx)
       graph.systemModule = precomp.module

compiler/pragmas.nim

@@ -21,8 +21,6 @@ import std/[os, math, strutils]
 when defined(nimPreviewSlimSystem):
   import std/assertions
 
-from ic / ic import addCompilerProc
-
 const
   FirstCallConv* = wNimcall
   LastCallConv* = wNoconv
@@ -569,7 +567,7 @@ proc processCompile(c: PContext, n: PNode) =
     n[i] = c.semConstExpr(c, n[i])
     case n[i].kind
     of nkStrLit, nkRStrLit, nkTripleStrLit:
-      when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc):
+      when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc) or defined(gcYrc):
         result = n[i].strVal
       else:
         shallowCopy(result, n[i].strVal)
@@ -767,8 +765,6 @@ proc markCompilerProc(c: PContext; s: PSym) =
   incl(s, sfCompilerProc)
   incl(s.flagsImpl, sfUsed)
   registerCompilerProc(c.graph, s)
-  if c.config.symbolFiles != disabledSf:
-    addCompilerProc(c.encoder, c.packedRepr, s)
 
 proc deprecatedStmt(c: PContext; outerPragma: PNode) =
   let pragma = outerPragma[1]

compiler/renderer.nim

@@ -14,7 +14,7 @@
 {.used.}
 
 import
-  lexer, options, idents, ast, msgs, lineinfos, wordrecg
+  lexer, options, idents, ast, msgs, lineinfos, wordrecg, trees
 
 import std/[strutils]
 
@@ -66,6 +66,359 @@ proc renderTree*(n: PNode, renderFlags: TRenderFlags = {}): string
 # determines how long the subtree will likely be, the second
 # phase appends to a buffer that will be the output.
 
+type
+  TPreferedDesc* = enum
+    preferName, # default
+    preferDesc, # probably should become what preferResolved is
+    preferExported,
+    preferModuleInfo, # fully qualified
+    preferGenericArg,
+    preferTypeName,
+    preferResolved, # fully resolved symbols
+    preferMixed,
+      # most useful, shows: symbol + resolved symbols if it differs, e.g.:
+      # tuple[a: MyInt{int}, b: float]
+    preferInlayHint,
+    preferInferredEffects,
+
+proc typeToString*(typ: PType; prefer: TPreferedDesc = preferName): string
+template `$`*(typ: PType): string = typeToString(typ)
+
+proc valueToString(a: PNode): string =
+  case a.kind
+  of nkCharLit, nkUIntLit..nkUInt64Lit:
+    result = $cast[uint64](a.intVal)
+  of nkIntLit..nkInt64Lit:
+    result = $a.intVal
+  of nkFloatLit..nkFloat128Lit: result = $a.floatVal
+  of nkStrLit..nkTripleStrLit: result = a.strVal
+  of nkStaticExpr: result = "static(" & a[0].renderTree & ")"
+  else: result = "<invalid value>"
+
+proc rangeToStr(n: PNode): string =
+  assert(n.kind == nkRange)
+  result = valueToString(n[0]) & ".." & valueToString(n[1])
+
+const preferToResolveSymbols = {preferName, preferTypeName, preferModuleInfo,
+  preferGenericArg, preferResolved, preferMixed, preferInlayHint, preferInferredEffects}
+
+
+const
+  typeToStr: array[TTypeKind, string] = ["None", "bool", "char", "empty",
+    "Alias", "typeof(nil)", "untyped", "typed", "typeDesc",
+    # xxx typeDesc=>typedesc: typedesc is declared as such, and is 10x more common.
+    "GenericInvocation", "GenericBody", "GenericInst", "GenericParam",
+    "distinct $1", "enum", "ordinal[$1]", "array[$1, $2]", "object", "tuple",
+    "set[$1]", "range[$1]", "ptr ", "ref ", "var ", "seq[$1]", "proc",
+    "pointer", "OpenArray[$1]", "string", "cstring", "Forward",
+    "int", "int8", "int16", "int32", "int64",
+    "float", "float32", "float64", "float128",
+    "uint", "uint8", "uint16", "uint32", "uint64",
+    "owned", "sink",
+    "lent ", "varargs[$1]", "UncheckedArray[$1]", "Error Type",
+    "BuiltInTypeClass", "UserTypeClass",
+    "UserTypeClassInst", "CompositeTypeClass", "inferred",
+    "and", "or", "not", "any", "static", "TypeFromExpr", "concept", # xxx bugfix
+    "void", "iterable"]
+
+proc addTypeFlags(name: var string, typ: PType) {.inline.} =
+  if tfNotNil in typ.flags: name.add(" not nil")
+
+proc isIntLit*(t: PType): bool {.inline.} =
+  result = t.kind == tyInt and t.n != nil and t.n.kind == nkIntLit
+
+proc isFloatLit*(t: PType): bool {.inline.} =
+  result = t.kind == tyFloat and t.n != nil and t.n.kind == nkFloatLit
+
+# TODO: It would be a good idea to kill the special state of a resolved
+# concept by switching to tyAlias within the instantiated procs.
+# Currently, tyAlias is always skipped with skipModifier, which means that
+# we can store information about the matched concept in another position.
+# Then builtInFieldAccess can be modified to properly read the derived
+# consts and types stored within the concept.
+template isResolvedUserTypeClass*(t: PType): bool =
+  tfResolved in t.flags
+
+proc typeToString(typ: PType, prefer: TPreferedDesc = preferName): string =
+  let preferToplevel = prefer
+  proc getPrefer(prefer: TPreferedDesc): TPreferedDesc =
+    if preferToplevel in {preferResolved, preferMixed}:
+      preferToplevel # sticky option
+    else:
+      prefer
+
+  proc typeToString(typ: PType, prefer: TPreferedDesc = preferName): string =
+    result = ""
+    let prefer = getPrefer(prefer)
+    let t = typ
+    if t == nil: return
+    if prefer in preferToResolveSymbols and t.sym != nil and
+         sfAnon notin t.sym.flags and t.kind notin {tySequence, tyInferred}:
+      if t.kind == tyInt and isIntLit(t):
+        if prefer == preferInlayHint:
+          result = t.sym.name.s
+        else:
+          result = t.sym.name.s & " literal(" & $t.n.intVal & ")"
+      elif t.kind == tyAlias and t.elementType.kind != tyAlias:
+        result = typeToString(t.elementType)
+      elif prefer in {preferResolved, preferMixed}:
+        case t.kind
+        of IntegralTypes + {tyFloat..tyFloat128} + {tyString, tyCstring}:
+          result = typeToStr[t.kind]
+        of tyGenericBody:
+          result = typeToString(t.last)
+        of tyCompositeTypeClass:
+          # avoids showing `A[any]` in `proc fun(a: A)` with `A = object[T]`
+          result = typeToString(t.last.last)
+        else:
+          result = t.sym.name.s
+        if prefer == preferMixed and result != t.sym.name.s:
+          result = t.sym.name.s & "{" & result & "}"
+      elif prefer in {preferName, preferTypeName, preferInlayHint, preferInferredEffects} or t.sym.owner.isNil:
+        # note: should probably be: {preferName, preferTypeName, preferGenericArg}
+        result = t.sym.name.s
+        if t.kind == tyGenericParam and t.genericParamHasConstraints:
+          result.add ": "
+          result.add t.elementType.typeToString
+      else:
+        result = t.sym.owner.name.s & '.' & t.sym.name.s
+      result.addTypeFlags(t)
+      return
+    case t.kind
+    of tyInt:
+      if not isIntLit(t) or prefer == preferExported:
+        result = typeToStr[t.kind]
+      else:
+        case prefer:
+        of preferGenericArg:
+          result = $t.n.intVal
+        of preferInlayHint:
+          result = "int"
+        else:
+          result = "int literal(" & $t.n.intVal & ")"
+    of tyGenericInst:
+      result = typeToString(t.genericHead) & '['
+      for needsComma, a in t.genericInstParams:
+        if needsComma: result.add(", ")
+        result.add(typeToString(a, preferGenericArg))
+      result.add(']')
+    of tyGenericInvocation:
+      result = typeToString(t.genericHead) & '['
+      for needsComma, a in t.genericInvocationParams:
+        if needsComma: result.add(", ")
+        result.add(typeToString(a, preferGenericArg))
+      result.add(']')
+    of tyGenericBody:
+      result = typeToString(t.typeBodyImpl) & '['
+      for i, a in t.genericBodyParams:
+        if i > 0: result.add(", ")
+        result.add(typeToString(a, preferTypeName))
+      result.add(']')
+    of tyTypeDesc:
+      if t.elementType.kind == tyNone: result = "typedesc"
+      else: result = "typedesc[" & typeToString(t.elementType) & "]"
+    of tyStatic:
+      if prefer == preferGenericArg and t.n != nil:
+        result = t.n.renderTree
+      else:
+        result = "static[" & (if t.hasElementType: typeToString(t.skipModifier) else: "") & "]"
+        if t.n != nil: result.add "(" & renderTree(t.n) & ")"
+    of tyUserTypeClass:
+      if t.sym != nil and t.sym.owner != nil:
+        if t.isResolvedUserTypeClass: return typeToString(t.last)
+        return t.sym.owner.name.s
+      else:
+        result = "<invalid tyUserTypeClass>"
+    of tyBuiltInTypeClass:
+      result =
+        case t.base.kind
+        of tyVar: "var"
+        of tyRef: "ref"
+        of tyPtr: "ptr"
+        of tySequence: "seq"
+        of tyArray: "array"
+        of tySet: "set"
+        of tyRange: "range"
+        of tyDistinct: "distinct"
+        of tyProc: "proc"
+        of tyObject: "object"
+        of tyTuple: "tuple"
+        of tyOpenArray: "openArray"
+        else: typeToStr[t.base.kind]
+    of tyInferred:
+      let concrete = t.previouslyInferred
+      if concrete != nil: result = typeToString(concrete)
+      else: result = "inferred[" & typeToString(t.base) & "]"
+    of tyUserTypeClassInst:
+      let body = t.base
+      result = body.sym.name.s & "["
+      for needsComma, a in t.userTypeClassInstParams:
+        if needsComma: result.add(", ")
+        result.add(typeToString(a))
+      result.add "]"
+    of tyAnd:
+      for i, son in t.ikids:
+        if i > 0: result.add(" and ")
+        result.add(typeToString(son))
+    of tyOr:
+      for i, son in t.ikids:
+        if i > 0: result.add(" or ")
+        result.add(typeToString(son))
+    of tyNot:
+      result = "not " & typeToString(t.elementType)
+    of tyUntyped:
+      #internalAssert t.len == 0
+      result = "untyped"
+    of tyFromExpr:
+      if t.n == nil:
+        result = "unknown"
+      else:
+        result = "typeof(" & renderTree(t.n) & ")"
+    of tyArray:
+      result = "array"
+      if t.hasElementType:
+        if t.indexType.kind == tyRange:
+          result &= "[" & rangeToStr(t.indexType.n) & ", " &
+              typeToString(t.elementType) & ']'
+        else:
+          result &= "[" & typeToString(t.indexType) & ", " &
+              typeToString(t.elementType) & ']'
+    of tyUncheckedArray:
+      result = "UncheckedArray"
+      if t.hasElementType:
+        result &= "[" & typeToString(t.elementType) & ']'
+    of tySequence:
+      if t.sym != nil and prefer != preferResolved:
+        result = t.sym.name.s
+      else:
+        result = "seq"
+        if t.hasElementType:
+          result &= "[" & typeToString(t.elementType) & ']'
+    of tyOrdinal:
+      result = "ordinal"
+      if t.hasElementType:
+        result &= "[" & typeToString(t.skipModifier) & ']'
+    of tySet:
+      result = "set"
+      if t.hasElementType:
+        result &= "[" & typeToString(t.elementType) & ']'
+    of tyOpenArray:
+      result = "openArray"
+      if t.hasElementType:
+        result &= "[" & typeToString(t.elementType) & ']'
+    of tyDistinct:
+      result = "distinct " & typeToString(t.elementType,
+        if prefer == preferModuleInfo: preferModuleInfo else: preferTypeName)
+    of tyIterable:
+      # xxx factor this pattern
+      result = "iterable"
+      if t.hasElementType:
+        result &= "[" & typeToString(t.skipModifier) & ']'
+    of tyTuple:
+      # we iterate over t.sons here, because t.n may be nil
+      if t.n != nil:
+        result = "tuple["
+        for i in 0..<t.n.len:
+          assert(t.n[i].kind == nkSym)
+          result.add(t.n[i].sym.name.s & ": " & typeToString(t.n[i].sym.typ))
+          if i < t.n.len - 1: result.add(", ")
+        result.add(']')
+      elif t.isEmptyTupleType:
+        result = "tuple[]"
+      elif t.isSingletonTupleType:
+        result = "("
+        for son in t.kids:
+          result.add(typeToString(son))
+        result.add(",)")
+      else:
+        result = "("
+        for i, son in t.ikids:
+          if i > 0: result.add ", "
+          result.add(typeToString(son))
+        result.add(')')
+    of tyPtr, tyRef, tyVar, tyLent:
+      result = if isOutParam(t): "out " else: typeToStr[t.kind]
+      result.add typeToString(t.elementType)
+    of tyRange:
+      result = "range "
+      if t.n != nil and t.n.kind == nkRange:
+        result.add rangeToStr(t.n)
+      if prefer != preferExported:
+        result.add("(" & typeToString(t.elementType) & ")")
+    of tyProc:
+      result = if tfIterator in t.flags: "iterator "
+               elif t.owner != nil:
+                 case t.owner.kind
+                 of skTemplate: "template "
+                 of skMacro: "macro "
+                 of skConverter: "converter "
+                 else: "proc "
+              else:
+                "proc "
+      if tfUnresolved in t.flags: result.add "[*missing parameters*]"
+      result.add "("
+      for i, a in t.paramTypes:
+        if i > FirstParamAt: result.add(", ")
+        let j = paramTypeToNodeIndex(i)
+        if t.n != nil and j < t.n.len and t.n[j].kind == nkSym:
+          result.add(t.n[j].sym.name.s)
+          result.add(": ")
+        result.add(typeToString(a))
+      result.add(')')
+      if t.returnType != nil: result.add(": " & typeToString(t.returnType))
+      var prag = if t.callConv == ccNimCall and tfExplicitCallConv notin t.flags: "" else: $t.callConv
+      var hasImplicitRaises = false
+      if not isNil(t.owner) and not isNil(t.owner.ast) and (t.owner.ast.len - 1) >= pragmasPos:
+        let pragmasNode = t.owner.ast[pragmasPos]
+        let raisesSpec = effectSpec(pragmasNode, wRaises)
+        if not isNil(raisesSpec):
+          addSep(prag)
+          prag.add("raises: ")
+          prag.add(renderTree raisesSpec)
+          hasImplicitRaises = true
+      if tfNoSideEffect in t.flags:
+        addSep(prag)
+        prag.add("noSideEffect")
+      if tfThread in t.flags:
+        addSep(prag)
+        prag.add("gcsafe")
+      var effectsOfStr = ""
+      for i, a in t.paramTypes:
+        let j = paramTypeToNodeIndex(i)
+        if t.n != nil and j < t.n.len and t.n[j].kind == nkSym and t.n[j].sym.kind == skParam and sfEffectsDelayed in t.n[j].sym.flags:
+          addSep(effectsOfStr)
+          effectsOfStr.add(t.n[j].sym.name.s)
+      if effectsOfStr != "":
+        addSep(prag)
+        prag.add("effectsOf: ")
+        prag.add(effectsOfStr)
+      if not hasImplicitRaises and prefer == preferInferredEffects and not isNil(t.owner) and not isNil(t.owner.typ) and not isNil(t.owner.typ.n) and (t.owner.typ.n.len > 0):
+        let effects = t.n[0]
+        if effects.kind == nkEffectList and effects.len == effectListLen:
+          var inferredRaisesStr = ""
+          let effs = effects[exceptionEffects]
+          if not isNil(effs):
+            for eff in items(effs):
+              if not isNil(eff):
+                addSep(inferredRaisesStr)
+                inferredRaisesStr.add($eff.typ)
+          addSep(prag)
+          prag.add("raises: <inferred> [")
+          prag.add(inferredRaisesStr)
+          prag.add("]")
+      if prag.len != 0: result.add("{." & prag & ".}")
+    of tyVarargs:
+      result = typeToStr[t.kind] % typeToString(t.elementType)
+    of tySink:
+      result = "sink " & typeToString(t.skipModifier)
+    of tyOwned:
+      result = "owned " & typeToString(t.elementType)
+    else:
+      result = typeToStr[t.kind]
+    result.addTypeFlags(t)
+  result = typeToString(typ, prefer)
+
+
 proc disamb(g: var TSrcGen; s: PSym): int =
   # we group by 's.name.s' to compute the stable name ID.
   result = 0
@@ -862,10 +1215,28 @@ proc genSymSuffix(result: var string, s: PSym) {.inline.} =
     result.add '_'
     result.addInt s.id
 
+proc gsemmedParams(g: var TSrcGen, n: PNode) =
+  put(g, tkParLe, "(")
+  for i in 1..<n.len:
+    if i > 1:
+      putWithSpace(g, tkComma, ";")
+    let x {.cursor.} = n[i]
+    if x.kind == nkSym:
+      put g, tkSymbol, renderDefinitionName(x.sym)
+      putWithSpace(g, tkColon, ":")
+      put g, tkSymbol, typeToString(x.sym.typ)
+    else:
+      gsub(g, x)
+  put(g, tkParRi, ")")
+  if not isEmptyType(n[0].typ):
+    putWithSpace(g, tkColon, ":")
+    gsub(g, n[0])
+
 proc gproc(g: var TSrcGen, n: PNode) =
   var c: TContext = initContext()
+  var s: PSym = nil
   if n[namePos].kind == nkSym:
-    let s = n[namePos].sym
+    s = n[namePos].sym
     var ret = renderDefinitionName(s)
     ret.genSymSuffix(s)
     put(g, tkSymbol, ret)
@@ -880,7 +1251,10 @@ proc gproc(g: var TSrcGen, n: PNode) =
       gsub(g, n[miscPos][1])
     else:
       gsub(g, n[genericParamsPos])
-  gsub(g, n[paramsPos])
+  if n[paramsPos].len == 0 and s != nil and s.typ != nil and s.typ.n != nil:
+    gsemmedParams(g, s.typ.n)
+  else:
+    gsub(g, n[paramsPos])
   if renderNoPragmas notin g.flags:
     gsub(g, n[pragmasPos])
   if renderNoBody notin g.flags:

compiler/scriptconfig.nim

@@ -231,7 +231,7 @@ proc runNimScript*(cache: IdentCache; scriptName: AbsoluteFile;
   if optOwnedRefs in oldGlobalOptions:
     conf.globalOptions.incl {optTinyRtti, optOwnedRefs, optSeqDestructors}
     defineSymbol(conf.symbols, "nimv2")
-  if conf.selectedGC in {gcArc, gcOrc, gcAtomicArc}:
+  if conf.selectedGC in {gcArc, gcOrc, gcYrc, gcAtomicArc}:
     conf.globalOptions.incl {optTinyRtti, optSeqDestructors}
     defineSymbol(conf.symbols, "nimv2")
     defineSymbol(conf.symbols, "gcdestructors")
@@ -241,6 +241,8 @@ proc runNimScript*(cache: IdentCache; scriptName: AbsoluteFile;
       defineSymbol(conf.symbols, "gcarc")
     of gcOrc:
       defineSymbol(conf.symbols, "gcorc")
+    of gcYrc:
+      defineSymbol(conf.symbols, "gcyrc")
     of gcAtomicArc:
       defineSymbol(conf.symbols, "gcatomicarc")
     else:

compiler/sem.nim

@@ -855,7 +855,7 @@ proc semStmtAndGenerateGenerics(c: PContext, n: PNode): PNode =
     appendToModule(c.module, result)
   trackStmt(c, c.module, result, isTopLevel = true)
   if optMultiMethods notin c.config.globalOptions and
-      c.config.selectedGC in {gcArc, gcOrc, gcAtomicArc} and
+      c.config.selectedGC in {gcArc, gcOrc, gcAtomicArc, gcYrc} and
       Feature.vtables in c.config.features:
     sortVTableDispatchers(c.graph)
 
@@ -889,8 +889,6 @@ proc semWithPContext*(c: PContext, n: PNode): PNode =
       else:
         result = newNodeI(nkEmpty, n.info)
       #if c.config.cmd == cmdIdeTools: findSuggest(c, n)
-  storeRodNode(c, result)
-
 
 proc reportUnusedModules(c: PContext) =
   if c.config.cmd == cmdM: return

compiler/semcall.nim

@@ -830,6 +830,21 @@ proc inheritBindings(c: PContext, x: var TCandidate, expectedType: PType) =
   for i in 0 ..< flatUnbound.len():
     x.bindings.put(flatUnbound[i], flatBound[i])
 
+proc compactVoidArgs(n: PNode): PNode =
+  # deletes void args from the argument list, which are created by `setSon`
+  var hasNil = false
+  for i in 0..<n.len:
+    if n[i] == nil:
+      hasNil = true
+      break
+  if not hasNil:
+    result = n
+  else:
+    result = copyNode(n)
+    for i in 0..<n.len:
+      if n[i] != nil:
+        result.add n[i]
+
 proc semResolvedCall(c: PContext, x: var TCandidate,
                      n: PNode, flags: TExprFlags;
                      expectedType: PType = nil): PNode =
@@ -880,7 +895,7 @@ proc semResolvedCall(c: PContext, x: var TCandidate,
   markUsed(c, info, finalCallee, isGenericInstance = true)
   onUse(info, finalCallee, isGenericInstance = true)
 
-  result = x.call
+  result = compactVoidArgs(x.call)
   instGenericConvertersSons(c, result, x)
   markConvertersUsed(c, result)
   result[0] = newSymNode(finalCallee, getCallLineInfo(result[0]))
@@ -966,7 +981,7 @@ proc setGenericParams(c: PContext, n, expectedParams: PNode) =
     if e.typ == nil:
       n[i].typ = errorType(c)
     else:
-      n[i].typ = e.typ.skipTypes({tyTypeDesc})
+      n[i].typ = e.typ
 
 proc explicitGenericInstantiation(c: PContext, n: PNode, s: PSym, doError: bool): PNode =
   assert n.kind == nkBracketExpr

compiler/semdata.nim

@@ -19,8 +19,6 @@ import
   magicsys, vmdef, modulegraphs, lineinfos, pathutils, layeredtable,
   types, lowerings, trees, parampatterns, astalgo
 
-import ic / ic
-
 type
   TOptionEntry* = object      # entries to put on a stack for pragma parsing
     options*: TOptions
@@ -336,28 +334,14 @@ proc newContext*(graph: ModuleGraph; module: PSym): PContext =
     signatures: initStrTable(),
     features: graph.config.features
   )
-  if graph.config.symbolFiles != disabledSf:
-    let id = module.position
-    if graph.config.cmd != cmdM:
-      assert graph.packed[id].status in {undefined, outdated}
-    graph.packed[id].status = storing
-    graph.packed[id].module = module
-    initEncoder graph, module
-
-template packedRepr*(c): untyped = c.graph.packed[c.module.position].fromDisk
-template encoder*(c): untyped = c.graph.encoders[c.module.position]
 
 proc addIncludeFileDep*(c: PContext; f: FileIndex) =
-  if c.config.symbolFiles != disabledSf:
-    addIncludeFileDep(c.encoder, c.packedRepr, f)
+  discard
 
 proc addImportFileDep*(c: PContext; f: FileIndex) =
-  if c.config.symbolFiles != disabledSf:
-    addImportFileDep(c.encoder, c.packedRepr, f)
+  discard
 
 proc addPragmaComputation*(c: PContext; n: PNode) =
-  if c.config.symbolFiles != disabledSf:
-    addPragmaComputation(c.encoder, c.packedRepr, n)
   # Also store for NIF-based IC (cmdM mode or optCompress)
   if optCompress in c.config.globalOptions or c.config.cmd == cmdM:
     addNifReplayAction(c.graph, c.module.position.int32, n)
@@ -368,38 +352,28 @@ proc inclSym(sq: var seq[PSym], s: PSym): bool =
   sq.add s
   result = true
 
-proc addConverter*(c: PContext, conv: LazySym) =
-  assert conv.sym != nil
-  if inclSym(c.converters, conv.sym):
+proc addConverter*(c: PContext, conv: PSym) =
+  assert conv != nil
+  if inclSym(c.converters, conv):
     add(c.graph.ifaces[c.module.position].converters, conv)
 
-proc addConverterDef*(c: PContext, conv: LazySym) =
+proc addConverterDef*(c: PContext, conv: PSym) =
   addConverter(c, conv)
-  if c.config.symbolFiles != disabledSf:
-    addConverter(c.encoder, c.packedRepr, conv.sym)
 
-proc addPureEnum*(c: PContext, e: LazySym) =
-  assert e.sym != nil
+proc addPureEnum*(c: PContext, e: PSym) =
+  assert e != nil
   add(c.graph.ifaces[c.module.position].pureEnums, e)
-  if c.config.symbolFiles != disabledSf:
-    addPureEnum(c.encoder, c.packedRepr, e.sym)
 
-proc addPattern*(c: PContext, p: LazySym) =
-  assert p.sym != nil
-  if inclSym(c.patterns, p.sym):
+proc addPattern*(c: PContext, p: PSym) =
+  assert p != nil
+  if inclSym(c.patterns, p):
     add(c.graph.ifaces[c.module.position].patterns, p)
-  if c.config.symbolFiles != disabledSf:
-    addTrmacro(c.encoder, c.packedRepr, p.sym)
 
 proc exportSym*(c: PContext; s: PSym) =
   strTableAdds(c.graph, c.module, s)
-  if c.config.symbolFiles != disabledSf:
-    addExported(c.encoder, c.packedRepr, s)
 
 proc reexportSym*(c: PContext; s: PSym) =
   strTableAdds(c.graph, c.module, s)
-  if c.config.symbolFiles != disabledSf:
-    addReexport(c.encoder, c.packedRepr, s)
 
 proc newLib*(kind: TLibKind): PLib =
   result = PLib(kind: kind)   #result.syms = initObjectSet()
@@ -614,19 +588,11 @@ template addExport*(c: PContext; s: PSym) =
   ## convenience to export a symbol from the current module
   addExport(c.graph, c.module, s)
 
-proc storeRodNode*(c: PContext, n: PNode) =
-  if c.config.symbolFiles != disabledSf:
-    toPackedNodeTopLevel(n, c.encoder, c.packedRepr)
-
 proc addToGenericProcCache*(c: PContext; s: PSym; inst: PInstantiation) =
-  c.graph.procInstCache.mgetOrPut(s.itemId, @[]).add LazyInstantiation(module: c.module.position, inst: inst)
-  if c.config.symbolFiles != disabledSf:
-    storeInstantiation(c.encoder, c.packedRepr, s, inst)
+  c.graph.procInstCache.mgetOrPut(s.itemId, @[]).add inst
 
 proc addToGenericCache*(c: PContext; s: PSym; inst: PType) =
-  c.graph.typeInstCache.mgetOrPut(s.itemId, @[]).add LazyType(typ: inst)
-  if c.config.symbolFiles != disabledSf:
-    storeTypeInst(c.encoder, c.packedRepr, s, inst)
+  c.graph.typeInstCache.mgetOrPut(s.itemId, @[]).add inst
 
 proc sealRodFile*(c: PContext) =
   if c.config.symbolFiles != disabledSf:
@@ -642,9 +608,8 @@ proc rememberExpansion*(c: PContext; info: TLineInfo; expandedSym: PSym) =
   ## in the sem'checked AST. This is very bad for IDE-like tooling
   ## ("find all usages of this template" would not work). We need special
   ## logic to remember macro/template expansions. This is done here and
-  ## delegated to the "rod" file mechanism.
-  if c.config.symbolFiles != disabledSf:
-    storeExpansion(c.encoder, c.packedRepr, info, expandedSym)
+  ## delegated to the "NIF" file mechanism.
+  discard "XXX To implement"
 
 const
   errVarForOutParamNeededX = "for a 'var' type a variable needs to be passed; but '$1' is immutable"

compiler/semexprs.nim

@@ -333,7 +333,7 @@ proc isCastable(c: PContext; dst, src: PType, info: TLineInfo): bool =
   if skipTypes(dst, abstractInst).kind == tyBuiltInTypeClass:
     return false
   let conf = c.config
-  if conf.selectedGC in {gcArc, gcOrc, gcAtomicArc}:
+  if conf.selectedGC in {gcArc, gcOrc, gcAtomicArc, gcYrc}:
     let d = skipTypes(dst, abstractInst)
     let s = skipTypes(src, abstractInst)
     if d.kind == tyRef and s.kind == tyRef and s[0].isFinal != d[0].isFinal:
@@ -813,7 +813,7 @@ proc semArrayConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PTyp
       inc(lastIndex)
     if isGeneric:
       for i in 0..<result.len:
-        if isIntLit(result[i].typ):
+        if result[i].typ != nil and isIntLit(result[i].typ):
           # generic instantiation strips int lit type which makes conversions fail
           result[i].typ = nil
       result.typ = nil # current result.typ is invalid, index type is nil
@@ -832,9 +832,6 @@ proc semArrayConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PTyp
 proc fixAbstractType(c: PContext, n: PNode) =
   for i in 1..<n.len:
     let it = n[i]
-    if it == nil:
-      localError(c.config, n.info, "'$1' has nil child at index $2" % [renderTree(n, {renderNoComments}), $i])
-      return
     # do not get rid of nkHiddenSubConv for OpenArrays, the codegen needs it:
     if it.kind == nkHiddenSubConv and
         skipTypes(it.typ, abstractVar).kind notin {tyOpenArray, tyVarargs}:
@@ -1155,7 +1152,7 @@ proc semIndirectOp(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType
           localError(c.config, n.info, msg)
         return errorNode(c, n)
     else:
-      result = m.call
+      result = compactVoidArgs(m.call)
       instGenericConvertersSons(c, result, m)
       markConvertersUsed(c, result)
 
@@ -1661,6 +1658,9 @@ proc semDeref(c: PContext, n: PNode, flags: TExprFlags): PNode =
     n[0] = a
   result = n
   var t = skipTypes(n[0].typ, {tyGenericInst, tyVar, tyLent, tyAlias, tySink, tyOwned})
+  if t.kind == tyTypeDesc:
+    localError(c.config, n.info, "missing generic parameter")
+    return nil
   case t.kind
   of tyRef, tyPtr: n.typ = t.elementType
   of tyMetaTypes, tyFromExpr:
@@ -2800,7 +2800,7 @@ proc semSetConstr(c: PContext, n: PNode, expectedType: PType = nil): PNode =
           expectedElementType = typ
     if isGeneric:
       for i in 0..<n.len:
-        if isIntLit(n[i].typ):
+        if n[i].typ != nil and isIntLit(n[i].typ):
           # generic instantiation strips int lit type which makes conversions fail
           n[i].typ = nil
         result.add n[i]
@@ -2913,7 +2913,7 @@ proc semTupleFieldsConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType
     result.add n[i]
   if isGeneric:
     for i in 0..<result.len:
-      if isIntLit(result[i][1].typ):
+      if result[i][1].typ != nil and isIntLit(result[i][1].typ):
         # generic instantiation strips int lit type which makes conversions fail
         result[i][1].typ = nil
     result.typ = makeTypeFromExpr(c, result.copyTree)
@@ -2954,7 +2954,7 @@ proc semTuplePositionsConstr(c: PContext, n: PNode, flags: TExprFlags; expectedT
     addSonSkipIntLit(typ, n[i].typ.skipTypes({tySink}), c.idgen)
   if isGeneric:
     for i in 0..<result.len:
-      if isIntLit(result[i].typ):
+      if result[i].typ != nil and isIntLit(result[i].typ):
         # generic instantiation strips int lit type which makes conversions fail
         result[i].typ = nil
     result.typ = makeTypeFromExpr(c, result.copyTree)
@@ -3013,9 +3013,9 @@ proc semExportExcept(c: PContext, n: PNode): PNode =
 
 proc semExport(c: PContext, n: PNode): PNode =
   proc specialSyms(c: PContext; s: PSym) {.inline.} =
-    if s.kind == skConverter: addConverter(c, LazySym(sym: s))
+    if s.kind == skConverter: addConverter(c, s)
     elif s.kind == skType and s.typ != nil and s.typ.kind == tyEnum and sfPure in s.flags:
-      addPureEnum(c, LazySym(sym: s))
+      addPureEnum(c, s)
 
   result = newNodeI(nkExportStmt, n.info)
   for i in 0..<n.len:

compiler/semmagic.nim

@@ -236,6 +236,8 @@ proc evalTypeTrait(c: PContext; traitCall: PNode, operand: PType, context: PSym)
     let complexObj = containsGarbageCollectedRef(t) or
                      hasDestructor(t)
     result = newIntNodeT(toInt128(ord(not complexObj)), traitCall, c.idgen, c.graph)
+  of "canFormCycles":
+    result = newIntNodeT(toInt128(ord(types.canFormAcycle(c.graph, operand))), traitCall, c.idgen, c.graph)
   of "hasDefaultValue":
     result = newIntNodeT(toInt128(ord(not operand.requiresInit)), traitCall, c.idgen, c.graph)
   of "isNamedTuple":

compiler/sempass2.nim

@@ -84,6 +84,8 @@ type
     gcUnsafe, isRecursive, isTopLevel, hasSideEffect, inEnforcedGcSafe: bool
     isInnerProc: bool
     inEnforcedNoSideEffects: bool
+    isArrayIndexing: bool
+    currentExceptType: PType
     unknownRaises: seq[(PSym, TLineInfo)]
     currOptions: TOptions
     optionsStack: seq[(TOptions, TNoteKinds)]
@@ -147,6 +149,49 @@ proc isLocalSym(a: PEffects, s: PSym): bool =
   s.typ != nil and (s.kind in {skLet, skVar, skResult} or (s.kind == skParam and isOutParam(s.typ))) and
     sfGlobal notin s.flags and s.owner == a.owner
 
+proc isRangeSupertype(conf: ConfigRef; wider, narrower: PType): bool =
+  ## Check if `wider` type fully contains `narrower` type
+  ## Returns true if narrower fits entirely within wider (safe conversion)
+  if wider.isOrdinalType:
+    let wideFirst = firstOrd(conf, wider)
+    let wideLast = lastOrd(conf, wider)
+    let narrowFirst = firstOrd(conf, narrower)
+    let narrowLast = lastOrd(conf, narrower)
+    result = narrowFirst >= wideFirst and narrowLast <= wideLast
+  elif not narrower.isOrdinalType:
+    let wideFirst = firstFloat(wider)
+    let wideLast = lastFloat(wider)
+    let narrowFirst = firstFloat(narrower)
+    let narrowLast = lastFloat(narrower)
+    result = narrowFirst >= wideFirst and narrowLast <= wideLast
+  else:
+    # int -> float ranges; warn
+    result = false
+
+proc shouldWarnRangeConversion(conf: ConfigRef; info: TLineInfo; formalType, argType: PType): bool =
+  ## Determine if an implicit range conversion should warn
+  ## We warn on conversions that are likely to cause panics
+  let f = formalType.skipTypes({tyGenericInst, tyAlias, tySink, tyDistinct})
+  let a = argType.skipTypes({tyGenericInst, tyAlias, tySink, tyDistinct})
+  if f.kind == tyRange:
+    # Only warn if formal range doesn't fully contain argument range
+    # Check if the ranges don't perfectly overlap
+    if a.kind == tyInt and f.sym != nil and f.sym.owner != nil and
+        sfSystemModule in f.sym.owner.flags and
+        (f.sym.name.s == "Positive" or
+          f.sym.name.s == "Natural"):
+      # Positive and Natural are special cases that we do not warn on with
+      # ImplicitRangeConversion, but may warn on with systemRangeConversion
+      # if that warning is enabled.
+      if conf.hasWarn(warnSystemRangeConversion):
+        message(conf, info, warnSystemRangeConversion,
+              typeToString(argType) & " -> " & typeToString(formalType))
+      result = false
+    else:
+      result = not isRangeSupertype(conf, f, a)
+  else:
+    result = false
+
 proc lockLocations(a: PEffects; pragma: PNode) =
   if pragma.kind != nkExprColonExpr:
     localError(a.config, pragma.info, "locks pragma without argument")
@@ -577,11 +622,25 @@ proc trackTryStmt(tracked: PEffects, n: PNode) =
     let b = n[i]
     if b.kind == nkExceptBranch:
       setLen(tracked.init, oldState)
+      # If this except branch catches exactly one type, record it so an
+      # empty `raise` inside the branch can be inferred as re-raising that
+      # specific exception type instead of the generic `Exception`.
+      var savedExcept: PType = tracked.currentExceptType
+      var inferredExcept: PType = nil
+      if b.len == 2:
+        if b[0].isInfixAs():
+          assert(b[0][1].kind == nkType)
+          inferredExcept = b[0][1].typ
+        else:
+          assert(b[0].kind == nkType)
+          inferredExcept = b[0].typ
+      tracked.currentExceptType = inferredExcept
       for j in 0..<b.len - 1:
         if b[j].isInfixAs(): # skips initialization checks
           assert(b[j][2].kind == nkSym)
           tracked.init.add b[j][2].sym.id
       track(tracked, b[^1])
+      tracked.currentExceptType = savedExcept
       for i in oldState..<tracked.init.len:
         addToIntersection(inter, tracked.init[i], bsNone)
     else:
@@ -1264,7 +1323,14 @@ proc track(tracked: PEffects, n: PNode) =
       # A `raise` with no arguments means we're going to re-raise the exception
       # being handled or, if outside of an `except` block, a `ReraiseDefect`.
       # Here we add a `Exception` tag in order to cover both the cases.
-      addRaiseEffect(tracked, createRaise(tracked.graph, n), nil)
+      if tracked.currentExceptType != nil:
+        var en = newNode(nkType)
+        en.typ = tracked.currentExceptType
+        en.info = n.info
+        addRaiseEffect(tracked, en, nil)
+        createTypeBoundOps(tracked, tracked.currentExceptType, n.info)
+      else:
+        addRaiseEffect(tracked, createRaise(tracked.graph, n), nil)
   of nkCallKinds:
     trackCall(tracked, n)
   of nkDotExpr:
@@ -1482,6 +1548,12 @@ proc track(tracked: PEffects, n: PNode) =
       message(tracked.config, n.info, warnPtrToCstringConv,
           $n[1].typ)
 
+    # Check for implicit range conversions
+    if n.kind == nkHiddenStdConv and (not tracked.isArrayIndexing) and
+          n[1].kind notin {nkCharLit..nkUInt64Lit, nkFloatLit..nkFloat128Lit} and
+          shouldWarnRangeConversion(tracked.config, n.info, n.typ, n[1].typ):
+      message(tracked.config, n.info, warnImplicitRangeConversion,
+              typeToString(n[1].typ) & " -> " & typeToString(n.typ))
 
     let t = n.typ.skipTypes(abstractInst)
     if t.kind == tyEnum:
@@ -1520,7 +1592,12 @@ proc track(tracked: PEffects, n: PNode) =
         checkBounds(tracked, n[0], n[1])
     track(tracked, n[0])
     dec tracked.leftPartOfAsgn
-    for i in 1 ..< n.len: track(tracked, n[i])
+    for i in 1 ..< n.len:
+      if i == 1:
+        tracked.isArrayIndexing = true
+      track(tracked, n[i])
+      if i == 1:
+        tracked.isArrayIndexing = false
     inc tracked.leftPartOfAsgn
   of nkError:
     localError(tracked.config, n.info, errorToString(tracked.config, n))
@@ -1692,7 +1769,7 @@ proc trackProc*(c: PContext; s: PSym, body: PNode) =
       let param = params[i].sym
       let typ = param.typ
       if isSinkTypeForParam(typ) or
-          (t.config.selectedGC in {gcArc, gcOrc, gcAtomicArc} and
+          (t.config.selectedGC in {gcArc, gcOrc, gcYrc, gcAtomicArc} and
             (isClosure(typ.skipTypes(abstractInst)) or param.id in t.escapingParams)):
         createTypeBoundOps(t, typ, param.info)
       if isOutParam(typ) and param.id notin t.init and s.magic == mNone:

compiler/semstmts.nim

@@ -1845,6 +1845,13 @@ proc typeSectionFinalPass(c: PContext, n: PNode) =
           let baseType = s.typ.safeSkipTypes(abstractPtrs)
           if baseType.kind in {tyObject, tyTuple} and not baseType.n.isNil:
             checkForMetaFields(c, baseType.n, hasError)
+
+        if s.typ.kind in {tySet, tyArray, tySequence, tyUncheckedArray} and s.typ.elementType.kind == tyNone:
+          # magic generics are not filled but tyNone is added to its elements by default,
+          # we lift them to tyBuiltInTypeClass here
+          s.typ = newTypeS(tyBuiltInTypeClass, c,
+                    newTypeS(s.typ.kind, c))
+
         if not hasError:
           checkConstructedType(c.config, s.info, s.typ)
   #instAllTypeBoundOp(c, n.info)
@@ -2168,7 +2175,7 @@ proc bindTypeHook(c: PContext; s: PSym; n: PNode; op: TTypeAttachedOp) =
   template notRefc: bool =
     # fixes refc with non-var destructor; cancel warnings (#23156)
     c.config.backend == backendJs or
-      c.config.selectedGC in {gcArc, gcAtomicArc, gcOrc}
+      c.config.selectedGC in {gcArc, gcAtomicArc, gcOrc, gcYrc}
   let cond = case op
              of attachedWasMoved:
                t.len == 2 and t.returnType == nil and t.firstParamType.kind == tyVar
@@ -2776,7 +2783,7 @@ proc semConverterDef(c: PContext, n: PNode): PNode =
   var t = s.typ
   if t.returnType == nil: localError(c.config, n.info, errXNeedsReturnType % "converter")
   if t.len != 2: localError(c.config, n.info, "a converter takes exactly one argument")
-  addConverterDef(c, LazySym(sym: s))
+  addConverterDef(c, s)
 
 proc semMacroDef(c: PContext, n: PNode): PNode =
   result = semProcAux(c, n, skMacro, macroPragmas)

compiler/semtempl.nim

@@ -925,4 +925,4 @@ proc semPattern(c: PContext, n: PNode; s: PSym): PNode =
     elif result.len == 0:
       localError(c.config, n.info, "a pattern cannot be empty")
   closeScope(c)
-  addPattern(c, LazySym(sym: s))
+  addPattern(c, s)

compiler/semtypes.nim

@@ -210,7 +210,7 @@ proc semEnum(c: PContext, n: PNode, prev: PType): PType =
     )
 
   if isPure and sfExported in result.sym.flags:
-    addPureEnum(c, LazySym(sym: result.sym))
+    addPureEnum(c, result.sym)
   if tfNotNil in e.typ.flags and not hasNull:
     result.incl tfRequiresInit
   setToStringProc(c.graph, result, genEnumToStrProc(result, n.info, c.graph, c.idgen))
@@ -1014,7 +1014,7 @@ proc skipGenericInvocation(t: PType): PType {.inline.} =
 proc tryAddInheritedFields(c: PContext, check: var IntSet, pos: var int,
                         obj: PType, n: PNode, isPartial = false, innerObj: PType = nil): bool =
   if ((not isPartial) and (obj.kind notin {tyObject, tyGenericParam} or tfFinal in obj.flags)) or
-    (innerObj != nil and obj.sym.id == innerObj.sym.id):
+    (innerObj != nil and obj.id == innerObj.id):
     localError(c.config, n.info, "Cannot inherit from: '" & $obj & "'")
     result = false
   elif obj.kind == tyObject:
@@ -1149,7 +1149,7 @@ proc semAnyRef(c: PContext; n: PNode; kind: TTypeKind; prev: PType): PType =
       result = t
     else: discard
     if result.kind == tyRef and
-        c.config.selectedGC in {gcArc, gcOrc, gcAtomicArc} and
+        c.config.selectedGC in {gcArc, gcOrc, gcAtomicArc, gcYrc} and
         tfTriggersCompileTime notin result.flags:
       result.incl tfHasAsgn
 
@@ -1203,7 +1203,15 @@ proc addImplicitGeneric(c: PContext; typeClass: PType, typId: PIdent;
   # is this a bindOnce type class already present in the param list?
   for i in 0..<genericParams.len:
     if genericParams[i].sym.name.id == finalTypId.id:
-      return genericParams[i].typ
+      if typeClass.kind == tyStatic and genericParams[i].typ.kind != tyStatic:
+        # The base type (e.g. from `auto`) was already added as a generic param,
+        # but `static[auto]` requires upgrading it to a `tyStatic` wrapper so
+        # it is instantiated as a compile-time value (`skConst`).
+        genericParams[i].sym.linkTo(typeClass)
+        typeClass.incl tfImplicitTypeParam
+        return typeClass
+      else:
+        return genericParams[i].typ
 
   let owner = if typeClass.sym != nil: typeClass.sym
               else: getCurrOwner(c)
@@ -1739,6 +1747,7 @@ proc semGeneric(c: PContext, n: PNode, s: PSym, prev: PType): PType =
     var isConcrete = true
     let rType = m.call[0].typ
     let mIndex = if rType != nil: rType.len - 1 else: -1
+    var hasForwardTypeParam = false
     for i in 1..<m.call.len:
       var typ = m.call[i].typ
       # is this a 'typedesc' *parameter*? If so, use the typedesc type,
@@ -1755,13 +1764,36 @@ proc semGeneric(c: PContext, n: PNode, s: PSym, prev: PType): PType =
           skip = false
         addToResult(typ, skip)
 
+      if typ.kind == tyForward:
+        hasForwardTypeParam = true
+
     if isConcrete:
       if s.ast == nil and s.typ.kind != tyCompositeTypeClass:
         # XXX: What kind of error is this? is it still relevant?
         localError(c.config, n.info, errCannotInstantiateX % s.name.s)
         result = newOrPrevType(tyError, prev, c)
-      elif containsGenericInvocationWithForward(n[0]):
+      elif containsGenericInvocationWithForward(n[0]) or hasForwardTypeParam:
+        # isConcrete == false means this generic type is not instanciated here because it invoked with generic parameters.
+        # Even if isConcrete == true, don't instanciate it now if there are any `tyForward` type params.
+        # Such `tyForward` type params will be semchecked later and we can instanciate this next time.
+        # Some generic types like std/options.Option[T] needs a type kinds of the given type argument.
+
+        # return `tyForward` instead of `tyGenericInvocation` because:
+        # ```nim
+        #   type Foo = object
+        #     x: Option[Foo]
+        # ```
+        # returning `tyGenericInvocation` makes `Option[Foo]` to `tyGenericInvocation` and
+        # next time `semGeneric` is called with `Option[Foo]`, containsGenericType(typeof(`Foo`)) == true
+        # and `isConcrete == false`.
+        if prev == nil:
+          result = newTypeS(tyForward, c)
+          result.sym = s
+        else:
+          assignType(result, newTypeS(tyForward, c))
+          result.sym = s
         c.forwardTypeUpdates.add (result, n) #fixes 1500
+        return
       else:
         result = instGenericContainer(c, n.info, result,
                                       allowMetaTypes = false)
@@ -2049,7 +2081,9 @@ proc semTypeIdent(c: PContext, n: PNode): PSym =
         # proc signature for example
         if c.inGenericInst > 0:
           let bound = result.typ.elementType.sym
-          if bound != nil: return bound
+          # the symbol may still point to the uninstantiated generic body type 
+          if bound != nil and bound.typ == result.typ.elementType:
+            return bound
           return result
         if result.typ.sym == nil:
           localError(c.config, n.info, errTypeExpected)
@@ -2219,7 +2253,8 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
     else:
       result = semTypeNode(c, whenResult, prev)
   of nkBracketExpr:
-    checkMinSonsLen(n, 2, c.config)
+    # Actually len >= 2 is required, but it doesn't print errors nicely with empty brackets
+    checkMinSonsLen(n, 1, c.config)
     var head = n[0]
     var s = if head.kind notin nkCallKinds: semTypeIdent(c, head)
             else: symFromExpectedTypeNode(c, semExpr(c, head))
@@ -2237,10 +2272,21 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
         incl result, tfHasAsgn
     of mVarargs: result = semVarargs(c, n, prev)
     of mTypeDesc, mType, mTypeOf:
-      result = makeTypeDesc(c, semTypeNode(c, n[1], nil))
-      result.incl tfExplicit
+      if n.len != 2:
+        let name = case s.magic:
+                   of mTypeDesc: "typedesc"
+                   of mType: "type"
+                   of mTypeOf: "typeof"
+                   else: ""
+        localError(c.config, n.info, errXExpectsOneTypeParam % name)
+      else:
+        result = makeTypeDesc(c, semTypeNode(c, n[1], nil))
+        result.incl tfExplicit
     of mStatic:
-      result = semStaticType(c, n[1], prev)
+      if n.len != 2:
+        localError(c.config, n.info, errXExpectsOneTypeParam % "static")
+      else:
+        result = semStaticType(c, n[1], prev)
     of mExpr:
       result = semTypeNode(c, n[0], nil)
       if result != nil:
@@ -2250,9 +2296,11 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
         for i in 1..<n.len:
           result.rawAddSon(semTypeNode(c, n[i], nil))
     of mDistinct:
+      checkSonsLen(n, 2, c.config)
       result = newOrPrevType(tyDistinct, prev, c)
       addSonSkipIntLit(result, semTypeNode(c, n[1], nil), c.idgen)
     of mVar:
+      checkSonsLen(n, 2, c.config)
       result = newOrPrevType(tyVar, prev, c)
       var base = semTypeNode(c, n[1], nil)
       if base.kind in {tyVar, tyLent}:
@@ -2376,7 +2424,7 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
 
       if n.kind == nkIteratorTy and result.kind == tyProc:
         result.incl(tfIterator)
-      if result.callConv == ccClosure and c.config.selectedGC in {gcArc, gcOrc, gcAtomicArc}:
+      if result.callConv == ccClosure and c.config.selectedGC in {gcArc, gcOrc, gcAtomicArc, gcYrc}:
         result.incl tfHasAsgn
   of nkEnumTy: result = semEnum(c, n, prev)
   of nkType: result = n.typ

compiler/semtypinst.nim

@@ -373,6 +373,7 @@ proc replaceTypeVarsS(cl: var TReplTypeVars, s: PSym, t: PType): PSym =
       var g: G[string]
 
   ]#
+  # XXX FIXME This causes system.Natural to be duplicated during compilation of system.nim as cl.owner == nil!
   result = copySym(s, cl.c.idgen)
   incl(result.flagsImpl, sfFromGeneric)
   #idTablePut(cl.symMap, s, result)
@@ -562,6 +563,26 @@ proc eraseVoidParams*(t: PType) =
       setLen t.n.sons, pos
       break
 
+proc eraseTupleVoidFields*(t: PType) =
+  ## Remove void fields from a named tuple type, compacting both `t.n`
+  ## (the field symbol nodes) and `t.sonsImpl` (the child types).
+  if t.n == nil: return  # anonymous tuple, nothing to compact
+  for i in 0..<t.kidsLen:
+    if t.n[i].kind == nkRecList or t[i].kind == tyVoid:
+      # found first void field, compact from here
+      var pos = i
+      for j in i+1..<t.kidsLen:
+        if t[j].kind != tyVoid and j < t.n.len and t.n[j].kind != nkRecList:
+          t.n[pos] = t.n[j]
+          t[pos] = t[j]
+          if t.n[pos].kind == nkSym:
+            t.n[pos].sym.position = pos
+          inc pos
+        # else: skip void entries
+      setLen t.n.sons, pos
+      t.setSonsLen pos
+      break
+
 proc skipIntLiteralParams*(t: PType; idgen: IdGenerator) =
   for i, p in t.ikids:
     if p == nil: continue
@@ -767,6 +788,8 @@ proc replaceTypeVarsTAux(cl: var TReplTypeVars, t: PType, isInstValue = false):
         propagateFieldFlags(result, result.n)
         if result.kind == tyObject and cl.c.computeRequiresInit(cl.c, result):
           result.incl tfRequiresInit
+        if result.kind == tyTuple:
+          eraseTupleVoidFields(result)
 
       of tyProc:
         eraseVoidParams(result)

compiler/sighashes.nim

@@ -41,6 +41,7 @@ type
     CoType
     CoOwnerSig
     CoIgnoreRange
+    CoIgnoreRangeInArray
     CoConsiderOwned
     CoDistinct
     CoHashTypeInsideNode
@@ -154,7 +155,7 @@ proc hashType(c: var MD5Context, t: PType; flags: set[ConsiderFlag]; conf: Confi
       assert inst.kind == tyGenericInst
       c.hashType inst.genericHead, flags, conf
       for _, a in inst.genericInstParams:
-        c.hashType a, flags, conf
+        c.hashType a, flags+{CoDistinct}, conf
       t.typeInstImpl = inst
       return
     c &= char(t.kind)
@@ -220,10 +221,17 @@ proc hashType(c: var MD5Context, t: PType; flags: set[ConsiderFlag]; conf: Confi
     else:
       for a in t.kids: c.hashType a, flags+{CoIgnoreRange}, conf
   of tyRange:
-    if CoIgnoreRange notin flags:
+    if {CoIgnoreRange, CoIgnoreRangeInArray} * flags == {}:
       c &= char(t.kind)
       c.hashTree(t.n, {}, conf)
-    c.hashType(t.elementType, flags, conf)
+      c.hashType(t.elementType, flags, conf)
+    elif CoIgnoreRangeInArray in flags:
+      # include only the length of the range (not its specific bounds)
+      c &= char(t.kind)
+      let l = lengthOrd(conf, t)
+      lowlevel l
+    else:
+      c.hashType(t.elementType, flags, conf)
   of tyStatic:
     c &= char(t.kind)
     c.hashTree(t.n, {}, conf)
@@ -253,7 +261,7 @@ proc hashType(c: var MD5Context, t: PType; flags: set[ConsiderFlag]; conf: Confi
     if tfVarargs in t.flags: c &= ".varargs"
   of tyArray:
     c &= char(t.kind)
-    c.hashType(t.indexType, flags-{CoIgnoreRange}, conf)
+    c.hashType(t.indexType, flags-{CoIgnoreRange}+{CoIgnoreRangeInArray}, conf)
     c.hashType(t.elementType, flags-{CoIgnoreRange}, conf)
   else:
     c &= char(t.kind)

compiler/sigmatch.nim

@@ -160,8 +160,7 @@ proc matchGenericParam(m: var TCandidate, formal: PType, n: PNode) =
       arg = newTypeS(tyStatic, m.c, son = evaluated.typ)
       arg.n = evaluated
   elif formalBase.kind == tyTypeDesc:
-    if arg.kind != tyTypeDesc:
-      arg = makeTypeDesc(m.c, arg)
+    discard # if arg is not tyTypeDesc, typeRel will report the mismatch
   else:
     arg = arg.skipTypes({tyTypeDesc})
   let tm = typeRel(m, formal, arg)
@@ -615,6 +614,8 @@ proc isGenericObjectOf(f, a: PType): bool =
   # use sym equality to check if the `tyGenericBody` types are equal
   result = aRoot != nil and f.sym == aRoot.sym
 
+
+
 proc isObjectSubtype(c: var TCandidate; a, f, fGenericOrigin: PType): int =
   var t = a
   assert t.kind == tyObject
@@ -1676,7 +1677,6 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
     elif a.kind == tyGenericInst:
       if roota.base == rootf.base:
         let nextFlags = flags + {trNoCovariance}
-        var hasCovariance = false
         # YYYY
         result = isEqual
 
@@ -1688,7 +1688,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
           if res notin {isEqual, isGeneric}:
             if trNoCovariance notin flags and ff.kind == aa.kind:
               let paramFlags = rootf.base[i-1].flags
-              hasCovariance =
+              let hasCovariance =
                 if tfCovariant in paramFlags:
                   if tfWeakCovariant in paramFlags:
                     isCovariantPtr(c, ff, aa)
@@ -1699,35 +1699,36 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
                     typeRel(c, aa, ff, flags) == isSubtype
               if hasCovariance:
                 continue
+            result = isNone
+            break
 
-            return isNone
-        if prev == nil: put(c, f, a)
-      else:
-        let fKind = rootf.last.kind
-        if fKind in {tyAnd, tyOr}:
-          result = typeRel(c, last(f), a, flags)
-          if result != isNone: put(c, f, a)
+        if result != isNone:
+          if prev == nil: put(c, f, a)
           return
 
-        var aAsObject = roota.last
+      let fKind = rootf.last.kind
+      if fKind in {tyAnd, tyOr}:
+        result = typeRel(c, last(f), a, flags)
+        if result != isNone: put(c, f, a)
+        return
 
-        if fKind in {tyRef, tyPtr}:
-          if aAsObject.kind == tyObject:
-            # bug #7600, tyObject cannot be passed
-            # as argument to tyRef/tyPtr
-            return isNone
-          elif aAsObject.kind == fKind:
-            aAsObject = aAsObject.base
+      var aAsObject = roota.last
 
-        if aAsObject.kind == tyObject and trIsOutParam notin flags:
-          let baseType = aAsObject.base
-          if baseType != nil:
-            if tfFinal notin aAsObject.flags:
-              inc c.inheritancePenalty, 1 + int(c.inheritancePenalty < 0)
-            let ret = typeRel(c, f, baseType, flags)
-            return if ret in {isEqual,isGeneric}: isSubtype else: ret
+      if fKind in {tyRef, tyPtr}:
+        if aAsObject.kind == tyObject:
+          # bug #7600, tyObject cannot be passed
+          # as argument to tyRef/tyPtr
+          return isNone
+        elif aAsObject.kind == fKind:
+          aAsObject = aAsObject.base
 
-        result = isNone
+      if aAsObject.kind == tyObject and trIsOutParam notin flags:
+        let baseType = aAsObject.base
+        if baseType != nil:
+          if tfFinal notin aAsObject.flags:
+            inc c.inheritancePenalty, 1 + int(c.inheritancePenalty < 0)
+          let ret = typeRel(c, f, baseType, flags)
+          return if ret in {isEqual,isGeneric}: isSubtype else: ret
     else:
       assert last(origF) != nil
       result = typeRel(c, last(origF), a, flags)
@@ -2184,9 +2185,9 @@ proc implicitConv(kind: TNodeKind, f: PType, arg: PNode, m: TCandidate,
       result.typ = errorType(c)
   else:
     result.typ = f.skipTypes({tySink})
-  # keep varness
+  # keep varness, but don't wrap lent types with var
   if arg.typ != nil and arg.typ.kind == tyVar:
-    result.typ = toVar(result.typ, tyVar, c.idgen)
+    result.typ = toVar(result.typ.skipTypes({tyLent}), tyVar, c.idgen)
     # copy the tfVarIsPtr flag
     result.typ.flags = arg.typ.flags
   else:
@@ -3092,6 +3093,7 @@ proc matches*(c: PContext, n, nOrig: PNode, m: var TCandidate) =
             put(m, formal.typ, defaultValue.typ)
         defaultValue.flags.incl nfDefaultParam
         setSon(m.call, formal.position + 1, defaultValue)
+
   # forget all inferred types if the overload matching failed
   if m.state == csNoMatch:
     for t in m.inferredTypes:

compiler/spawn.nim

@@ -37,7 +37,7 @@ proc spawnResult*(t: PType; inParallel: bool): TSpawnResult =
   else: srFlowVar
 
 proc flowVarKind(c: ConfigRef, t: PType): TFlowVarKind =
-  if c.selectedGC in {gcArc, gcOrc, gcAtomicArc}: fvBlob
+  if c.selectedGC in {gcArc, gcOrc, gcAtomicArc, gcYrc}: fvBlob
   elif t.skipTypes(abstractInst).kind in {tyRef, tyString, tySequence}: fvGC
   elif containsGarbageCollectedRef(t): fvInvalid
   else: fvBlob
@@ -66,7 +66,7 @@ proc addLocalVar(g: ModuleGraph; varSection, varInit: PNode; idgen: IdGenerator;
   vpart[2] = if varInit.isNil: v else: vpart[1]
   varSection.add vpart
   if varInit != nil:
-    if g.config.selectedGC in {gcArc, gcOrc, gcAtomicArc}:
+    if g.config.selectedGC in {gcArc, gcOrc, gcAtomicArc, gcYrc}:
       # inject destructors pass will do its own analysis
       varInit.add newFastMoveStmt(g, newSymNode(result), v)
     else:

compiler/types.nim

@@ -18,21 +18,9 @@ import std/[intsets, strutils]
 when defined(nimPreviewSlimSystem):
   import std/[assertions, formatfloat]
 
-type
-  TPreferedDesc* = enum
-    preferName, # default
-    preferDesc, # probably should become what preferResolved is
-    preferExported,
-    preferModuleInfo, # fully qualified
-    preferGenericArg,
-    preferTypeName,
-    preferResolved, # fully resolved symbols
-    preferMixed,
-      # most useful, shows: symbol + resolved symbols if it differs, e.g.:
-      # tuple[a: MyInt{int}, b: float]
-    preferInlayHint,
-    preferInferredEffects,
+export isResolvedUserTypeClass, TPreferedDesc, typeToString
 
+type
   TTypeRelation* = enum      # order is important!
     isNone, isConvertible,
     isIntConv,
@@ -55,8 +43,6 @@ type
     pcmNotIterator
     pcmDifferentCallConv
 
-proc typeToString*(typ: PType; prefer: TPreferedDesc = preferName): string
-
 proc addTypeDeclVerboseMaybe*(result: var string, conf: ConfigRef; typ: PType) =
   if optDeclaredLocs in conf.globalOptions:
     result.add typeToString(typ, preferMixed)
@@ -64,8 +50,6 @@ proc addTypeDeclVerboseMaybe*(result: var string, conf: ConfigRef; typ: PType) =
   else:
     result.add typeToString(typ)
 
-template `$`*(typ: PType): string = typeToString(typ)
-
 # ------------------- type iterator: ----------------------------------------
 type
   TTypeIter* = proc (t: PType, closure: RootRef): bool {.nimcall.} # true if iteration should stop
@@ -157,15 +141,9 @@ proc getFloatValue*(n: PNode): BiggestFloat =
   of nkHiddenStdConv: getFloatValue(n[1])
   else: NaN
 
-proc isIntLit*(t: PType): bool {.inline.} =
-  result = t.kind == tyInt and t.n != nil and t.n.kind == nkIntLit
-
-proc isFloatLit*(t: PType): bool {.inline.} =
-  result = t.kind == tyFloat and t.n != nil and t.n.kind == nkFloatLit
-
 proc addTypeHeader*(result: var string, conf: ConfigRef; typ: PType; prefer: TPreferedDesc = preferMixed; getDeclarationPath = true) =
   result.add typeToString(typ, prefer)
-  if getDeclarationPath: result.addDeclaredLoc(conf, typ.sym)
+  if getDeclarationPath and typ.sym != nil: result.addDeclaredLoc(conf, typ.sym)
 
 proc getProcHeader*(conf: ConfigRef; sym: PSym; prefer: TPreferedDesc = preferName; getDeclarationPath = true): string =
   assert sym != nil
@@ -460,337 +438,10 @@ proc canFormAcycle*(g: ModuleGraph, typ: PType): bool =
   let t = skipTypes(typ, abstractInst+{tyOwned}-{tyTypeDesc})
   result = canFormAcycleAux(g, marker, t, t, false, false)
 
-proc valueToString(a: PNode): string =
-  case a.kind
-  of nkCharLit, nkUIntLit..nkUInt64Lit:
-    result = $cast[uint64](a.intVal)
-  of nkIntLit..nkInt64Lit:
-    result = $a.intVal
-  of nkFloatLit..nkFloat128Lit: result = $a.floatVal
-  of nkStrLit..nkTripleStrLit: result = a.strVal
-  of nkStaticExpr: result = "static(" & a[0].renderTree & ")"
-  else: result = "<invalid value>"
-
-proc rangeToStr(n: PNode): string =
-  assert(n.kind == nkRange)
-  result = valueToString(n[0]) & ".." & valueToString(n[1])
-
-const
-  typeToStr: array[TTypeKind, string] = ["None", "bool", "char", "empty",
-    "Alias", "typeof(nil)", "untyped", "typed", "typeDesc",
-    # xxx typeDesc=>typedesc: typedesc is declared as such, and is 10x more common.
-    "GenericInvocation", "GenericBody", "GenericInst", "GenericParam",
-    "distinct $1", "enum", "ordinal[$1]", "array[$1, $2]", "object", "tuple",
-    "set[$1]", "range[$1]", "ptr ", "ref ", "var ", "seq[$1]", "proc",
-    "pointer", "OpenArray[$1]", "string", "cstring", "Forward",
-    "int", "int8", "int16", "int32", "int64",
-    "float", "float32", "float64", "float128",
-    "uint", "uint8", "uint16", "uint32", "uint64",
-    "owned", "sink",
-    "lent ", "varargs[$1]", "UncheckedArray[$1]", "Error Type",
-    "BuiltInTypeClass", "UserTypeClass",
-    "UserTypeClassInst", "CompositeTypeClass", "inferred",
-    "and", "or", "not", "any", "static", "TypeFromExpr", "concept", # xxx bugfix
-    "void", "iterable"]
-
-const preferToResolveSymbols = {preferName, preferTypeName, preferModuleInfo,
-  preferGenericArg, preferResolved, preferMixed, preferInlayHint, preferInferredEffects}
-
 template bindConcreteTypeToUserTypeClass*(tc, concrete: PType) =
   tc.add concrete
   tc.incl tfResolved
 
-# TODO: It would be a good idea to kill the special state of a resolved
-# concept by switching to tyAlias within the instantiated procs.
-# Currently, tyAlias is always skipped with skipModifier, which means that
-# we can store information about the matched concept in another position.
-# Then builtInFieldAccess can be modified to properly read the derived
-# consts and types stored within the concept.
-template isResolvedUserTypeClass*(t: PType): bool =
-  tfResolved in t.flags
-
-proc addTypeFlags(name: var string, typ: PType) {.inline.} =
-  if tfNotNil in typ.flags: name.add(" not nil")
-
-proc typeToString(typ: PType, prefer: TPreferedDesc = preferName): string =
-  let preferToplevel = prefer
-  proc getPrefer(prefer: TPreferedDesc): TPreferedDesc =
-    if preferToplevel in {preferResolved, preferMixed}:
-      preferToplevel # sticky option
-    else:
-      prefer
-
-  proc typeToString(typ: PType, prefer: TPreferedDesc = preferName): string =
-    result = ""
-    let prefer = getPrefer(prefer)
-    let t = typ
-    if t == nil: return
-    if prefer in preferToResolveSymbols and t.sym != nil and
-         sfAnon notin t.sym.flags and t.kind notin {tySequence, tyInferred}:
-      if t.kind == tyInt and isIntLit(t):
-        if prefer == preferInlayHint:
-          result = t.sym.name.s
-        else:
-          result = t.sym.name.s & " literal(" & $t.n.intVal & ")"
-      elif t.kind == tyAlias and t.elementType.kind != tyAlias:
-        result = typeToString(t.elementType)
-      elif prefer in {preferResolved, preferMixed}:
-        case t.kind
-        of IntegralTypes + {tyFloat..tyFloat128} + {tyString, tyCstring}:
-          result = typeToStr[t.kind]
-        of tyGenericBody:
-          result = typeToString(t.last)
-        of tyCompositeTypeClass:
-          # avoids showing `A[any]` in `proc fun(a: A)` with `A = object[T]`
-          result = typeToString(t.last.last)
-        else:
-          result = t.sym.name.s
-        if prefer == preferMixed and result != t.sym.name.s:
-          result = t.sym.name.s & "{" & result & "}"
-      elif prefer in {preferName, preferTypeName, preferInlayHint, preferInferredEffects} or t.sym.owner.isNil:
-        # note: should probably be: {preferName, preferTypeName, preferGenericArg}
-        result = t.sym.name.s
-        if t.kind == tyGenericParam and t.genericParamHasConstraints:
-          result.add ": "
-          result.add t.elementType.typeToString
-      else:
-        result = t.sym.owner.name.s & '.' & t.sym.name.s
-      result.addTypeFlags(t)
-      return
-    case t.kind
-    of tyInt:
-      if not isIntLit(t) or prefer == preferExported:
-        result = typeToStr[t.kind]
-      else:
-        case prefer:
-        of preferGenericArg:
-          result = $t.n.intVal
-        of preferInlayHint:
-          result = "int"
-        else:
-          result = "int literal(" & $t.n.intVal & ")"
-    of tyGenericInst:
-      result = typeToString(t.genericHead) & '['
-      for needsComma, a in t.genericInstParams:
-        if needsComma: result.add(", ")
-        result.add(typeToString(a, preferGenericArg))
-      result.add(']')
-    of tyGenericInvocation:
-      result = typeToString(t.genericHead) & '['
-      for needsComma, a in t.genericInvocationParams:
-        if needsComma: result.add(", ")
-        result.add(typeToString(a, preferGenericArg))
-      result.add(']')
-    of tyGenericBody:
-      result = typeToString(t.typeBodyImpl) & '['
-      for i, a in t.genericBodyParams:
-        if i > 0: result.add(", ")
-        result.add(typeToString(a, preferTypeName))
-      result.add(']')
-    of tyTypeDesc:
-      if t.elementType.kind == tyNone: result = "typedesc"
-      else: result = "typedesc[" & typeToString(t.elementType) & "]"
-    of tyStatic:
-      if prefer == preferGenericArg and t.n != nil:
-        result = t.n.renderTree
-      else:
-        result = "static[" & (if t.hasElementType: typeToString(t.skipModifier) else: "") & "]"
-        if t.n != nil: result.add "(" & renderTree(t.n) & ")"
-    of tyUserTypeClass:
-      if t.sym != nil and t.sym.owner != nil:
-        if t.isResolvedUserTypeClass: return typeToString(t.last)
-        return t.sym.owner.name.s
-      else:
-        result = "<invalid tyUserTypeClass>"
-    of tyBuiltInTypeClass:
-      result =
-        case t.base.kind
-        of tyVar: "var"
-        of tyRef: "ref"
-        of tyPtr: "ptr"
-        of tySequence: "seq"
-        of tyArray: "array"
-        of tySet: "set"
-        of tyRange: "range"
-        of tyDistinct: "distinct"
-        of tyProc: "proc"
-        of tyObject: "object"
-        of tyTuple: "tuple"
-        of tyOpenArray: "openArray"
-        else: typeToStr[t.base.kind]
-    of tyInferred:
-      let concrete = t.previouslyInferred
-      if concrete != nil: result = typeToString(concrete)
-      else: result = "inferred[" & typeToString(t.base) & "]"
-    of tyUserTypeClassInst:
-      let body = t.base
-      result = body.sym.name.s & "["
-      for needsComma, a in t.userTypeClassInstParams:
-        if needsComma: result.add(", ")
-        result.add(typeToString(a))
-      result.add "]"
-    of tyAnd:
-      for i, son in t.ikids:
-        if i > 0: result.add(" and ")
-        result.add(typeToString(son))
-    of tyOr:
-      for i, son in t.ikids:
-        if i > 0: result.add(" or ")
-        result.add(typeToString(son))
-    of tyNot:
-      result = "not " & typeToString(t.elementType)
-    of tyUntyped:
-      #internalAssert t.len == 0
-      result = "untyped"
-    of tyFromExpr:
-      if t.n == nil:
-        result = "unknown"
-      else:
-        result = "typeof(" & renderTree(t.n) & ")"
-    of tyArray:
-      result = "array"
-      if t.hasElementType:
-        if t.indexType.kind == tyRange:
-          result &= "[" & rangeToStr(t.indexType.n) & ", " &
-              typeToString(t.elementType) & ']'
-        else:
-          result &= "[" & typeToString(t.indexType) & ", " &
-              typeToString(t.elementType) & ']'
-    of tyUncheckedArray:
-      result = "UncheckedArray"
-      if t.hasElementType:
-        result &= "[" & typeToString(t.elementType) & ']'
-    of tySequence:
-      if t.sym != nil and prefer != preferResolved:
-        result = t.sym.name.s
-      else:
-        result = "seq"
-        if t.hasElementType:
-          result &= "[" & typeToString(t.elementType) & ']'
-    of tyOrdinal:
-      result = "ordinal"
-      if t.hasElementType:
-        result &= "[" & typeToString(t.skipModifier) & ']'
-    of tySet:
-      result = "set"
-      if t.hasElementType:
-        result &= "[" & typeToString(t.elementType) & ']'
-    of tyOpenArray:
-      result = "openArray"
-      if t.hasElementType:
-        result &= "[" & typeToString(t.elementType) & ']'
-    of tyDistinct:
-      result = "distinct " & typeToString(t.elementType,
-        if prefer == preferModuleInfo: preferModuleInfo else: preferTypeName)
-    of tyIterable:
-      # xxx factor this pattern
-      result = "iterable"
-      if t.hasElementType:
-        result &= "[" & typeToString(t.skipModifier) & ']'
-    of tyTuple:
-      # we iterate over t.sons here, because t.n may be nil
-      if t.n != nil:
-        result = "tuple["
-        for i in 0..<t.n.len:
-          assert(t.n[i].kind == nkSym)
-          result.add(t.n[i].sym.name.s & ": " & typeToString(t.n[i].sym.typ))
-          if i < t.n.len - 1: result.add(", ")
-        result.add(']')
-      elif t.isEmptyTupleType:
-        result = "tuple[]"
-      elif t.isSingletonTupleType:
-        result = "("
-        for son in t.kids:
-          result.add(typeToString(son))
-        result.add(",)")
-      else:
-        result = "("
-        for i, son in t.ikids:
-          if i > 0: result.add ", "
-          result.add(typeToString(son))
-        result.add(')')
-    of tyPtr, tyRef, tyVar, tyLent:
-      result = if isOutParam(t): "out " else: typeToStr[t.kind]
-      result.add typeToString(t.elementType)
-    of tyRange:
-      result = "range "
-      if t.n != nil and t.n.kind == nkRange:
-        result.add rangeToStr(t.n)
-      if prefer != preferExported:
-        result.add("(" & typeToString(t.elementType) & ")")
-    of tyProc:
-      result = if tfIterator in t.flags: "iterator "
-               elif t.owner != nil:
-                 case t.owner.kind
-                 of skTemplate: "template "
-                 of skMacro: "macro "
-                 of skConverter: "converter "
-                 else: "proc "
-              else:
-                "proc "
-      if tfUnresolved in t.flags: result.add "[*missing parameters*]"
-      result.add "("
-      for i, a in t.paramTypes:
-        if i > FirstParamAt: result.add(", ")
-        let j = paramTypeToNodeIndex(i)
-        if t.n != nil and j < t.n.len and t.n[j].kind == nkSym:
-          result.add(t.n[j].sym.name.s)
-          result.add(": ")
-        result.add(typeToString(a))
-      result.add(')')
-      if t.returnType != nil: result.add(": " & typeToString(t.returnType))
-      var prag = if t.callConv == ccNimCall and tfExplicitCallConv notin t.flags: "" else: $t.callConv
-      var hasImplicitRaises = false
-      if not isNil(t.owner) and not isNil(t.owner.ast) and (t.owner.ast.len - 1) >= pragmasPos:
-        let pragmasNode = t.owner.ast[pragmasPos]
-        let raisesSpec = effectSpec(pragmasNode, wRaises)
-        if not isNil(raisesSpec):
-          addSep(prag)
-          prag.add("raises: ")
-          prag.add($raisesSpec)
-          hasImplicitRaises = true
-      if tfNoSideEffect in t.flags:
-        addSep(prag)
-        prag.add("noSideEffect")
-      if tfThread in t.flags:
-        addSep(prag)
-        prag.add("gcsafe")
-      var effectsOfStr = ""
-      for i, a in t.paramTypes:
-        let j = paramTypeToNodeIndex(i)
-        if t.n != nil and j < t.n.len and t.n[j].kind == nkSym and t.n[j].sym.kind == skParam and sfEffectsDelayed in t.n[j].sym.flags:
-          addSep(effectsOfStr)
-          effectsOfStr.add(t.n[j].sym.name.s)
-      if effectsOfStr != "":
-        addSep(prag)
-        prag.add("effectsOf: ")
-        prag.add(effectsOfStr)
-      if not hasImplicitRaises and prefer == preferInferredEffects and not isNil(t.owner) and not isNil(t.owner.typ) and not isNil(t.owner.typ.n) and (t.owner.typ.n.len > 0):
-        let effects = t.n[0]
-        if effects.kind == nkEffectList and effects.len == effectListLen:
-          var inferredRaisesStr = ""
-          let effs = effects[exceptionEffects]
-          if not isNil(effs):
-            for eff in items(effs):
-              if not isNil(eff):
-                addSep(inferredRaisesStr)
-                inferredRaisesStr.add($eff.typ)
-          addSep(prag)
-          prag.add("raises: <inferred> [")
-          prag.add(inferredRaisesStr)
-          prag.add("]")
-      if prag.len != 0: result.add("{." & prag & ".}")
-    of tyVarargs:
-      result = typeToStr[t.kind] % typeToString(t.elementType)
-    of tySink:
-      result = "sink " & typeToString(t.skipModifier)
-    of tyOwned:
-      result = "owned " & typeToString(t.elementType)
-    else:
-      result = typeToStr[t.kind]
-    result.addTypeFlags(t)
-  result = typeToString(typ, prefer)
-
 proc firstOrd*(conf: ConfigRef; t: PType): Int128 =
   case t.kind
   of tyBool, tyChar, tySequence, tyOpenArray, tyString, tyVarargs, tyError:

compiler/vm.nim

@@ -120,7 +120,7 @@ template decodeBx(k: untyped) {.dirty.} =
   ensureKind(k)
 
 template move(a, b: untyped) {.dirty.} =
-  when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc):
+  when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc) or defined(gcYrc):
     a = move b
   else:
     system.shallowCopy(a, b)
@@ -557,7 +557,7 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
   # Used to keep track of where the execution is resumed.
   var savedPC = -1
   var savedFrame: PStackFrame = nil
-  when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc):
+  when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc) or defined(gcYrc):
     template updateRegsAlias = discard
     template regs: untyped = tos.slots
   else:
@@ -663,7 +663,10 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
       of rkNode:
         if regs[rb].node.typ.kind notin PtrLikeKinds:
           stackTrace(c, tos, pc, "opcCastIntToPtr: regs[rb].node.typ: " & $regs[rb].node.typ.kind)
-        node2.intVal = regs[rb].node.intVal
+        if regs[rb].node.kind == nkNilLit:
+          node2.intVal = 0
+        else:
+          node2.intVal = regs[rb].node.intVal
       else: stackTrace(c, tos, pc, "opcCastIntToPtr: regs[rb].kind: " & $regs[rb].kind)
       regs[ra].node = node2
     of opcAsgnComplex:
@@ -1837,6 +1840,20 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
       case a.kind
       of nkFloatLit..nkFloat64Lit: regs[ra].floatVal = a.floatVal
       else: stackTrace(c, tos, pc, errFieldXNotFound & "floatVal")
+    of opcNSymbol:
+      decodeB(rkNode)
+      let a = regs[rb].node
+      if a.kind == nkSym:
+        regs[ra].node = copyNode(a)
+      else:
+        stackTrace(c, tos, pc, errFieldXNotFound & "symbol")
+    of opcNIdent:
+      decodeB(rkNode)
+      let a = regs[rb].node
+      if a.kind == nkIdent:
+        regs[ra].node = copyNode(a)
+      else:
+        stackTrace(c, tos, pc, errFieldXNotFound & "ident")
     of opcNodeId:
       decodeB(rkInt)
       when defined(useNodeIds):
@@ -2142,6 +2159,20 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
         dest.floatVal = regs[rb].floatVal
       else:
         stackTrace(c, tos, pc, errFieldXNotFound & "floatVal")
+    of opcNSetSymbol:
+      decodeB(rkNode)
+      var dest = regs[ra].node
+      if dest.kind == nkSym and regs[rb].node.kind == nkSym:
+        dest.sym = regs[rb].node.sym
+      else:
+        stackTrace(c, tos, pc, errFieldXNotFound & "symbol")
+    of opcNSetIdent:
+      decodeB(rkNode)
+      var dest = regs[ra].node
+      if dest.kind == nkIdent and regs[rb].node.kind == nkIdent:
+        dest.ident = regs[rb].node.ident
+      else:
+        stackTrace(c, tos, pc, errFieldXNotFound & "ident")
     of opcNSetStrVal:
       decodeB(rkNode)
       var dest = regs[ra].node

compiler/vmdef.nim

@@ -119,13 +119,15 @@ type
     opcNSymKind,
     opcNIntVal,
     opcNFloatVal,
+    opcNSymbol,
+    opcNIdent,
     opcNGetType,
     opcNStrVal,
     opcNSigHash,
     opcNGetSize,
 
     opcNSetIntVal,
-    opcNSetFloatVal, opcNSetStrVal,
+    opcNSetFloatVal, opcNSetSymbol, opcNSetIdent, opcNSetStrVal,
     opcNNewNimNode, opcNCopyNimNode, opcNCopyNimTree, opcNDel, opcGenSym,
 
     opcNccValue, opcNccInc, opcNcsAdd, opcNcsIncl, opcNcsLen, opcNcsAt,

compiler/vmgen.nim

@@ -803,6 +803,8 @@ proc genNarrow(c: PCtx; n: PNode; dest: TDest) =
     let first = c.genx(newIntTypeNode(firstOrd(c.config, t), intType))
     let last = c.genx(newIntTypeNode(lastOrd(c.config, t), intType))
     c.gABC(n, opcNarrowR, dest, first, last)
+    c.freeTemp(first)
+    c.freeTemp(last)
 
 proc genNarrowU(c: PCtx; n: PNode; dest: TDest) =
   let t = skipTypes(n.typ, abstractVar-{tyTypeDesc})
@@ -1373,6 +1375,8 @@ proc genMagic(c: PCtx; n: PNode; dest: var TDest; flags: TGenFlags = {}, m: TMag
 
   of mNIntVal: genUnaryABC(c, n, dest, opcNIntVal)
   of mNFloatVal: genUnaryABC(c, n, dest, opcNFloatVal)
+  of mNSymbol: genUnaryABC(c, n, dest, opcNSymbol)
+  of mNIdent: genUnaryABC(c, n, dest, opcNIdent)
   of mNGetType:
     let tmp = c.genx(n[1])
     if dest < 0: dest = c.getTemp(n.typ)
@@ -1399,6 +1403,12 @@ proc genMagic(c: PCtx; n: PNode; dest: var TDest; flags: TGenFlags = {}, m: TMag
   of mNSetFloatVal:
     unused(c, n, dest)
     genBinaryStmt(c, n, opcNSetFloatVal)
+  of mNSetSymbol:
+    unused(c, n, dest)
+    genBinaryStmt(c, n, opcNSetSymbol)
+  of mNSetIdent:
+    unused(c, n, dest)
+    genBinaryStmt(c, n, opcNSetIdent)
   of mNSetStrVal:
     unused(c, n, dest)
     genBinaryStmt(c, n, opcNSetStrVal)
@@ -1578,7 +1588,6 @@ proc genAsgn(c: PCtx; dest: TDest; ri: PNode; requiresCopy: bool) =
 proc setSlot(c: PCtx; v: PSym) =
   # XXX generate type initialization here?
   if v.position == 0:
-    # IC: review this solution again later
     v.positionImpl = getFreeRegister(c, if v.kind == skLet: slotFixedLet else: slotFixedVar, start = 1)
 
 template cannotEval(c: PCtx; n: PNode) =

compiler/vtables.nim

@@ -82,7 +82,7 @@ proc containGenerics(base: PType, s: seq[tuple[depth: int, value: PType]]): bool
       break
 
 proc collectVTableDispatchers*(g: ModuleGraph) =
-  var itemTable = initTable[ItemId, seq[LazySym]]()
+  var itemTable = initTable[ItemId, seq[PSym]]()
   var rootTypeSeq = newSeq[PType]()
   var rootItemIdCount = initCountTable[ItemId]()
   for bucket in 0..<g.methods.len:
@@ -95,7 +95,7 @@ proc collectVTableDispatchers*(g: ModuleGraph) =
       let methodIndexLen = g.bucketTable[baseType.itemId]
       if baseType.itemId notin itemTable: # once is enough
         rootTypeSeq.add baseType
-        itemTable[baseType.itemId] = newSeq[LazySym](methodIndexLen)
+        itemTable[baseType.itemId] = newSeq[PSym](methodIndexLen)
 
         sort(g.objectTree[baseType.itemId], cmp = proc (x, y: tuple[depth: int, value: PType]): int =
           if x.depth >= y.depth: 1
@@ -104,7 +104,7 @@ proc collectVTableDispatchers*(g: ModuleGraph) =
 
         for item in g.objectTree[baseType.itemId]:
           if item.value.itemId notin itemTable:
-            itemTable[item.value.itemId] = newSeq[LazySym](methodIndexLen)
+            itemTable[item.value.itemId] = newSeq[PSym](methodIndexLen)
 
       var mIndex = 0 # here is the correpsonding index
       if baseType.itemId notin rootItemIdCount:
@@ -114,13 +114,13 @@ proc collectVTableDispatchers*(g: ModuleGraph) =
         rootItemIdCount.inc(baseType.itemId)
       for idx in 0..<g.methods[bucket].methods.len:
         let obj = g.methods[bucket].methods[idx].typ.firstParamType.skipTypes(skipPtrs)
-        itemTable[obj.itemId][mIndex] = LazySym(sym: g.methods[bucket].methods[idx])
+        itemTable[obj.itemId][mIndex] = g.methods[bucket].methods[idx]
       g.addDispatchers genVTableDispatcher(g, g.methods[bucket].methods, mIndex)
     else: # if the base object doesn't have this method
       g.addDispatchers genIfDispatcher(g, g.methods[bucket].methods, relevantCols, g.idgen)
 
 proc sortVTableDispatchers*(g: ModuleGraph) =
-  var itemTable = initTable[ItemId, seq[LazySym]]()
+  var itemTable = initTable[ItemId, seq[PSym]]()
   var rootTypeSeq = newSeq[ItemId]()
   var rootItemIdCount = initCountTable[ItemId]()
   for bucket in 0..<g.methods.len:
@@ -133,7 +133,7 @@ proc sortVTableDispatchers*(g: ModuleGraph) =
       let methodIndexLen = g.bucketTable[baseType.itemId]
       if baseType.itemId notin itemTable: # once is enough
         rootTypeSeq.add baseType.itemId
-        itemTable[baseType.itemId] = newSeq[LazySym](methodIndexLen)
+        itemTable[baseType.itemId] = newSeq[PSym](methodIndexLen)
 
         sort(g.objectTree[baseType.itemId], cmp = proc (x, y: tuple[depth: int, value: PType]): int =
           if x.depth >= y.depth: 1
@@ -142,7 +142,7 @@ proc sortVTableDispatchers*(g: ModuleGraph) =
 
         for item in g.objectTree[baseType.itemId]:
           if item.value.itemId notin itemTable:
-            itemTable[item.value.itemId] = newSeq[LazySym](methodIndexLen)
+            itemTable[item.value.itemId] = newSeq[PSym](methodIndexLen)
 
       var mIndex = 0 # here is the correpsonding index
       if baseType.itemId notin rootItemIdCount:
@@ -152,7 +152,7 @@ proc sortVTableDispatchers*(g: ModuleGraph) =
         rootItemIdCount.inc(baseType.itemId)
       for idx in 0..<g.methods[bucket].methods.len:
         let obj = g.methods[bucket].methods[idx].typ.firstParamType.skipTypes(skipPtrs)
-        itemTable[obj.itemId][mIndex] = LazySym(sym: g.methods[bucket].methods[idx])
+        itemTable[obj.itemId][mIndex] = g.methods[bucket].methods[idx]
 
   for baseType in rootTypeSeq:
     g.setMethodsPerType(baseType, itemTable[baseType])
@@ -160,7 +160,7 @@ proc sortVTableDispatchers*(g: ModuleGraph) =
       let typ = item.value.skipTypes(skipPtrs)
       let idx = typ.itemId
       for mIndex in 0..<itemTable[idx].len:
-        if itemTable[idx][mIndex].sym == nil:
+        if itemTable[idx][mIndex] == nil:
           let parentIndex = typ.baseClass.skipTypes(skipPtrs).itemId
           itemTable[idx][mIndex] = itemTable[parentIndex][mIndex]
       g.setMethodsPerType(idx, itemTable[idx])

doc/advopt.txt

@@ -115,6 +115,7 @@ Advanced options:
   --docSeeSrcUrl:url        activate 'see source' for doc command
                             (see doc.item.seesrc in config/nimdoc.cfg)
   --docInternal             also generate documentation for non-exported symbols
+  --raw                     turn off markup rendering for JSON docs
   --lineDir:on|off          generation of #line directive on|off
   --embedsrc:on|off         embeds the original source code as comments
                             in the generated output

doc/ic.md

@@ -0,0 +1,166 @@
+======================================
+  Incremental Compilation (IC)
+======================================
+
+The ``nim ic`` command provides incremental compilation support for Nim projects,
+allowing faster rebuilds by reusing previously compiled intermediate representations
+of modules that haven't changed.
+
+Overview
+========
+
+Incremental compilation works by decomposing the compilation process into several stages:
+
+1. **Parsing** - Source files are parsed into an abstract syntax tree (AST)
+2. **Semantic Analysis** - Symbols are resolved and type checking is performed
+3. **Code Generation** - Platform-specific code is generated from the analyzed AST
+4. **Linking** - The generated code is linked into an executable
+
+The IC mechanism caches the results of earlier stages in NIF files
+(Nim intermediate format): ``.p.nif`` (parsed), ``.deps.nif`` (dependencies),
+and ``.nif`` (semantically analyzed). When recompiling, only modules that have
+changed need to be reprocessed through the semantic analysis and code generation
+stages, significantly reducing compilation time for large projects.
+
+NIF File Format
+===============
+
+NIF (Nim Intermediate Format) files are text-based files that use a Lisp-like
+syntax. They employ a hybrid format where byte offsets into the text are used for
+efficient access, making them simultaneously human-readable and machine-efficient.
+The text representation is particularly valuable for debugging and introspection.
+
+Each ``.nim`` module produces its own ``.nif`` file during compilation.
+The NIF format contains:
+
+- **Header** - Version information (e.g., `(.nif26)`)
+- **Dependencies** - List of source files and dependencies
+- **Interface** - Exported symbols and their indices
+- **Body** - The intermediate representation of the module's code in Lisp-like syntax
+
+The NIF format is designed specifically for Nim and allows efficient serialization
+and deserialization of the compiler's intermediate representation while remaining
+readable and debuggable by tools and developers.
+
+The ``nim ic`` Switch
+=====================
+
+The ``nim ic`` command initiates incremental compilation for a project.
+It automatically manages the build process by:
+
+1. Parsing all source files into ``.nif`` format (using the ``nifler`` tool)
+2. Performing semantic analysis on modified modules
+3. Generating code only for modules with changes or dependencies on changed modules
+4. Generating a build file (in NIFMake format) that orchestrates the compilation
+5. Executing the build file through ``nifmake``
+
+Prerequisites
+-------------
+
+- **nifler** - Tool for parsing Nim source files into NIF format. The ``nim ic`` command uses ``nifler parse --deps`` to generate both parsed files (``.p.nif``) and dependency files (``.deps.nif``).
+- **nifmake** - Build orchestration tool that follows dependencies and executes the build rules defined in ``.build.nif`` files.
+
+If these tools are not available, ``nim ic`` will display instructions on how to
+obtain them.
+
+Key Modules for IC Logic
+=========================
+
+The primary modules in the compiler that handle incremental compilation logic are:
+
+- **deps.nim** - Dependency analysis and build file generation. Contains the
+  ``commandIc`` procedure which is the main entry point for the ``nim ic`` command.
+  This module orchestrates the incremental compilation process, handling dependency
+  traversal (via ``nifler deps``), build rule generation, and build file creation.
+  The build file is written to ``nifcache/`` directory. This module also explicitly
+  models ``system.nim`` as a dependency of all modules.
+
+- **ast2nif.nim** - Core mapping between AST and NIF.
+
+
+**Code, Logic & Debugging**
+===========================
+
+This section focuses on the compiler-side code paths, the logic you will
+inspect while debugging IC, and a pragmatic manual workflow for bug hunting
+using local invocations such as ``nim m --nimcache:nifcache``.
+
+Core places to inspect
+- **`compiler/deps.nim`**: generates the NIF-based build file and implements
+  ``commandIc`` (entry point for ``nim ic``). Look for how build rules are
+  emitted (calls to the NIF builder) and how inputs/outputs are wired.
+- **`compiler/modulegraphs.nim`** and **`compiler/pipelines.nim`**:
+  dependency graph and compilation pipeline integration — useful when a module
+  is rebuilt unexpectedly.
+
+Understanding the NIF text
+- NIF files are human-readable; open the per-module ``.nif`` files in
+  ``nifcache/`` to inspect parsed ASTs, dependency lists and interface tables.
+- Because NIF uses textual nodes and byte offsets, tools can quickly seek to
+  positions in the file — but for debugging you usually only need to read the
+  file top-to-bottom.
+
+Manual bug-hunting workflow
+- Prepare a clean nimcache directory (relative to your project):
+
+  ```bash
+  mkdir -p nifcache
+  ```
+
+- Parse/semantic-check a single module and write NIF/sem artifacts:
+
+  ```bash
+  nim m --nimcache:nifcache path/to/module.nim
+  ```
+
+  - ``nim m`` runs the compiler up to the semantic checking stage for the
+    specified module and emits intermediate cache files into ``nifcache/``.
+  - Use this to reproduce and isolate failures in the semantic stage.
+
+- Inspect the generated files for that module under ``nifcache/`` (look for
+  ``.nif``, sem/parsed artifacts). Because NIF is text-based you can open and
+  grep it directly:
+
+  ```bash
+  sed -n '1,200p' nifcache/ModuleName.nif
+  grep -n "someSymbol" -n nifcache/ModuleName.nif
+  ```
+
+- To reproduce a full incremental compilation of the project, generate the
+  build file and run it (``nim ic`` automates this). The build file is generated
+  in ``nifcache/`` directory. To debug an individual build step, run the command
+  that the build file would execute manually:
+  - Parsing step: ``nifler parse --deps input.nim`` (produces ``.p.nif`` and ``.deps.nif``)
+  - Semantic step: ``nim m --nimcache:nifcache input.nim`` (produces ``.nif``)
+  - Code generation: ``nim nifc --nimcache:nifcache input.nim`` (produces executable)
+
+- Force a cache invalidation for a single module by removing its NIF/sem
+  artifact and re-running the semantic step:
+
+  ```bash
+  rm nifcache/ModuleName.nif
+  nim m --nimcache:nifcache path/to/ModuleName.nim
+  ```
+
+- When investigating incorrect replayed state (pragmas, `{.compile: ...}`):
+  inspect the replay actions in ``compiler/ic/replayer.nim`` and open the
+  module's NIF to find the ``toReplay``/action entries that will be executed
+  during reload.
+
+Tips for efficient debugging
+- Use ``--path:...`` flags when invoking ``nim m`` to emulate the exact
+  search paths used in your project, e.g. ``--path:lib --path:vendor``.
+- Compare two successive ``.nif`` files with ``diff`` to see what changed and
+  why a module was rebuilt.
+
+Where to change behavior
+- Cache invalidation decisions and build-rule emission are implemented in
+  ``compiler/deps.nim``. When investigating surprising
+  rebuilds, instrument those modules to log the footprint/hash/comparison
+  outcome.
+
+See also
+========
+
+- `nif-spec` - NIF format specification (text format and node grammar):
+  [nifspec/doc/nif-spec.md](../nifspec/doc/nif-spec.md)

doc/manual.md

@@ -1144,6 +1144,8 @@ semantic analysis). Assignments from the base type to one of its subrange types
 A subrange type has the same size as its base type (`int` in the
 Subrange example).
 
+Implicit "downsizing" conversions to range types (for example, `int -> range[0..255]` or `range[1..256] -> range[0..255]`) emit the `ImplicitRangeConversion` warning. Conversions that are clearly safe (for example, `range[0..255] -> range[0..65535]`) and any explicit casts do not trigger this warning. Conversions from `int` to common subranges such as `Natural` or `Positive` do not trigger this warning by default, but can be enabled with `--warning:systemRangeConversion`.
+
 
 Pre-defined floating-point types
 --------------------------------
@@ -7904,7 +7906,7 @@ alignment requirement of the type are ignored.
   main()
   ```
 
-This pragma has no effect on the JS backend.
+This pragma has no effect on the JavaScript backend and may significantly increase memory usage with the `--mm:refc` option.
 
 
 Noalias pragma

doc/manual_experimental.md

@@ -2127,7 +2127,7 @@ can be used in an `isolate` context:
     `=destroy`(dest.value)
   ```
 
-The `.sendable` pragma itself is an experimenal, unchecked, unsafe annotation. It is
+The `.sendable` pragma itself is an experimental, unchecked, unsafe annotation. It is
 currently only used by `Isolated[T]`.
 
 Virtual pragma

doc/markdown_rst.md

@@ -276,9 +276,9 @@ This parser has 2 modes for inline markup:
 
 2) Compatibility mode which is RST rules.
 
-.. Note:: in both modes the parser interpretes text between single
+.. Note:: in both modes the parser interprets text between single
      backticks (code) identically:
-     backslash does not escape; the only exception: ``\`` folowed by `
+     backslash does not escape; the only exception: ``\`` followed by `
      does escape so that we can always input a single backtick ` in
      inline code. However that makes impossible to input code with
      ``\`` at the end in *single* backticks, one must use *double*

doc/nimgrep_cmdline.txt

@@ -52,7 +52,7 @@ Options:
                           nimgrep --filenames               # In current dir
                           nimgrep --filenames "" DIRECTORY
                            # Note empty pattern "", lists all files in DIRECTORY
-* Interprete patterns:
+* Interpret patterns:
   --peg               PATTERN and PAT are Peg
   --re                PATTERN and PAT are regular expressions (default)
   --rex, -x           use the "extended" syntax for the regular expression

doc/packaging.md

@@ -27,7 +27,7 @@ Nim runs on a wide variety of platforms. Support on amd64 and i386 is tested reg
 - ppc64el (aka ppc64le)
 - riscv64
 
-The following platforms are seldomly tested:
+The following platforms are rarely tested:
 
 - alpha
 - hppa

doc/pegdocs.txt

@@ -20,8 +20,8 @@ notation           meaning
                    as they succeed. Indicate success if all succeeded.
                    Otherwise, do not consume any text and indicate failure.
                    The sequence's precedence is higher than that of ordered
-                   choice: ``A B / C`` means ``(A B) / Z`` and
-                   not ``A (B / Z)``.
+                   choice: ``A B / C`` means ``(A B) / C`` and
+                   not ``A (B / C)``.
 ``(E)``            Grouping: Parenthesis can be used to change
                    operator priority.
 ``{E}``            Capture: Apply expression `E` and store the substring

doc/tut1.md

@@ -1159,8 +1159,8 @@ In Nim new types can be defined within a `type` statement:
 
   ```nim  test = "nim c $1"
   type
-    biggestInt = int64      # biggest integer type that is available
-    biggestFloat = float64  # biggest float type that is available
+    BiggestInt = int64      # biggest integer type that is available
+    BiggestFloat = float64  # biggest float type that is available
   ```
 
 Enumeration and object types may only be defined within a

koch.nim

@@ -12,11 +12,11 @@
 const
   # examples of possible values for repos: Head, ea82b54
   NimbleStableCommit = "9207e8b2bbdf66b5a4d1020214cff44d2d30df92"    # 0.20.1
-  AtlasStableCommit = "2aa62121b40d580aa2fb27920a37b938d36c5f57"     # 0.9.4
+  AtlasStableCommit = "ff1f4289482dce94ba9f95b3b0ae16d16e21eb3d"     # 0.10.1
   ChecksumsStableCommit = "0b8e46379c5bc1bf73d8b3011908389c60fb9b98" # 2.0.1
-  SatStableCommit = "faf1617f44d7632ee9601ebc13887644925dcc01"
+  SatStableCommit = "e63eaea8baf00bed8bcd5a29ffd8823abb265b39"
 
-  NimonyStableCommit = "fc8baa61b9911caf4666685a5f5ed41b9c04f6f8" # unversioned \
+  NimonyStableCommit = "deb9b50c573fb55e071825ab55385e293b7216d5" # 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.
@@ -558,9 +558,7 @@ proc icTest(args: string) =
   for fragment in content.split("#!EDIT!#"):
     let file = inp.replace(".nim", "_temp.nim")
     writeFile(file, fragment)
-    var cmd = nimExe & " cpp --ic:legacy -d:nimIcIntegrityChecks --listcmd "
-    if i == 0:
-      cmd.add "-f "
+    var cmd = nimExe & " ic --hint:Conf:off --warnings:off "
     cmd.add quoteShell(file)
     exec(cmd)
     inc i

lib/core/macros.nim

@@ -117,6 +117,7 @@ type
     ntyCompositeTypeClass, ntyInferred, ntyAnd, ntyOr, ntyNot,
     ntyAnything, ntyStatic, ntyFromExpr, ntyOptDeprecated, ntyVoid
 
+  TNimTypeKinds* {.deprecated.} = set[NimTypeKind]
   NimSymKind* = enum
     nskUnknown, nskConditional, nskDynLib, nskParam,
     nskGenericParam, nskTemp, nskModule, nskType, nskVar, nskLet,
@@ -126,10 +127,24 @@ type
     nskEnumField, nskForVar, nskLabel,
     nskStub
 
+  TNimSymKinds* {.deprecated.} = set[NimSymKind]
+
 const
   nnkMutableTy* {.deprecated.} = nnkOutTy
   nnkSharedTy* {.deprecated.} = nnkSinkAsgn
 
+type
+  NimIdent* {.deprecated.} = object of RootObj
+    ## Represents a Nim identifier in the AST. **Note**: This is only
+    ## rarely useful, for identifier construction from a string
+    ## use `ident"abc"`.
+
+  NimSymObj = object # hidden
+  NimSym* {.deprecated.} = ref NimSymObj
+    ## Represents a Nim *symbol* in the compiler; a *symbol* is a looked-up
+    ## *ident*.
+
+
 const
   nnkLiterals* = {nnkCharLit..nnkNilLit}
   # see matching set CallNodes below
@@ -137,10 +152,26 @@ const
                    nnkCallStrLit, nnkHiddenCallConv}
   nnkPragmaCallKinds = {nnkExprColonExpr, nnkCall, nnkCallStrLit}
 
+{.push warnings: off.}
+
+proc toNimIdent*(s: string): NimIdent {.magic: "StrToIdent", noSideEffect, deprecated:
+  "Deprecated since version 0.18.0: Use 'ident' or 'newIdentNode' instead.".}
+  ## Constructs an identifier from the string `s`.
+
+proc `==`*(a, b: NimIdent): bool {.magic: "EqIdent", noSideEffect, deprecated:
+  "Deprecated since version 0.18.1; Use '==' on 'NimNode' instead.".}
+  ## Compares two Nim identifiers.
+
 proc `==`*(a, b: NimNode): bool {.magic: "EqNimrodNode", noSideEffect.}
   ## Compare two Nim nodes. Return true if nodes are structurally
   ## equivalent. This means two independently created nodes can be equal.
 
+proc `==`*(a, b: NimSym): bool {.magic: "EqNimrodNode", noSideEffect, deprecated:
+  "Deprecated since version 0.18.1; Use '==(NimNode, NimNode)' instead.".}
+  ## Compares two Nim symbols.
+
+{.pop.}
+
 proc sameType*(a, b: NimNode): bool {.magic: "SameNodeType", noSideEffect.} =
   ## Compares two Nim nodes' types. Return true if the types are the same,
   ## e.g. true when comparing alias with original type.
@@ -221,6 +252,25 @@ proc strVal*(n: NimNode): string  {.magic: "NStrVal", noSideEffect.}
   ## See also:
   ## * `strVal= proc<#strVal=,NimNode,string>`_ for setting the string value.
 
+{.push warnings: off.} # silence `deprecated`
+
+proc ident*(n: NimNode): NimIdent {.magic: "NIdent", noSideEffect, deprecated:
+  "Deprecated since version 0.18.1; All functionality is defined on 'NimNode'.".}
+
+proc symbol*(n: NimNode): NimSym {.magic: "NSymbol", noSideEffect, deprecated:
+  "Deprecated since version 0.18.1; All functionality is defined on 'NimNode'.".}
+
+proc getImpl*(s: NimSym): NimNode {.magic: "GetImpl", noSideEffect, deprecated: "use `getImpl: NimNode -> NimNode` instead".}
+
+proc `$`*(i: NimIdent): string {.magic: "NStrVal", noSideEffect, deprecated:
+  "Deprecated since version 0.18.1; Use 'strVal' instead.".}
+  ## Converts a Nim identifier to a string.
+
+proc `$`*(s: NimSym): string {.magic: "NStrVal", noSideEffect, deprecated:
+  "Deprecated since version 0.18.1; Use 'strVal' instead.".}
+  ## Converts a Nim symbol to a string.
+
+{.pop.}
 
 when (NimMajor, NimMinor, NimPatch) >= (1, 3, 5) or defined(nimSymImplTransform):
   proc getImplTransformed*(symbol: NimNode): NimNode {.magic: "GetImplTransf", noSideEffect.}
@@ -323,6 +373,15 @@ proc getTypeImpl*(n: typedesc): NimNode {.magic: "NGetType", noSideEffect.}
 proc `intVal=`*(n: NimNode, val: BiggestInt) {.magic: "NSetIntVal", noSideEffect.}
 proc `floatVal=`*(n: NimNode, val: BiggestFloat) {.magic: "NSetFloatVal", noSideEffect.}
 
+{.push warnings: off.}
+
+proc `symbol=`*(n: NimNode, val: NimSym) {.magic: "NSetSymbol", noSideEffect, deprecated:
+  "Deprecated since version 0.18.1; Generate a new 'NimNode' with 'genSym' instead.".}
+
+proc `ident=`*(n: NimNode, val: NimIdent) {.magic: "NSetIdent", noSideEffect, deprecated:
+  "Deprecated since version 0.18.1; Generate a new 'NimNode' with 'ident(string)' instead.".}
+
+{.pop.}
 
 proc `strVal=`*(n: NimNode, val: string) {.magic: "NSetStrVal", noSideEffect.}
   ## Sets the string value of a string literal or comment.
@@ -374,15 +433,15 @@ when defined(nimHasNoReturnError):
 else:
   {.pragma: errorNoReturn.}
 
-proc error*(msg: string, n: NimNode = nil) {.magic: "NError", benign, errorNoReturn.}
+proc error*(msg: string, n: NimNode = nil) {.magic: "NError", gcsafe, errorNoReturn.}
   ## Writes an error message at compile time. The optional `n: NimNode`
   ## parameter is used as the source for file and line number information in
   ## the compilation error message.
 
-proc warning*(msg: string, n: NimNode = nil) {.magic: "NWarning", benign.}
+proc warning*(msg: string, n: NimNode = nil) {.magic: "NWarning", gcsafe.}
   ## Writes a warning message at compile time.
 
-proc hint*(msg: string, n: NimNode = nil) {.magic: "NHint", benign.}
+proc hint*(msg: string, n: NimNode = nil) {.magic: "NHint", gcsafe.}
   ## Writes a hint message at compile time.
 
 proc newStrLitNode*(s: string): NimNode {.noSideEffect.} =
@@ -405,6 +464,14 @@ proc newFloatLitNode*(f: BiggestFloat): NimNode =
   result = newNimNode(nnkFloatLit)
   result.floatVal = f
 
+{.push warnings: off.}
+
+proc newIdentNode*(i: NimIdent): NimNode {.deprecated: "use ident(string)".} =
+  ## Creates an identifier node from `i`.
+  result = newNimNode(nnkIdent)
+  result.ident = i
+
+{.pop.}
 
 proc newIdentNode*(i: string): NimNode {.magic: "StrToIdent", noSideEffect.}
   ## Creates an identifier node from `i`. It is simply an alias for
@@ -444,7 +511,7 @@ proc genSym*(kind: NimSymKind = nskLet; ident = ""): NimNode {.
   ## Generates a fresh symbol that is guaranteed to be unique. The symbol
   ## needs to occur in a declaration context.
 
-proc callsite*(): NimNode {.magic: "NCallSite", benign, deprecated:
+proc callsite*(): NimNode {.magic: "NCallSite", gcsafe, deprecated:
   "Deprecated since v0.18.1; use `varargs[untyped]` in the macro prototype instead".}
   ## Returns the AST of the invocation expression that invoked this macro.
   # see https://github.com/nim-lang/RFCs/issues/387 as candidate replacement.
@@ -655,6 +722,17 @@ proc newCall*(theProc: NimNode, args: varargs[NimNode]): NimNode =
   result.add(theProc)
   result.add(args)
 
+{.push warnings: off.}
+
+proc newCall*(theProc: NimIdent, args: varargs[NimNode]): NimNode {.deprecated:
+  "Deprecated since v0.18.1; use 'newCall(string, ...)' or 'newCall(NimNode, ...)' instead".} =
+  ## Produces a new call node. `theProc` is the proc that is called with
+  ## the arguments `args[0..]`.
+  result = newNimNode(nnkCall)
+  result.add(newIdentNode(theProc))
+  result.add(args)
+
+{.pop.}
 
 proc newCall*(theProc: string,
               args: varargs[NimNode]): NimNode =
@@ -855,7 +933,7 @@ proc eqIdent*(a: NimNode; b: NimNode): bool {.magic: "EqIdent", noSideEffect.}
 
 const collapseSymChoice = not defined(nimLegacyMacrosCollapseSymChoice)
 
-proc treeTraverse(n: NimNode; res: var string; level = 0; isLisp = false, indented = false) {.benign.} =
+proc treeTraverse(n: NimNode; res: var string; level = 0; isLisp = false, indented = false) {.gcsafe.} =
   if level > 0:
     if indented:
       res.add("\n")
@@ -904,21 +982,21 @@ proc treeTraverse(n: NimNode; res: var string; level = 0; isLisp = false, indent
   if isLisp:
     res.add(")")
 
-proc treeRepr*(n: NimNode): string {.benign.} =
+proc treeRepr*(n: NimNode): string {.gcsafe.} =
   ## Convert the AST `n` to a human-readable tree-like string.
   ##
   ## See also `repr`, `lispRepr`_, and `astGenRepr`_.
   result = ""
   n.treeTraverse(result, isLisp = false, indented = true)
 
-proc lispRepr*(n: NimNode; indented = false): string {.benign.} =
+proc lispRepr*(n: NimNode; indented = false): string {.gcsafe.} =
   ## Convert the AST `n` to a human-readable lisp-like string.
   ##
   ## See also `repr`, `treeRepr`_, and `astGenRepr`_.
   result = ""
   n.treeTraverse(result, isLisp = true, indented = indented)
 
-proc astGenRepr*(n: NimNode): string {.benign.} =
+proc astGenRepr*(n: NimNode): string {.gcsafe.} =
   ## Convert the AST `n` to the code required to generate that AST.
   ##
   ## See also `repr`_, `treeRepr`_, and `lispRepr`_.
@@ -927,7 +1005,7 @@ proc astGenRepr*(n: NimNode): string {.benign.} =
     NodeKinds = {nnkEmpty, nnkIdent, nnkSym, nnkNone, nnkCommentStmt}
     LitKinds = {nnkCharLit..nnkInt64Lit, nnkFloatLit..nnkFloat64Lit, nnkStrLit..nnkTripleStrLit}
 
-  proc traverse(res: var string, level: int, n: NimNode) {.benign.} =
+  proc traverse(res: var string, level: int, n: NimNode) {.gcsafe.} =
     for i in 0..level-1: res.add "  "
     if n.kind in NodeKinds:
       res.add("new" & ($n.kind).substr(3) & "Node(")

lib/impure/nre/private/util.nim

@@ -15,6 +15,9 @@ template formatStr*(howExpr, namegetter, idgetter): untyped =
       val.add(how[i])
       i += 1
     else:
+      if i + 1 >= how.len:
+        raise newException(ValueError, "Syntax error in format string at " & $i)
+
       if how[i + 1] == '$':
         val.add('$')
         i += 2
@@ -27,7 +30,7 @@ template formatStr*(howExpr, namegetter, idgetter): untyped =
         i += 1
         var id {.inject.} = 0
         while i < how.len and how[i] in {'0'..'9'}:
-          id += (id * 10) + (ord(how[i]) - ord('0'))
+          id = (id * 10) + (ord(how[i]) - ord('0'))
           i += 1
         val.add(idgetter)
         lastNum = id + 1
@@ -44,6 +47,8 @@ template formatStr*(howExpr, namegetter, idgetter): untyped =
         while i < how.len and how[i] != '}':
           name.add(how[i])
           i += 1
+        if i >= how.len or how[i] != '}':
+          raise newException(ValueError, "Syntax error in format string at " & $i)
         i += 1
         val.add(namegetter)
       else:

lib/pure/asyncdispatch.nim

@@ -1946,9 +1946,14 @@ proc withTimeout*[T](fut: Future[T], timeout: int): owned(Future[bool]) =
           retFuture.fail(fut.error)
         else:
           retFuture.complete(true)
+        # Timeout side lost; drop its callback to avoid retaining closures/futures.
+        timeoutFuture.clearCallbacks()
   timeoutFuture.callback =
     proc () =
-      if not retFuture.finished: retFuture.complete(false)
+      if not retFuture.finished:
+        retFuture.complete(false)
+        # Wrapped future side lost; drop its callback to avoid retaining closures/futures.
+        fut.clearCallbacks()
   return retFuture
 
 proc accept*(socket: AsyncFD,

lib/pure/asynchttpserver.nim

@@ -188,7 +188,7 @@ proc processRequest(
   # \n
   request.headers.clear()
   request.body = ""
-  when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc):
+  when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc) or defined(gcYrc):
     request.hostname = address
   else:
     request.hostname.shallowCopy(address)

lib/pure/base64.nim

@@ -255,6 +255,9 @@ proc decode*(s: string): string =
   while inputIndex <= inputEnds:
     while s[inputIndex] in {'\n', '\r', ' '}:
       inc inputIndex
+    # double check inputIndex as it can be incremented due to whitespace
+    if inputIndex > inputEnds:
+      break
     inputChar(a)
     inputChar(b)
     inputChar(c)

lib/pure/coro.nim

@@ -36,7 +36,7 @@ when defined(nimPreviewSlimSystem):
   import std/assertions
 
 const defaultStackSize = 512 * 1024
-const useOrcArc = defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc)
+const useOrcArc = defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc) or defined(gcYrc)
 
 when useOrcArc:
   proc nimGC_setStackBottom*(theStackBottom: pointer) = discard

lib/pure/json.nim

@@ -866,7 +866,7 @@ proc parseJson(p: var JsonParser; rawIntegers, rawFloats: bool, depth = 0): Json
   case p.tok
   of tkString:
     # we capture 'p.a' here, so we need to give it a fresh buffer afterwards:
-    when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc):
+    when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc) or defined(gcYrc):
       result = JsonNode(kind: JString, str: move p.a)
     else:
       result = JsonNode(kind: JString)

lib/pure/marshal.nim

@@ -305,7 +305,7 @@ proc store*[T](s: Stream, data: sink T) =
 
   var stored = initIntSet()
   var d: T
-  when defined(gcArc) or defined(gcOrc)or defined(gcAtomicArc):
+  when defined(gcArc) or defined(gcOrc)or defined(gcAtomicArc) or defined(gcYrc):
     d = data
   else:
     shallowCopy(d, data)
@@ -334,7 +334,7 @@ proc `$$`*[T](x: sink T): string =
   else:
     var stored = initIntSet()
     var d: T
-    when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc):
+    when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc) or defined(gcYrc):
       d = x
     else:
       shallowCopy(d, x)

lib/pure/parseopt.nim

@@ -14,149 +14,306 @@
 ## Supported Syntax
 ## ================
 ##
-## The following syntax is supported when arguments for the `shortNoVal` and
-## `longNoVal` parameters, which are
-## `described later<#nimshortnoval-and-nimlongnoval>`_, are not provided:
+## The syntax described here applies to the default way the parser works.
+## The behavior is configurable, though, and two additional modes
+## are supported, see the details: `Parser Modes`_.
 ##
-## 1. Short options: `-abcd`, `-e:5`, `-e=5`
+## Parsing also depends on whether the `shortNoVal` and `longNoVal` parameters
+## are omitted/empty or provided. The details are described in a
+## `later section<#nimshortnoval-and-nimlongnoval>`_.
+##
+## The following syntax is supported:
+##
+## 1. Short options: `-a:5`, `-b=5`, `-cde`, `-fgh=5`
 ## 2. Long options: `--foo:bar`, `--foo=bar`, `--foo`
 ## 3. Arguments: everything that does not start with a `-`
 ##
-## These three kinds of tokens are enumerated in the
-## `CmdLineKind enum<#CmdLineKind>`_.
+## Passing values to options **requires** a separator (`:`/`=`), short options
+## (flags) can be bundled together and the last one can take a value.
 ##
-## When option values begin with ':' or '=', they need to be doubled up (as in
-## `--delim::`) or alternated (as in `--delim=:`).
+## Option values can begin with the separator character (`:`/`=`), so all of the
+## following is valid:
+##   - option `foo`, value `:`:  `--foo::`, `--foo=:`
+##   - option `foo`, value `=`:  `--foo:=`, `--foo==`
 ##
 ## The `--` option, commonly used to denote that every token that follows is
 ## an argument, is interpreted as a long option, and its name is the empty
-## string.
+## string. Trailing arguments can be accessed with `remainingArgs<#remainingArgs,OptParser>`_
+## or `cmdLineRest<#cmdLineRest,OptParser>`_.
 ##
 ## Parsing
 ## =======
 ##
-## Use an `OptParser<#OptParser>`_ to parse command line options. It can be
-## created with `initOptParser<#initOptParser,string,set[char],seq[string]>`_,
-## and `next<#next,OptParser>`_ advances the parser by one token.
+## To parse command line options, use the `getopt iterator<#getopt.i,OptParser>`_.
+## It initializes the `OptParser<#OptParser>`_ object internally and iterates
+## through the command line options.
 ##
-## For each token, the parser's `kind`, `key`, and `val` fields give
-## information about that token. If the token is a long or short option, `key`
-## is the option's name, and  `val` is either the option's value, if provided,
-## or the empty string. For arguments, the `key` field contains the argument
-## itself, and `val` is unused. To check if the end of the command line has
-## been reached, check if `kind` is equal to `cmdEnd`.
+## For each token, the parser's `kind` (`CmdLineKind enum<#CmdLineKind>`_.),
+## `key`, and `val` fields are yielded.
+##
+## For long and short options, `key` is the option's name, and `val` is either
+## the option's value, if given, or an empty string. For arguments, the `key`
+## field contains the argument itself, and `val` is unused (empty).
 ##
 ## Here is an example:
 ##
-##   ```Nim
-##   import std/parseopt
+runnableExamples:
+  import std/os
+
+  let cmds = "-ab -e:5 --foo --bar=20 file.txt".parseCmdLine()
+  var output: seq[string] = @[]
+  # If cmds is not supplied, real arguments will be retrieved by the `os` module
+  for kind, key, val in getopt(cmds):
+    case kind
+    of cmdEnd: break
+    of cmdShortOption, cmdLongOption:
+      if val == "":
+        output.add("Option: " & key)
+      else:
+        output.add("Option and value: " & key & ", " & val)
+    of cmdArgument:
+      output.add("Argument: " & key)
+
+  doAssert output == @[
+    "Option: a",
+    "Option: b",
+    "Option and value: e, 5",
+    "Option: foo",
+    "Option and value: bar, 20",
+    "Argument: file.txt"
+  ]
 ##
-##   var p = initOptParser("-ab -e:5 --foo --bar=20 file.txt")
-##   while true:
-##     p.next()
-##     case p.kind
-##     of cmdEnd: break
-##     of cmdShortOption, cmdLongOption:
-##       if p.val == "":
-##         echo "Option: ", p.key
-##       else:
-##         echo "Option and value: ", p.key, ", ", p.val
-##     of cmdArgument:
-##       echo "Argument: ", p.key
+## The `OptParser<#OptParser>`_ can be initialized with
+## `initOptParser<#initOptParser,string,set[char],seq[string]>`_.
+## The `next<#next,OptParser>`_ proc advances the parser by one token.
 ##
-##   # Output:
-##   # Option: a
-##   # Option: b
-##   # Option and value: e, 5
-##   # Option: foo
-##   # Option and value: bar, 20
-##   # Argument: file.txt
-##   ```
+## When iterating the object manually with `next<#next,OptParser>`_, reaching
+## the end of the command line is signalled by setting the `kind` field
+## to `cmdEnd`.
 ##
-## The `getopt iterator<#getopt.i,OptParser>`_, which is provided for
-## convenience, can be used to iterate through all command line options as well.
+## To set a default value for an option, assign the default value to a variable
+## beforehand, then update it while parsing.
 ##
-## To set a default value for a variable assigned through `getopt` and accept arguments from the cmd line.
-## Assign the default value to a variable before parsing.
-## Then set the variable to the new value while parsing.
-##
-## Here is an example:
-##
-##   ```Nim
-##   import std/parseopt
-##
-##   var varName: string = "defaultValue"
-##
-##   for kind, key, val in getopt():
-##     case kind
-##     of cmdArgument:
-##       discard
-##     of cmdLongOption, cmdShortOption:
-##       case key:
-##       of "varName": # --varName:<value> in the console when executing
-##         varName = val # do input sanitization in production systems
-##     of cmdEnd:
-##       discard
-##   ```
+runnableExamples:
+  import std/strutils
+
+  var varName: string = "defaultValue"
+
+  for kind, key, val in getopt(@["--varName:HELLO"]):
+    case kind
+    of cmdArgument:
+      discard
+    of cmdLongOption, cmdShortOption:
+      case key
+      of "varName":  # --varName:<value> in the console when executing
+        varName = val.toLowerAscii() # do input sanitization in production
+    of cmdEnd:
+      discard
+
+  doAssert varName == "hello"
 ##
 ## `shortNoVal` and `longNoVal`
 ## ============================
 ##
-## The optional `shortNoVal` and `longNoVal` parameters present in
-## `initOptParser<#initOptParser,string,set[char],seq[string]>`_ are for
+## The optional `shortNoVal` and `longNoVal` parameters in
+## `initOptParser<#initOptParser,string,set[char],seq[string]>`_ and
+## `getopt iterator<#getopt.i,OptParser>`_ are for
 ## specifying which short and long options do not accept values.
 ##
-## When `shortNoVal` is non-empty, users are not required to separate short
-## options and their values with a ':' or '=' since the parser knows which
-## options accept values and which ones do not. This behavior also applies for
-## long options if `longNoVal` is non-empty. For short options, `-j4`
-## becomes supported syntax, and for long options, `--foo bar` becomes
-## supported. This is in addition to the `previously mentioned
-## syntax<#supported-syntax>`_. Users can still separate options and their
-## values with ':' or '=', but that becomes optional.
+## When `shortNoVal` or `longNoVal` is non-empty, using the separators (`:`/`=`)
+## becomes non-mandatory and users can separate a value from long
+## options (that are not supplied to the corresponding argument) by whitespace
+## or, in the case of a short option, by writing the value directly adjacent to
+## the option.
+##
+## For short options, `-j4` becomes supported syntax (parsed as option `j` with
+## value `4` instead of two separate options `j` and `4`). For long options,
+## `--foo bar` becomes supported syntax in all `modes<Parser Modes>`_.
+##
+## In `LaxMode` and `GnuMode`, short options can also take values from the next
+## argument (`-c val`), but this does **not** work in the default `Nim` mode.
 ##
 ## As more options which do not accept values are added to your program,
 ## remember to amend `shortNoVal` and `longNoVal` accordingly.
 ##
+## The parser does not validate the input for syntax mistakes, thus, options
+## can still have values if passed explicitly by the user, even when they are
+## marked as `shortNoVal`/`longNoVal`.
+##
+## This behavior allows associating an option with the mistakenly passed value:
+##
+runnableExamples:
+  import std/[sequtils, os]
+
+  let cmds = "-n:9 --foo:bar".parseCmdLine()
+  let parsed = toSeq(cmds.getopt(shortNoVal = {'n'}, longNoVal = @["foo"]))
+  for (kind, key, val) in parsed:
+   case kind
+   of cmdEnd: raise newException(AssertionDefect, "Unreachable")
+   of cmdShortOption, cmdLongOption:
+     if key in ["n", "foo"] and val != "":
+       # Substitute for proper error handling in your code
+       discard "Option " & key & " can't take values!"
+     else: discard
+   of cmdArgument: discard
+  doAssert parsed == @[
+   (cmdShortOption, "n", "9"),
+   (cmdLongOption, "foo", "bar")]
+##
+## .. Important::
+##   Next-argument value-taking for short/long options is only enabled when
+##   `shortNoVal`/`longNoVal` are non-empty. If your program has *no* options
+##   that take no value, you still must pass a non-empty placeholder (for example,
+##   `shortNoVal = {'\0'}` and/or `longNoVal = @[""]`) to enable this form.
+##
 ## The following example illustrates the difference between having an empty
 ## `shortNoVal` and `longNoVal`, which is the default, and providing
 ## arguments for those two parameters:
 ##
-##   ```Nim
-##   import std/parseopt
+runnableExamples:
+
+  proc format(kind: CmdLineKind; key, val: string): string =
+    case kind
+    of cmdEnd: raise newException(AssertionDefect, "Unreachable")
+    of cmdShortOption, cmdLongOption:
+      if val == "": "Option: " & key
+      else:         "Option and value: " & key & ", " & val
+    of cmdArgument: "Argument: " & key
+
+  let cmdLine = "-j4 --first bar"
+  var output1, output2: seq[string] = @[]
+
+  var emptyNoVal = initOptParser(cmdLine)
+  for kind, key, val in emptyNoVal.getopt():
+    output1.add format(kind, key, val)
+
+  doAssert output1 == @[
+    "Option: j",
+    "Option: 4",
+    "Option: first",
+    "Argument: bar"
+  ]
+
+  var withNoVal = cmdLine.initOptParser(shortNoVal = {'c'},
+                                  longNoVal = @["second"])
+  for kind, key, val in withNoVal.getopt():
+    output2.add format(kind, key, val)
+
+  doAssert output2 == @[
+    "Option and value: j, 4",
+    "Option and value: first, bar"
+  ]
 ##
-##   proc printToken(kind: CmdLineKind, key: string, val: string) =
-##     case kind
-##     of cmdEnd: doAssert(false)  # Doesn't happen with getopt()
-##     of cmdShortOption, cmdLongOption:
-##       if val == "":
-##         echo "Option: ", key
-##       else:
-##         echo "Option and value: ", key, ", ", val
-##     of cmdArgument:
-##       echo "Argument: ", key
+## Parser Modes
+## ============
 ##
-##   let cmdLine = "-j4 --first bar"
+## .. Warning:: Modes other than the default (`Nim`) are **experimental** and may
+##    change in future releases.
 ##
-##   var emptyNoVal = initOptParser(cmdLine)
-##   for kind, key, val in emptyNoVal.getopt():
-##     printToken(kind, key, val)
+## The parser supports several distinct rule sets that change how options are
+## interpreted:
 ##
-##   # Output:
-##   # Option: j
-##   # Option: 4
-##   # Option: first
-##   # Argument: bar
+## 1. **LaxMode**: Most forgiving mode, combines `Nim` with POSIX-like
+##    short option handling. Tries to follow the POSIX_ guidelines where possible.
+## 2. **NimMode**: Standard Nim parsing rules (default).
+## 3. **GnuMode**: GNU-inspired parsing (e.g. `=` as the only delimiter).
+##    Puts some additional restrictions, following some of the GNU_ conventions.
 ##
-##   var withNoVal = initOptParser(cmdLine, shortNoVal = {'c'},
-##                                 longNoVal = @["second"])
-##   for kind, key, val in withNoVal.getopt():
-##     printToken(kind, key, val)
+## Modes are ordered from most relaxed to strictest. The names were
+## chosen to set general user expectations and full compliance is neither
+## achieved nor planned.
 ##
-##   # Output:
-##   # Option and value: j, 4
-##   # Option and value: first, bar
-##   ```
+## Mode Differences
+## ----------------
+##
+## **NimMode** (default):
+##
+## - Short options require adjacent values or explicit delimiters:
+##   `-cval`, `-c:val`, `-c=val`
+## - Short options follow POSIX-style bundling rules
+## - Next-argument value taking (`-c val`) is **not** supported by default
+## - Supports both `:` and `=` as delimiters
+## - Allows whitespace around delimiters
+## - Values starting with `-` are interpreted as new options
+##
+## **LaxMode**:
+##
+## - Essentially the Nim mode with some relaxations for short options:
+##   + Allows short options to take values from the next argument: `-c val`
+##   + Supports bundled short options with trailing value: `-abc val`
+## - Values starting with `-` can be consumed as option arguments
+##
+## **GnuMode**:
+##
+## - Only `=` is treated as a delimiter (`:` is not a delimiter)
+## - No whitespace allowed around `=`
+## - Short options can take next-argument values (`-c val`), but only whitespace
+##   is allowed as a delimiter, separators parse as part of the value
+## - Short options follow POSIX-style bundling rules
+## - Values starting with `-` can be consumed as option arguments
+## - Known discrepancies compared to GNU getopt:
+##   + No notion of optional/mandatory arguments, colon (`:`) doesn't
+##     indicate them and overall is not a special character.
+##
+## Mode-Specific Behavior
+## ----------------------
+##
+## The parser's behavior varies significantly between modes, particularly
+## around how options consume their values:
+##
+## **Short Options**
+##
+## Consider `-c val`:
+##
+## - In `Nim` mode: `-c` is parsed as an option without a value, and `val` is
+##   parsed as a separate argument, regardless of `shortNoVal` being empty or not.
+## - In `Lax` and `Gnu` modes:
+##   + When `shortNoVal` is empty, or not empty and `-c` is in it:
+##     Same as `Nim`, parsed as option `-c` followed by argument `val`.
+##   + When `-c` is not in `shortNoVal`:
+##     parsed as option `-c`, `val` is consumed as its value.
+##
+## Consider `-c-10`:
+##
+## - If `shortNoVal` value is empty, all three modes parse three separate short
+##   options: `c`, `1` and `0`.
+## - Otherwise, if `-c` is not in `shortNoVal`:
+##   + `Nim`: `-c` is an option without an argument. `-10` is interpreted as a
+##      an option `-1` with the `0` argument.
+##   + `Lax` and `Gnu` modes: `-10` is consumed as the value of `-c`
+##     (allowing negative number values).
+##
+## **Long Options**
+##
+## Consider `--foo:bar`:
+##
+## - `Nim`: `:` is a valid delimiter, so `bar` is the value of `--foo`.
+## - `LaxMode`: same as `Nim`.
+## - `Gnu`: only `=` is a valid delimiter, so this parses as an option named
+##   `foo:bar` without a value (unless `longNoVal` is non-empty and allows
+##   next-argument consumption).
+##
+## Consider `--foo =bar`:
+##
+## - `Nim`: whitespace around delimiters is allowed, so `=bar` is the
+##   value of `--foo`.
+## - `LaxMode`: same as `Nim`.
+## - `Gnu`: whitespace around `=` is not allowed, so `--foo` is an
+##   option without a value, and `=bar` is parsed as an argument.
+##
+## Custom Rule Sets
+## ================
+##
+## .. Warning:: Custom rule sets are unsupported and not tested
+##
+## If you require parsing rules beyond the three provided modes, it's possible
+## to define a custom parser behavior by specifying a set of individual parser
+## rules.
+##
+## Due to this feature being unsupported, it requires importing the private
+## symbols of the module (with `import std/parseopt {.all.}`) and utilizing
+## the unexported `initOptParser` overload, which accepts `set[ParserRules]`
+## (see the `ParserRules` enum in the code for details).
 ##
 ## See also
 ## ========
@@ -171,13 +328,42 @@
 ##   parser
 ## * `parsexml module<parsexml.html>`_ for a XML / HTML parser
 ## * `other parsers<lib.html#pure-libraries-parsers>`_ for more parsers
+## * POSIX_ - The Open Group Base Specifications Issue 8. Utility Conventions
+## * GNU_ - GNU C Library reference manual. 26.1.1 Program Argument Syntax Conventions
+##
+## .. _GNU: https://sourceware.org/glibc/manual/latest/html_node/Argument-Syntax.html
+## .. _POSIX: https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap12.html
 
 {.push debugger: off.}
 
 include "system/inclrtl"
 
-import std/strutils
 import std/os
+when defined(nimscript):
+  from std/strutils import toLowerAscii, endsWith
+
+type
+  CliMode* = enum
+    ## Parser behavior profiles used to control parser behavior.
+    ## See `Parser Modes`_ for details.
+    LaxMode, ## The most forgiving mode
+    NimMode, ## Nim parsing rules (default)
+    GnuMode ## GNU-style parsing
+
+type
+  ParserRules = enum
+    ## Feature flags used to assemble parser behavior for a given mode.
+    prSepAllowDelimBefore,       ## Allow whitespace before an opt-val separator
+    prSepAllowDelimAfter,        ## Allow whitespace after an opt-val separator
+    prShortAllowSep,             ## Allow `-k<separator>val` form
+    prShortBundle,               ## Allow bundling short options behind one '-'
+    prShortValAllowAdjacent,     ## Allow adjacent short option values: `-kval`
+    prShortValAllowNextArg,      ## Allow next-argv short option values: `-k val`
+    prShortValAllowDashLeading,  ## Allow values that start with '-' to be taken
+    prLongAllowSep,              ## Allow `--opt<separator>val` form
+    prLongValAllowNextArg,       ## Allow `--opt val` form, requires non-empty `longNoVal`
+    prSepAllowColon,             ## Allow `:` as an opt-val separator
+    prSepAllowEq,                ## Allow `=` as an opt-val separator
 
 type
   CmdLineKind* = enum ## The detected command line token.
@@ -189,21 +375,51 @@ type
     ## Implementation of the command line parser.
     ##
     ## To initialize it, use the
-    ## `initOptParser proc<#initOptParser,string,set[char],seq[string]>`_.
+    ## `initOptParser proc<#initOptParser,string,set[char],seq[string],CliMode>`_.
+    ## `next<#next,OptParser>`_ is used to advance the parser state and move
+    ## through the parsed tokens.
     pos: int
     inShortState: bool
-    allowWhitespaceAfterColon: bool
     shortNoVal: set[char]
     longNoVal: seq[string]
     cmds: seq[string]
     idx: int
+    separators: set[char]        ## Allowed separators for long/short option values
+    rules: set[ParserRules]
     kind*: CmdLineKind           ## The detected command line token
     key*, val*: string           ## Key and value pair; the key is the option
                                  ## or the argument, and the value is not "" if
                                  ## the option was given a value
 
+const DelimSet = {'\t', ' '} ## Allowed delimiters between tokens
+
+func toRules(m: CliMode): set[ParserRules] =
+  ## Default rule sets for the given mode `m`
+  let
+    Common = {
+      prSepAllowEq,
+      prShortValAllowAdjacent,
+      prShortBundle,
+      prLongValAllowNextArg,
+      prLongAllowSep,
+    }
+    Lax = {
+      prSepAllowColon,
+      prSepAllowDelimBefore,
+      prSepAllowDelimAfter,
+      prShortAllowSep,
+    }
+    ShortPosix = {
+      prShortValAllowNextArg,
+      prShortValAllowDashLeading,
+    }
+  case m
+  of LaxMode: Common + Lax + ShortPosix
+  of NimMode: Common + Lax
+  of GnuMode: Common + ShortPosix
+
 proc parseWord(s: string, i: int, w: var string,
-               delim: set[char] = {'\t', ' '}): int =
+               delim: set[char] = DelimSet): int =
   result = i
   if result < s.len and s[result] == '\"':
     inc(result)
@@ -218,34 +434,23 @@ proc parseWord(s: string, i: int, w: var string,
       add(w, s[result])
       inc(result)
 
-proc initOptParser*(cmdline: seq[string], shortNoVal: set[char] = {},
-                    longNoVal: seq[string] = @[];
-                    allowWhitespaceAfterColon = true): OptParser =
-  ## Initializes the command line parser.
-  ##
-  ## If `cmdline.len == 0`, the real command line as provided by the
-  ## `os` module is retrieved instead if it is available. If the
-  ## command line is not available, a `ValueError` will be raised.
-  ## Behavior of the other parameters remains the same as in
-  ## `initOptParser(string, ...)
-  ## <#initOptParser,string,set[char],seq[string]>`_.
-  ##
-  ## See also:
-  ## * `getopt iterator<#getopt.i,seq[string],set[char],seq[string]>`_
-  runnableExamples:
-    var p = initOptParser()
-    p = initOptParser(@["--left", "--debug:3", "-l", "-r:2"])
-    p = initOptParser(@["--left", "--debug:3", "-l", "-r:2"],
-                      shortNoVal = {'l'}, longNoVal = @["left"])
-  result = OptParser(pos: 0, idx: 0, inShortState: false,
-                    shortNoVal: shortNoVal, longNoVal: longNoVal,
-                    allowWhitespaceAfterColon: allowWhitespaceAfterColon
+proc initOptParser(cmdline: openArray[string];
+                    shortNoVal: set[char];
+                    longNoVal: seq[string];
+                    rules: set[ParserRules]): OptParser =
+  result = OptParser(pos: 0, idx: 0,
+                    cmds: @cmdline,
+                    inShortState: false,
+                    shortNoVal: shortNoVal,
+                    longNoVal: longNoVal,
+                    separators: {},
+                    rules: rules,
+                    kind: cmdEnd,
+                    key: "", val: "",
                     )
-  if cmdline.len != 0:
-    result.cmds = newSeq[string](cmdline.len)
-    for i in 0..<cmdline.len:
-      result.cmds[i] = cmdline[i]
-  else:
+  if prSepAllowEq    in rules: result.separators.incl('=')
+  if prSepAllowColon in rules: result.separators.incl(':')
+  if cmdline.len == 0:
     when declared(paramCount):
       when defined(nimscript):
         var ctr = 0
@@ -254,7 +459,7 @@ proc initOptParser*(cmdline: seq[string], shortNoVal: set[char] = {},
           if firstNimsFound: 
             result.cmds[ctr] = paramStr(i)
             inc ctr, 1
-          if paramStr(i).endsWith(".nims") and not firstNimsFound:
+          if paramStr(i).toLowerAscii().endsWith(".nims") and not firstNimsFound:
             firstNimsFound = true 
             result.cmds = newSeq[string](paramCount()-i)
       else:
@@ -266,25 +471,73 @@ proc initOptParser*(cmdline: seq[string], shortNoVal: set[char] = {},
       # access the command line arguments then!
       raiseAssert "empty command line given but" &
         " real command line is not accessible"
-  result.kind = cmdEnd
-  result.key = ""
-  result.val = ""
 
-proc initOptParser*(cmdline = "", shortNoVal: set[char] = {},
+proc initOptParser*(cmdline: seq[string];
+                    shortNoVal: set[char] = {};
                     longNoVal: seq[string] = @[];
-                    allowWhitespaceAfterColon = true): OptParser =
+                    mode: CliMode = NimMode): OptParser =
   ## Initializes the command line parser.
   ##
-  ## If `cmdline == ""`, the real command line as provided by the
-  ## `os` module is retrieved instead if it is available. If the
-  ## command line is not available, a `ValueError` will be raised.
+  ## **Parameters:**
   ##
-  ## `shortNoVal` and `longNoVal` are used to specify which options
-  ## do not take values. See the `documentation about these
-  ## parameters<#nimshortnoval-and-nimlongnoval>`_ for more information on
-  ## how this affects parsing.
+  ## - `cmdline`: Sequence of command line arguments to parse. If empty, the
+  ##   real command line as provided by the `os` module is retrieved instead.
+  ##   If the command line is not available, an assertion will be raised.
+  ## - `shortNoVal`: Set of short option characters that do not accept values.
+  ##   See `shortNoVal and longNoVal<#nimshortnoval-and-nimlongnoval>`_ for details.
+  ## - `longNoVal`: Sequence of long option names that do not accept values.
+  ##   See `shortNoVal and longNoVal<#nimshortnoval-and-nimlongnoval>`_ for details.
+  ## - `mode`: Parser behavior profile (`NimMode`, `LaxMode`, or `GnuMode`).
+  ##   See `Parser Modes`_ for details.
   ##
-  ## This does not provide a way of passing default values to arguments.
+  ## See also:
+  ## * `getopt iterator<#getopt.i,seq[string],set[char],seq[string],CliMode>`_
+  runnableExamples:
+    var p = initOptParser()
+    p = initOptParser(@["--left", "--debug:3", "-l", "-r:2"])
+    p = initOptParser(@["--left", "--debug:3", "-l", "-r:2"],
+                      shortNoVal = {'l'}, longNoVal = @["left"])
+  initOptParser(cmdline, shortNoVal, longNoVal, toRules(mode))
+
+proc initOptParser*(cmdline: seq[string],
+                    shortNoVal: set[char] = {},
+                    longNoVal: seq[string] = @[];
+                    allowWhitespaceAfterColon: bool): OptParser {.deprecated:
+      "`allowWhitespaceAfterColon` is deprecated, use parser modes instead".} =
+  ## This is an overload for continued support of the legacy `allowWhitespaceAfterColon`
+  ## option. It modifies the default parser mode so that the passed value is respected.
+  ##
+  ## Current default parser mode behaves as if `true` was passed (old default)
+  ##
+  ## - `allowWhitespaceAfterColon`: When `true`, allows forms like
+  ##   `--option: value` or `--option= value` where the value is in the next
+  ##   token after the delimiter. When `false`, the value must be in the same
+  ##   token as the delimiter.
+  var nimrules = toRules(NimMode)
+  if allowWhitespaceAfterColon == false: nimrules.excl prSepAllowDelimAfter
+  initOptParser(cmdline, shortNoVal, longNoVal, nimrules)
+
+proc initOptParser*(cmdline = "";
+                    shortNoVal: set[char] = {};
+                    longNoVal: seq[string] = @[];
+                    mode: CliMode = NimMode): OptParser =
+  ## Initializes the command line parser from a command line string.
+  ##
+  ## The `cmdline` string is parsed into tokens using shell-like quoting rules.
+  ##
+  ## **Parameters:**
+  ##
+  ## - `cmdline`: Command line string to parse. If empty, the real command line
+  ##   as provided by the `os` module is retrieved instead. If the command line
+  ##   is not available, an assertion will be raised.
+  ## - `shortNoVal`: Set of short option characters that do not accept values.
+  ##   See `shortNoVal and longNoVal<#nimshortnoval-and-nimlongnoval>`_ for details.
+  ## - `longNoVal`: Sequence of long option names that do not accept values.
+  ##   See `shortNoVal and longNoVal<#nimshortnoval-and-nimlongnoval>`_ for details.
+  ## - `mode`: Parser behavior profile (`NimMode`, `LaxMode`, or `GnuMode`).
+  ##   See `Parser Modes`_ for details.
+  ##
+  ## **Note:** This does not provide a way of passing default values to arguments.
   ##
   ## See also:
   ## * `getopt iterator<#getopt.i,OptParser>`_
@@ -293,34 +546,81 @@ proc initOptParser*(cmdline = "", shortNoVal: set[char] = {},
     p = initOptParser("--left --debug:3 -l -r:2")
     p = initOptParser("--left --debug:3 -l -r:2",
                       shortNoVal = {'l'}, longNoVal = @["left"])
+  initOptParser(parseCmdLine(cmdline), shortNoVal, longNoVal, toRules(mode))
 
-  initOptParser(parseCmdLine(cmdline), shortNoVal, longNoVal, allowWhitespaceAfterColon)
+proc initOptParser*(cmdline = "";
+                    shortNoVal: set[char] = {};
+                    longNoVal: seq[string] = @[];
+                    allowWhitespaceAfterColon: bool): OptParser {.deprecated:
+      "`allowWhitespaceAfterColon` is deprecated, use parser modes instead".} =
+  ## This is an overload for continued support of the legacy `allowWhitespaceAfterColon`
+  ## option. It modifies the default parser mode so that the passed value is respected.
+  ##
+  ## Current default parser mode behaves as if `true` was passed (old default).
+  ##
+  ## - `allowWhitespaceAfterColon`: When `true`, allows forms like
+  ##   `--option: value` or `--option= value` where the value is in the next
+  ##   token after the delimiter. When `false`, the value must be in the same
+  ##   token as the delimiter.
+  var nimrules = toRules(NimMode)
+  if allowWhitespaceAfterColon == false: nimrules.excl prSepAllowDelimAfter
+  initOptParser(parseCmdLine(cmdline), shortNoVal, longNoVal, nimrules)
 
 proc handleShortOption(p: var OptParser; cmd: string) =
   var i = p.pos
   p.kind = cmdShortOption
-  if i < cmd.len:
+  if i < cmd.len: # multidigit short option support goes here
     add(p.key, cmd[i])
     inc(i)
   p.inShortState = true
-  while i < cmd.len and cmd[i] in {'\t', ' '}:
-    inc(i)
-    p.inShortState = false
-  if i < cmd.len and (cmd[i] in {':', '='} or
-      card(p.shortNoVal) > 0 and p.key[0] notin p.shortNoVal):
-    if i < cmd.len and cmd[i] in {':', '='}:
+  if prSepAllowDelimBefore in p.rules:
+    while i < cmd.len and cmd[i] in DelimSet:
       inc(i)
+      p.inShortState = false
+
+  proc consumeDelims() =
+    while i < cmd.len and cmd[i] in DelimSet: inc(i)
+
+  proc advance(p: var OptParser; n = 1)=
     p.inShortState = false
-    while i < cmd.len and cmd[i] in {'\t', ' '}: inc(i)
+    p.pos = 0
+    inc p.idx, n
+    
+  template next(): untyped = p.cmds[p.idx + 1]
+
+  let canTakeVal = card(p.shortNoVal) > 0 and p.key[0] notin p.shortNoVal 
+  if i < cmd.len and cmd[i] in p.separators:
+    # separator case
+    if prShortAllowSep in p.rules:
+      # allow separators: skip the separator and take the value after it
+      inc(i)
+      if prSepAllowDelimAfter in p.rules:
+        consumeDelims()
+    # prohibit separators: treat separator + remainder as the value
+    # this represents an error state but produces output that can be validated
     p.val = substr(cmd, i)
-    p.pos = 0
-    inc p.idx
-  else:
-    p.pos = i
+    p.advance(1)
+    return
+  elif canTakeVal and prShortValAllowAdjacent in p.rules and i < cmd.len:
+    # adjacent value
+    if prSepAllowDelimBefore in p.rules:
+      consumeDelims()
+    p.val = substr(cmd, i)
+    p.advance(1)
+    return
+  elif canTakeVal and
+      prShortValAllowNextArg in p.rules and
+      i >= cmd.len and
+      p.idx + 1 < p.cmds.len and (
+        prShortValAllowDashLeading in p.rules or
+        not (next().len > 0 and next()[0] == '-')):
+    # next-argument value
+    p.val = next()
+    p.advance(2)
+    return
+  p.pos = i
   if i >= cmd.len:
-    p.inShortState = false
-    p.pos = 0
-    inc p.idx
+    p.advance(1)
 
 proc next*(p: var OptParser) {.rtl, extern: "npo$1".} =
   ## Parses the next token.
@@ -343,54 +643,71 @@ proc next*(p: var OptParser) {.rtl, extern: "npo$1".} =
     return
 
   var i = p.pos
-  while i < p.cmds[p.idx].len and p.cmds[p.idx][i] in {'\t', ' '}: inc(i)
+  template cmd(): untyped = p.cmds[p.idx]
+  template nextArg(): untyped = p.cmds[p.idx + 1]
+
+  proc consumeDelims(cmds: openArray[string]; idx: int) =
+    while i < cmds[idx].len and cmds[idx][i] in DelimSet: inc(i)
+
+  proc advance(p: var OptParser; n = 1) =
+    p.pos = 0
+    inc p.idx, n
+
+  consumeDelims(p.cmds, p.idx)
   p.pos = i
   setLen(p.key, 0)
   setLen(p.val, 0)
   if p.inShortState:
     p.inShortState = false
-    if i >= p.cmds[p.idx].len:
-      inc(p.idx)
-      p.pos = 0
+    if i < cmd.len:
+      handleShortOption(p, p.cmds[p.idx])
+      return
+    else:
+      p.advance(1)
       if p.idx >= p.cmds.len:
         p.kind = cmdEnd
         return
-    else:
-      handleShortOption(p, p.cmds[p.idx])
-      return
 
-  if i < p.cmds[p.idx].len and p.cmds[p.idx][i] == '-':
+  if i < cmd.len and cmd[i] == '-':
     inc(i)
-    if i < p.cmds[p.idx].len and p.cmds[p.idx][i] == '-':
+    if i < cmd.len and cmd[i] == '-':
       p.kind = cmdLongOption
       inc(i)
-      i = parseWord(p.cmds[p.idx], i, p.key, {' ', '\t', ':', '='})
-      while i < p.cmds[p.idx].len and p.cmds[p.idx][i] in {'\t', ' '}: inc(i)
-      if i < p.cmds[p.idx].len and p.cmds[p.idx][i] in {':', '='}:
+      i = parseWord(cmd, i, p.key,
+        DelimSet + (if prLongAllowSep in p.rules: p.separators else: {}))
+      if prSepAllowDelimBefore in p.rules:
+        consumeDelims(p.cmds, p.idx)
+      if prLongAllowSep in p.rules and i < cmd.len and cmd[i] in p.separators:
         inc(i)
-        while i < p.cmds[p.idx].len and p.cmds[p.idx][i] in {'\t', ' '}: inc(i)
-        # if we're at the end, use the next command line option:
-        if i >= p.cmds[p.idx].len and p.idx < p.cmds.len and
-            p.allowWhitespaceAfterColon:
-          inc p.idx
-          i = 0
-        if p.idx < p.cmds.len:
-          p.val = p.cmds[p.idx].substr(i)
-      elif len(p.longNoVal) > 0 and p.key notin p.longNoVal and p.idx+1 < p.cmds.len:
-        p.val = p.cmds[p.idx+1]
-        inc p.idx
+        if prSepAllowDelimAfter in p.rules:
+          consumeDelims(p.cmds, p.idx)
+        if i >= cmd.len and p.idx + 1 < p.cmds.len and
+            prSepAllowDelimAfter in p.rules:
+          p.val = nextArg()
+          p.advance(2)
+        else:
+          p.val = cmd.substr(i)
+          p.advance(1)
+      elif prLongValAllowNextArg in p.rules and
+          len(p.longNoVal) > 0 and
+          p.key notin p.longNoVal and
+          p.idx + 1 < p.cmds.len:
+        p.val = nextArg()
+        p.advance(2)
       else:
-        p.val = ""
-      inc p.idx
-      p.pos = 0
+        if i < cmd.len:
+          # Leave remainder of the current token to be parsed as an argument.
+          consumeDelims(p.cmds, p.idx)
+          p.cmds[p.idx] = cmd.substr(i)
+        else:
+          p.advance(1)
     else:
       p.pos = i
-      handleShortOption(p, p.cmds[p.idx])
+      handleShortOption(p, cmd)
   else:
     p.kind = cmdArgument
-    p.key = p.cmds[p.idx]
-    inc p.idx
-    p.pos = 0
+    p.key = cmd
+    p.advance(1)
 
 when declared(quoteShellCommand):
   proc cmdLineRest*(p: OptParser): string {.rtl, extern: "npo$1".} =
@@ -399,15 +716,13 @@ when declared(quoteShellCommand):
     ## See also:
     ## * `remainingArgs proc<#remainingArgs,OptParser>`_
     ##
-    ## **Examples:**
-    ##   ```Nim
-    ##   var p = initOptParser("--left -r:2 -- foo.txt bar.txt")
-    ##   while true:
-    ##     p.next()
-    ##     if p.kind == cmdLongOption and p.key == "":  # Look for "--"
-    ##       break
-    ##   doAssert p.cmdLineRest == "foo.txt bar.txt"
-    ##   ```
+    runnableExamples:
+      var p = initOptParser("--left -r:2 -- foo.txt bar.txt")
+      while true:
+        p.next()
+        if p.kind == cmdLongOption and p.key == "":  # Look for "--"
+          break
+      doAssert p.cmdLineRest == "foo.txt bar.txt"
     result = p.cmds[p.idx .. ^1].quoteShellCommand
 
 proc remainingArgs*(p: OptParser): seq[string] {.rtl, extern: "npo$1".} =
@@ -416,15 +731,13 @@ proc remainingArgs*(p: OptParser): seq[string] {.rtl, extern: "npo$1".} =
   ## See also:
   ## * `cmdLineRest proc<#cmdLineRest,OptParser>`_
   ##
-  ## **Examples:**
-  ##   ```Nim
-  ##   var p = initOptParser("--left -r:2 -- foo.txt bar.txt")
-  ##   while true:
-  ##     p.next()
-  ##     if p.kind == cmdLongOption and p.key == "":  # Look for "--"
-  ##       break
-  ##   doAssert p.remainingArgs == @["foo.txt", "bar.txt"]
-  ##   ```
+  runnableExamples:
+    var p = initOptParser("--left -r:2 -- foo.txt bar.txt")
+    while true:
+      p.next()
+      if p.kind == cmdLongOption and p.key == "":  # Look for "--"
+        break
+    doAssert p.remainingArgs == @["foo.txt", "bar.txt"]
   result = @[]
   for i in p.idx..<p.cmds.len: result.add p.cmds[i]
 
@@ -439,29 +752,26 @@ iterator getopt*(p: var OptParser): tuple[kind: CmdLineKind, key,
   ## See also:
   ## * `initOptParser proc<#initOptParser,string,set[char],seq[string]>`_
   ##
-  ## **Examples:**
-  ##
-  ##   ```Nim
-  ##   # these are placeholders, of course
-  ##   proc writeHelp() = discard
-  ##   proc writeVersion() = discard
-  ##
-  ##   var filename: string
-  ##   var p = initOptParser("--left --debug:3 -l -r:2")
-  ##
-  ##   for kind, key, val in p.getopt():
-  ##     case kind
-  ##     of cmdArgument:
-  ##       filename = key
-  ##     of cmdLongOption, cmdShortOption:
-  ##       case key
-  ##       of "help", "h": writeHelp()
-  ##       of "version", "v": writeVersion()
-  ##     of cmdEnd: assert(false) # cannot happen
-  ##   if filename == "":
-  ##     # no filename has been given, so we show the help
-  ##     writeHelp()
-  ##   ```
+  runnableExamples:
+    # these are placeholders, of course
+    proc writeHelp() = discard
+    proc writeVersion() = discard
+
+    var filename: string = ""
+    var p = initOptParser("--left --debug:3 -l -r:2")
+
+    for kind, key, val in p.getopt():
+      case kind
+      of cmdArgument:
+        filename = key
+      of cmdLongOption, cmdShortOption:
+        case key
+        of "help", "h": writeHelp()
+        of "version", "v": writeVersion()
+      of cmdEnd: assert(false) # cannot happen
+    if filename == "":
+      # no filename has been given, so we show the help
+      writeHelp()
   p.pos = 0
   p.idx = 0
   while true:
@@ -469,8 +779,10 @@ iterator getopt*(p: var OptParser): tuple[kind: CmdLineKind, key,
     if p.kind == cmdEnd: break
     yield (p.kind, p.key, p.val)
 
-iterator getopt*(cmdline: seq[string] = @[],
-                  shortNoVal: set[char] = {}, longNoVal: seq[string] = @[]):
+iterator getopt*(cmdline: seq[string] = @[];
+                  shortNoVal: set[char] = {};
+                  longNoVal: seq[string] = @[];
+                  mode: CliMode = NimMode):
             tuple[kind: CmdLineKind, key, val: string] =
   ## Convenience iterator for iterating over command line arguments.
   ##
@@ -483,6 +795,9 @@ iterator getopt*(cmdline: seq[string] = @[],
   ## parameters<#nimshortnoval-and-nimlongnoval>`_ for more information on
   ## how this affects parsing.
   ##
+  ## `mode` selects the parser behavior profile (`NimMode`, `LaxMode`,
+  ## or `GnuMode`). See `Parser Modes`_ for details.
+  ##
   ## There is no need to check for `cmdEnd` while iterating. If using `getopt`
   ## with case switching, checking for `cmdEnd` is required.
   ##
@@ -513,7 +828,8 @@ iterator getopt*(cmdline: seq[string] = @[],
   ##     writeHelp()
   ##   ```
   var p = initOptParser(cmdline, shortNoVal = shortNoVal,
-      longNoVal = longNoVal)
+      longNoVal = longNoVal,
+      rules = toRules(mode))
   while true:
     next(p)
     if p.kind == cmdEnd: break

lib/pure/random.nim

@@ -243,7 +243,7 @@ proc rand[T: uint | uint64](r: var Rand; max: T): T =
       else:
         inc iters
 
-proc rand*(r: var Rand; max: Natural): int {.benign.} =
+proc rand*(r: var Rand; max: Natural): int {.gcsafe.} =
   ## Returns a random integer in the range `0..max` using the given state.
   ##
   ## **See also:**
@@ -260,7 +260,7 @@ proc rand*(r: var Rand; max: Natural): int {.benign.} =
   cast[int](rand(r, uint64(max)))
     # xxx toUnsigned pending https://github.com/nim-lang/Nim/pull/18445
 
-proc rand*(max: int): int {.benign.} =
+proc rand*(max: int): int {.gcsafe.} =
   ## Returns a random integer in the range `0..max`.
   ##
   ## If `randomize <#randomize>`_ has not been called, the sequence of random
@@ -281,7 +281,7 @@ proc rand*(max: int): int {.benign.} =
 
   rand(state, max)
 
-proc rand*(r: var Rand; max: range[0.0 .. high(float)]): float {.benign.} =
+proc rand*(r: var Rand; max: range[0.0 .. high(float)]): float {.gcsafe.} =
   ## Returns a random floating point number in the range `0.0..max`
   ## using the given state.
   ##
@@ -308,7 +308,7 @@ proc rand*(r: var Rand; max: range[0.0 .. high(float)]): float {.benign.} =
     let u = (0x3FFu64 shl 52u64) or (x shr 12u64)
     result = (cast[float](u) - 1.0) * max
 
-proc rand*(max: float): float {.benign.} =
+proc rand*(max: float): float {.gcsafe.} =
   ## Returns a random floating point number in the range `0.0..max`.
   ##
   ## If `randomize <#randomize>`_ has not been called, the sequence of random
@@ -612,7 +612,7 @@ proc initRand*(seed: int64): Rand =
     skipRandomNumbers(result)
   discard next(result)
 
-proc randomize*(seed: int64) {.benign.} =
+proc randomize*(seed: int64) {.gcsafe.} =
   ## Initializes the default random number generator with the given seed.
   ##
   ## Providing a specific seed will produce the same results for that seed each time.
@@ -736,7 +736,7 @@ when not defined(standalone):
   since (1, 5, 1):
     export initRand
 
-  proc randomize*() {.benign.} =
+  proc randomize*() {.gcsafe.} =
     ## Initializes the default random number generator with a seed based on
     ## random number source.
     ##

lib/pure/streams.nim

@@ -16,9 +16,9 @@
 ## stream interface.
 ##
 ## .. warning:: Due to the use of `pointer`, the `readData`, `peekData` and
-## `writeData` interfaces are not available on the compile-time VM, and must
-## be cast from a `ptr string` on the JS backend. However, `readDataStr` is
-## available generally in place of `readData`.
+##   `writeData` interfaces are not available on the compile-time VM, and must
+##   be cast from a `ptr string` on the JS backend. However, `readDataStr` is
+##   available generally in place of `readData`.
 ##
 ## Basic usage
 ## ===========

lib/pure/times.nim

@@ -382,9 +382,9 @@ type
       ## timezones. The `times` module only supplies implementations for the
       ## system's local time and UTC.
     zonedTimeFromTimeImpl: proc (x: Time): ZonedTime
-        {.tags: [], raises: [], benign.}
+        {.tags: [], raises: [], gcsafe.}
     zonedTimeFromAdjTimeImpl: proc (x: Time): ZonedTime
-        {.tags: [], raises: [], benign.}
+        {.tags: [], raises: [], gcsafe.}
     name: string
 
   ZonedTime* = object ## Represents a point in time with an associated
@@ -432,7 +432,7 @@ else:
 # Helper procs
 #
 
-{.pragma: operator, rtl, noSideEffect, benign.}
+{.pragma: operator, rtl, noSideEffect, gcsafe.}
 
 proc convert*[T: SomeInteger](unitFrom, unitTo: FixedTimeUnit, quantity: T): T
     {.inline.} =
@@ -518,7 +518,7 @@ proc fromEpochDay(epochday: int64):
   return (d.MonthdayRange, m.Month, (y + ord(m <= 2)).int)
 
 proc getDayOfYear*(monthday: MonthdayRange, month: Month, year: int):
-    YeardayRange {.tags: [], raises: [], benign.} =
+    YeardayRange {.tags: [], raises: [], gcsafe.} =
   ## Returns the day of the year.
   ## Equivalent with `dateTime(year, month, monthday, 0, 0, 0, 0).yearday`.
   runnableExamples:
@@ -538,7 +538,7 @@ proc getDayOfYear*(monthday: MonthdayRange, month: Month, year: int):
     result = daysUntilMonth[month] + monthday - 1
 
 proc getDayOfWeek*(monthday: MonthdayRange, month: Month, year: int): WeekDay
-    {.tags: [], raises: [], benign.} =
+    {.tags: [], raises: [], gcsafe.} =
   ## Returns the day of the week enum from day, month and year.
   ## Equivalent with `dateTime(year, month, monthday, 0, 0, 0, 0).weekday`.
   runnableExamples:
@@ -922,21 +922,21 @@ proc nanosecond*(time: Time): NanosecondRange =
   time.nanosecond
 
 proc fromUnix*(unix: int64): Time
-    {.benign, tags: [], raises: [], noSideEffect.} =
+    {.gcsafe, tags: [], raises: [], noSideEffect.} =
   ## Convert a unix timestamp (seconds since `1970-01-01T00:00:00Z`)
   ## to a `Time`.
   runnableExamples:
     doAssert $fromUnix(0).utc == "1970-01-01T00:00:00Z"
   initTime(unix, 0)
 
-proc toUnix*(t: Time): int64 {.benign, tags: [], raises: [], noSideEffect.} =
+proc toUnix*(t: Time): int64 {.gcsafe, tags: [], raises: [], noSideEffect.} =
   ## Convert `t` to a unix timestamp (seconds since `1970-01-01T00:00:00Z`).
   ## See also `toUnixFloat` for subsecond resolution.
   runnableExamples:
     doAssert fromUnix(0).toUnix() == 0
   t.seconds
 
-proc fromUnixFloat(seconds: float): Time {.benign, tags: [], raises: [], noSideEffect.} =
+proc fromUnixFloat(seconds: float): Time {.gcsafe, tags: [], raises: [], noSideEffect.} =
   ## Convert a unix timestamp in seconds to a `Time`; same as `fromUnix`
   ## but with subsecond resolution.
   runnableExamples:
@@ -946,7 +946,7 @@ proc fromUnixFloat(seconds: float): Time {.benign, tags: [], raises: [], noSideE
   let nsecs = (seconds - secs) * 1e9
   initTime(secs.int64, nsecs.NanosecondRange)
 
-proc toUnixFloat(t: Time): float {.benign, tags: [], raises: [].} =
+proc toUnixFloat(t: Time): float {.gcsafe, tags: [], raises: [].} =
   ## Same as `toUnix` but using subsecond resolution.
   runnableExamples:
     let t = getTime()
@@ -975,7 +975,7 @@ proc toWinTime*(t: Time): int64 =
 proc getTimeImpl(typ: typedesc[Time]): Time =
   raiseAssert "implemented in the vm"
 
-proc getTime*(): Time {.tags: [TimeEffect], benign.} =
+proc getTime*(): Time {.tags: [TimeEffect], gcsafe.} =
   ## Gets the current time as a `Time` with up to nanosecond resolution.
   when nimvm:
     result = getTimeImpl(Time)
@@ -1154,7 +1154,7 @@ proc isLeapDay*(dt: DateTime): bool {.since: (1, 1).} =
   assertDateTimeInitialized dt
   dt.year.isLeapYear and dt.month == mFeb and dt.monthday == 29
 
-proc toTime*(dt: DateTime): Time {.tags: [], raises: [], benign.} =
+proc toTime*(dt: DateTime): Time {.tags: [], raises: [], gcsafe.} =
   ## Converts a `DateTime` to a `Time` representing the same point in time.
   assertDateTimeInitialized dt
   let epochDay = toEpochDay(dt.monthday, dt.month, dt.year)
@@ -1197,9 +1197,9 @@ proc initDateTime(zt: ZonedTime, zone: Timezone): DateTime =
 proc newTimezone*(
       name: string,
       zonedTimeFromTimeImpl: proc (time: Time): ZonedTime
-          {.tags: [], raises: [], benign.},
+          {.tags: [], raises: [], gcsafe.},
       zonedTimeFromAdjTimeImpl: proc (adjTime: Time): ZonedTime
-          {.tags: [], raises: [], benign.}
+          {.tags: [], raises: [], gcsafe.}
     ): owned Timezone =
   ## Create a new `Timezone`.
   ##
@@ -1263,12 +1263,12 @@ proc `==`*(zone1, zone2: Timezone): bool =
   zone1.name == zone2.name
 
 proc inZone*(time: Time, zone: Timezone): DateTime
-    {.tags: [], raises: [], benign.} =
+    {.tags: [], raises: [], gcsafe.} =
   ## Convert `time` into a `DateTime` using `zone` as the timezone.
   result = initDateTime(zone.zonedTimeFromTime(time), zone)
 
 proc inZone*(dt: DateTime, zone: Timezone): DateTime
-    {.tags: [], raises: [], benign.} =
+    {.tags: [], raises: [], gcsafe.} =
   ## Returns a `DateTime` representing the same point in time as `dt` but
   ## using `zone` as the timezone.
   assertDateTimeInitialized dt
@@ -1283,14 +1283,14 @@ proc toAdjTime(dt: DateTime): Time =
   result = initTime(seconds, dt.nanosecond)
 
 when defined(js):
-  proc localZonedTimeFromTime(time: Time): ZonedTime {.benign.} =
+  proc localZonedTimeFromTime(time: Time): ZonedTime {.gcsafe.} =
     let jsDate = newDate(time.seconds * 1000)
     let offset = jsDate.getTimezoneOffset() * secondsInMin
     result.time = time
     result.utcOffset = offset
     result.isDst = false
 
-  proc localZonedTimeFromAdjTime(adjTime: Time): ZonedTime {.benign.} =
+  proc localZonedTimeFromAdjTime(adjTime: Time): ZonedTime {.gcsafe.} =
     let utcDate = newDate(adjTime.seconds * 1000)
     let localDate = newDate(utcDate.getUTCFullYear(), utcDate.getUTCMonth(),
         utcDate.getUTCDate(), utcDate.getUTCHours(), utcDate.getUTCMinutes(),
@@ -1337,11 +1337,11 @@ else:
       return ((a.int64 - tm.toAdjUnix).int, tm.tm_isdst > 0)
     return (0, false)
 
-  proc localZonedTimeFromTime(time: Time): ZonedTime {.benign.} =
+  proc localZonedTimeFromTime(time: Time): ZonedTime {.gcsafe.} =
     let (offset, dst) = getLocalOffsetAndDst(time.seconds)
     result = ZonedTime(time: time, utcOffset: offset, isDst: dst)
 
-  proc localZonedTimeFromAdjTime(adjTime: Time): ZonedTime {.benign.} =
+  proc localZonedTimeFromAdjTime(adjTime: Time): ZonedTime {.gcsafe.} =
     var adjUnix = adjTime.seconds
     let past = adjUnix - secondsInDay
     let (pastOffset, _) = getLocalOffsetAndDst(past)
@@ -1408,7 +1408,7 @@ proc local*(t: Time): DateTime =
   ## Shorthand for `t.inZone(local())`.
   t.inZone(local())
 
-proc now*(): DateTime {.tags: [TimeEffect], benign.} =
+proc now*(): DateTime {.tags: [TimeEffect], gcsafe.} =
   ## Get the current time as a  `DateTime` in the local timezone.
   ## Shorthand for `getTime().local`.
   ##
@@ -2327,7 +2327,7 @@ proc parseTime*(input: string, f: static[string], zone: Timezone): Time
   const f2 = initTimeFormat(f)
   result = input.parse(f2, zone).toTime()
 
-proc `$`*(dt: DateTime): string {.tags: [], raises: [], benign.} =
+proc `$`*(dt: DateTime): string {.tags: [], raises: [], gcsafe.} =
   ## Converts a `DateTime` object to a string representation.
   ## It uses the format `yyyy-MM-dd'T'HH:mm:sszzz`.
   runnableExamples:
@@ -2339,7 +2339,7 @@ proc `$`*(dt: DateTime): string {.tags: [], raises: [], benign.} =
   else:
     result = format(dt, "yyyy-MM-dd'T'HH:mm:sszzz")
 
-proc `$`*(time: Time): string {.tags: [], raises: [], benign.} =
+proc `$`*(time: Time): string {.tags: [], raises: [], gcsafe.} =
   ## Converts a `Time` value to a string representation. It will use the local
   ## time zone and use the format `yyyy-MM-dd'T'HH:mm:sszzz`.
   runnableExamples:

lib/pure/typetraits.nim

@@ -96,6 +96,9 @@ proc supportsCopyMem*(t: typedesc): bool {.magic: "TypeTrait".}
   ##
   ## Other languages name a type like these `blob`:idx:.
 
+proc canFormCycles*(t: typedesc): bool {.magic: "TypeTrait".}
+  ## Returns true if `t` can form cycles.
+
 proc hasDefaultValue*(t: typedesc): bool {.magic: "TypeTrait".} =
   ## Returns true if `t` has a valid default value.
   runnableExamples:

lib/std/private/osdirs.nim

@@ -331,7 +331,7 @@ proc rawRemoveDir(dir: string) {.noWeirdTarget.} =
     if rmdir(dir) != 0'i32 and errno != ENOENT: raiseOSError(osLastError(), dir)
 
 proc removeDir*(dir: string, checkDir = false) {.rtl, extern: "nos$1", tags: [
-  WriteDirEffect, ReadDirEffect], benign, noWeirdTarget.} =
+  WriteDirEffect, ReadDirEffect], gcsafe, noWeirdTarget.} =
   ## Removes the directory `dir` including all subdirectories and files
   ## in `dir` (recursively).
   ##
@@ -441,7 +441,7 @@ proc createDir*(dir: string) {.rtl, extern: "nos$1",
       discard existsOrCreateDir(p)
 
 proc copyDir*(source, dest: string, skipSpecial = false) {.rtl, extern: "nos$1",
-  tags: [ReadDirEffect, WriteIOEffect, ReadIOEffect], benign, noWeirdTarget.} =
+  tags: [ReadDirEffect, WriteIOEffect, ReadIOEffect], gcsafe, noWeirdTarget.} =
   ## Copies a directory from `source` to `dest`.
   ##
   ## On non-Windows OSes, symlinks are copied as symlinks. On Windows, symlinks
@@ -482,7 +482,7 @@ proc copyDirWithPermissions*(source, dest: string,
                              ignorePermissionErrors = true,
                              skipSpecial = false)
   {.rtl, extern: "nos$1", tags: [ReadDirEffect, WriteIOEffect, ReadIOEffect],
-   benign, noWeirdTarget.} =
+   gcsafe, noWeirdTarget.} =
   ## Copies a directory from `source` to `dest` preserving file permissions.
   ##
   ## On non-Windows OSes, symlinks are copied as symlinks. On Windows, symlinks

lib/std/syncio.nim

@@ -182,7 +182,7 @@ proc checkErr(f: File) =
 
 {.push stackTrace: off, profiler: off.}
 proc readBuffer*(f: File, buffer: pointer, len: Natural): int {.
-  tags: [ReadIOEffect], benign.} =
+  tags: [ReadIOEffect], gcsafe.} =
   ## Reads `len` bytes into the buffer pointed to by `buffer`. Returns
   ## the actual number of bytes that have been read which may be less than
   ## `len` (if not as many bytes are remaining), but not greater.
@@ -191,20 +191,20 @@ proc readBuffer*(f: File, buffer: pointer, len: Natural): int {.
 
 proc readBytes*(f: File, a: var openArray[int8|uint8], start,
     len: Natural): int {.
-  tags: [ReadIOEffect], benign.} =
+  tags: [ReadIOEffect], gcsafe.} =
   ## Reads `len` bytes into the buffer `a` starting at `a[start]`. Returns
   ## the actual number of bytes that have been read which may be less than
   ## `len` (if not as many bytes are remaining), but not greater.
   result = readBuffer(f, addr(a[start]), len)
 
-proc readChars*(f: File, a: var openArray[char]): int {.tags: [ReadIOEffect], benign.} =
+proc readChars*(f: File, a: var openArray[char]): int {.tags: [ReadIOEffect], gcsafe.} =
   ## Reads up to `a.len` bytes into the buffer `a`. Returns
   ## the actual number of bytes that have been read which may be less than
   ## `a.len` (if not as many bytes are remaining), but not greater.
   result = readBuffer(f, addr(a[0]), a.len)
 
 proc readChars*(f: File, a: var openArray[char], start, len: Natural): int {.
-  tags: [ReadIOEffect], benign, deprecated:
+  tags: [ReadIOEffect], gcsafe, deprecated:
     "use other `readChars` overload, possibly via: readChars(toOpenArray(buf, start, len-1))".} =
   ## Reads `len` bytes into the buffer `a` starting at `a[start]`. Returns
   ## the actual number of bytes that have been read which may be less than
@@ -213,13 +213,13 @@ proc readChars*(f: File, a: var openArray[char], start, len: Natural): int {.
     raiseEIO("buffer overflow: (start+len) > length of openarray buffer")
   result = readBuffer(f, addr(a[start]), len)
 
-proc write*(f: File, c: cstring) {.tags: [WriteIOEffect], benign.} =
+proc write*(f: File, c: cstring) {.tags: [WriteIOEffect], gcsafe.} =
   ## Writes a value to the file `f`. May throw an IO exception.
   discard c_fputs(c, f)
   checkErr(f)
 
 proc writeBuffer*(f: File, buffer: pointer, len: Natural): int {.
-  tags: [WriteIOEffect], benign.} =
+  tags: [WriteIOEffect], gcsafe.} =
   ## Writes the bytes of buffer pointed to by the parameter `buffer` to the
   ## file `f`. Returns the number of actual written bytes, which may be less
   ## than `len` in case of an error.
@@ -227,7 +227,7 @@ proc writeBuffer*(f: File, buffer: pointer, len: Natural): int {.
   checkErr(f)
 
 proc writeBytes*(f: File, a: openArray[int8|uint8], start, len: Natural): int {.
-  tags: [WriteIOEffect], benign.} =
+  tags: [WriteIOEffect], gcsafe.} =
   ## Writes the bytes of `a[start..start+len-1]` to the file `f`. Returns
   ## the number of actual written bytes, which may be less than `len` in case
   ## of an error.
@@ -235,7 +235,7 @@ proc writeBytes*(f: File, a: openArray[int8|uint8], start, len: Natural): int {.
   result = writeBuffer(f, addr(x[int(start)]), len)
 
 proc writeChars*(f: File, a: openArray[char], start, len: Natural): int {.
-  tags: [WriteIOEffect], benign.} =
+  tags: [WriteIOEffect], gcsafe.} =
   ## Writes the bytes of `a[start..start+len-1]` to the file `f`. Returns
   ## the number of actual written bytes, which may be less than `len` in case
   ## of an error.
@@ -264,7 +264,7 @@ when defined(windows):
           break
         inc i, w
 
-proc write*(f: File, s: string) {.tags: [WriteIOEffect], benign.} =
+proc write*(f: File, s: string) {.tags: [WriteIOEffect], gcsafe.} =
   when defined(windows):
     writeWindows(f, s, doRaise = true)
   else:
@@ -393,7 +393,7 @@ when defined(nimdoc) or (defined(posix) and not defined(nimscript)) or defined(w
                                     inheritable.WinDWORD) != 0
 
 proc readLine*(f: File, line: var string): bool {.tags: [ReadIOEffect],
-              benign.} =
+              gcsafe.} =
   ## Reads a line of text from the file `f` into `line`. May throw an IO
   ## exception.
   ## A line of text may be delimited by `LF` or `CRLF`. The newline
@@ -519,43 +519,43 @@ proc readLine*(f: File, line: var string): bool {.tags: [ReadIOEffect],
     sp = 128 # read in 128 bytes at a time
     line.setLen(pos+sp)
 
-proc readLine*(f: File): string {.tags: [ReadIOEffect], benign.} =
+proc readLine*(f: File): string {.tags: [ReadIOEffect], gcsafe.} =
   ## Reads a line of text from the file `f`. May throw an IO exception.
   ## A line of text may be delimited by `LF` or `CRLF`. The newline
   ## character(s) are not part of the returned string.
   result = newStringOfCap(80)
   if not readLine(f, result): raiseEOF()
 
-proc write*(f: File, i: int) {.tags: [WriteIOEffect], benign.} =
+proc write*(f: File, i: int) {.tags: [WriteIOEffect], gcsafe.} =
   when sizeof(int) == 8:
     if c_fprintf(f, "%lld", i) < 0: checkErr(f)
   else:
     if c_fprintf(f, "%ld", i) < 0: checkErr(f)
 
-proc write*(f: File, i: BiggestInt) {.tags: [WriteIOEffect], benign.} =
+proc write*(f: File, i: BiggestInt) {.tags: [WriteIOEffect], gcsafe.} =
   when sizeof(BiggestInt) == 8:
     if c_fprintf(f, "%lld", i) < 0: checkErr(f)
   else:
     if c_fprintf(f, "%ld", i) < 0: checkErr(f)
 
-proc write*(f: File, b: bool) {.tags: [WriteIOEffect], benign.} =
+proc write*(f: File, b: bool) {.tags: [WriteIOEffect], gcsafe.} =
   if b: write(f, "true")
   else: write(f, "false")
 
-proc write*(f: File, r: float32) {.tags: [WriteIOEffect], benign.} =
+proc write*(f: File, r: float32) {.tags: [WriteIOEffect], gcsafe.} =
   var buffer {.noinit.}: array[65, char]
   discard writeFloatToBuffer(buffer, r)
   if c_fprintf(f, "%s", buffer[0].addr) < 0: checkErr(f)
 
-proc write*(f: File, r: BiggestFloat) {.tags: [WriteIOEffect], benign.} =
+proc write*(f: File, r: BiggestFloat) {.tags: [WriteIOEffect], gcsafe.} =
   var buffer {.noinit.}: array[65, char]
   discard writeFloatToBuffer(buffer, r)
   if c_fprintf(f, "%s", buffer[0].addr) < 0: checkErr(f)
 
-proc write*(f: File, c: char) {.tags: [WriteIOEffect], benign.} =
+proc write*(f: File, c: char) {.tags: [WriteIOEffect], gcsafe.} =
   discard c_putc(cint(c), f)
 
-proc write*(f: File, a: varargs[string, `$`]) {.tags: [WriteIOEffect], benign.} =
+proc write*(f: File, a: varargs[string, `$`]) {.tags: [WriteIOEffect], gcsafe.} =
   for x in items(a): write(f, x)
 
 proc readAllBuffer(file: File): string =
@@ -579,7 +579,7 @@ proc rawFileSize(file: File): int64 =
   result = c_ftell(file)
   discard c_fseek(file, oldPos, 0)
 
-proc endOfFile*(f: File): bool {.tags: [], benign.} =
+proc endOfFile*(f: File): bool {.tags: [], gcsafe.} =
   ## Returns true if `f` is at the end.
   var c = c_fgetc(f)
   discard c_ungetc(c, f)
@@ -603,7 +603,7 @@ proc readAllFile(file: File): string =
   var len = rawFileSize(file)
   result = readAllFile(file, len)
 
-proc readAll*(file: File): string {.tags: [ReadIOEffect], benign.} =
+proc readAll*(file: File): string {.tags: [ReadIOEffect], gcsafe.} =
   ## Reads all data from the stream `file`.
   ##
   ## Raises an IO exception in case of an error. It is an error if the
@@ -621,7 +621,7 @@ proc readAll*(file: File): string {.tags: [ReadIOEffect], benign.} =
     result = readAllBuffer(file)
 
 proc writeLine*[Ty](f: File, x: varargs[Ty, `$`]) {.inline,
-                          tags: [WriteIOEffect], benign.} =
+                          tags: [WriteIOEffect], gcsafe.} =
   ## Writes the values `x` to `f` and then writes "\\n".
   ## May throw an IO exception.
   for i in items(x):
@@ -713,7 +713,7 @@ when defined(posix) and not defined(nimscript):
 
 proc open*(f: var File, filename: string,
           mode: FileMode = fmRead,
-          bufSize: int = -1): bool {.tags: [], raises: [], benign.} =
+          bufSize: int = -1): bool {.tags: [], raises: [], gcsafe.} =
   ## Opens a file named `filename` with given `mode`.
   ##
   ## Default mode is readonly. Returns true if the file could be opened.
@@ -747,7 +747,7 @@ proc open*(f: var File, filename: string,
     result = false
 
 proc reopen*(f: File, filename: string, mode: FileMode = fmRead): bool {.
-  tags: [], benign.} =
+  tags: [], gcsafe.} =
   ## Reopens the file `f` with given `filename` and `mode`. This
   ## is often used to redirect the `stdin`, `stdout` or `stderr`
   ## file variables.
@@ -766,7 +766,7 @@ proc reopen*(f: File, filename: string, mode: FileMode = fmRead): bool {.
     result = false
 
 proc open*(f: var File, filehandle: FileHandle,
-           mode: FileMode = fmRead): bool {.tags: [], raises: [], benign.} =
+           mode: FileMode = fmRead): bool {.tags: [], raises: [], gcsafe.} =
   ## Creates a `File` from a `filehandle` with given `mode`.
   ##
   ## Default mode is readonly. Returns true if the file could be opened.
@@ -792,26 +792,26 @@ proc open*(filename: string,
   if not open(result, filename, mode, bufSize):
     raise newException(IOError, "cannot open: " & filename)
 
-proc setFilePos*(f: File, pos: int64, relativeTo: FileSeekPos = fspSet) {.benign, sideEffect.} =
+proc setFilePos*(f: File, pos: int64, relativeTo: FileSeekPos = fspSet) {.gcsafe, sideEffect.} =
   ## Sets the position of the file pointer that is used for read/write
   ## operations. The file's first byte has the index zero.
   if c_fseek(f, pos, cint(relativeTo)) != 0:
     raiseEIO("cannot set file position")
 
-proc getFilePos*(f: File): int64 {.benign.} =
+proc getFilePos*(f: File): int64 {.gcsafe.} =
   ## Retrieves the current position of the file pointer that is used to
   ## read from the file `f`. The file's first byte has the index zero.
   result = c_ftell(f)
   if result < 0: raiseEIO("cannot retrieve file position")
 
-proc getFileSize*(f: File): int64 {.tags: [ReadIOEffect], benign.} =
+proc getFileSize*(f: File): int64 {.tags: [ReadIOEffect], gcsafe.} =
   ## Retrieves the file size (in bytes) of `f`.
   let oldPos = getFilePos(f)
   discard c_fseek(f, 0, 2) # seek the end of the file
   result = getFilePos(f)
   setFilePos(f, oldPos)
 
-proc setStdIoUnbuffered*() {.tags: [], benign.} =
+proc setStdIoUnbuffered*() {.tags: [], gcsafe.} =
   ## Configures `stdin`, `stdout` and `stderr` to be unbuffered.
   when declared(stdout):
     discard c_setvbuf(stdout, nil, IONBF, 0)
@@ -865,7 +865,7 @@ when defined(windows) and appType == "console" and
     discard setConsoleCP(Utf8codepage)
     addExitProc(restoreConsoleCP)
 
-proc readFile*(filename: string): string {.tags: [ReadIOEffect], benign.} =
+proc readFile*(filename: string): string {.tags: [ReadIOEffect], gcsafe.} =
   ## Opens a file named `filename` for reading, calls `readAll
   ## <#readAll,File>`_ and closes the file afterwards. Returns the string.
   ## Raises an IO exception in case of an error. If you need to call
@@ -880,7 +880,7 @@ proc readFile*(filename: string): string {.tags: [ReadIOEffect], benign.} =
   else:
     raise newException(IOError, "cannot open: " & filename)
 
-proc writeFile*(filename, content: string) {.tags: [WriteIOEffect], benign.} =
+proc writeFile*(filename, content: string) {.tags: [WriteIOEffect], gcsafe.} =
   ## Opens a file named `filename` for writing. Then writes the
   ## `content` completely to the file and closes the file afterwards.
   ## Raises an IO exception in case of an error.

lib/std/sysatomics.nim

@@ -219,16 +219,16 @@ elif someVcc:
     elif mem == ATOMIC_ACQ_REL: fence()
     elif mem == ATOMIC_SEQ_CST: fence()
 
-  proc atomicStoreN*[T: AtomType](p: ptr T, val: T, mem: static[AtomMemModel]) =
+  proc atomicStoreN*[T: AtomType](p: ptr T, val: T, mem: static[AtomMemModel]) {.enforcenoraises.} =
     barrier(mem)
     p[] = val
 
-  proc atomicLoadN*[T: AtomType](p: ptr T, mem: static[AtomMemModel]): T =
+  proc atomicLoadN*[T: AtomType](p: ptr T, mem: static[AtomMemModel]): T {.enforcenoraises.} =
     result = p[]
     barrier(mem)
 
   proc atomicCompareExchangeN*[T: ptr](p, expected: ptr T, desired: T,
-    weak: bool, success_memmodel: AtomMemModel, failure_memmodel: AtomMemModel): bool =
+    weak: bool, success_memmodel: AtomMemModel, failure_memmodel: AtomMemModel): bool {.enforcenoraises.} =
     when sizeof(T) == 8:
       interlockedCompareExchange64(p, cast[int64](desired), cast[int64](expected[])) ==
         cast[int64](expected[])
@@ -236,7 +236,7 @@ elif someVcc:
       interlockedCompareExchange32(p, cast[int32](desired), cast[int32](expected[])) ==
         cast[int32](expected[])
 
-  proc atomicExchangeN*[T: ptr](p: ptr T, val: T, mem: AtomMemModel): T =
+  proc atomicExchangeN*[T: ptr](p: ptr T, val: T, mem: AtomMemModel): T {.enforcenoraises.} =
     when sizeof(T) == 8:
       cast[T](interlockedExchange64(p, cast[int64](val)))
     elif sizeof(T) == 4:

lib/std/tasks.nim

@@ -68,7 +68,7 @@ type
 
 proc `=copy`*(x: var Task, y: Task) {.error.}
 
-const arcLike = defined(gcArc) or defined(gcAtomicArc) or defined(gcOrc)
+const arcLike = defined(gcArc) or defined(gcAtomicArc) or defined(gcOrc) or defined(gcYrc)
 when defined(nimAllowNonVarDestructor) and arcLike:
   proc `=destroy`*(t: Task) {.inline, gcsafe.} =
     ## Frees the resources allocated for a `Task`.

lib/std/typedthreads.nim

@@ -9,13 +9,13 @@
 
 ##[
 Thread support for Nim. Threads allow multiple functions to execute concurrently.
- 
+
 In Nim, threads are a low-level construct and using a library like `malebolgia`, `taskpools` or `weave` is recommended.
- 
+
 When creating a thread, you can pass arguments to it. As Nim's garbage collector does not use atomic references, sharing
 `ref` and other variables managed by the garbage collector between threads is not supported.
 Use global variables to do so, or pointers.
- 
+
 Memory allocated using [`sharedAlloc`](./system.html#allocShared.t%2CNatural) can be used and shared between threads.
 
 To communicate between threads, consider using [channels](./system.html#Channel)
@@ -44,7 +44,7 @@ joinThreads(thr)
 
 deinitLock(L)
 ```
- 
+
 When using a memory management strategy that supports shared heaps like `arc` or `boehm`,
 you can pass pointer to threads and share memory between them, but the memory must outlive the thread.
 The default memory management strategy, `orc`, supports this.
@@ -52,14 +52,14 @@ The example below is **not valid** for memory management strategies that use loc
 
 ```Nim
 import locks
- 
+
 var l: Lock
- 
+
 proc threadFunc(obj: ptr seq[int]) {.thread.} =
   withLock l:
     for i in 0..<100:
       obj[].add(obj[].len * obj[].len)
- 
+
 proc threadHandler() =
   var thr: array[0..4, Thread[ptr seq[int]]]
   var s = newSeq[int]()
@@ -68,7 +68,7 @@ proc threadHandler() =
     createThread(thr[i], threadFunc, s.addr)
   joinThreads(thr)
   echo s
- 
+
 initLock(l)
 threadHandler()
 deinitLock(l)
@@ -303,5 +303,5 @@ else:
 proc createThread*(t: var Thread[void], tp: proc () {.thread, nimcall.}) =
   createThread[void](t, tp)
 
-when not defined(gcOrc):
+when not defined(gcOrc) and not defined(gcYrc):
   include system/threadids

lib/std/widestrs.nim

@@ -25,7 +25,7 @@ when not (defined(cpu16) or defined(cpu8)):
         bytes: int
         data: WideCString
 
-    const arcLike = defined(gcArc) or defined(gcAtomicArc) or defined(gcOrc)
+    const arcLike = defined(gcArc) or defined(gcAtomicArc) or defined(gcOrc) or defined(gcYrc)
     when defined(nimAllowNonVarDestructor) and arcLike:
       proc `=destroy`(a: WideCStringObj) =
         if a.data != nil:

lib/system.nim

@@ -125,7 +125,7 @@ proc unsafeAddr*[T](x: T): ptr T {.magic: "Addr", noSideEffect.} =
 
 const ThisIsSystem = true
 
-const arcLikeMem = defined(gcArc) or defined(gcAtomicArc) or defined(gcOrc)
+const arcLikeMem = defined(gcArc) or defined(gcAtomicArc) or defined(gcOrc) or defined(gcYrc)
 
 when defined(nimAllowNonVarDestructor) and arcLikeMem:
   proc new*[T](a: var ref T, finalizer: proc (x: T) {.nimcall.}) {.
@@ -356,7 +356,7 @@ proc low*(x: string): int {.magic: "Low", noSideEffect.}
   ## See also:
   ## * `high(string) <#high,string>`_
 
-when not defined(gcArc) and not defined(gcOrc) and not defined(gcAtomicArc):
+when not defined(gcArc) and not defined(gcOrc) and not defined(gcYrc) and not defined(gcAtomicArc):
   proc shallowCopy*[T](x: var T, y: T) {.noSideEffect, magic: "ShallowCopy".}
     ## Use this instead of `=` for a `shallow copy`:idx:.
     ##
@@ -407,7 +407,7 @@ when defined(nimHasDup):
 
 proc `=sink`*[T](x: var T; y: T) {.inline, nodestroy, magic: "Asgn".} =
   ## Generic `sink`:idx: implementation that can be overridden.
-  when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc):
+  when defined(gcArc) or defined(gcOrc) or defined(gcYrc) or defined(gcAtomicArc):
     x = y
   else:
     shallowCopy(x, y)
@@ -627,7 +627,7 @@ proc newSeq*[T](s: var seq[T], len: Natural) {.magic: "NewSeq", noSideEffect.}
   ##   #inputStrings[3] = "out of bounds"
   ##   ```
 
-proc newSeq*[T](len = 0.Natural): seq[T] =
+proc newSeq*[T](len = 0.Natural): seq[T] {.noSideEffect.} =
   ## Creates a new sequence of type `seq[T]` with length `len`.
   ##
   ## Note that the sequence will be filled with zeroed entries.
@@ -1147,7 +1147,7 @@ template sysAssert(cond: bool, msg: string) =
 const hasAlloc = (hostOS != "standalone" or not defined(nogc)) and not defined(nimscript)
 
 when notJSnotNims and hasAlloc and not defined(nimSeqsV2):
-  proc addChar(s: NimString, c: char): NimString {.compilerproc, benign.}
+  proc addChar(s: NimString, c: char): NimString {.compilerproc, gcsafe.}
 
 when defined(nimscript) or not defined(nimSeqsV2):
   proc add*[T](x: var seq[T], y: sink T) {.magic: "AppendSeqElem", noSideEffect.}
@@ -1459,6 +1459,7 @@ proc isNil*[T: proc | iterator {.closure.}](x: T): bool {.noSideEffect, magic: "
   ## `== nil`.
 
 proc supportsCopyMem(t: typedesc): bool {.magic: "TypeTrait".}
+proc canFormCycles(t: typedesc): bool {.magic: "TypeTrait".}
 
 when defined(nimHasTopDownInference):
   # magic used for seq type inference
@@ -1664,7 +1665,7 @@ when not defined(js) and hasThreadSupport and hostOS != "standalone":
 
 when not defined(js) and defined(nimV2):
   type
-    DestructorProc = proc (p: pointer) {.nimcall, benign, raises: [].}
+    DestructorProc = proc (p: pointer) {.nimcall, gcsafe, raises: [].}
     TNimTypeV2 {.compilerproc.} = object
       destructor: pointer
       size: int
@@ -1776,7 +1777,7 @@ when not defined(nimscript):
 when not declared(sysFatal):
   include "system/fatal"
 
-proc echo*(x: varargs[typed, `$`]) {.magic: "Echo", benign, sideEffect.}
+proc echo*(x: varargs[typed, `$`]) {.magic: "Echo", gcsafe, sideEffect.}
   ## Writes and flushes the parameters to the standard output.
   ##
   ## Special built-in that takes a variable number of arguments. Each argument
@@ -1883,7 +1884,7 @@ when notJSnotNims:
       ## lead to the `raise` statement. This only works for debug builds.
 
   var
-    globalRaiseHook*: proc (e: ref Exception): bool {.nimcall, benign.}
+    globalRaiseHook*: proc (e: ref Exception): bool {.nimcall, gcsafe.}
       ## With this hook you can influence exception handling on a global level.
       ## If not nil, every 'raise' statement ends up calling this hook.
       ##
@@ -1892,7 +1893,7 @@ when notJSnotNims:
       ## If `globalRaiseHook` returns false, the exception is caught and does
       ## not propagate further through the call stack.
 
-    localRaiseHook* {.threadvar.}: proc (e: ref Exception): bool {.nimcall, benign.}
+    localRaiseHook* {.threadvar.}: proc (e: ref Exception): bool {.nimcall, gcsafe.}
       ## With this hook you can influence exception handling on a
       ## thread local level.
       ## If not nil, every 'raise' statement ends up calling this hook.
@@ -1902,7 +1903,7 @@ when notJSnotNims:
       ## If `localRaiseHook` returns false, the exception
       ## is caught and does not propagate further through the call stack.
 
-    outOfMemHook*: proc () {.nimcall, tags: [], benign, raises: [].}
+    outOfMemHook*: proc () {.nimcall, tags: [], gcsafe, raises: [].}
       ## Set this variable to provide a procedure that should be called
       ## in case of an `out of memory`:idx: event. The standard handler
       ## writes an error message and terminates the program.
@@ -1923,7 +1924,7 @@ when notJSnotNims:
       ## If the handler does not raise an exception, ordinary control flow
       ## continues and the program is terminated.
 
-    unhandledExceptionHook*: proc (e: ref Exception) {.nimcall, tags: [], benign, raises: [].}
+    unhandledExceptionHook*: proc (e: ref Exception) {.nimcall, tags: [], gcsafe, raises: [].}
       ## Set this variable to provide a procedure that should be called
       ## in case of an `unhandle exception` event. The standard handler
       ## writes an error message and terminates the program, except when
@@ -2066,7 +2067,7 @@ when hostOS == "standalone" and defined(nogc):
     if s == nil or s.len == 0: result = cstring""
     else: result = cast[cstring](addr s.data)
 
-proc getTypeInfo*[T](x: T): pointer {.magic: "GetTypeInfo", benign.}
+proc getTypeInfo*[T](x: T): pointer {.magic: "GetTypeInfo", gcsafe.}
   ## Get type information for `x`.
   ##
   ## Ordinary code should not use this, but the `typeinfo module
@@ -2285,21 +2286,21 @@ when not defined(js) and declared(alloc0) and declared(dealloc):
     dealloc(a)
 
 when notJSnotNims and hostOS != "standalone":
-  proc getCurrentException*(): ref Exception {.compilerRtl, inl, benign.} =
+  proc getCurrentException*(): ref Exception {.compilerRtl, inl, gcsafe.} =
     ## Retrieves the current exception; if there is none, `nil` is returned.
     result = currException
 
-  proc nimBorrowCurrentException(): ref Exception {.compilerRtl, inl, benign, nodestroy.} =
+  proc nimBorrowCurrentException(): ref Exception {.compilerRtl, inl, gcsafe, nodestroy.} =
     # .nodestroy here so that we do not produce a write barrier as the
     # C codegen only uses it in a borrowed way:
     result = currException
 
-  proc getCurrentExceptionMsg*(): string {.inline, benign.} =
+  proc getCurrentExceptionMsg*(): string {.inline, gcsafe.} =
     ## Retrieves the error message that was attached to the current
     ## exception; if there is none, `""` is returned.
     return if currException == nil: "" else: currException.msg
 
-  proc setCurrentException*(exc: ref Exception) {.inline, benign.} =
+  proc setCurrentException*(exc: ref Exception) {.inline, gcsafe.} =
     ## Sets the current exception.
     ##
     ## .. warning:: Only use this if you know what you are doing.
@@ -2561,7 +2562,7 @@ when compileOption("rangechecks"):
 else:
   template rangeCheck*(cond) = discard
 
-when not defined(gcArc) and not defined(gcOrc) and not defined(gcAtomicArc):
+when not defined(gcArc) and not defined(gcOrc) and not defined(gcYrc) and not defined(gcAtomicArc):
   proc shallow*[T](s: var seq[T]) {.noSideEffect, inline.} =
     ## Marks a sequence `s` as `shallow`:idx:. Subsequent assignments will not
     ## perform deep copies of `s`.
@@ -2630,7 +2631,7 @@ when hasAlloc or defined(nimscript):
     setLen(x, xl+item.len)
     var j = xl-1
     while j >= i:
-      when defined(gcArc) or defined(gcOrc) or defined(gcAtomicArc):
+      when defined(gcArc) or defined(gcOrc) or defined(gcYrc) or defined(gcAtomicArc):
         x[j+item.len] = move x[j]
       else:
         shallowCopy(x[j+item.len], x[j])
@@ -3141,3 +3142,27 @@ proc arrayWithDefault*[T](size: static int): array[size, T] {.noinit, nodestroy,
   ## Creates a new array filled with `default(T)`.
   for i in 0..size-1:
     result[i] = default(T)
+
+when hostOS == "standalone":
+  # Include panicoverride.nim late so users can use the full extent of the
+  # language in their custom panic handlers (e.g. macros).
+  # Users define `proc panic(msg: string)` and `proc rawoutput(msg: string)`.
+  include "$projectpath/panicoverride"
+
+  when not declared(panic):
+    {.error:
+      "a panic proc with the following signature must be provided " &
+      "when compiling with --os:standalone: " &
+      "`proc panic(msg: string) {.nimcall.}`".}
+
+  when not declared(rawoutput):
+     {.error:
+      "a rawoutput proc with the following signature must be provided " &
+      "when compiling with --os:standalone: " &
+      "`proc rawoutput(msg: string) {.nimcall.}`".}
+
+  # Wrappers with exportc that fatal.nim references via importc.
+  # This way panicoverride keeps old API and can still be included without
+  # ssymbols being duplicated.
+  proc nimPanic(s: string) {.exportc, noreturn.} = panic(s)
+  proc nimRawoutput(s: string) {.exportc.} = rawoutput(s)