split PackedModule into reader and writer

.github/workflows/ci_bench.yml

@@ -0,0 +1,115 @@
+name: Benchmarks CI
+on:
+  pull_request:
+  push:
+    branches:
+      - 'devel'
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-20.04]
+        cpu: [amd64]
+    name: '${{ matrix.os }}'
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 60 # refs bug #18178
+    steps:
+      - name: 'Checkout'
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+
+      - name: 'Install node.js 20.x'
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20.x'
+
+      - name: 'Install dependencies (Linux amd64)'
+        if: runner.os == 'Linux' && matrix.cpu == 'amd64'
+        run: |
+          sudo apt-fast update -qq
+          DEBIAN_FRONTEND='noninteractive' \
+            sudo apt-fast install --no-install-recommends -yq \
+              libcurl4-openssl-dev libgc-dev libsdl1.2-dev libsfml-dev \
+              valgrind libc6-dbg libblas-dev xorg-dev
+
+      - name: 'Add build binaries to PATH'
+        shell: bash
+        run: echo "${{ github.workspace }}/bin" >> "${GITHUB_PATH}"
+
+      - name: 'Build csourcesAny'
+        shell: bash
+        run: . ci/funs.sh && nimBuildCsourcesIfNeeded CC=gcc ucpu='${{ matrix.cpu }}'
+
+      - name: 'Build koch'
+        shell: bash
+        run: nim c koch
+
+      - name: 'Build Nim'
+        shell: bash
+        run: ./koch boot -d:release -d:nimStrictMode --lib:lib
+
+      - name: 'Build Nimble'
+        shell: bash
+        run: ./koch nimble
+
+      - name: 'Action'
+        shell: bash
+        run: nim c -r -d:release ci/action.nim
+
+      - name: 'Checkout minimize'
+        uses: actions/checkout@v4
+        with:
+          repository: 'nim-lang/ci_bench'
+          path: minimize
+
+      - name: 'Run minimize benchmarks'
+        shell: bash
+        run: ./minimize/minimize ci-bench
+
+      - name: 'Restore minimize cached database'
+        uses: actions/cache/restore@v3
+        with:
+          path: minimize.csv
+          key: minimize-db-key
+
+      - name: 'Update minimize db'
+        shell: bash
+        run: ./minimize/minimize update-db
+
+      - name: 'Save minimize cached database'
+        if: |
+          github.event_name == 'push' && github.ref == 'refs/heads/devel' &&
+          matrix.target == 'linux'
+        uses: actions/cache/save@v3
+        with:
+          path: minimize.csv
+          key: minimize-db-key
+
+      - name: 'Generate minimize report'
+        shell: bash
+        run: ./minimize/minimize generate-report
+
+      - name: 'Archive minimize report'
+        uses: actions/upload-artifact@v3
+        with:
+          name: minimize-report
+          path: |
+            minimize/minimize.html
+            minimize/minimize.csv
+
+      # Requires additional permissions, see:
+      # https://github.com/nim-lang/Nim/actions/runs/4778177321/jobs/8494423792?pr=21566
+      # - name: 'Publish HTML report'
+      #   uses: rossjrw/pr-preview-action@v1
+      #   with:
+      #     source-dir: minimize
+      #     umbrella-dir: minimize
+      #   env:
+      #     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract md summary
+        run: |
+          cat minimize/summary.md  >> $GITHUB_STEP_SUMMARY

changelog.md

@@ -19,8 +19,6 @@
 
 - JS backend now supports lambda lifting for closures. Use `--legacy:jsNoLambdaLifting` to emulate old behavior.
 
-- `owner` in `std/macros` is deprecated.
-
 ## Standard library additions and changes
 
 [//]: # "Changes:"
@@ -32,7 +30,7 @@
 [//]: # "Additions:"
 
 - Added `newStringUninit` to system, which creates a new string of length `len` like `newString` but with uninitialized content.
-- Added `setLenUninit` to system, which doesn't initialize
+- Added `setLenUninit` to system, which doesn't initalize
 slots when enlarging a sequence.
 - Added `hasDefaultValue` to `std/typetraits` to check if a type has a valid default value.
 - Added Viewport API for the JavaScript targets in the `dom` module.
@@ -41,12 +39,9 @@ slots when enlarging a sequence.
   objects the cyclic collector did free. If the number is zero that is a strong indicator that you can use `--mm:arc`
   instead of `--mm:orc`.
 - A `$` template is provided for `Path` in `std/paths`.
-- `std/hashes.hash(x:string)` changed to produce a 64-bit string `Hash` (based
-on Google's Farm Hash) which is also often faster than the present one.  Define
-`nimStringHash2` to get the old values back.  `--jsbigint=off` mode always only
-produces the old values.  This may impact your automated tests if they depend
-on hash order in some obvious or indirect way.  Using `sorted` or `OrderedTable`
-is often an easy workaround.
+- `nimPreviewHashFarm` has been added to `lib/pure/hashes.nim` to default to a
+64-bit string `Hash` (based upon Google's Farm Hash) which is also faster than
+the present one.  At present, this is incompatible with `--jsbigint=off` mode.
 
 [//]: # "Deprecations:"
 

compiler/ast.nim

@@ -41,7 +41,7 @@ type
   TNodeKinds* = set[TNodeKind]
 
 type
-  TSymFlag* = enum    # 53 flags!
+  TSymFlag* = enum    # 52 flags!
     sfUsed,           # read access of sym (for warnings) or simply used
     sfExported,       # symbol is exported from module
     sfFromGeneric,    # symbol is instantiation of a generic; this is needed
@@ -52,7 +52,6 @@ type
     sfForward,        # symbol is forward declared
     sfWasForwarded,   # symbol had a forward declaration
                       # (implies it's too dangerous to patch its type signature)
-    sfNosinks,        # symbol has a `nosinks` pragma
     sfImportc,        # symbol is external; imported
     sfExportc,        # symbol is exported (under a specified name)
     sfMangleCpp,      # mangle as cpp (combines with `sfExportc`)
@@ -128,7 +127,6 @@ type
     sfMember          # proc is a C++ member of a type
     sfCodegenDecl     # type, proc, global or proc param is marked as codegenDecl
     sfWasGenSym       # symbol was 'gensym'ed
-    sfForceLift       # variable has to be lifted into closure environment
 
   TSymFlags* = set[TSymFlag]
 

compiler/ccgcalls.nim

@@ -170,7 +170,7 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
     line(p, cpsStmts, pl)
     if canRaise: raiseExit(p)
 
-proc genBoundsCheck(p: BProc; arr, a, b: TLoc; arrTyp: PType)
+proc genBoundsCheck(p: BProc; arr, a, b: TLoc)
 
 proc reifiedOpenArray(n: PNode): bool {.inline.} =
   var x = n
@@ -191,15 +191,15 @@ proc genOpenArraySlice(p: BProc; q: PNode; formalType, destType: PType; prepareF
   var a = initLocExpr(p, q[1])
   var b = initLocExpr(p, q[2])
   var c = initLocExpr(p, q[3])
-  # bug #23321: In the function mapType, ptrs (tyPtr, tyVar, tyLent, tyRef)
-  # are mapped into ctPtrToArray, the dereference of which is skipped
-  # in the `genDeref`. We need to skip these ptrs here
-  let ty = skipTypes(a.t, abstractVar+{tyPtr, tyRef})
   # but first produce the required index checks:
   if optBoundsCheck in p.options:
-    genBoundsCheck(p, a, b, c, ty)
+    genBoundsCheck(p, a, b, c)
   if prepareForMutation:
     linefmt(p, cpsStmts, "#nimPrepareStrMutationV2($1);$n", [byRefLoc(p, a)])
+  # bug #23321: In the function mapType, ptrs (tyPtr, tyVar, tyLent, tyRef)
+  # are mapped into ctPtrToArray, the dereference of which is skipped
+  # in the `genref`. We need to skip these ptrs here
+  let ty = skipTypes(a.t, abstractVar+{tyPtr, tyRef})
   let dest = getTypeDesc(p.module, destType)
   let lengthExpr = "($1)-($2)+1" % [rdLoc(c), rdLoc(b)]
   case ty.kind
@@ -331,23 +331,13 @@ proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Rope; need
       addAddrLoc(p.config, withTmpIfNeeded(p, a, needsTmp), result)
   elif p.module.compileToCpp and param.typ.kind in {tyVar} and
       n.kind == nkHiddenAddr:
-    # bug #23748: we need to introduce a temporary here. The expression type
-    # will be a reference in C++ and we cannot create a temporary reference
-    # variable. Thus, we create a temporary pointer variable instead.
-    let needsIndirect = mapType(p.config, n[0].typ, mapTypeChooser(n[0]) == skParam) != ctArray
-    if needsIndirect:
-      n.typ = n.typ.exactReplica
-      n.typ.flags.incl tfVarIsPtr
-    a = initLocExprSingleUse(p, n)
-    a = withTmpIfNeeded(p, a, needsTmp)
-    if needsIndirect: a.flags.incl lfIndirect
+    a = initLocExprSingleUse(p, n[0])
     # if the proc is 'importc'ed but not 'importcpp'ed then 'var T' still
     # means '*T'. See posix.nim for lots of examples that do that in the wild.
     let callee = call[0]
     if callee.kind == nkSym and
         {sfImportc, sfInfixCall, sfCompilerProc} * callee.sym.flags == {sfImportc} and
-        {lfHeader, lfNoDecl} * callee.sym.loc.flags != {} and
-        needsIndirect:
+        {lfHeader, lfNoDecl} * callee.sym.loc.flags != {}:
       addAddrLoc(p.config, a, result)
     else:
       addRdLoc(a, result)
@@ -440,11 +430,9 @@ proc genParams(p: BProc, ri: PNode, typ: PType; result: var Rope) =
         if not needTmp[i - 1]:
           needTmp[i - 1] = potentialAlias(n, potentialWrites)
       getPotentialWrites(ri[i], false, potentialWrites)
-    when false:
-      # this optimization is wrong, see bug #23748
-      if ri[i].kind in {nkHiddenAddr, nkAddr}:
-        # Optimization: don't use a temp, if we would only take the address anyway
-        needTmp[i - 1] = false
+    if ri[i].kind in {nkHiddenAddr, nkAddr}:
+      # Optimization: don't use a temp, if we would only take the address anyway
+      needTmp[i - 1] = false
 
   var oldLen = result.len
   for i in 1..<ri.len:

compiler/ccgexprs.nim

@@ -343,7 +343,7 @@ proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) =
   of tyString:
     if optSeqDestructors in p.config.globalOptions:
       genGenericAsgn(p, dest, src, flags)
-    elif ({needToCopy, needToCopySinkParam} * flags == {} and src.storage != OnStatic) or canMove(p, src.lode, dest):
+    elif (needToCopy notin flags and src.storage != OnStatic) or canMove(p, src.lode, dest):
       genRefAssign(p, dest, src)
     else:
       if (dest.storage == OnStack and p.config.selectedGC != gcGo) or not usesWriteBarrier(p.config):
@@ -812,8 +812,6 @@ proc genAddr(p: BProc, e: PNode, d: var TLoc) =
     #Message(e.info, warnUser, "HERE NEW &")
   elif mapType(p.config, e[0].typ, mapTypeChooser(e[0]) == skParam) == ctArray or isCppRef(p, e.typ):
     expr(p, e[0], d)
-    # bug #19497
-    d.lode = e
   else:
     var a: TLoc = initLocExpr(p, e[0])
     putIntoDest(p, d, e, addrLoc(p.config, a), a.storage)
@@ -1021,8 +1019,8 @@ proc genCStringElem(p: BProc, n, x, y: PNode, d: var TLoc) =
   putIntoDest(p, d, n,
               ropecg(p.module, "$1[$2]", [rdLoc(a), rdCharLoc(b)]), a.storage)
 
-proc genBoundsCheck(p: BProc; arr, a, b: TLoc; arrTyp: PType) =
-  let ty = arrTyp
+proc genBoundsCheck(p: BProc; arr, a, b: TLoc) =
+  let ty = skipTypes(arr.t, abstractVarRange)
   case ty.kind
   of tyOpenArray, tyVarargs:
     if reifiedOpenArray(arr.lode):
@@ -1857,7 +1855,7 @@ proc genArrayLen(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
       var b = initLocExpr(p, a[2])
       var c = initLocExpr(p, a[3])
       if optBoundsCheck in p.options:
-        genBoundsCheck(p, m, b, c, skipTypes(m.t, abstractVarRange))
+        genBoundsCheck(p, m, b, c)
       if op == mHigh:
         putIntoDest(p, d, e, ropecg(p.module, "(($2)-($1))", [rdLoc(b), rdLoc(c)]))
       else:
@@ -2347,13 +2345,8 @@ proc genMove(p: BProc; n: PNode; d: var TLoc) =
           else:
             linefmt(p, cpsStmts, "$1($2);$n", [rdLoc(b), byRefLoc(p, a)])
     else:
-      if n[1].kind == nkSym and isSinkParam(n[1].sym):
-        var tmp = getTemp(p, n[1].typ.skipTypes({tySink}))
-        genAssignment(p, tmp, a, {needToCopySinkParam})
-        genAssignment(p, d, tmp, {})
-        resetLoc(p, tmp)
-      else:
-        genAssignment(p, d, a, {})
+      let flags = if not canMove(p, n[1], d): {needToCopy} else: {}
+      genAssignment(p, d, a, flags)
       resetLoc(p, a)
 
 proc genDestroy(p: BProc; n: PNode) =

compiler/ccgtypes.nim

@@ -1475,7 +1475,7 @@ proc genObjectInfo(m: BModule; typ, origType: PType, name: Rope; info: TLineInfo
                       typeToString(typ))
   genTypeInfoAux(m, typ, origType, name, info)
   var tmp = getNimNode(m)
-  if (not isImportedType(typ)) or tfCompleteStruct in typ.flags:
+  if not isImportedType(typ):
     genObjectFields(m, typ, origType, typ.n, tmp, info)
   m.s[cfsTypeInit3].addf("$1.node = &$2;$n", [tiNameForHcr(m, name), tmp])
   var t = typ.baseClass

compiler/cgen.nim

@@ -412,7 +412,6 @@ proc rdCharLoc(a: TLoc): Rope =
 type
   TAssignmentFlag = enum
     needToCopy
-    needToCopySinkParam
     needTempForOpenArray
   TAssignmentFlags = set[TAssignmentFlag]
 

compiler/closureiters.nim

@@ -36,6 +36,13 @@
 #  else:
 #    return
 
+# The transformation should play well with lambdalifting, however depending
+# on situation, it can be called either before or after lambdalifting
+# transformation. As such we behave slightly differently, when accessing
+# iterator state, or using temp variables. If lambdalifting did not happen,
+# we just create local variables, so that they will be lifted further on.
+# Otherwise, we utilize existing env, created by lambdalifting.
+
 # Lambdalifting treats :state variable specially, it should always end up
 # as the first field in env. Currently C codegen depends on this behavior.
 
@@ -144,6 +151,7 @@ type
   Ctx = object
     g: ModuleGraph
     fn: PSym
+    stateVarSym: PSym # :state variable. nil if env already introduced by lambdalifting
     tmpResultSym: PSym # Used when we return, but finally has to interfere
     unrollFinallySym: PSym # Indicates that we're unrolling finally states (either exception happened or premature return)
     curExcSym: PSym # Current exception
@@ -160,18 +168,18 @@ type
     nearestFinally: int # Index of the nearest finally block. For try/except it
                     # is their finally. For finally it is parent finally. Otherwise -1
     idgen: IdGenerator
-    varStates: Table[ItemId, int] # Used to detect if local variable belongs to multiple states
 
 const
   nkSkip = {nkEmpty..nkNilLit, nkTemplateDef, nkTypeSection, nkStaticStmt,
             nkCommentStmt, nkMixinStmt, nkBindStmt} + procDefs
   emptyStateLabel = -1
-  localNotSeen = -1
-  localRequiresLifting = -2
 
 proc newStateAccess(ctx: var Ctx): PNode =
-  result = rawIndirectAccess(newSymNode(getEnvParam(ctx.fn)),
-      getStateField(ctx.g, ctx.fn), ctx.fn.info)
+  if ctx.stateVarSym.isNil:
+    result = rawIndirectAccess(newSymNode(getEnvParam(ctx.fn)),
+        getStateField(ctx.g, ctx.fn), ctx.fn.info)
+  else:
+    result = newSymNode(ctx.stateVarSym)
 
 proc newStateAssgn(ctx: var Ctx, toValue: PNode): PNode =
   # Creates state assignment:
@@ -187,17 +195,24 @@ proc newEnvVar(ctx: var Ctx, name: string, typ: PType): PSym =
   result = newSym(skVar, getIdent(ctx.g.cache, name), ctx.idgen, ctx.fn, ctx.fn.info)
   result.typ = typ
   result.flags.incl sfNoInit
-  assert(not typ.isNil, "Env var needs a type")
+  assert(not typ.isNil)
 
-  let envParam = getEnvParam(ctx.fn)
-  # let obj = envParam.typ.lastSon
-  result = addUniqueField(envParam.typ.elementType, result, ctx.g.cache, ctx.idgen)
+  if not ctx.stateVarSym.isNil:
+    # We haven't gone through labmda lifting yet, so just create a local var,
+    # it will be lifted later
+    if ctx.tempVars.isNil:
+      ctx.tempVars = newNodeI(nkVarSection, ctx.fn.info)
+      addVar(ctx.tempVars, newSymNode(result))
+  else:
+    let envParam = getEnvParam(ctx.fn)
+    # let obj = envParam.typ.lastSon
+    result = addUniqueField(envParam.typ.elementType, result, ctx.g.cache, ctx.idgen)
 
 proc newEnvVarAccess(ctx: Ctx, s: PSym): PNode =
-  result = rawIndirectAccess(newSymNode(getEnvParam(ctx.fn)), s, ctx.fn.info)
-
-proc newTempVarAccess(ctx: Ctx, s: PSym): PNode =
-  result = newSymNode(s, ctx.fn.info)
+  if ctx.stateVarSym.isNil:
+    result = rawIndirectAccess(newSymNode(getEnvParam(ctx.fn)), s, ctx.fn.info)
+  else:
+    result = newSymNode(s)
 
 proc newTmpResultAccess(ctx: var Ctx): PNode =
   if ctx.tmpResultSym.isNil:
@@ -240,18 +255,9 @@ proc addGotoOut(n: PNode, gotoOut: PNode): PNode =
   if result.len == 0 or result[^1].kind != nkGotoState:
     result.add(gotoOut)
 
-proc newTempVarDef(ctx: Ctx, s: PSym, initialValue: PNode): PNode =
-  var v = initialValue
-  if v == nil:
-    v = ctx.g.emptyNode
-  newTree(nkVarSection, newTree(nkIdentDefs, newSymNode(s), ctx.g.emptyNode, v))
-
-proc newTempVar(ctx: var Ctx, typ: PType, parent: PNode, initialValue: PNode = nil): PSym =
-  result = newSym(skVar, getIdent(ctx.g.cache, ":tmpSlLower" & $ctx.tempVarId), ctx.idgen, ctx.fn, ctx.fn.info)
+proc newTempVar(ctx: var Ctx, typ: PType): PSym =
+  result = ctx.newEnvVar(":tmpSlLower" & $ctx.tempVarId, typ)
   inc ctx.tempVarId
-  result.typ = typ
-  assert(not typ.isNil, "Temp var needs a type")
-  parent.add(ctx.newTempVarDef(result, initialValue))
 
 proc hasYields(n: PNode): bool =
   # TODO: This is very inefficient. It traverses the node, looking for nkYieldStmt.
@@ -423,20 +429,21 @@ proc exprToStmtList(n: PNode): tuple[s, res: PNode] =
 
   result.res = n
 
-proc newTempVarAsgn(ctx: Ctx, s: PSym, v: PNode): PNode =
+
+proc newEnvVarAsgn(ctx: Ctx, s: PSym, v: PNode): PNode =
   if isEmptyType(v.typ):
     result = v
   else:
-    result = newTree(nkFastAsgn, ctx.newTempVarAccess(s), v)
+    result = newTree(nkFastAsgn, ctx.newEnvVarAccess(s), v)
     result.info = v.info
 
 proc addExprAssgn(ctx: Ctx, output, input: PNode, sym: PSym) =
   if input.kind == nkStmtListExpr:
     let (st, res) = exprToStmtList(input)
     output.add(st)
-    output.add(ctx.newTempVarAsgn(sym, res))
+    output.add(ctx.newEnvVarAsgn(sym, res))
   else:
-    output.add(ctx.newTempVarAsgn(sym, input))
+    output.add(ctx.newEnvVarAsgn(sym, input))
 
 proc convertExprBodyToAsgn(ctx: Ctx, exprBody: PNode, res: PSym): PNode =
   result = newNodeI(nkStmtList, exprBody.info)
@@ -450,12 +457,6 @@ proc boolLit(g: ModuleGraph; info: TLineInfo; value: bool): PNode =
   result = newIntLit(g, info, ord value)
   result.typ = getSysType(g, info, tyBool)
 
-proc captureVar(c: var Ctx, s: PSym) =
-  if c.varStates.getOrDefault(s.itemId) != localRequiresLifting:
-    c.varStates[s.itemId] = localRequiresLifting # Mark this variable for lifting
-    let e = getEnvParam(c.fn)
-    discard addField(e.typ.elementType, s, c.g.cache, c.idgen)
-
 proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
   result = n
   case n.kind
@@ -512,9 +513,9 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
       var tmp: PSym = nil
       let isExpr = not isEmptyType(n.typ)
       if isExpr:
+        tmp = ctx.newTempVar(n.typ)
         result = newNodeI(nkStmtListExpr, n.info)
         result.typ = n.typ
-        tmp = ctx.newTempVar(n.typ, result)
       else:
         result = newNodeI(nkStmtList, n.info)
 
@@ -565,7 +566,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
         else:
           internalError(ctx.g.config, "lowerStmtListExpr(nkIf): " & $branch.kind)
 
-      if isExpr: result.add(ctx.newTempVarAccess(tmp))
+      if isExpr: result.add(ctx.newEnvVarAccess(tmp))
 
   of nkTryStmt, nkHiddenTryStmt:
     var ns = false
@@ -579,7 +580,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
       if isExpr:
         result = newNodeI(nkStmtListExpr, n.info)
         result.typ = n.typ
-        let tmp = ctx.newTempVar(n.typ, result)
+        let tmp = ctx.newTempVar(n.typ)
 
         n[0] = ctx.convertExprBodyToAsgn(n[0], tmp)
         for i in 1..<n.len:
@@ -595,7 +596,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
           else:
             internalError(ctx.g.config, "lowerStmtListExpr(nkTryStmt): " & $branch.kind)
         result.add(n)
-        result.add(ctx.newTempVarAccess(tmp))
+        result.add(ctx.newEnvVarAccess(tmp))
 
   of nkCaseStmt:
     var ns = false
@@ -608,9 +609,9 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
       let isExpr = not isEmptyType(n.typ)
 
       if isExpr:
+        let tmp = ctx.newTempVar(n.typ)
         result = newNodeI(nkStmtListExpr, n.info)
         result.typ = n.typ
-        let tmp = ctx.newTempVar(n.typ, result)
 
         if n[0].kind == nkStmtListExpr:
           let (st, ex) = exprToStmtList(n[0])
@@ -627,7 +628,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
           else:
             internalError(ctx.g.config, "lowerStmtListExpr(nkCaseStmt): " & $branch.kind)
         result.add(n)
-        result.add(ctx.newTempVarAccess(tmp))
+        result.add(ctx.newEnvVarAccess(tmp))
       elif n[0].kind == nkStmtListExpr:
         result = newNodeI(nkStmtList, n.info)
         let (st, ex) = exprToStmtList(n[0])
@@ -657,10 +658,10 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
           result.add(st)
           cond = ex
 
-        let tmp = ctx.newTempVar(cond.typ, result, cond)
-        # result.add(ctx.newTempVarAsgn(tmp, cond))
+        let tmp = ctx.newTempVar(cond.typ)
+        result.add(ctx.newEnvVarAsgn(tmp, cond))
 
-        var check = ctx.newTempVarAccess(tmp)
+        var check = ctx.newEnvVarAccess(tmp)
         if n[0].sym.magic == mOr:
           check = ctx.g.newNotCall(check)
 
@@ -670,12 +671,12 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
           let (st, ex) = exprToStmtList(cond)
           ifBody.add(st)
           cond = ex
-        ifBody.add(ctx.newTempVarAsgn(tmp, cond))
+        ifBody.add(ctx.newEnvVarAsgn(tmp, cond))
 
         let ifBranch = newTree(nkElifBranch, check, ifBody)
         let ifNode = newTree(nkIfStmt, ifBranch)
         result.add(ifNode)
-        result.add(ctx.newTempVarAccess(tmp))
+        result.add(ctx.newEnvVarAccess(tmp))
       else:
         for i in 0..<n.len:
           if n[i].kind == nkStmtListExpr:
@@ -684,9 +685,9 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
             n[i] = ex
 
           if n[i].kind in nkCallKinds: # XXX: This should better be some sort of side effect tracking
-            let tmp = ctx.newTempVar(n[i].typ, result, n[i])
-            # result.add(ctx.newTempVarAsgn(tmp, n[i]))
-            n[i] = ctx.newTempVarAccess(tmp)
+            let tmp = ctx.newTempVar(n[i].typ)
+            result.add(ctx.newEnvVarAsgn(tmp, n[i]))
+            n[i] = ctx.newEnvVarAccess(tmp)
 
         result.add(n)
 
@@ -702,12 +703,6 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
         let (st, ex) = exprToStmtList(c[^1])
         result.add(st)
         c[^1] = ex
-      for i in 0 .. c.len - 3:
-        if c[i].kind == nkSym:
-          let s = c[i].sym
-          if sfForceLift in s.flags:
-            ctx.captureVar(s)
-
       result.add(varSect)
 
   of nkDiscardStmt, nkReturnStmt, nkRaiseStmt:
@@ -1284,6 +1279,13 @@ proc wrapIntoStateLoop(ctx: var Ctx, n: PNode): PNode =
   result.info = n.info
 
   let localVars = newNodeI(nkStmtList, n.info)
+  if not ctx.stateVarSym.isNil:
+    let varSect = newNodeI(nkVarSection, n.info)
+    addVar(varSect, newSymNode(ctx.stateVarSym))
+    localVars.add(varSect)
+
+    if not ctx.tempVars.isNil:
+      localVars.add(ctx.tempVars)
 
   let blockStmt = newNodeI(nkBlockStmt, n.info)
   blockStmt.add(newSymNode(ctx.stateLoopLabel))
@@ -1431,67 +1433,15 @@ proc preprocess(c: var PreprocessContext; n: PNode): PNode =
     for i in 0 ..< n.len:
       result[i] = preprocess(c, n[i])
 
-proc detectCapturedVars(c: var Ctx, n: PNode, stateIdx: int) =
-  case n.kind
-  of nkSym:
-    let s = n.sym
-    if s.kind in {skResult, skVar, skLet, skForVar, skTemp} and sfGlobal notin s.flags and s.owner == c.fn:
-      let vs = c.varStates.getOrDefault(s.itemId, localNotSeen)
-      if vs == localNotSeen: # First seing this variable
-        c.varStates[s.itemId] = stateIdx
-      elif vs == localRequiresLifting:
-        discard # Sym already marked
-      elif vs != stateIdx:
-        c.captureVar(s)
-  of nkReturnStmt:
-    if n[0].kind in {nkAsgn, nkFastAsgn, nkSinkAsgn}:
-      # we have a `result = result` expression produced by the closure
-      # transform, let's not touch the LHS in order to make the lifting pass
-      # correct when `result` is lifted
-      detectCapturedVars(c, n[0][1], stateIdx)
-    else:
-      detectCapturedVars(c, n[0], stateIdx)
-  else:
-    for i in 0 ..< n.safeLen:
-      detectCapturedVars(c, n[i], stateIdx)
-
-proc detectCapturedVars(c: var Ctx) =
-  for i, s in c.states:
-    detectCapturedVars(c, s.body, i)
-
-proc liftLocals(c: var Ctx, n: PNode): PNode =
-  result = n
-  case n.kind
-  of nkSym:
-    let s = n.sym
-    if c.varStates.getOrDefault(s.itemId) == localRequiresLifting:
-      # lift
-      let e = getEnvParam(c.fn)
-      let field = getFieldFromObj(e.typ.elementType, s)
-      assert(field != nil)
-      result = rawIndirectAccess(newSymNode(e), field, n.info)
-    # elif c.varStates.getOrDefault(s.itemId, localNotSeen) != localNotSeen:
-    #   echo "Not lifting ", s.name.s
-
-  of nkReturnStmt:
-    if n[0].kind in {nkAsgn, nkFastAsgn, nkSinkAsgn}:
-      # we have a `result = result` expression produced by the closure
-      # transform, let's not touch the LHS in order to make the lifting pass
-      # correct when `result` is lifted
-      n[0][1] = liftLocals(c, n[0][1])
-    else:
-      n[0] = liftLocals(c, n[0])
-  else:
-    for i in 0 ..< n.safeLen:
-      n[i] = liftLocals(c, n[i])
-
 proc transformClosureIterator*(g: ModuleGraph; idgen: IdGenerator; fn: PSym, n: PNode): PNode =
   var ctx = Ctx(g: g, fn: fn, idgen: idgen)
 
-  # The transformation should always happen after at least partial lambdalifting
-  # is performed, so that the closure iter environment is always created upfront.
-  doAssert(getEnvParam(fn) != nil, "Env param not created before iter transformation")
-
+  if getEnvParam(fn).isNil:
+    # Lambda lifting was not done yet. Use temporary :state sym, which will
+    # be handled specially by lambda lifting. Local temp vars (if needed)
+    # should follow the same logic.
+    ctx.stateVarSym = newSym(skVar, getIdent(ctx.g.cache, ":state"), idgen, fn, fn.info)
+    ctx.stateVarSym.typ = g.createClosureIterStateType(fn, idgen)
   ctx.stateLoopLabel = newSym(skLabel, getIdent(ctx.g.cache, ":stateLoop"), idgen, fn, fn.info)
   var pc = PreprocessContext(finallys: @[], config: g.config, idgen: idgen)
   var n = preprocess(pc, n.toStmtList)
@@ -1516,10 +1466,6 @@ proc transformClosureIterator*(g: ModuleGraph; idgen: IdGenerator; fn: PSym, n:
   let caseDispatcher = newTreeI(nkCaseStmt, n.info,
       ctx.newStateAccess())
 
-  # Lamdalifting will not touch our locals, it is our responsibility to lift those that
-  # need it.
-  detectCapturedVars(ctx)
-
   for s in ctx.states:
     let body = ctx.transformStateAssignments(s.body)
     caseDispatcher.add newTreeI(nkOfBranch, body.info, g.newIntLit(body.info, s.label), body)
@@ -1527,7 +1473,6 @@ proc transformClosureIterator*(g: ModuleGraph; idgen: IdGenerator; fn: PSym, n:
   caseDispatcher.add newTreeI(nkElse, n.info, newTreeI(nkReturnStmt, n.info, g.emptyNode))
 
   result = wrapIntoStateLoop(ctx, caseDispatcher)
-  result = liftLocals(ctx, result)
 
   when false:
     echo "TRANSFORM TO STATES: "
@@ -1536,5 +1481,3 @@ proc transformClosureIterator*(g: ModuleGraph; idgen: IdGenerator; fn: PSym, n:
     echo "exception table:"
     for i, e in ctx.exceptionTable:
       echo i, " -> ", e
-
-    echo "ENV: ", renderTree(getEnvParam(fn).typ.elementType.n)

compiler/commands.nim

@@ -462,6 +462,7 @@ proc handleCmdInput*(conf: ConfigRef) =
 proc parseCommand*(command: string): Command =
   case command.normalize
   of "c", "cc", "compile", "compiletoc": cmdCompileToC
+  of "nir": cmdCompileToNir
   of "cpp", "compiletocpp": cmdCompileToCpp
   of "objc", "compiletooc": cmdCompileToOC
   of "js", "compiletojs": cmdCompileToJS
@@ -499,6 +500,7 @@ proc setCmd*(conf: ConfigRef, cmd: Command) =
   of cmdCompileToCpp: conf.backend = backendCpp
   of cmdCompileToOC: conf.backend = backendObjc
   of cmdCompileToJS: conf.backend = backendJs
+  of cmdCompileToNir: conf.backend = backendNir
   else: discard
 
 proc setCommandEarly*(conf: ConfigRef, command: string) =

compiler/extccomp.nim

@@ -172,22 +172,6 @@ compiler vcc:
     cppXsupport: "",
     props: {hasCpp, hasAssume, hasDeclspec})
 
-# Nvidia CUDA NVCC Compiler
-compiler nvcc:
-  result = gcc()
-  result.name = "nvcc"
-  result.compilerExe = "nvcc"
-  result.cppCompiler = "nvcc"
-  result.compileTmpl = "-c -x cu -Xcompiler=\"$options\" $include -o $objfile $file"
-  result.linkTmpl = "$buildgui $builddll -o $exefile $objfiles -Xcompiler=\"$options\""
-
-# AMD HIPCC Compiler (rocm/cuda)
-compiler hipcc:
-  result = clang()
-  result.name = "hipcc"
-  result.compilerExe = "hipcc"
-  result.cppCompiler = "hipcc"
-
 compiler clangcl:
   result = vcc()
   result.name = "clang_cl"
@@ -301,9 +285,7 @@ const
     envcc(),
     icl(),
     icc(),
-    clangcl(),
-    hipcc(),
-    nvcc()]
+    clangcl()]
 
   hExt* = ".h"
 
@@ -337,7 +319,7 @@ proc getConfigVar(conf: ConfigRef; c: TSystemCC, suffix: string): string =
   var fullSuffix = suffix
   case conf.backend
   of backendCpp, backendJs, backendObjc: fullSuffix = "." & $conf.backend & suffix
-  of backendC: discard
+  of backendC, backendNir: discard
   of backendInvalid:
     # during parsing of cfg files; we don't know the backend yet, no point in
     # guessing wrong thing

compiler/ic/ic.nim

@@ -16,7 +16,7 @@ from std/os import removeFile, isAbsolute
 
 import ../../dist/checksums/src/checksums/sha1
 
-import iclineinfos
+import ".." / nir / nirlineinfos
 
 when defined(nimPreviewSlimSystem):
   import std/[syncio, assertions, formatfloat]
@@ -33,7 +33,42 @@ type
     HasDatInitProc
     HasModuleInitProc
 
-  PackedModule* = object ## the parts of a PackedEncoder that are part of the .rod file
+  PackedModuleReader* = object ## the parts of a PackedEncoder that are part of the .rod file
+    definedSymbols: string
+    moduleFlags: TSymFlags
+    includes*: seq[(LitId, string)] # first entry is the module filename itself
+    imports: seq[LitId] # the modules this module depends on
+    toReplay*: PackedTree # pragmas and VM specific state to replay.
+    topLevel*: PackedTree  # top level statements
+    bodies*: PackedTree # other trees. Referenced from typ.n and sym.ast by their position.
+    #producedGenerics*: Table[GenericKey, SymId]
+    exports*: seq[(LitId, int32)]
+    hidden: seq[(LitId, int32)]
+    reexports: seq[(LitId, PackedItemId)]
+    compilerProcs*: seq[(LitId, int32)]
+    converters*, methods*, trmacros*, pureEnums*: seq[int32]
+
+    typeInstCache*: seq[(PackedItemId, PackedItemId)]
+    procInstCache*: seq[PackedInstantiation]
+    attachedOps*: seq[(PackedItemId, TTypeAttachedOp, PackedItemId)]
+    methodsPerGenericType*: seq[(PackedItemId, int, PackedItemId)]
+    enumToStringProcs*: seq[(PackedItemId, PackedItemId)]
+    methodsPerType*: seq[(PackedItemId, PackedItemId)]
+    dispatchers*: seq[PackedItemId]
+
+    emittedTypeInfo*: seq[string]
+    backendFlags*: set[ModuleBackendFlag]
+
+    syms*: OrderedTable[int32, PackedSym]
+    types*: OrderedTable[int32, PackedType]
+    strings*: BiTable[string] # we could share these between modules.
+    numbers*: BiTable[BiggestInt] # we also store floats in here so
+                                  # that we can assure that every bit is kept
+    man*: LineInfoManager
+
+    cfg: PackedConfig
+
+  PackedModuleWriter* = object ## the parts of a PackedEncoder that are part of the .rod file
     definedSymbols: string
     moduleFlags: TSymFlags
     includes*: seq[(LitId, string)] # first entry is the module filename itself
@@ -69,7 +104,7 @@ type
     cfg: PackedConfig
 
   PackedEncoder* = object
-    #m*: PackedModule
+    #m*: PackedModuleWriter
     thisModule*: int32
     lastFile*: FileIndex # remember the last lookup entry.
     lastLit*: LitId
@@ -80,7 +115,7 @@ type
     symMarker*: IntSet #Table[ItemId, SymId]    # ItemId.item -> SymId
     config*: ConfigRef
 
-proc toString*(tree: PackedTree; pos: NodePos; m: PackedModule; nesting: int;
+proc toString*(tree: PackedTree; pos: NodePos; m: PackedModuleWriter|PackedModuleReader; nesting: int;
                result: var string) =
   if result.len > 0 and result[^1] notin {' ', '\n'}:
     result.add ' '
@@ -116,11 +151,11 @@ proc toString*(tree: PackedTree; pos: NodePos; m: PackedModule; nesting: int;
     result.add ")"
     #for i in 1..nesting*2: result.add ' '
 
-proc toString*(tree: PackedTree; n: NodePos; m: PackedModule): string =
+proc toString*(tree: PackedTree; n: NodePos; m: PackedModuleWriter|PackedModuleReader): string =
   result = ""
   toString(tree, n, m, 0, result)
 
-proc debug*(tree: PackedTree; m: PackedModule) =
+proc debug*(tree: PackedTree; m: PackedModuleWriter|PackedModuleReader) =
   stdout.write toString(tree, NodePos 0, m)
 
 proc isActive*(e: PackedEncoder): bool = e.config != nil
@@ -140,7 +175,7 @@ proc definedSymbolsAsString(config: ConfigRef): string =
     result.add ' '
     result.add d
 
-proc rememberConfig(c: var PackedEncoder; m: var PackedModule; config: ConfigRef; pc: PackedConfig) =
+proc rememberConfig(c: var PackedEncoder; m: var PackedModuleWriter; config: ConfigRef; pc: PackedConfig) =
   m.definedSymbols = definedSymbolsAsString(config)
   #template rem(x) =
   #  c.m.cfg.x = config.x
@@ -153,7 +188,7 @@ const
 when debugConfigDiff:
   import hashes, tables, intsets, sha1, strutils, sets
 
-proc configIdentical(m: PackedModule; config: ConfigRef): bool =
+proc configIdentical(m: PackedModuleReader; config: ConfigRef): bool =
   result = m.definedSymbols == definedSymbolsAsString(config)
   when debugConfigDiff:
     if not result:
@@ -183,7 +218,7 @@ proc hashFileCached(conf: ConfigRef; fileIdx: FileIndex): string =
     result = $secureHashFile(fullpath)
     msgs.setHash(conf, fileIdx, result)
 
-proc toLitId(x: FileIndex; c: var PackedEncoder; m: var PackedModule): LitId =
+proc toLitId(x: FileIndex; c: var PackedEncoder; m: var PackedModuleWriter): LitId =
   ## store a file index as a literal
   if x == c.lastFile:
     result = c.lastLit
@@ -197,16 +232,16 @@ proc toLitId(x: FileIndex; c: var PackedEncoder; m: var PackedModule): LitId =
     c.lastLit = result
   assert result != LitId(0)
 
-proc toFileIndex*(x: LitId; m: PackedModule; config: ConfigRef): FileIndex =
+proc toFileIndex*(x: LitId; m: PackedModuleReader; config: ConfigRef): FileIndex =
   result = msgs.fileInfoIdx(config, AbsoluteFile m.strings[x])
 
-proc includesIdentical(m: var PackedModule; config: ConfigRef): bool =
+proc includesIdentical(m: var PackedModuleReader; config: ConfigRef): bool =
   for it in mitems(m.includes):
     if hashFileCached(config, toFileIndex(it[0], m, config)) != it[1]:
       return false
   result = true
 
-proc initEncoder*(c: var PackedEncoder; m: var PackedModule; moduleSym: PSym; config: ConfigRef; pc: PackedConfig) =
+proc initEncoder*(c: var PackedEncoder; m: var PackedModuleWriter; moduleSym: PSym; config: ConfigRef; pc: PackedConfig) =
   ## setup a context for serializing to packed ast
   c.thisModule = moduleSym.itemId.module
   c.config = config
@@ -228,54 +263,54 @@ proc initEncoder*(c: var PackedEncoder; m: var PackedModule; moduleSym: PSym; co
 
   rememberConfig(c, m, config, pc)
 
-proc addIncludeFileDep*(c: var PackedEncoder; m: var PackedModule; f: FileIndex) =
+proc addIncludeFileDep*(c: var PackedEncoder; m: var PackedModuleWriter; f: FileIndex) =
   m.includes.add((toLitId(f, c, m), hashFileCached(c.config, f)))
 
-proc addImportFileDep*(c: var PackedEncoder; m: var PackedModule; f: FileIndex) =
+proc addImportFileDep*(c: var PackedEncoder; m: var PackedModuleWriter; f: FileIndex) =
   m.imports.add toLitId(f, c, m)
 
-proc addHidden*(c: var PackedEncoder; m: var PackedModule; s: PSym) =
+proc addHidden*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym) =
   assert s.kind != skUnknown
   let nameId = getOrIncl(m.strings, s.name.s)
   m.hidden.add((nameId, s.itemId.item))
   assert s.itemId.module == c.thisModule
 
-proc addExported*(c: var PackedEncoder; m: var PackedModule; s: PSym) =
+proc addExported*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym) =
   assert s.kind != skUnknown
   assert s.itemId.module == c.thisModule
   let nameId = getOrIncl(m.strings, s.name.s)
   m.exports.add((nameId, s.itemId.item))
 
-proc addConverter*(c: var PackedEncoder; m: var PackedModule; s: PSym) =
+proc addConverter*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym) =
   assert c.thisModule == s.itemId.module
   m.converters.add(s.itemId.item)
 
-proc addTrmacro*(c: var PackedEncoder; m: var PackedModule; s: PSym) =
+proc addTrmacro*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym) =
   m.trmacros.add(s.itemId.item)
 
-proc addPureEnum*(c: var PackedEncoder; m: var PackedModule; s: PSym) =
+proc addPureEnum*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym) =
   assert s.kind == skType
   m.pureEnums.add(s.itemId.item)
 
-proc addMethod*(c: var PackedEncoder; m: var PackedModule; s: PSym) =
+proc addMethod*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym) =
   m.methods.add s.itemId.item
 
-proc addReexport*(c: var PackedEncoder; m: var PackedModule; s: PSym) =
+proc addReexport*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym) =
   assert s.kind != skUnknown
   if s.kind == skModule: return
   let nameId = getOrIncl(m.strings, s.name.s)
   m.reexports.add((nameId, PackedItemId(module: toLitId(s.itemId.module.FileIndex, c, m),
                                         item: s.itemId.item)))
 
-proc addCompilerProc*(c: var PackedEncoder; m: var PackedModule; s: PSym) =
+proc addCompilerProc*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym) =
   let nameId = getOrIncl(m.strings, s.name.s)
   m.compilerProcs.add((nameId, s.itemId.item))
 
-proc toPackedNode*(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModule)
-proc storeSym*(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId
-proc storeType(t: PType; c: var PackedEncoder; m: var PackedModule): PackedItemId
+proc toPackedNode*(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModuleWriter)
+proc storeSym*(s: PSym; c: var PackedEncoder; m: var PackedModuleWriter): PackedItemId
+proc storeType(t: PType; c: var PackedEncoder; m: var PackedModuleWriter): PackedItemId
 
-proc flush(c: var PackedEncoder; m: var PackedModule) =
+proc flush(c: var PackedEncoder; m: var PackedModuleWriter) =
   ## serialize any pending types or symbols from the context
   while true:
     if c.pendingTypes.len > 0:
@@ -285,19 +320,19 @@ proc flush(c: var PackedEncoder; m: var PackedModule) =
     else:
       break
 
-proc toLitId(x: string; m: var PackedModule): LitId =
+proc toLitId(x: string; m: var PackedModuleWriter): LitId =
   ## store a string as a literal
   result = getOrIncl(m.strings, x)
 
-proc toLitId(x: BiggestInt; m: var PackedModule): LitId =
+proc toLitId(x: BiggestInt; m: var PackedModuleWriter): LitId =
   ## store an integer as a literal
   result = getOrIncl(m.numbers, x)
 
-proc toPackedInfo(x: TLineInfo; c: var PackedEncoder; m: var PackedModule): PackedLineInfo =
+proc toPackedInfo(x: TLineInfo; c: var PackedEncoder; m: var PackedModuleWriter): PackedLineInfo =
   pack(m.man, toLitId(x.fileIndex, c, m), x.line.int32, x.col.int32)
   #PackedLineInfo(line: x.line, col: x.col, file: toLitId(x.fileIndex, c, m))
 
-proc safeItemId(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId {.inline.} =
+proc safeItemId(s: PSym; c: var PackedEncoder; m: var PackedModuleWriter): PackedItemId {.inline.} =
   ## given a symbol, produce an ItemId with the correct properties
   ## for local or remote symbols, packing the symbol as necessary
   if s == nil or s.kind == skPackage:
@@ -331,7 +366,7 @@ template storeNode(dest, src, field) =
     nodeId = emptyNodeId
   dest.field = nodeId
 
-proc storeTypeLater(t: PType; c: var PackedEncoder; m: var PackedModule): PackedItemId =
+proc storeTypeLater(t: PType; c: var PackedEncoder; m: var PackedModuleWriter): PackedItemId =
   # We store multiple different trees in m.bodies. For this to work out, we
   # cannot immediately store types/syms. We enqueue them instead to ensure
   # we only write one tree into m.bodies after the other.
@@ -344,7 +379,7 @@ proc storeTypeLater(t: PType; c: var PackedEncoder; m: var PackedModule): Packed
     # the type belongs to this module, so serialize it here, eventually.
     addMissing(c, t)
 
-proc storeSymLater(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId =
+proc storeSymLater(s: PSym; c: var PackedEncoder; m: var PackedModuleWriter): PackedItemId =
   if s.isNil: return nilItemId
   assert s.itemId.module >= 0
   assert s.itemId.item >= 0
@@ -353,7 +388,7 @@ proc storeSymLater(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedIt
     # the sym belongs to this module, so serialize it here, eventually.
     addMissing(c, s)
 
-proc storeType(t: PType; c: var PackedEncoder; m: var PackedModule): PackedItemId =
+proc storeType(t: PType; c: var PackedEncoder; m: var PackedModuleWriter): PackedItemId =
   ## serialize a ptype
   if t.isNil: return nilItemId
 
@@ -380,7 +415,7 @@ proc storeType(t: PType; c: var PackedEncoder; m: var PackedModule): PackedItemI
     # fill the reserved slot, nothing else:
     m.types[t.uniqueId.item] = p
 
-proc toPackedLib(l: PLib; c: var PackedEncoder; m: var PackedModule): PackedLib =
+proc toPackedLib(l: PLib; c: var PackedEncoder; m: var PackedModuleWriter): PackedLib =
   ## the plib hangs off the psym via the .annex field
   if l.isNil: return
   result = PackedLib(kind: l.kind, generated: l.generated,
@@ -388,7 +423,7 @@ proc toPackedLib(l: PLib; c: var PackedEncoder; m: var PackedModule): PackedLib
   )
   storeNode(result, l, path)
 
-proc storeSym*(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId =
+proc storeSym*(s: PSym; c: var PackedEncoder; m: var PackedModuleWriter): PackedItemId =
   ## serialize a psym
   if s.isNil: return nilItemId
 
@@ -428,7 +463,7 @@ proc storeSym*(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId
     # fill the reserved slot, nothing else:
     m.syms[s.itemId.item] = p
 
-proc addModuleRef(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModule) =
+proc addModuleRef(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModuleWriter) =
   ## add a remote symbol reference to the tree
   let info = n.info.toPackedInfo(c, m)
   if n.typ != n.sym.typ:
@@ -443,7 +478,7 @@ proc addModuleRef(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var Pac
   ir.addNode(kind = nkNone, info = info,
              operand = n.sym.itemId.item)
 
-proc toPackedNode*(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModule) =
+proc toPackedNode*(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModuleWriter) =
   ## serialize a node into the tree
   if n == nil:
     ir.addNode(kind = nkNilRodNode, operand = 1, info = NoLineInfo)
@@ -491,13 +526,13 @@ proc toPackedNode*(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var Pa
       toPackedNode(n[i], ir, c, m)
     ir.patch patchPos
 
-proc storeTypeInst*(c: var PackedEncoder; m: var PackedModule; s: PSym; inst: PType) =
+proc storeTypeInst*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym; inst: PType) =
   m.typeInstCache.add (storeSymLater(s, c, m), storeTypeLater(inst, c, m))
 
-proc addPragmaComputation*(c: var PackedEncoder; m: var PackedModule; n: PNode) =
+proc addPragmaComputation*(c: var PackedEncoder; m: var PackedModuleWriter; n: PNode) =
   toPackedNode(n, m.toReplay, c, m)
 
-proc toPackedProcDef(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModule) =
+proc toPackedProcDef(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModuleWriter) =
   let info = toPackedInfo(n.info, c, m)
   let patchPos = ir.prepare(n.kind, n.flags,
                             storeTypeLater(n.typ, c, m), info)
@@ -512,7 +547,7 @@ proc toPackedProcDef(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var
                  typeId = nilItemId, info = info)
   ir.patch patchPos
 
-proc toPackedNodeIgnoreProcDefs(n: PNode, encoder: var PackedEncoder; m: var PackedModule) =
+proc toPackedNodeIgnoreProcDefs(n: PNode, encoder: var PackedEncoder; m: var PackedModuleWriter) =
   case n.kind
   of routineDefs:
     toPackedProcDef(n, m.topLevel, encoder, m)
@@ -534,11 +569,11 @@ proc toPackedNodeIgnoreProcDefs(n: PNode, encoder: var PackedEncoder; m: var Pac
   else:
     toPackedNode(n, m.topLevel, encoder, m)
 
-proc toPackedNodeTopLevel*(n: PNode, encoder: var PackedEncoder; m: var PackedModule) =
+proc toPackedNodeTopLevel*(n: PNode, encoder: var PackedEncoder; m: var PackedModuleWriter) =
   toPackedNodeIgnoreProcDefs(n, encoder, m)
   flush encoder, m
 
-proc toPackedGeneratedProcDef*(s: PSym, encoder: var PackedEncoder; m: var PackedModule) =
+proc toPackedGeneratedProcDef*(s: PSym, encoder: var PackedEncoder; m: var PackedModuleWriter) =
   ## Generic procs and generated `=hook`'s need explicit top-level entries so
   ## that the code generator can work without having to special case these. These
   ## entries will also be useful for other tools and are the cleanest design
@@ -548,7 +583,7 @@ proc toPackedGeneratedProcDef*(s: PSym, encoder: var PackedEncoder; m: var Packe
   #flush encoder, m
 
 proc storeAttachedProcDef*(t: PType; op: TTypeAttachedOp; s: PSym,
-                           encoder: var PackedEncoder; m: var PackedModule) =
+                           encoder: var PackedEncoder; m: var PackedModuleWriter) =
   assert s.kind in routineKinds
   assert isActive(encoder)
   let tid = storeTypeLater(t, encoder, m)
@@ -556,7 +591,7 @@ proc storeAttachedProcDef*(t: PType; op: TTypeAttachedOp; s: PSym,
   m.attachedOps.add (tid, op, sid)
   toPackedGeneratedProcDef(s, encoder, m)
 
-proc storeInstantiation*(c: var PackedEncoder; m: var PackedModule; s: PSym; i: PInstantiation) =
+proc storeInstantiation*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym; i: PInstantiation) =
   var t = newSeq[PackedItemId](i.concreteTypes.len)
   for j in 0..high(i.concreteTypes):
     t[j] = storeTypeLater(i.concreteTypes[j], c, m)
@@ -565,7 +600,7 @@ proc storeInstantiation*(c: var PackedEncoder; m: var PackedModule; s: PSym; i:
                                           concreteTypes: t)
   toPackedGeneratedProcDef(i.sym, c, m)
 
-proc storeExpansion*(c: var PackedEncoder; m: var PackedModule; info: TLineInfo; s: PSym) =
+proc storeExpansion*(c: var PackedEncoder; m: var PackedModuleWriter; info: TLineInfo; s: PSym) =
   toPackedNode(newSymNode(s, info), m.bodies, c, m)
 
 proc loadError(err: RodFileError; filename: AbsoluteFile; config: ConfigRef;) =
@@ -596,7 +631,7 @@ when BenchIC:
 else:
   template bench(x, body) = body
 
-proc loadRodFile*(filename: AbsoluteFile; m: var PackedModule; config: ConfigRef;
+proc loadRodFile*(filename: AbsoluteFile; m: var PackedModuleReader; config: ConfigRef;
                   ignoreConfig = false): RodFileError =
   var f = rodfiles.open(filename.string)
   f.loadHeader()
@@ -676,7 +711,7 @@ proc storeError(err: RodFileError; filename: AbsoluteFile) =
   echo "Error: ", $err, "; couldn't write to ", filename.string
   removeFile(filename.string)
 
-proc saveRodFile*(filename: AbsoluteFile; encoder: var PackedEncoder; m: var PackedModule) =
+proc saveRodFile*(filename: AbsoluteFile; encoder: var PackedEncoder; m: var PackedModuleWriter) =
   flush encoder, m
   #rememberConfig(encoder, encoder.config)
 
@@ -748,7 +783,7 @@ proc saveRodFile*(filename: AbsoluteFile; encoder: var PackedEncoder; m: var Pac
 
   when false:
     # basic loader testing:
-    var m2: PackedModule
+    var m2: PackedModuleReader
     discard loadRodFile(filename, m2, encoder.config)
     echo "loaded ", filename.string
 
@@ -774,7 +809,8 @@ type
   LoadedModule* = object
     status*: ModuleStatus
     symsInit, typesInit, loadedButAliveSetChanged*: bool
-    fromDisk*: PackedModule
+    fromDisk*: PackedModuleReader
+    toDisk*: PackedModuleWriter
     syms: OrderedTable[int32, PSym] # indexed by itemId
     types: OrderedTable[int32, PType]
     module*: PSym # the one true module symbol.
@@ -1193,7 +1229,7 @@ proc translateId*(id: PackedItemId; g: PackedModuleGraph; thisModule: int; confi
     ItemId(module: toFileIndex(id.module, g[thisModule].fromDisk, config).int32, item: id.item)
 
 proc simulateLoadedModule*(g: var PackedModuleGraph; conf: ConfigRef; cache: IdentCache;
-                           moduleSym: PSym; m: PackedModule) =
+                           moduleSym: PSym; m: PackedModuleWriter) =
   # For now only used for heavy debugging. In the future we could use this to reduce the
   # compiler's memory consumption.
   let idx = moduleSym.position
@@ -1291,7 +1327,7 @@ proc searchForCompilerproc*(m: LoadedModule; name: string): int32 =
 # ------------------------- .rod file viewer ---------------------------------
 
 proc rodViewer*(rodfile: AbsoluteFile; config: ConfigRef, cache: IdentCache) =
-  var m: PackedModule = PackedModule()
+  var m: PackedModuleReader = PackedModuleReader()
   let err = loadRodFile(rodfile, m, config, ignoreConfig=true)
   if err != ok:
     config.quitOrRaise "Error: could not load: " & $rodfile.string & " reason: " & $err

compiler/ic/integrity.nim

@@ -100,11 +100,11 @@ proc checkNode(c: var CheckedContext; tree: PackedTree; n: NodePos) =
 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]) =
+proc checkLocalSymIds(c: var CheckedContext; m: PackedModuleReader; 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) =
+proc checkModule(c: var CheckedContext; m: PackedModuleReader) =
   # We check that:
   # - Every symbol references existing types and symbols.
   # - Every tree node references existing types and symbols.

compiler/ic/navigator.nim

@@ -20,7 +20,7 @@ when defined(nimPreviewSlimSystem):
   import std/assertions
 
 import ".." / [ast, modulegraphs, msgs, options]
-import iclineinfos
+import ".." / nir / nirlineinfos
 import packed_ast, bitabs, ic
 
 type

compiler/ic/packed_ast.nim

@@ -16,7 +16,7 @@ import std/[hashes, tables, strtabs]
 import bitabs, rodfiles
 import ".." / [ast, options]
 
-import iclineinfos
+import ".." / nir / nirlineinfos
 
 when defined(nimPreviewSlimSystem):
   import std/assertions

compiler/injectdestructors.nim

@@ -653,7 +653,7 @@ template handleNestedTempl(n, processCall: untyped, willProduceStmt = false,
       for j in 0 ..< it.len-1:
         branch[j] = copyTree(it[j])
       var ofScope = nestedScope(s, it.lastSon)
-      branch[^1] = if n.typ.isEmptyType or it[^1].typ.isEmptyType or willProduceStmt:
+      branch[^1] = if it[^1].typ.isEmptyType or willProduceStmt:
                      processScope(c, ofScope, maybeVoid(it[^1], ofScope))
                    else:
                      processScopeExpr(c, ofScope, it[^1], processCall, tmpFlags)
@@ -701,7 +701,7 @@ template handleNestedTempl(n, processCall: untyped, willProduceStmt = false,
         #Condition needs to be destroyed outside of the condition/branch scope
         branch[0] = p(it[0], c, s, normal)
 
-      branch[^1] = if n.typ.isEmptyType or it[^1].typ.isEmptyType or willProduceStmt:
+      branch[^1] = if it[^1].typ.isEmptyType or willProduceStmt:
                      processScope(c, branchScope, maybeVoid(it[^1], branchScope))
                    else:
                      processScopeExpr(c, branchScope, it[^1], processCall, tmpFlags)

compiler/lambdalifting.nim

@@ -145,13 +145,11 @@ proc createStateField(g: ModuleGraph; iter: PSym; idgen: IdGenerator): PSym =
   result = newSym(skField, getIdent(g.cache, ":state"), idgen, iter, iter.info)
   result.typ = createClosureIterStateType(g, iter, idgen)
 
-template isIterator*(owner: PSym): bool =
-  owner.kind == skIterator and owner.typ.callConv == ccClosure
-
 proc createEnvObj(g: ModuleGraph; idgen: IdGenerator; owner: PSym; info: TLineInfo): PType =
+  # YYY meh, just add the state field for every closure for now, it's too
+  # hard to figure out if it comes from a closure iterator:
   result = createObj(g, idgen, owner, info, final=false)
-  if owner.isIterator:
-    rawAddField(result, createStateField(g, owner, idgen))
+  rawAddField(result, createStateField(g, owner, idgen))
 
 proc getClosureIterResult*(g: ModuleGraph; iter: PSym; idgen: IdGenerator): PSym =
   if resultPos < iter.ast.len:
@@ -174,22 +172,26 @@ proc addHiddenParam(routine: PSym, param: PSym) =
   assert sfFromGeneric in param.flags
   #echo "produced environment: ", param.id, " for ", routine.id
 
-proc getEnvParam*(routine: PSym): PSym =
+proc getHiddenParam(g: ModuleGraph; routine: PSym): PSym =
   let params = routine.ast[paramsPos]
   let hidden = lastSon(params)
   if hidden.kind == nkSym and hidden.sym.kind == skParam and hidden.sym.name.s == paramName:
     result = hidden.sym
     assert sfFromGeneric in result.flags
   else:
-    result = nil
-
-proc getHiddenParam(g: ModuleGraph; routine: PSym): PSym =
-  result = getEnvParam(routine)
-  if result.isNil:
     # writeStackTrace()
     localError(g.config, routine.info, "internal error: could not find env param for " & routine.name.s)
     result = routine
 
+proc getEnvParam*(routine: PSym): PSym =
+  let params = routine.ast[paramsPos]
+  let hidden = lastSon(params)
+  if hidden.kind == nkSym and hidden.sym.name.s == paramName:
+    result = hidden.sym
+    assert sfFromGeneric in result.flags
+  else:
+    result = nil
+
 proc interestingVar(s: PSym): bool {.inline.} =
   result = s.kind in {skVar, skLet, skTemp, skForVar, skParam, skResult} and
     sfGlobal notin s.flags and
@@ -228,6 +230,15 @@ proc makeClosure*(g: ModuleGraph; idgen: IdGenerator; prc: PSym; env: PNode; inf
   if tfHasAsgn in result.typ.flags or optSeqDestructors in g.config.globalOptions:
     prc.flags.incl sfInjectDestructors
 
+proc interestingIterVar(s: PSym): bool {.inline.} =
+  # XXX optimization: Only lift the variable if it lives across
+  # yield/return boundaries! This can potentially speed up
+  # closure iterators quite a bit.
+  result = s.kind in {skResult, skVar, skLet, skTemp, skForVar} and sfGlobal notin s.flags
+
+template isIterator*(owner: PSym): bool =
+  owner.kind == skIterator and owner.typ.callConv == ccClosure
+
 template liftingHarmful(conf: ConfigRef; owner: PSym): bool =
   ## lambda lifting can be harmful for JS-like code generators.
   let isCompileTime = sfCompileTime in owner.flags or owner.kind == skMacro
@@ -274,6 +285,15 @@ proc liftIterSym*(g: ModuleGraph; n: PNode; idgen: IdGenerator; owner: PSym): PN
   createTypeBoundOpsLL(g, env.typ, n.info, idgen, owner)
   result.add makeClosure(g, idgen, iter, env, n.info)
 
+proc freshVarForClosureIter*(g: ModuleGraph; s: PSym; idgen: IdGenerator; owner: PSym): PNode =
+  let envParam = getHiddenParam(g, owner)
+  let obj = envParam.typ.skipTypes({tyOwned, tyRef, tyPtr})
+  let field = addField(obj, s, g.cache, idgen)
+
+  var access = newSymNode(envParam)
+  assert obj.kind == tyObject
+  result = rawIndirectAccess(access, field, s.info)
+
 # ------------------ new stuff -------------------------------------------
 
 proc markAsClosure(g: ModuleGraph; owner: PSym; n: PNode) =
@@ -321,13 +341,9 @@ proc getEnvTypeForOwner(c: var DetectionPass; owner: PSym;
                         info: TLineInfo): PType =
   result = c.ownerToType.getOrDefault(owner.id)
   if result.isNil:
-    let env = getEnvParam(owner)
-    if env.isNil or not owner.isIterator:
-      result = newType(tyRef, c.idgen, owner)
-      let obj = createEnvObj(c.graph, c.idgen, owner, info)
-      rawAddSon(result, obj)
-    else:
-      result = env.typ
+    result = newType(tyRef, c.idgen, owner)
+    let obj = createEnvObj(c.graph, c.idgen, owner, info)
+    rawAddSon(result, obj)
     c.ownerToType[owner.id] = result
 
 proc asOwnedRef(c: var DetectionPass; t: PType): PType =
@@ -443,6 +459,17 @@ proc detectCapturedVars(n: PNode; owner: PSym; c: var DetectionPass) =
       if owner.isIterator:
         c.somethingToDo = true
         addClosureParam(c, owner, n.info)
+        if interestingIterVar(s):
+          if not c.capturedVars.contains(s.id):
+            if not c.inTypeOf: c.capturedVars.incl(s.id)
+            let obj = getHiddenParam(c.graph, owner).typ.skipTypes({tyOwned, tyRef, tyPtr})
+            #let obj = c.getEnvTypeForOwner(s.owner).skipTypes({tyOwned, tyRef, tyPtr})
+
+            if s.name.id == getIdent(c.graph.cache, ":state").id:
+              obj.n[0].sym.flags.incl sfNoInit
+              obj.n[0].sym.itemId = ItemId(module: s.itemId.module, item: -s.itemId.item)
+            else:
+              discard addField(obj, s, c.graph.cache, c.idgen)
     # direct or indirect dependency:
     elif innerClosure or interested:
       discard """
@@ -746,6 +773,8 @@ proc liftCapturedVars(n: PNode; owner: PSym; d: var DetectionPass;
     elif s.id in d.capturedVars:
       if s.owner != owner:
         result = accessViaEnvParam(d.graph, n, owner)
+      elif owner.isIterator and interestingIterVar(s):
+        result = accessViaEnvParam(d.graph, n, owner)
       else:
         result = accessViaEnvVar(n, owner, d, c)
   of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit, nkComesFrom,
@@ -863,9 +892,6 @@ proc liftLambdas*(g: ModuleGraph; fn: PSym, body: PNode; tooEarly: var bool;
     # ignore forward declaration:
     result = body
     tooEarly = true
-    if fn.isIterator:
-      var d = initDetectionPass(g, fn, idgen)
-      addClosureParam(d, fn, body.info)
   else:
     var d = initDetectionPass(g, fn, idgen)
     detectCapturedVars(body, fn, d)

compiler/main.nim

@@ -22,6 +22,8 @@ import
   modules,
   modulegraphs, lineinfos, pathutils, vmprofiler
 
+# ensure NIR compiles:
+import nir / nir
 
 when defined(nimPreviewSlimSystem):
   import std/[syncio, assertions]
@@ -46,6 +48,9 @@ proc writeDepsFile(g: ModuleGraph) =
       f.writeLine(toFullPath(g.config, k))
   f.close()
 
+proc writeNinjaFile(g: ModuleGraph) =
+  discard "to implement"
+
 proc writeCMakeDepsFile(conf: ConfigRef) =
   ## write a list of C files for build systems like CMake.
   ## only updated when the C file list changes.
@@ -156,6 +161,26 @@ proc commandCompileToC(graph: ModuleGraph) =
     if optGenCDeps in graph.config.globalOptions:
       writeCMakeDepsFile(conf)
 
+proc commandCompileToNir(graph: ModuleGraph) =
+  let conf = graph.config
+  extccomp.initVars(conf)
+  if conf.symbolFiles == disabledSf:
+    if {optRun, optForceFullMake} * conf.globalOptions == {optRun}:
+      if not changeDetectedViaJsonBuildInstructions(conf, conf.jsonBuildInstructionsFile):
+        # nothing changed
+        graph.config.notes = graph.config.mainPackageNotes
+        return
+
+  if not extccomp.ccHasSaneOverflow(conf):
+    conf.symbols.defineSymbol("nimEmulateOverflowChecks")
+
+  if conf.symbolFiles == disabledSf:
+    setPipeLinePass(graph, NirPass)
+  else:
+    setPipeLinePass(graph, SemPass)
+  compilePipelineProject(graph)
+  writeNinjaFile(graph)
+
 proc commandJsonScript(graph: ModuleGraph) =
   extccomp.runJsonBuildInstructions(graph.config, graph.config.jsonBuildInstructionsFile)
 
@@ -172,13 +197,16 @@ proc commandCompileToJS(graph: ModuleGraph) =
     if optGenScript in conf.globalOptions:
       writeDepsFile(graph)
 
-proc commandInteractive(graph: ModuleGraph) =
+proc commandInteractive(graph: ModuleGraph; useNir: bool) =
   graph.config.setErrorMaxHighMaybe
   initDefines(graph.config.symbols)
-  defineSymbol(graph.config.symbols, "nimscript")
+  if useNir:
+    defineSymbol(graph.config.symbols, "noSignalHandler")
+  else:
+    defineSymbol(graph.config.symbols, "nimscript")
   # note: seems redundant with -d:nimHasLibFFI
   when hasFFI: defineSymbol(graph.config.symbols, "nimffi")
-  setPipeLinePass(graph, InterpreterPass)
+  setPipeLinePass(graph, if useNir: NirReplPass else: InterpreterPass)
   compilePipelineSystemModule(graph)
   if graph.config.commandArgs.len > 0:
     discard graph.compilePipelineModule(fileInfoIdx(graph.config, graph.config.projectFull), {})
@@ -265,6 +293,8 @@ proc mainCommand*(graph: ModuleGraph) =
         # and it has added this define implictly, so we must undo that here.
         # A better solution might be to fix system.nim
         undefSymbol(conf.symbols, "useNimRtl")
+    of backendNir:
+      if conf.exc == excNone: conf.exc = excGoto
     of backendInvalid: raiseAssert "unreachable"
 
   proc compileToBackend() =
@@ -275,6 +305,7 @@ proc mainCommand*(graph: ModuleGraph) =
     of backendCpp: commandCompileToC(graph)
     of backendObjc: commandCompileToC(graph)
     of backendJs: commandCompileToJS(graph)
+    of backendNir: commandCompileToNir(graph)
     of backendInvalid: raiseAssert "unreachable"
 
   template docLikeCmd(body) =
@@ -413,7 +444,7 @@ proc mainCommand*(graph: ModuleGraph) =
     wantMainModule(conf)
     commandView(graph)
     #msgWriteln(conf, "Beware: Indentation tokens depend on the parser's state!")
-  of cmdInteractive: commandInteractive(graph)
+  of cmdInteractive: commandInteractive(graph, isDefined(conf, "nir"))
   of cmdNimscript:
     if conf.projectIsCmd or conf.projectIsStdin: discard
     elif not fileExists(conf.projectFull):

compiler/modulegraphs.nim

@@ -62,6 +62,8 @@ type
     CgenPass
     EvalPass
     InterpreterPass
+    NirPass
+    NirReplPass
     GenDependPass
     Docgen2TexPass
     Docgen2JsonPass
@@ -218,7 +220,7 @@ proc isCachedModule(g: ModuleGraph; module: int): bool {.inline.} =
 proc isCachedModule*(g: ModuleGraph; m: PSym): bool {.inline.} =
   isCachedModule(g, m.position)
 
-proc simulateCachedModule(g: ModuleGraph; moduleSym: PSym; m: PackedModule) =
+proc simulateCachedModule(g: ModuleGraph; moduleSym: PSym; m: PackedModuleWriter) =
   when false:
     echo "simulating ", moduleSym.name.s, " ", moduleSym.position
   simulateLoadedModule(g.packed, g.config, g.cache, moduleSym, m)
@@ -228,7 +230,7 @@ proc initEncoder*(g: ModuleGraph; module: PSym) =
   if id >= g.encoders.len:
     setLen g.encoders, id+1
   ic.initEncoder(g.encoders[id],
-    g.packed[id].fromDisk, module, g.config, g.startupPackedConfig)
+    g.packed[id].toDisk, module, g.config, g.startupPackedConfig)
 
 type
   ModuleIter* = object
@@ -349,8 +351,8 @@ proc completePartialOp*(g: ModuleGraph; module: int; t: PType; op: TTypeAttached
   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)
+    toPackedGeneratedProcDef(value, g.encoders[module], g.packed[module].toDisk)
+    #storeAttachedProcDef(t, op, value, g.encoders[module], g.packed[module].toDisk)
 
 iterator getDispatchers*(g: ModuleGraph): PSym =
   for i in g.dispatchers.mitems:
@@ -553,14 +555,14 @@ proc rememberEmittedTypeInfo*(g: ModuleGraph; m: FileIndex; ti: string) =
   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
+    g.packed[m.int32].toDisk.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
+    g.packed[m.position].toDisk.backendFlags.incl flag
 
 proc closeRodFile*(g: ModuleGraph; m: PSym) =
   if g.config.symbolFiles in {readOnlySf, v2Sf}:
@@ -569,14 +571,14 @@ proc closeRodFile*(g: ModuleGraph; m: PSym) =
     # 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.encoders[mint], g.packed[mint].toDisk)
     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)
+    simulateCachedModule(g, m, g.packed[mint].toDisk)
     g.packed[mint].status = loaded
 
 proc dependsOn(a, b: int): int {.inline.} = (a shl 15) + b

compiler/nim.nim

@@ -116,7 +116,8 @@ proc handleCmdLine(cache: IdentCache; conf: ConfigRef) =
     conf.backend = backendC
 
   if conf.selectedGC == gcUnselected:
-    if conf.backend in {backendC, backendCpp, backendObjc} or
+    if conf.backend in {backendC, backendCpp, backendObjc, backendNir} or
+        (conf.cmd == cmdInteractive and isDefined(conf, "nir")) or
         (conf.cmd in cmdDocLike and conf.backend != backendJs):
       initOrcDefines(conf)
 

compiler/nir/cir.nim

@@ -0,0 +1,983 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+# We produce C code as a list of tokens.
+
+import std / [assertions, syncio, tables, intsets, formatfloat]
+from std / strutils import toOctal
+import .. / ic / [bitabs, rodfiles]
+import nirtypes, nirinsts, nirfiles
+import ../../dist/checksums/src/checksums/md5
+
+type
+  Token = LitId # indexing into the tokens BiTable[string]
+
+  PredefinedToken = enum
+    IgnoreMe = "<unused>"
+    EmptyToken = ""
+    CurlyLe = "{"
+    CurlyRi = "}"
+    ParLe = "("
+    ParRi = ")"
+    BracketLe = "["
+    BracketRi = "]"
+    NewLine = "\n"
+    Semicolon = ";"
+    Comma = ", "
+    Space = " "
+    Colon = ": "
+    Dot = "."
+    Arrow = "->"
+    Star = "*"
+    Amp = "&"
+    AsgnOpr = " = "
+    ScopeOpr = "::"
+    ConstKeyword = "const "
+    StaticKeyword = "static "
+    ExternKeyword = "extern "
+    WhileKeyword = "while "
+    IfKeyword = "if ("
+    ElseKeyword = "else "
+    SwitchKeyword = "switch "
+    CaseKeyword = "case "
+    DefaultKeyword = "default:"
+    BreakKeyword = "break"
+    NullPtr = "nullptr"
+    IfNot = "if (!("
+    ReturnKeyword = "return "
+    TypedefStruct = "typedef struct "
+    TypedefUnion = "typedef union "
+    IncludeKeyword = "#include "
+
+proc fillTokenTable(tab: var BiTable[string]) =
+  for e in EmptyToken..high(PredefinedToken):
+    let id = tab.getOrIncl $e
+    assert id == LitId(e), $(id, " ", ord(e))
+
+type
+  GeneratedCode* = object
+    m: NirModule
+    includes: seq[LitId]
+    includedHeaders: IntSet
+    data: seq[LitId]
+    protos: seq[LitId]
+    code: seq[LitId]
+    init: seq[LitId]
+    tokens: BiTable[string]
+    emittedStrings: IntSet
+    needsPrefix: IntSet
+    generatedTypes: IntSet
+    mangledModules: Table[LitId, LitId]
+
+proc initGeneratedCode*(m: sink NirModule): GeneratedCode =
+  result = GeneratedCode(m: m, code: @[], tokens: initBiTable[string]())
+  fillTokenTable(result.tokens)
+
+proc add*(g: var GeneratedCode; t: PredefinedToken) {.inline.} =
+  g.code.add Token(t)
+
+proc add*(g: var GeneratedCode; s: string) {.inline.} =
+  g.code.add g.tokens.getOrIncl(s)
+
+proc mangleModuleName(c: var GeneratedCode; key: LitId): LitId =
+  result = c.mangledModules.getOrDefault(key, LitId(0))
+  if result == LitId(0):
+    let u {.cursor.} = c.m.lit.strings[key]
+    var last = u.len - len(".nim") - 1
+    var start = last
+    while start >= 0 and u[start] != '/': dec start
+    var sum = getMD5(u)
+    sum.setLen(8)
+    let dest = u.substr(start+1, last) & sum
+    result = c.tokens.getOrIncl(dest)
+    c.mangledModules[key] = result
+
+type
+  CppFile = object
+    f: File
+
+proc write(f: var CppFile; s: string) = write(f.f, s)
+proc write(f: var CppFile; c: char) = write(f.f, c)
+
+proc writeTokenSeq(f: var CppFile; s: seq[Token]; c: GeneratedCode) =
+  var indent = 0
+  for i in 0..<s.len:
+    let x = s[i]
+    case x
+    of Token(CurlyLe):
+      inc indent
+      write f, c.tokens[x]
+      write f, "\n"
+      for i in 1..indent*2: write f, ' '
+    of Token(CurlyRi):
+      dec indent
+      write f, c.tokens[x]
+      if i+1 < s.len and s[i+1] == Token(CurlyRi):
+        discard
+      else:
+        write f, "\n"
+        for i in 1..indent*2: write f, ' '
+    of Token(Semicolon):
+      write f, c.tokens[x]
+      if i+1 < s.len and s[i+1] == Token(CurlyRi):
+        discard "no newline before }"
+      else:
+        write f, "\n"
+        for i in 1..indent*2: write f, ' '
+    of Token(NewLine):
+      write f, c.tokens[x]
+      for i in 1..indent*2: write f, ' '
+    else:
+      write f, c.tokens[x]
+
+
+# Type graph
+
+type
+  TypeList = object
+    processed: IntSet
+    s: seq[(TypeId, PredefinedToken)]
+
+proc add(dest: var TypeList; elem: TypeId; decl: PredefinedToken) =
+  if not containsOrIncl(dest.processed, int(elem)):
+    dest.s.add (elem, decl)
+
+type
+  TypeOrder = object
+    forwardedDecls, ordered: TypeList
+    typeImpls: Table[string, TypeId]
+    lookedAt: IntSet
+
+proc traverseObject(types: TypeGraph; lit: Literals; c: var TypeOrder; t: TypeId)
+
+proc recordDependency(types: TypeGraph; lit: Literals; c: var TypeOrder; parent, child: TypeId) =
+  var ch = child
+  var viaPointer = false
+  while true:
+    case types[ch].kind
+    of APtrTy, UPtrTy, AArrayPtrTy, UArrayPtrTy:
+      viaPointer = true
+      ch = elementType(types, ch)
+    of LastArrayTy:
+      ch = elementType(types, ch)
+    else:
+      break
+
+  case types[ch].kind
+  of ObjectTy, UnionTy:
+    let decl = if types[ch].kind == ObjectTy: TypedefStruct else: TypedefUnion
+    let obj = c.typeImpls.getOrDefault(lit.strings[types[ch].litId])
+    if viaPointer:
+      c.forwardedDecls.add obj, decl
+    else:
+      if not containsOrIncl(c.lookedAt, obj.int):
+        traverseObject(types, lit, c, obj)
+      c.ordered.add obj, decl
+  of ArrayTy:
+    if viaPointer:
+      c.forwardedDecls.add ch, TypedefStruct
+    else:
+      if not containsOrIncl(c.lookedAt, ch.int):
+        traverseObject(types, lit, c, ch)
+      c.ordered.add ch, TypedefStruct
+  else:
+    discard "uninteresting type as we only focus on the required struct declarations"
+
+proc traverseObject(types: TypeGraph; lit: Literals; c: var TypeOrder; t: TypeId) =
+  for x in sons(types, t):
+    case types[x].kind
+    of FieldDecl:
+      recordDependency types, lit, c, t, x.firstSon
+    of ObjectTy:
+      # inheritance
+      recordDependency types, lit, c, t, x
+    else: discard
+
+proc traverseTypes(types: TypeGraph; lit: Literals; c: var TypeOrder) =
+  for t in allTypes(types):
+    if types[t].kind in {ObjectDecl, UnionDecl}:
+      assert types[t.firstSon].kind == NameVal
+      c.typeImpls[lit.strings[types[t.firstSon].litId]] = t
+
+  for t in allTypesIncludingInner(types):
+    case types[t].kind
+    of ObjectDecl, UnionDecl:
+      traverseObject types, lit, c, t
+      let decl = if types[t].kind == ObjectDecl: TypedefStruct else: TypedefUnion
+      c.ordered.add t, decl
+    of ArrayTy:
+      traverseObject types, lit, c, t
+      c.ordered.add t, TypedefStruct
+    else: discard
+
+when false:
+  template emitType(s: string) = c.types.add c.tokens.getOrIncl(s)
+  template emitType(t: Token) = c.types.add t
+  template emitType(t: PredefinedToken) = c.types.add Token(t)
+
+proc genType(g: var GeneratedCode; types: TypeGraph; lit: Literals; t: TypeId; name = "") =
+  template maybeAddName =
+    if name != "":
+      g.add Space
+      g.add name
+
+  template atom(s: string) =
+    g.add s
+    maybeAddName()
+  case types[t].kind
+  of VoidTy: atom "void"
+  of IntTy: atom "NI" & $types[t].integralBits
+  of UIntTy: atom "NU" & $types[t].integralBits
+  of FloatTy: atom "NF" & $types[t].integralBits
+  of BoolTy: atom "NB" & $types[t].integralBits
+  of CharTy: atom "NC" & $types[t].integralBits
+  of ObjectTy, UnionTy, NameVal, AnnotationVal:
+    atom lit.strings[types[t].litId]
+  of VarargsTy:
+    g.add "..."
+  of APtrTy, UPtrTy, AArrayPtrTy, UArrayPtrTy:
+    genType g, types, lit, elementType(types, t)
+    g.add Star
+    maybeAddName()
+  of ArrayTy:
+    genType g, types, lit, arrayName(types, t)
+    maybeAddName()
+  of LastArrayTy:
+    genType g, types, lit, elementType(types, t)
+    maybeAddName()
+    g.add BracketLe
+    g.add BracketRi
+  of ProcTy:
+    let (retType, callConv) = returnType(types, t)
+    genType g, types, lit, retType
+    g.add Space
+    g.add ParLe
+    genType g, types, lit, callConv
+    g.add Star # "(*fn)"
+    maybeAddName()
+    g.add ParRi
+    g.add ParLe
+    var i = 0
+    for ch in params(types, t):
+      if i > 0: g.add Comma
+      genType g, types, lit, ch
+      inc i
+    g.add ParRi
+  of ObjectDecl, UnionDecl:
+    atom lit.strings[types[t.firstSon].litId]
+  of IntVal, SizeVal, AlignVal, OffsetVal, FieldDecl:
+    #raiseAssert "did not expect: " & $types[t].kind
+    g.add "BUG "
+    atom $types[t].kind
+
+proc generateTypes(g: var GeneratedCode; types: TypeGraph; lit: Literals; c: TypeOrder) =
+  for (t, declKeyword) in c.forwardedDecls.s:
+    let name = if types[t].kind == ArrayTy: arrayName(types, t) else: t.firstSon
+    let s {.cursor.} = lit.strings[types[name].litId]
+    g.add declKeyword
+    g.add s
+    g.add Space
+    g.add s
+    g.add Semicolon
+
+  for (t, declKeyword) in c.ordered.s:
+    let name = if types[t].kind == ArrayTy: arrayName(types, t) else: t.firstSon
+    let litId = types[name].litId
+    if not g.generatedTypes.containsOrIncl(litId.int):
+      let s {.cursor.} = lit.strings[litId]
+      g.add declKeyword
+      g.add CurlyLe
+      if types[t].kind == ArrayTy:
+        genType g, types, lit, elementType(types, t), "a"
+        g.add BracketLe
+        g.add $arrayLen(types, t)
+        g.add BracketRi
+        g.add Semicolon
+      else:
+        var i = 0
+        for x in sons(types, t):
+          case types[x].kind
+          of FieldDecl:
+            genType g, types, lit, x.firstSon, "F" & $i
+            g.add Semicolon
+            inc i
+          of ObjectTy:
+            genType g, types, lit, x, "P"
+            g.add Semicolon
+          else: discard
+      g.add CurlyRi
+      g.add s
+      g.add Semicolon
+
+# Procs
+
+proc toCChar*(c: char; result: var string) {.inline.} =
+  case c
+  of '\0'..'\x1F', '\x7F'..'\xFF':
+    result.add '\\'
+    result.add toOctal(c)
+  of '\'', '\"', '\\', '?':
+    result.add '\\'
+    result.add c
+  else:
+    result.add c
+
+proc makeCString(s: string): string =
+  result = newStringOfCap(s.len + 10)
+  result.add('"')
+  for c in s: toCChar(c, result)
+  result.add('"')
+
+template emitData(s: string) = c.data.add c.tokens.getOrIncl(s)
+template emitData(t: Token) = c.data.add t
+template emitData(t: PredefinedToken) = c.data.add Token(t)
+
+proc genStrLit(c: var GeneratedCode; lit: Literals; litId: LitId): Token =
+  result = Token(c.tokens.getOrIncl "QStr" & $litId)
+  if not containsOrIncl(c.emittedStrings, int(litId)):
+    let s {.cursor.} = lit.strings[litId]
+    emitData "static const struct "
+    emitData CurlyLe
+    emitData "NI cap"
+    emitData Semicolon
+    emitData "NC8 data"
+    emitData BracketLe
+    emitData $s.len
+    emitData "+1"
+    emitData BracketRi
+    emitData Semicolon
+    emitData CurlyRi
+    emitData result
+    emitData AsgnOpr
+    emitData CurlyLe
+    emitData $s.len
+    emitData " | NIM_STRLIT_FLAG"
+    emitData Comma
+    emitData makeCString(s)
+    emitData CurlyRi
+    emitData Semicolon
+
+proc genIntLit(c: var GeneratedCode; lit: Literals; litId: LitId) =
+  let i = lit.numbers[litId]
+  if i > low(int32) and i <= high(int32):
+    c.add $i
+  elif i == low(int32):
+    # Nim has the same bug for the same reasons :-)
+    c.add "(-2147483647 -1)"
+  elif i > low(int64):
+    c.add "IL64("
+    c.add $i
+    c.add ")"
+  else:
+    c.add "(IL64(-9223372036854775807) - IL64(1))"
+
+proc gen(c: var GeneratedCode; t: Tree; n: NodePos)
+
+proc genDisplayName(c: var GeneratedCode; symId: SymId) =
+  let displayName = c.m.symnames[symId]
+  if displayName != LitId(0):
+    c.add "/*"
+    c.add c.m.lit.strings[displayName]
+    c.add "*/"
+
+proc genSymDef(c: var GeneratedCode; t: Tree; n: NodePos) =
+  if t[n].kind == SymDef:
+    let symId = t[n].symId
+    c.needsPrefix.incl symId.int
+    genDisplayName c, symId
+  gen c, t, n
+
+proc genGlobal(c: var GeneratedCode; t: Tree; name, typ: NodePos; annotation: string) =
+  c.add annotation
+  let m: string
+  if t[name].kind == SymDef:
+    let symId = t[name].symId
+    m = c.tokens[mangleModuleName(c, c.m.namespace)] & "__" & $symId
+    genDisplayName c, symId
+  else:
+    assert t[name].kind == ModuleSymUse
+    let (x, y) = sons2(t, name)
+    m = c.tokens[mangleModuleName(c, t[x].litId)] & "__" & $t[y].immediateVal
+  genType c, c.m.types, c.m.lit, t[typ].typeId, m
+
+proc genLocal(c: var GeneratedCode; t: Tree; name, typ: NodePos; annotation: string) =
+  assert t[name].kind == SymDef
+  c.add annotation
+  let symId = t[name].symId
+  genType c, c.m.types, c.m.lit, t[typ].typeId, "q" & $symId
+  genDisplayName c, symId
+
+proc genProcDecl(c: var GeneratedCode; t: Tree; n: NodePos; isExtern: bool) =
+  let signatureBegin = c.code.len
+  let name = n.firstSon
+
+  var prc = n.firstSon
+  next t, prc
+
+  while true:
+    case t[prc].kind
+    of PragmaPair:
+      let (x, y) = sons2(t, prc)
+      let key = cast[PragmaKey](t[x].rawOperand)
+      case key
+      of HeaderImport:
+        let lit = t[y].litId
+        let headerAsStr {.cursor.} = c.m.lit.strings[lit]
+        let header = c.tokens.getOrIncl(headerAsStr)
+        # headerAsStr can be empty, this has the semantics of the `nodecl` pragma:
+        if headerAsStr.len > 0 and not c.includedHeaders.containsOrIncl(int header):
+          if headerAsStr[0] == '#':
+            discard "skip the #include"
+          else:
+            c.includes.add Token(IncludeKeyword)
+          c.includes.add header
+          c.includes.add Token NewLine
+        # do not generate code for importc'ed procs:
+        return
+      of DllImport:
+        let lit = t[y].litId
+        raiseAssert "cannot eval: " & c.m.lit.strings[lit]
+      else: discard
+    of PragmaId: discard
+    else: break
+    next t, prc
+
+  var resultDeclPos = NodePos(-1)
+  if t[prc].kind == SummonResult:
+    resultDeclPos = prc
+    gen c, t, prc.firstSon
+    next t, prc
+  else:
+    c.add "void"
+  c.add Space
+  genSymDef c, t, name
+  c.add ParLe
+  var params = 0
+  while t[prc].kind == SummonParam:
+    if params > 0: c.add Comma
+    let (typ, sym) = sons2(t, prc)
+    genLocal c, t, sym, typ, ""
+    next t, prc
+    inc params
+  if params == 0:
+    c.add "void"
+  c.add ParRi
+
+  for i in signatureBegin ..< c.code.len:
+    c.protos.add c.code[i]
+  c.protos.add Token Semicolon
+
+  if isExtern:
+    c.code.setLen signatureBegin
+  else:
+    c.add CurlyLe
+    if resultDeclPos.int >= 0:
+      gen c, t, resultDeclPos
+    for ch in sonsRest(t, n, prc):
+      gen c, t, ch
+    c.add CurlyRi
+
+template triop(opr) =
+  let (typ, a, b) = sons3(t, n)
+  c.add ParLe
+  c.add ParLe
+  gen c, t, typ
+  c.add ParRi
+  gen c, t, a
+  c.add opr
+  gen c, t, b
+  c.add ParRi
+
+template cmpop(opr) =
+  let (_, a, b) = sons3(t, n)
+  c.add ParLe
+  gen c, t, a
+  c.add opr
+  gen c, t, b
+  c.add ParRi
+
+template binaryop(opr) =
+  let (typ, a) = sons2(t, n)
+  c.add ParLe
+  c.add ParLe
+  gen c, t, typ
+  c.add ParRi
+  c.add opr
+  gen c, t, a
+  c.add ParRi
+
+template checkedBinaryop(opr) =
+  let (typ, labIdx, a, b) = sons4(t, n)
+  let bits = integralBits(c.m.types[t[typ].typeId])
+  let lab = t[labIdx].label
+
+  c.add (opr & $bits)
+  c.add ParLe
+  c.gen t, a
+  c.add Comma
+  c.gen t, b
+  c.add Comma
+  c.add "L" & $lab.int
+  c.add ParRi
+
+proc genNumberConv(c: var GeneratedCode; t: Tree; n: NodePos) =
+  let (typ, arg) = sons2(t, n)
+  if t[arg].kind == IntVal:
+    let litId = t[arg].litId
+    c.add ParLe
+    c.add ParLe
+    gen c, t, typ
+    c.add ParRi
+    case c.m.types[t[typ].typeId].kind
+    of UIntTy:
+      let x = cast[uint64](c.m.lit.numbers[litId])
+      c.add $x
+    of FloatTy:
+      let x = cast[float64](c.m.lit.numbers[litId])
+      c.add $x
+    else:
+      gen c, t, arg
+    c.add ParRi
+  else:
+    binaryop ""
+
+template moveToDataSection(body: untyped) =
+  let oldLen = c.code.len
+  body
+  for i in oldLen ..< c.code.len:
+    c.data.add c.code[i]
+  setLen c.code, oldLen
+
+proc gen(c: var GeneratedCode; t: Tree; n: NodePos) =
+  case t[n].kind
+  of Nop:
+    discard "nothing to emit"
+  of ImmediateVal:
+    c.add $t[n].immediateVal
+  of IntVal:
+    genIntLit c, c.m.lit, t[n].litId
+  of StrVal:
+    c.code.add genStrLit(c, c.m.lit, t[n].litId)
+  of Typed:
+    genType c, c.m.types, c.m.lit, t[n].typeId
+  of SymDef, SymUse:
+    let s = t[n].symId
+    if c.needsPrefix.contains(s.int):
+      c.code.add mangleModuleName(c, c.m.namespace)
+      c.add "__"
+      c.add $s
+    else:
+      # XXX Use proper names here
+      c.add "q"
+      c.add $s
+
+  of ModuleSymUse:
+    let (x, y) = sons2(t, n)
+    let u = mangleModuleName(c, t[x].litId)
+    let s = t[y].immediateVal
+    c.code.add u
+    c.add "__"
+    c.add $s
+
+  of NilVal:
+    c.add NullPtr
+  of LoopLabel:
+    c.add WhileKeyword
+    c.add ParLe
+    c.add "1"
+    c.add ParRi
+    c.add CurlyLe
+  of GotoLoop:
+    c.add CurlyRi
+  of Label:
+    let lab = t[n].label
+    c.add "L"
+    c.add $lab.int
+    c.add Colon
+    c.add Semicolon
+  of Goto:
+    let lab = t[n].label
+    c.add "goto L"
+    c.add $lab.int
+    c.add Semicolon
+  of CheckedGoto:
+    discard "XXX todo"
+  of ArrayConstr:
+    c.add CurlyLe
+    c.add ".a = "
+    c.add CurlyLe
+    var i = 0
+    for ch in sonsFrom1(t, n):
+      if i > 0: c.add Comma
+      c.gen t, ch
+      inc i
+    c.add CurlyRi
+    c.add CurlyRi
+  of ObjConstr:
+    c.add CurlyLe
+    var i = 0
+    for ch in sonsFrom1(t, n):
+      if i mod 2 == 0:
+        if i > 0: c.add Comma
+        c.add ".F" & $t[ch].immediateVal
+        c.add AsgnOpr
+      else:
+        c.gen t, ch
+      inc i
+    c.add CurlyRi
+  of Ret:
+    c.add ReturnKeyword
+    c.gen t, n.firstSon
+    c.add Semicolon
+  of Select:
+    c.add SwitchKeyword
+    c.add ParLe
+    let (_, selector) = sons2(t, n)
+    c.gen t, selector
+    c.add ParRi
+    c.add CurlyLe
+    for ch in sonsFromN(t, n, 2):
+      c.gen t, ch
+    c.add CurlyRi
+  of SelectPair:
+    let (le, ri) = sons2(t, n)
+    c.gen t, le
+    c.gen t, ri
+  of SelectList:
+    for ch in sons(t, n):
+      c.gen t, ch
+  of SelectValue:
+    c.add CaseKeyword
+    c.gen t, n.firstSon
+    c.add Colon
+  of SelectRange:
+    let (le, ri) = sons2(t, n)
+    c.add CaseKeyword
+    c.gen t, le
+    c.add " ... "
+    c.gen t, ri
+    c.add Colon
+  of ForeignDecl:
+    c.data.add LitId(ExternKeyword)
+    c.gen t, n.firstSon
+  of SummonGlobal:
+    moveToDataSection:
+      let (typ, sym) = sons2(t, n)
+      c.genGlobal t, sym, typ, ""
+      c.add Semicolon
+  of SummonThreadLocal:
+    moveToDataSection:
+      let (typ, sym) = sons2(t, n)
+      c.genGlobal t, sym, typ, "__thread "
+      c.add Semicolon
+  of SummonConst:
+    moveToDataSection:
+      let (typ, sym, val) = sons3(t, n)
+      c.genGlobal t, sym, typ, "const "
+      c.add AsgnOpr
+      c.gen t, val
+      c.add Semicolon
+  of Summon, SummonResult:
+    let (typ, sym) = sons2(t, n)
+    c.genLocal t, sym, typ, ""
+    c.add Semicolon
+
+  of SummonParam:
+    raiseAssert "SummonParam should have been handled in genProc"
+  of Kill:
+    discard "we don't care about Kill instructions"
+  of AddrOf:
+    let (_, arg) = sons2(t, n)
+    c.add "&"
+    gen c, t, arg
+  of DerefArrayAt:
+    let (_, a, i) = sons3(t, n)
+    gen c, t, a
+    c.add BracketLe
+    gen c, t, i
+    c.add BracketRi
+  of ArrayAt:
+    let (_, a, i) = sons3(t, n)
+    gen c, t, a
+    c.add Dot
+    c.add "a"
+    c.add BracketLe
+    gen c, t, i
+    c.add BracketRi
+  of FieldAt:
+    let (_, a, b) = sons3(t, n)
+    gen c, t, a
+    let field = t[b].immediateVal
+    c.add Dot
+    c.add "F" & $field
+  of DerefFieldAt:
+    let (_, a, b) = sons3(t, n)
+    gen c, t, a
+    let field = t[b].immediateVal
+    c.add Arrow
+    c.add "F" & $field
+  of Load:
+    let (_, arg) = sons2(t, n)
+    c.add ParLe
+    c.add "*"
+    gen c, t, arg
+    c.add ParRi
+  of Store:
+    raiseAssert "Assumption was that Store is unused!"
+  of Asgn:
+    let (_, dest, src) = sons3(t, n)
+    gen c, t, dest
+    c.add AsgnOpr
+    gen c, t, src
+    c.add Semicolon
+  of CheckedRange:
+    c.add "nimCheckRange"
+    c.add ParLe
+    let (_, gotoInstr, x, a, b) = sons5(t, n)
+    gen c, t, x
+    c.add Comma
+    gen c, t, a
+    c.add Comma
+    gen c, t, b
+    c.add Comma
+    c.add "L" & $t[gotoInstr].label.int
+    c.add ParRi
+  of CheckedIndex:
+    c.add "nimCheckIndex"
+    c.add ParLe
+    let (gotoInstr, x, a) = sons3(t, n)
+    gen c, t, x
+    c.add Comma
+    gen c, t, a
+    c.add Comma
+    c.add "L" & $t[gotoInstr].label.int
+    c.add ParRi
+  of Call, IndirectCall:
+    let (typ, fn) = sons2(t, n)
+    gen c, t, fn
+    c.add ParLe
+    var i = 0
+    for ch in sonsFromN(t, n, 2):
+      if i > 0: c.add Comma
+      gen c, t, ch
+      inc i
+    c.add ParRi
+    if c.m.types[t[typ].typeId].kind == VoidTy:
+      c.add Semicolon
+  of CheckedCall, CheckedIndirectCall:
+    let (typ, gotoInstr, fn) = sons3(t, n)
+    gen c, t, fn
+    c.add ParLe
+    var i = 0
+    for ch in sonsFromN(t, n, 3):
+      if i > 0: c.add Comma
+      gen c, t, ch
+      inc i
+    c.add ParRi
+    if c.m.types[t[typ].typeId].kind == VoidTy:
+      c.add Semicolon
+
+  of CheckedAdd: checkedBinaryop "nimAddInt"
+  of CheckedSub: checkedBinaryop "nimSubInt"
+  of CheckedMul: checkedBinaryop "nimMulInt"
+  of CheckedDiv: checkedBinaryop "nimDivInt"
+  of CheckedMod: checkedBinaryop "nimModInt"
+  of Add: triop " + "
+  of Sub: triop " - "
+  of Mul: triop " * "
+  of Div: triop " / "
+  of Mod: triop " % "
+  of BitShl: triop " << "
+  of BitShr: triop " >> "
+  of BitAnd: triop " & "
+  of BitOr: triop " | "
+  of BitXor: triop " ^ "
+  of BitNot: binaryop " ~ "
+  of BoolNot: binaryop " !"
+  of Eq: cmpop " == "
+  of Le: cmpop " <= "
+  of Lt: cmpop " < "
+  of Cast: binaryop ""
+  of NumberConv: genNumberConv c, t, n
+  of CheckedObjConv: binaryop ""
+  of ObjConv: binaryop ""
+  of Emit: raiseAssert "cannot interpret: Emit"
+  of ProcDecl: genProcDecl c, t, n, false
+  of ForeignProcDecl: genProcDecl c, t, n, true
+  of PragmaPair, PragmaId, TestOf, Yld, SetExc, TestExc:
+    c.add "cannot interpret: " & $t[n].kind
+
+const
+  Prelude = """
+/* GENERATED CODE. DO NOT EDIT. */
+
+#ifdef __cplusplus
+#define NB8 bool
+#elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901)
+// see #13798: to avoid conflicts for code emitting `#include <stdbool.h>`
+#define NB8 _Bool
+#else
+typedef unsigned char NB8; // best effort
+#endif
+
+typedef unsigned char NC8;
+
+typedef float NF32;
+typedef double NF64;
+#if defined(__BORLANDC__) || defined(_MSC_VER)
+typedef signed char NI8;
+typedef signed short int NI16;
+typedef signed int NI32;
+typedef __int64 NI64;
+/* XXX: Float128? */
+typedef unsigned char NU8;
+typedef unsigned short int NU16;
+typedef unsigned int NU32;
+typedef unsigned __int64 NU64;
+#elif defined(HAVE_STDINT_H)
+#ifndef USE_NIM_NAMESPACE
+#  include <stdint.h>
+#endif
+typedef int8_t NI8;
+typedef int16_t NI16;
+typedef int32_t NI32;
+typedef int64_t NI64;
+typedef uint8_t NU8;
+typedef uint16_t NU16;
+typedef uint32_t NU32;
+typedef uint64_t NU64;
+#elif defined(HAVE_CSTDINT)
+#ifndef USE_NIM_NAMESPACE
+#  include <cstdint>
+#endif
+typedef std::int8_t NI8;
+typedef std::int16_t NI16;
+typedef std::int32_t NI32;
+typedef std::int64_t NI64;
+typedef std::uint8_t NU8;
+typedef std::uint16_t NU16;
+typedef std::uint32_t NU32;
+typedef std::uint64_t NU64;
+#else
+/* Unknown compiler/version, do our best */
+#ifdef __INT8_TYPE__
+typedef __INT8_TYPE__ NI8;
+#else
+typedef signed char NI8;
+#endif
+#ifdef __INT16_TYPE__
+typedef __INT16_TYPE__ NI16;
+#else
+typedef signed short int NI16;
+#endif
+#ifdef __INT32_TYPE__
+typedef __INT32_TYPE__ NI32;
+#else
+typedef signed int NI32;
+#endif
+#ifdef __INT64_TYPE__
+typedef __INT64_TYPE__ NI64;
+#else
+typedef long long int NI64;
+#endif
+/* XXX: Float128? */
+#ifdef __UINT8_TYPE__
+typedef __UINT8_TYPE__ NU8;
+#else
+typedef unsigned char NU8;
+#endif
+#ifdef __UINT16_TYPE__
+typedef __UINT16_TYPE__ NU16;
+#else
+typedef unsigned short int NU16;
+#endif
+#ifdef __UINT32_TYPE__
+typedef __UINT32_TYPE__ NU32;
+#else
+typedef unsigned int NU32;
+#endif
+#ifdef __UINT64_TYPE__
+typedef __UINT64_TYPE__ NU64;
+#else
+typedef unsigned long long int NU64;
+#endif
+#endif
+
+#ifdef NIM_INTBITS
+#  if NIM_INTBITS == 64
+typedef NI64 NI;
+typedef NU64 NU;
+#  elif NIM_INTBITS == 32
+typedef NI32 NI;
+typedef NU32 NU;
+#  elif NIM_INTBITS == 16
+typedef NI16 NI;
+typedef NU16 NU;
+#  elif NIM_INTBITS == 8
+typedef NI8 NI;
+typedef NU8 NU;
+#  else
+#    error "invalid bit width for int"
+#  endif
+#endif
+
+#define NIM_STRLIT_FLAG ((NU)(1) << ((NIM_INTBITS) - 2)) /* This has to be the same as system.strlitFlag! */
+
+#define nimAddInt64(a, b, L) ({long long int res; if(__builtin_saddll_overflow(a, b, &res)) goto L; res})
+#define nimSubInt64(a, b, L) ({long long int res; if(__builtin_ssubll_overflow(a, b, &res)) goto L; res})
+#define nimMulInt64(a, b, L) ({long long int res; if(__builtin_smulll_overflow(a, b, &res)) goto L; res})
+
+#define nimAddInt32(a, b, L) ({long int res; if(__builtin_sadd_overflow(a, b, &res)) goto L; res})
+#define nimSubInt32(a, b, L) ({long int res; if(__builtin_ssub_overflow(a, b, &res)) goto L; res})
+#define nimMulInt32(a, b, L) ({long int res; if(__builtin_smul_overflow(a, b, &res)) goto L; res})
+
+#define nimCheckRange(x, a, b, L) ({if (x < a || x > b) goto L; x})
+#define nimCheckIndex(x, a, L) ({if (x >= a) goto L; x})
+
+"""
+
+proc traverseCode(c: var GeneratedCode) =
+  const AllowedInToplevelC = {SummonConst, SummonGlobal, SummonThreadLocal,
+                              ProcDecl, ForeignDecl, ForeignProcDecl}
+  var i = NodePos(0)
+  while i.int < c.m.code.len:
+    let oldLen = c.code.len
+    let moveToInitSection = c.m.code[NodePos(i)].kind notin AllowedInToplevelC
+
+    gen c, c.m.code, NodePos(i)
+    next c.m.code, i
+
+    if moveToInitSection:
+      for i in oldLen ..< c.code.len:
+        c.init.add c.code[i]
+      setLen c.code, oldLen
+
+proc generateCode*(inp, outp: string) =
+  var c = initGeneratedCode(load(inp))
+
+  var co = TypeOrder()
+  traverseTypes(c.m.types, c.m.lit, co)
+
+  generateTypes(c, c.m.types, c.m.lit, co)
+  let typeDecls = move c.code
+
+  traverseCode c
+  var f = CppFile(f: open(outp, fmWrite))
+  f.write "#define NIM_INTBITS " & $c.m.intbits & "\n"
+  f.write Prelude
+  writeTokenSeq f, c.includes, c
+  writeTokenSeq f, typeDecls, c
+  writeTokenSeq f, c.data, c
+  writeTokenSeq f, c.protos, c
+  writeTokenSeq f, c.code, c
+  if c.init.len > 0:
+    f.write "void __attribute__((constructor)) init(void) {"
+    writeTokenSeq f, c.init, c
+    f.write "}\n\n"
+  f.f.close

compiler/nir/nir.nim

@@ -0,0 +1,105 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## Nim Intermediate Representation, designed to capture all of Nim's semantics without losing too much
+## precious information. Can easily be translated into C. And to JavaScript, hopefully.
+
+from std/os import addFileExt, `/`, createDir
+
+import std / assertions
+import ".." / [ast, modulegraphs, renderer, transf, options, msgs, lineinfos]
+import nirtypes, nirinsts, ast2ir, nirlineinfos, nirfiles, nirvm
+
+import ".." / ic / [rodfiles, bitabs]
+
+type
+  PCtx* = ref object of TPassContext
+    m: ModuleCon
+    c: ProcCon
+    oldErrorCount: int
+    bytecode: Bytecode
+
+proc newCtx*(module: PSym; g: ModuleGraph; idgen: IdGenerator): PCtx =
+  var lit = Literals()
+  var nirm = (ref NirModule)(types: initTypeGraph(lit), lit: lit)
+  var m = initModuleCon(g, g.config, idgen, module, nirm)
+  m.noModularity = true
+  PCtx(m: m, c: initProcCon(m, nil, g.config), idgen: idgen, bytecode: initBytecode(nirm))
+
+proc refresh*(c: PCtx; module: PSym; idgen: IdGenerator) =
+  #c.m = initModuleCon(c.m.graph, c.m.graph.config, idgen, module, c.m.nirm)
+  #c.m.noModularity = true
+  c.c = initProcCon(c.m, nil, c.m.graph.config)
+  c.idgen = idgen
+
+proc setupGlobalCtx*(module: PSym; graph: ModuleGraph; idgen: IdGenerator) =
+  if graph.repl.isNil:
+    graph.repl = newCtx(module, graph, idgen)
+    #registerAdditionalOps(PCtx graph.repl)
+  else:
+    refresh(PCtx graph.repl, module, idgen)
+
+proc setupNirReplGen*(graph: ModuleGraph; module: PSym; idgen: IdGenerator): PPassContext =
+  setupGlobalCtx(module, graph, idgen)
+  result = PCtx graph.repl
+
+proc evalStmt(c: PCtx; n: PNode) =
+  let n = transformExpr(c.m.graph, c.idgen, c.m.module, n)
+  let pc = genStmt(c.c, n)
+  #var res = ""
+  #toString c.m.nirm.code, NodePos(pc), c.m.nirm.lit.strings, c.m.nirm.lit.numbers, c.m.symnames, res
+  #res.add "\n--------------------------\n"
+  #toString res, c.m.types.g
+  if pc.int < c.m.nirm.code.len:
+    c.bytecode.interactive = c.m.graph.interactive
+    execCode c.bytecode, c.m.nirm.code, pc
+  #echo res
+
+proc runCode*(c: PPassContext; n: PNode): PNode =
+  let c = PCtx(c)
+  # don't eval errornous code:
+  if c.oldErrorCount == c.m.graph.config.errorCounter:
+    evalStmt(c, n)
+    result = newNodeI(nkEmpty, n.info)
+  else:
+    result = n
+  c.oldErrorCount = c.m.graph.config.errorCounter
+
+type
+  NirPassContext* = ref object of TPassContext
+    m: ModuleCon
+    c: ProcCon
+
+proc openNirBackend*(g: ModuleGraph; module: PSym; idgen: IdGenerator): PPassContext =
+  var lit = Literals()
+  var nirm = (ref NirModule)(types: initTypeGraph(lit), lit: lit)
+  let m = initModuleCon(g, g.config, idgen, module, nirm)
+  NirPassContext(m: m, c: initProcCon(m, nil, g.config), idgen: idgen)
+
+proc gen(c: NirPassContext; n: PNode) =
+  let n = transformExpr(c.m.graph, c.idgen, c.m.module, n)
+  let pc = genStmt(c.c, n)
+
+proc nirBackend*(c: PPassContext; n: PNode): PNode =
+  gen(NirPassContext(c), n)
+  result = n
+
+proc closeNirBackend*(c: PPassContext; finalNode: PNode) =
+  discard nirBackend(c, finalNode)
+
+  let c = NirPassContext(c)
+  let nimcache = getNimcacheDir(c.c.config).string
+  createDir nimcache
+  let outp = nimcache / c.m.module.name.s.addFileExt("nir")
+  #c.m.nirm.code = move c.c.code
+  try:
+    store c.m.nirm[], outp
+    echo "created: ", outp
+  except IOError:
+    rawMessage(c.c.config, errFatal, "serialization failed: " & outp)

compiler/nir/nirc.nim

@@ -0,0 +1,52 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## Nir Compiler.
+
+import ".." / ic / [bitabs, rodfiles]
+import nirinsts, nirtypes, nirlineinfos, nirfiles, cir
+
+proc view(filename: string) =
+  let m = load(filename)
+  var res = ""
+  allTreesToString m.code, m.lit.strings, m.lit.numbers, m.symnames, res
+  res.add "\n# TYPES\n"
+  nirtypes.toString res, m.types
+  echo res
+
+import std / [syncio, parseopt]
+
+proc writeHelp =
+  echo """Usage: nirc view|c <file.nir>"""
+  quit 0
+
+proc main =
+  var inp = ""
+  var cmd = ""
+  for kind, key, val in getopt():
+    case kind
+    of cmdArgument:
+      if cmd.len == 0: cmd = key
+      elif inp.len == 0: inp = key
+      else: quit "Error: too many arguments"
+    of cmdLongOption, cmdShortOption:
+      case key
+      of "help", "h": writeHelp()
+      of "version", "v": stdout.write "1.0\n"
+    of cmdEnd: discard
+  if inp.len == 0:
+    quit "Error: no input file specified"
+  case cmd
+  of "", "view":
+    view inp
+  of "c":
+    let outp = inp & ".c"
+    cir.generateCode inp, outp
+
+main()

compiler/nir/nirfiles.nim

@@ -0,0 +1,83 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+import ".." / ic / [bitabs, rodfiles]
+import nirinsts, nirtypes, nirlineinfos
+
+type
+  NirModule* = object
+    code*: Tree
+    man*: LineInfoManager
+    types*: TypeGraph
+    lit*: Literals
+    namespace*: LitId
+    intbits*: uint32
+    symnames*: SymNames
+
+proc load*(filename: string): NirModule =
+  let lit = Literals()
+  result = NirModule(lit: lit, types: initTypeGraph(lit))
+  var r = rodfiles.open(filename)
+  try:
+    r.loadHeader(nirCookie)
+    r.loadSection stringsSection
+    r.load result.lit.strings
+
+    r.loadSection numbersSection
+    r.load result.lit.numbers
+
+    r.loadSection bodiesSection
+    r.load result.code
+
+    r.loadSection typesSection
+    r.load result.types
+
+    r.loadSection sideChannelSection
+    r.load result.man
+
+    r.loadSection namespaceSection
+    r.loadPrim result.namespace
+    r.loadPrim result.intbits
+
+    r.loadSection symnamesSection
+    r.load result.symnames
+
+  finally:
+    r.close()
+
+proc store*(m: NirModule; outp: string) =
+  var r = rodfiles.create(outp)
+  try:
+    r.storeHeader(nirCookie)
+    r.storeSection stringsSection
+    r.store m.lit.strings
+
+    r.storeSection numbersSection
+    r.store m.lit.numbers
+
+    r.storeSection bodiesSection
+    r.store m.code
+
+    r.storeSection typesSection
+    r.store m.types
+
+    r.storeSection sideChannelSection
+    r.store m.man
+
+    r.storeSection namespaceSection
+    r.storePrim m.namespace
+    r.storePrim m.intbits
+
+    r.storeSection symnamesSection
+    r.store m.symnames
+
+  finally:
+    r.close()
+  if r.err != ok:
+    raise newException(IOError, "could store into: " & outp)

compiler/nir/nirinsts.nim

@@ -0,0 +1,582 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## NIR instructions. Somewhat inspired by LLVM's instructions.
+
+import std / [assertions, hashes]
+import .. / ic / [bitabs, rodfiles]
+import nirlineinfos, nirtypes
+
+const
+  NirVersion = 1
+  nirCookie* = [byte(0), byte('N'), byte('I'), byte('R'),
+            byte(sizeof(int)*8), byte(system.cpuEndian), byte(0), byte(NirVersion)]
+
+type
+  SymId* = distinct int
+
+proc `$`*(s: SymId): string {.borrow.}
+proc hash*(s: SymId): Hash {.borrow.}
+proc `==`*(a, b: SymId): bool {.borrow.}
+
+type
+  Opcode* = enum
+    Nop,
+    ImmediateVal,
+    IntVal,
+    StrVal,
+    SymDef,
+    SymUse,
+    Typed,   # with type ID
+    PragmaId, # with Pragma ID, possible values: see PragmaKey enum
+    NilVal,
+    Label,
+    Goto,
+    CheckedGoto,
+    LoopLabel,
+    GotoLoop,  # last atom
+
+    ModuleSymUse, # `"module".x`
+
+    ArrayConstr,
+    ObjConstr,
+    Ret,
+    Yld,
+
+    Select,
+    SelectPair,  # ((values...), Label)
+    SelectList,  # (values...)
+    SelectValue, # (value)
+    SelectRange, # (valueA..valueB)
+    ForeignDecl, # Can wrap SummonGlobal, SummonThreadLocal, SummonConst
+    SummonGlobal,
+    SummonThreadLocal,
+    Summon, # x = Summon Typed <Type ID>; x begins to live
+    SummonResult,
+    SummonParam,
+    SummonConst,
+    Kill, # `Kill x`: scope end for `x`
+
+    AddrOf,
+    ArrayAt, # a[i]
+    DerefArrayAt, # a[i] where `a` is a PtrArray; `a[][i]`
+    FieldAt, # obj.field
+    DerefFieldAt, # obj[].field
+
+    Load, # a[]
+    Store, # a[] = b
+    Asgn,  # a = b
+    SetExc,
+    TestExc,
+
+    CheckedRange,
+    CheckedIndex,
+
+    Call,
+    IndirectCall,
+    CheckedCall, # call that can raise
+    CheckedIndirectCall, # call that can raise
+    CheckedAdd, # with overflow checking etc.
+    CheckedSub,
+    CheckedMul,
+    CheckedDiv,
+    CheckedMod,
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Mod,
+    BitShl,
+    BitShr,
+    BitAnd,
+    BitOr,
+    BitXor,
+    BitNot,
+    BoolNot,
+    Eq,
+    Le,
+    Lt,
+    Cast,
+    NumberConv,
+    CheckedObjConv,
+    ObjConv,
+    TestOf,
+    Emit,
+    ProcDecl,
+    ForeignProcDecl,
+    PragmaPair
+
+type
+  PragmaKey* = enum
+    FastCall, StdCall, CDeclCall, SafeCall, SysCall, InlineCall, NoinlineCall, ThisCall, NoCall,
+    CoreName,
+    ExternName,
+    HeaderImport,
+    DllImport,
+    DllExport,
+    ObjExport
+
+const
+  LastAtomicValue = GotoLoop
+
+  OpcodeBits = 8'u32
+  OpcodeMask = (1'u32 shl OpcodeBits) - 1'u32
+
+  ValueProducingAtoms = {ImmediateVal, IntVal, StrVal, SymUse, NilVal}
+
+  ValueProducing* = {
+    ImmediateVal,
+    IntVal,
+    StrVal,
+    SymUse,
+    NilVal,
+    ModuleSymUse,
+    ArrayConstr,
+    ObjConstr,
+    CheckedAdd,
+    CheckedSub,
+    CheckedMul,
+    CheckedDiv,
+    CheckedMod,
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Mod,
+    BitShl,
+    BitShr,
+    BitAnd,
+    BitOr,
+    BitXor,
+    BitNot,
+    BoolNot,
+    Eq,
+    Le,
+    Lt,
+    Cast,
+    NumberConv,
+    CheckedObjConv,
+    ObjConv,
+    AddrOf,
+    Load,
+    ArrayAt,
+    DerefArrayAt,
+    FieldAt,
+    DerefFieldAt,
+    TestOf
+  }
+
+type
+  Instr* = object     # 8 bytes
+    x: uint32
+    info*: PackedLineInfo
+
+template kind*(n: Instr): Opcode = Opcode(n.x and OpcodeMask)
+template operand(n: Instr): uint32 = (n.x shr OpcodeBits)
+
+template rawOperand*(n: Instr): uint32 = (n.x shr OpcodeBits)
+
+template toX(k: Opcode; operand: uint32): uint32 =
+  uint32(k) or (operand shl OpcodeBits)
+
+template toX(k: Opcode; operand: LitId): uint32 =
+  uint32(k) or (operand.uint32 shl OpcodeBits)
+
+type
+  Tree* = object
+    nodes: seq[Instr]
+
+  Values* = object
+    numbers: BiTable[int64]
+    strings: BiTable[string]
+
+type
+  PatchPos* = distinct int
+  NodePos* = distinct int
+
+const
+  InvalidPatchPos* = PatchPos(-1)
+
+proc isValid(p: PatchPos): bool {.inline.} = p.int != -1
+
+proc prepare*(tree: var Tree; info: PackedLineInfo; kind: Opcode): PatchPos =
+  result = PatchPos tree.nodes.len
+  tree.nodes.add Instr(x: toX(kind, 1'u32), info: info)
+
+proc isAtom(tree: Tree; pos: int): bool {.inline.} = tree.nodes[pos].kind <= LastAtomicValue
+proc isAtom(tree: Tree; pos: NodePos): bool {.inline.} = tree.nodes[pos.int].kind <= LastAtomicValue
+
+proc patch*(tree: var Tree; pos: PatchPos) =
+  let pos = pos.int
+  let k = tree.nodes[pos].kind
+  assert k > LastAtomicValue
+  let distance = int32(tree.nodes.len - pos)
+  assert distance > 0
+  tree.nodes[pos].x = toX(k, cast[uint32](distance))
+
+template build*(tree: var Tree; info: PackedLineInfo; kind: Opcode; body: untyped) =
+  let pos = prepare(tree, info, kind)
+  body
+  patch(tree, pos)
+
+template buildTyped*(tree: var Tree; info: PackedLineInfo; kind: Opcode; typ: TypeId; body: untyped) =
+  let pos = prepare(tree, info, kind)
+  tree.addTyped info, typ
+  body
+  patch(tree, pos)
+
+proc len*(tree: Tree): int {.inline.} = tree.nodes.len
+
+template rawSpan(n: Instr): int = int(operand(n))
+
+proc nextChild(tree: Tree; pos: var int) {.inline.} =
+  if tree.nodes[pos].kind > LastAtomicValue:
+    assert tree.nodes[pos].operand > 0'u32
+    inc pos, tree.nodes[pos].rawSpan
+  else:
+    inc pos
+
+proc next*(tree: Tree; pos: var NodePos) {.inline.} = nextChild tree, int(pos)
+
+template firstSon*(n: NodePos): NodePos = NodePos(n.int+1)
+
+template skipTyped*(n: NodePos): NodePos = NodePos(n.int+2)
+
+iterator sons*(tree: Tree; n: NodePos): NodePos =
+  var pos = n.int
+  assert tree.nodes[pos].kind > LastAtomicValue
+  let last = pos + tree.nodes[pos].rawSpan
+  inc pos
+  while pos < last:
+    yield NodePos pos
+    nextChild tree, pos
+
+iterator sonsFrom1*(tree: Tree; n: NodePos): NodePos =
+  var pos = n.int
+  assert tree.nodes[pos].kind > LastAtomicValue
+  let last = pos + tree.nodes[pos].rawSpan
+  inc pos
+  nextChild tree, pos
+  while pos < last:
+    yield NodePos pos
+    nextChild tree, pos
+
+iterator sonsFromN*(tree: Tree; n: NodePos; toSkip = 2): NodePos =
+  var pos = n.int
+  assert tree.nodes[pos].kind > LastAtomicValue
+  let last = pos + tree.nodes[pos].rawSpan
+  inc pos
+  for i in 1..toSkip:
+    nextChild tree, pos
+  while pos < last:
+    yield NodePos pos
+    nextChild tree, pos
+
+template `[]`*(t: Tree; n: NodePos): Instr = t.nodes[n.int]
+
+iterator sonsRest*(tree: Tree; parent, n: NodePos): NodePos =
+  var pos = n.int
+  assert tree[parent].kind > LastAtomicValue
+  let last = parent.int + tree[parent].rawSpan
+  while pos < last:
+    yield NodePos pos
+    nextChild tree, pos
+
+proc span(tree: Tree; pos: int): int {.inline.} =
+  if tree.nodes[pos].kind <= LastAtomicValue: 1 else: int(tree.nodes[pos].operand)
+
+proc copyTree*(dest: var Tree; src: Tree) =
+  let pos = 0
+  let L = span(src, pos)
+  let d = dest.nodes.len
+  dest.nodes.setLen(d + L)
+  assert L > 0
+  for i in 0..<L:
+    dest.nodes[d+i] = src.nodes[pos+i]
+
+proc sons2*(tree: Tree; n: NodePos): (NodePos, NodePos) {.inline.} =
+  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: Tree; n: NodePos): (NodePos, NodePos, NodePos) {.inline.} =
+  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 sons4*(tree: Tree; n: NodePos): (NodePos, NodePos, NodePos, NodePos) {.inline.} =
+  assert(not isAtom(tree, n.int))
+  let a = n.int+1
+  let b = a + span(tree, a)
+  let c = b + span(tree, b)
+  let d = c + span(tree, c)
+  result = (NodePos a, NodePos b, NodePos c, NodePos d)
+
+proc sons5*(tree: Tree; n: NodePos): (NodePos, NodePos, NodePos, NodePos, NodePos) {.inline.} =
+  assert(not isAtom(tree, n.int))
+  let a = n.int+1
+  let b = a + span(tree, a)
+  let c = b + span(tree, b)
+  let d = c + span(tree, c)
+  let e = d + span(tree, d)
+  result = (NodePos a, NodePos b, NodePos c, NodePos d, NodePos e)
+
+proc typeId*(ins: Instr): TypeId {.inline.} =
+  assert ins.kind == Typed
+  result = TypeId(ins.operand)
+
+proc symId*(ins: Instr): SymId {.inline.} =
+  assert ins.kind in {SymUse, SymDef}
+  result = SymId(ins.operand)
+
+proc immediateVal*(ins: Instr): int {.inline.} =
+  assert ins.kind == ImmediateVal
+  result = cast[int](ins.operand)
+
+proc litId*(ins: Instr): LitId {.inline.} =
+  assert ins.kind in {StrVal, IntVal}
+  result = LitId(ins.operand)
+
+
+type
+  LabelId* = distinct int
+
+proc `==`*(a, b: LabelId): bool {.borrow.}
+proc hash*(a: LabelId): Hash {.borrow.}
+
+proc label*(ins: Instr): LabelId {.inline.} =
+  assert ins.kind in {Label, LoopLabel, Goto, GotoLoop, CheckedGoto}
+  result = LabelId(ins.operand)
+
+proc newLabel*(labelGen: var int): LabelId {.inline.} =
+  result = LabelId labelGen
+  inc labelGen
+
+proc newLabels*(labelGen: var int; n: int): LabelId {.inline.} =
+  result = LabelId labelGen
+  inc labelGen, n
+
+proc addNewLabel*(t: var Tree; labelGen: var int; info: PackedLineInfo; k: Opcode): LabelId =
+  assert k in {Label, LoopLabel}
+  result = LabelId labelGen
+  t.nodes.add Instr(x: toX(k, uint32(result)), info: info)
+  inc labelGen
+
+proc gotoLabel*(t: var Tree; info: PackedLineInfo; k: Opcode; L: LabelId) =
+  assert k in {Goto, GotoLoop, CheckedGoto}
+  t.nodes.add Instr(x: toX(k, uint32(L)), info: info)
+
+proc addLabel*(t: var Tree; info: PackedLineInfo; k: Opcode; L: LabelId) {.inline.} =
+  assert k in {Label, LoopLabel, Goto, GotoLoop, CheckedGoto}
+  t.nodes.add Instr(x: toX(k, uint32(L)), info: info)
+
+proc addSymUse*(t: var Tree; info: PackedLineInfo; s: SymId) {.inline.} =
+  t.nodes.add Instr(x: toX(SymUse, uint32(s)), info: info)
+
+proc addSymDef*(t: var Tree; info: PackedLineInfo; s: SymId) {.inline.} =
+  t.nodes.add Instr(x: toX(SymDef, uint32(s)), info: info)
+
+proc addNop*(t: var Tree; info: PackedLineInfo) {.inline.} =
+  t.nodes.add Instr(x: toX(Nop, 0'u32), info: info)
+
+proc addTyped*(t: var Tree; info: PackedLineInfo; typ: TypeId) {.inline.} =
+  assert typ.int >= 0
+  t.nodes.add Instr(x: toX(Typed, uint32(typ)), info: info)
+
+proc addSummon*(t: var Tree; info: PackedLineInfo; s: SymId; typ: TypeId; opc = Summon) {.inline.} =
+  assert typ.int >= 0
+  assert opc in {Summon, SummonConst, SummonGlobal, SummonThreadLocal, SummonParam, SummonResult}
+  let x = prepare(t, info, opc)
+  t.nodes.add Instr(x: toX(Typed, uint32(typ)), info: info)
+  t.nodes.add Instr(x: toX(SymDef, uint32(s)), info: info)
+  patch t, x
+
+proc addImmediateVal*(t: var Tree; info: PackedLineInfo; x: int) =
+  assert x >= 0 and x < ((1 shl 32) - OpcodeBits.int)
+  t.nodes.add Instr(x: toX(ImmediateVal, uint32(x)), info: info)
+
+proc addPragmaId*(t: var Tree; info: PackedLineInfo; x: PragmaKey) =
+  t.nodes.add Instr(x: toX(PragmaId, uint32(x)), info: info)
+
+proc addIntVal*(t: var Tree; integers: var BiTable[int64]; info: PackedLineInfo; typ: TypeId; x: int64) =
+  buildTyped t, info, NumberConv, typ:
+    t.nodes.add Instr(x: toX(IntVal, uint32(integers.getOrIncl(x))), info: info)
+
+proc boolVal*(t: var Tree; integers: var BiTable[int64]; info: PackedLineInfo; b: bool) =
+  buildTyped t, info, NumberConv, Bool8Id:
+    t.nodes.add Instr(x: toX(IntVal, uint32(integers.getOrIncl(ord b))), info: info)
+
+proc addStrVal*(t: var Tree; strings: var BiTable[string]; info: PackedLineInfo; s: string) =
+  t.nodes.add Instr(x: toX(StrVal, uint32(strings.getOrIncl(s))), info: info)
+
+proc addStrLit*(t: var Tree; info: PackedLineInfo; s: LitId) =
+  t.nodes.add Instr(x: toX(StrVal, uint32(s)), info: info)
+
+proc addNilVal*(t: var Tree; info: PackedLineInfo; typ: TypeId) =
+  buildTyped t, info, NumberConv, typ:
+    t.nodes.add Instr(x: toX(NilVal, uint32(0)), info: info)
+
+proc store*(r: var RodFile; t: Tree) = storeSeq r, t.nodes
+proc load*(r: var RodFile; t: var Tree) = loadSeq r, t.nodes
+
+proc escapeToNimLit*(s: string; result: var string) =
+  result.add '"'
+  for c in items s:
+    if c < ' ' or int(c) >= 128:
+      result.add '\\'
+      result.addInt int(c)
+    elif c == '\\':
+      result.add r"\\"
+    elif c == '\n':
+      result.add r"\n"
+    elif c == '\r':
+      result.add r"\r"
+    elif c == '\t':
+      result.add r"\t"
+    else:
+      result.add c
+  result.add '"'
+
+type
+  SymNames* = object
+    s: seq[LitId]
+
+proc `[]=`*(t: var SymNames; key: SymId; val: LitId) =
+  let k = int(key)
+  if k >= t.s.len: t.s.setLen k+1
+  t.s[k] = val
+
+proc `[]`*(t: SymNames; key: SymId): LitId =
+  let k = int(key)
+  if k < t.s.len: result = t.s[k]
+  else: result = LitId(0)
+
+template localName(s: SymId): string =
+  let name = names[s]
+  if name != LitId(0):
+    strings[name]
+  else:
+    $s.int
+
+proc store*(r: var RodFile; t: SymNames) = storeSeq(r, t.s)
+proc load*(r: var RodFile; t: var SymNames) = loadSeq(r, t.s)
+
+proc toString*(t: Tree; pos: NodePos; strings: BiTable[string]; integers: BiTable[int64];
+               names: SymNames;
+               r: var string; nesting = 0) =
+  if r.len > 0 and r[r.len-1] notin {' ', '\n', '(', '[', '{'}:
+    r.add ' '
+
+  case t[pos].kind
+  of Nop: r.add "Nop"
+  of ImmediateVal:
+    r.add $t[pos].operand
+  of IntVal:
+    r.add "IntVal "
+    r.add $integers[LitId t[pos].operand]
+  of StrVal:
+    escapeToNimLit(strings[LitId t[pos].operand], r)
+  of SymDef:
+    r.add "SymDef "
+    r.add localName(SymId t[pos].operand)
+  of SymUse:
+    r.add "SymUse "
+    r.add localName(SymId t[pos].operand)
+  of PragmaId:
+    r.add $cast[PragmaKey](t[pos].operand)
+  of Typed:
+    r.add "T<"
+    r.add $t[pos].operand
+    r.add ">"
+  of NilVal:
+    r.add "NilVal"
+  of Label:
+    # undo the nesting:
+    var spaces = r.len-1
+    while spaces >= 0 and r[spaces] == ' ': dec spaces
+    r.setLen spaces+1
+    r.add "\n  L"
+    r.add $t[pos].operand
+  of Goto, CheckedGoto, LoopLabel, GotoLoop:
+    r.add $t[pos].kind
+    r.add " L"
+    r.add $t[pos].operand
+  else:
+    r.add $t[pos].kind
+    r.add "{\n"
+    for i in 0..<(nesting+1)*2: r.add ' '
+    for p in sons(t, pos):
+      toString t, p, strings, integers, names, r, nesting+1
+    r.add "\n"
+    for i in 0..<nesting*2: r.add ' '
+    r.add "}"
+
+proc allTreesToString*(t: Tree; strings: BiTable[string]; integers: BiTable[int64];
+                       names: SymNames;
+                       r: var string) =
+  var i = 0
+  while i < t.len:
+    toString t, NodePos(i), strings, integers, names, r
+    nextChild t, i
+
+type
+  Value* = distinct Tree
+
+proc prepare*(dest: var Value; info: PackedLineInfo; k: Opcode): PatchPos {.inline.} =
+  assert k in ValueProducing - ValueProducingAtoms
+  result = prepare(Tree(dest), info, k)
+
+proc patch*(dest: var Value; pos: PatchPos) {.inline.} =
+  patch(Tree(dest), pos)
+
+proc localToValue*(info: PackedLineInfo; s: SymId): Value =
+  result = Value(Tree())
+  Tree(result).addSymUse info, s
+
+proc hasValue*(v: Value): bool {.inline.} = Tree(v).len > 0
+
+proc isEmpty*(v: Value): bool {.inline.} = Tree(v).len == 0
+
+proc extractTemp*(v: Value): SymId =
+  if hasValue(v) and Tree(v)[NodePos 0].kind == SymUse:
+    result = SymId(Tree(v)[NodePos 0].operand)
+  else:
+    result = SymId(-1)
+
+proc copyTree*(dest: var Tree; src: Value) = copyTree dest, Tree(src)
+
+proc addImmediateVal*(t: var Value; info: PackedLineInfo; x: int) =
+  assert x >= 0 and x < ((1 shl 32) - OpcodeBits.int)
+  Tree(t).nodes.add Instr(x: toX(ImmediateVal, uint32(x)), info: info)
+
+template build*(tree: var Value; info: PackedLineInfo; kind: Opcode; body: untyped) =
+  let pos = prepare(Tree(tree), info, kind)
+  body
+  patch(tree, pos)
+
+proc addTyped*(t: var Value; info: PackedLineInfo; typ: TypeId) {.inline.} =
+  addTyped(Tree(t), info, typ)
+
+template buildTyped*(tree: var Value; info: PackedLineInfo; kind: Opcode; typ: TypeId; body: untyped) =
+  let pos = prepare(tree, info, kind)
+  tree.addTyped info, typ
+  body
+  patch(tree, pos)
+
+proc addStrVal*(t: var Value; strings: var BiTable[string]; info: PackedLineInfo; s: string) =
+  addStrVal(Tree(t), strings, info, s)
+
+proc addNilVal*(t: var Value; info: PackedLineInfo; typ: TypeId) =
+  addNilVal Tree(t), info, typ
+
+proc addIntVal*(t: var Value; integers: var BiTable[int64]; info: PackedLineInfo; typ: TypeId; x: int64) =
+  addIntVal Tree(t), integers, info, typ, x

compiler/nir/nirlineinfos.nim

@@ -1,7 +1,7 @@
 #
 #
 #           The Nim Compiler
-#        (c) Copyright 2024 Andreas Rumpf
+#        (c) Copyright 2023 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
 #    distribution, for details about the copyright.

compiler/nir/nirslots.nim

@@ -0,0 +1,104 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## Management of slots. Similar to "register allocation"
+## in lower level languages.
+
+import std / [assertions, tables]
+import nirtypes, nirinsts
+
+type
+  SlotManagerFlag* = enum
+    ReuseTemps,
+    ReuseVars
+  SlotKind* = enum
+    Temp, Perm
+  SlotManager* = object # "register allocator"
+    live: Table[SymId, (SlotKind, TypeId)]
+    dead: Table[TypeId, seq[SymId]]
+    flags: set[SlotManagerFlag]
+    inScope: seq[SymId]
+
+proc initSlotManager*(flags: set[SlotManagerFlag]): SlotManager {.inline.} =
+  SlotManager(flags: flags)
+
+proc allocRaw(m: var SlotManager; t: TypeId; f: SlotManagerFlag; k: SlotKind;
+              symIdgen: var int32): SymId {.inline.} =
+  if f in m.flags and m.dead.hasKey(t) and m.dead[t].len > 0:
+    result = m.dead[t].pop()
+  else:
+    inc symIdgen
+    result = SymId(symIdgen)
+    m.inScope.add result
+  m.live[result] = (k, t)
+
+proc allocTemp*(m: var SlotManager; t: TypeId; symIdgen: var int32): SymId {.inline.} =
+  result = allocRaw(m, t, ReuseTemps, Temp, symIdgen)
+
+proc allocVar*(m: var SlotManager; t: TypeId; symIdgen: var int32): SymId {.inline.} =
+  result = allocRaw(m, t, ReuseVars, Perm, symIdgen)
+
+proc freeLoc*(m: var SlotManager; s: SymId) =
+  let t = m.live.getOrDefault(s)
+  assert t[1].int != 0
+  m.live.del s
+  m.dead.mgetOrPut(t[1], @[]).add s
+
+proc freeTemp*(m: var SlotManager; s: SymId) =
+  let t = m.live.getOrDefault(s)
+  if t[1].int != 0 and t[0] == Temp:
+    m.live.del s
+    m.dead.mgetOrPut(t[1], @[]).add s
+
+iterator stillAlive*(m: SlotManager): (SymId, TypeId) =
+  for k, v in pairs(m.live):
+    yield (k, v[1])
+
+proc getType*(m: SlotManager; s: SymId): TypeId {.inline.} = m.live[s][1]
+
+proc openScope*(m: var SlotManager) =
+  m.inScope.add SymId(-1) # add marker
+
+proc closeScope*(m: var SlotManager) =
+  var i = m.inScope.len - 1
+  while i >= 0:
+    if m.inScope[i] == SymId(-1):
+      m.inScope.setLen i
+      break
+    dec i
+
+when isMainModule:
+  var symIdgen: int32
+  var m = initSlotManager({ReuseTemps})
+
+  var g = initTypeGraph(Literals())
+
+  let a = g.openType ArrayTy
+  g.addBuiltinType Int8Id
+  g.addArrayLen 5
+  let finalArrayType = finishType(g, a)
+
+  let obj = g.openType ObjectDecl
+  g.addName "MyType"
+
+  g.addField "p", finalArrayType, 0
+  let objB = finishType(g, obj)
+
+  let x = m.allocTemp(objB, symIdgen)
+  assert x.int == 0
+
+  let y = m.allocTemp(objB, symIdgen)
+  assert y.int == 1
+
+  let z = m.allocTemp(Int8Id, symIdgen)
+  assert z.int == 2
+
+  m.freeLoc y
+  let y2 = m.allocTemp(objB, symIdgen)
+  assert y2.int == 1

compiler/nir/nirtypes.nim

@@ -0,0 +1,475 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## Type system for NIR. Close to C's type system but without its quirks.
+
+import std / [assertions, hashes]
+import .. / ic / [bitabs, rodfiles]
+
+type
+  NirTypeKind* = enum
+    VoidTy, IntTy, UIntTy, FloatTy, BoolTy, CharTy, NameVal,
+    IntVal, SizeVal, AlignVal, OffsetVal,
+    AnnotationVal,
+    ObjectTy,
+    UnionTy,
+    VarargsTy, # the `...` in a C prototype; also the last "atom"
+    APtrTy, # pointer to aliasable memory
+    UPtrTy, # pointer to unique/unaliasable memory
+    AArrayPtrTy, # pointer to array of aliasable memory
+    UArrayPtrTy, # pointer to array of unique/unaliasable memory
+    ArrayTy,
+    LastArrayTy, # array of unspecified size as a last field inside an object
+    ProcTy,
+    ObjectDecl,
+    UnionDecl,
+    FieldDecl
+
+const
+  TypeKindBits = 8'u32
+  TypeKindMask = (1'u32 shl TypeKindBits) - 1'u32
+
+type
+  TypeNode* = object     # 4 bytes
+    x: uint32
+
+template kind*(n: TypeNode): NirTypeKind = NirTypeKind(n.x and TypeKindMask)
+template operand(n: TypeNode): uint32 = (n.x shr TypeKindBits)
+
+proc integralBits*(n: TypeNode): int {.inline.} =
+  # Number of bits in the IntTy, etc. Only valid for integral types.
+  assert n.kind in {IntTy, UIntTy, FloatTy, BoolTy, CharTy}
+  result = int(n.operand)
+
+template toX(k: NirTypeKind; operand: uint32): uint32 =
+  uint32(k) or (operand shl TypeKindBits)
+
+template toX(k: NirTypeKind; operand: LitId): uint32 =
+  uint32(k) or (operand.uint32 shl TypeKindBits)
+
+type
+  TypeId* = distinct int
+
+proc `==`*(a, b: TypeId): bool {.borrow.}
+proc hash*(a: TypeId): Hash {.borrow.}
+
+type
+  Literals* = ref object
+    strings*: BiTable[string]
+    numbers*: BiTable[int64]
+
+  TypeGraph* = object
+    nodes: seq[TypeNode]
+    lit: Literals
+
+const
+  VoidId* = TypeId 0
+  Bool8Id* = TypeId 1
+  Char8Id* = TypeId 2
+  Int8Id* = TypeId 3
+  Int16Id* = TypeId 4
+  Int32Id* = TypeId 5
+  Int64Id* = TypeId 6
+  UInt8Id* = TypeId 7
+  UInt16Id* = TypeId 8
+  UInt32Id* = TypeId 9
+  UInt64Id* = TypeId 10
+  Float32Id* = TypeId 11
+  Float64Id* = TypeId 12
+  VoidPtrId* = TypeId 13
+  LastBuiltinId* = 13
+
+proc initTypeGraph*(lit: Literals): TypeGraph =
+  result = TypeGraph(nodes: @[
+    TypeNode(x: toX(VoidTy, 0'u32)),
+    TypeNode(x: toX(BoolTy, 8'u32)),
+    TypeNode(x: toX(CharTy, 8'u32)),
+    TypeNode(x: toX(IntTy, 8'u32)),
+    TypeNode(x: toX(IntTy, 16'u32)),
+    TypeNode(x: toX(IntTy, 32'u32)),
+    TypeNode(x: toX(IntTy, 64'u32)),
+    TypeNode(x: toX(UIntTy, 8'u32)),
+    TypeNode(x: toX(UIntTy, 16'u32)),
+    TypeNode(x: toX(UIntTy, 32'u32)),
+    TypeNode(x: toX(UIntTy, 64'u32)),
+    TypeNode(x: toX(FloatTy, 32'u32)),
+    TypeNode(x: toX(FloatTy, 64'u32)),
+    TypeNode(x: toX(APtrTy, 2'u32)),
+    TypeNode(x: toX(VoidTy, 0'u32))
+  ], lit: lit)
+  assert result.nodes.len == LastBuiltinId+2
+
+type
+  TypePatchPos* = distinct int
+
+const
+  InvalidTypePatchPos* = TypePatchPos(-1)
+  LastAtomicValue = VarargsTy
+
+proc isValid(p: TypePatchPos): bool {.inline.} = p.int != -1
+
+proc prepare(tree: var TypeGraph; kind: NirTypeKind): TypePatchPos =
+  result = TypePatchPos tree.nodes.len
+  tree.nodes.add TypeNode(x: toX(kind, 1'u32))
+
+proc isAtom(tree: TypeGraph; pos: int): bool {.inline.} = tree.nodes[pos].kind <= LastAtomicValue
+proc isAtom(tree: TypeGraph; pos: TypeId): bool {.inline.} = tree.nodes[pos.int].kind <= LastAtomicValue
+
+proc patch(tree: var TypeGraph; pos: TypePatchPos) =
+  let pos = pos.int
+  let k = tree.nodes[pos].kind
+  assert k > LastAtomicValue
+  let distance = int32(tree.nodes.len - pos)
+  assert distance > 0
+  tree.nodes[pos].x = toX(k, cast[uint32](distance))
+
+proc len*(tree: TypeGraph): int {.inline.} = tree.nodes.len
+
+template rawSpan(n: TypeNode): int = int(operand(n))
+
+proc nextChild(tree: TypeGraph; pos: var int) {.inline.} =
+  if tree.nodes[pos].kind > LastAtomicValue:
+    assert tree.nodes[pos].operand > 0'u32
+    inc pos, tree.nodes[pos].rawSpan
+  else:
+    inc pos
+
+iterator sons*(tree: TypeGraph; n: TypeId): TypeId =
+  var pos = n.int
+  assert tree.nodes[pos].kind > LastAtomicValue
+  let last = pos + tree.nodes[pos].rawSpan
+  inc pos
+  while pos < last:
+    yield TypeId pos
+    nextChild tree, pos
+
+template `[]`*(t: TypeGraph; n: TypeId): TypeNode = t.nodes[n.int]
+
+proc elementType*(tree: TypeGraph; n: TypeId): TypeId {.inline.} =
+  assert tree[n].kind in {APtrTy, UPtrTy, AArrayPtrTy, UArrayPtrTy, ArrayTy, LastArrayTy}
+  result = TypeId(n.int+1)
+
+proc litId*(n: TypeNode): LitId {.inline.} =
+  assert n.kind in {NameVal, IntVal, SizeVal, AlignVal, OffsetVal, AnnotationVal, ObjectTy, UnionTy}
+  result = LitId(n.operand)
+
+proc kind*(tree: TypeGraph; n: TypeId): NirTypeKind {.inline.} = tree[n].kind
+
+proc span(tree: TypeGraph; pos: int): int {.inline.} =
+  if tree.nodes[pos].kind <= LastAtomicValue: 1 else: int(tree.nodes[pos].operand)
+
+proc sons2(tree: TypeGraph; n: TypeId): (TypeId, TypeId) =
+  assert(not isAtom(tree, n.int))
+  let a = n.int+1
+  let b = a + span(tree, a)
+  result = (TypeId a, TypeId b)
+
+proc sons3(tree: TypeGraph; n: TypeId): (TypeId, TypeId, TypeId) =
+  assert(not isAtom(tree, n.int))
+  let a = n.int+1
+  let b = a + span(tree, a)
+  let c = b + span(tree, b)
+  result = (TypeId a, TypeId b, TypeId c)
+
+proc arrayName*(tree: TypeGraph; n: TypeId): TypeId {.inline.} =
+  assert tree[n].kind == ArrayTy
+  let (_, _, c) = sons3(tree, n)
+  result = c
+
+proc arrayLen*(tree: TypeGraph; n: TypeId): BiggestInt =
+  assert tree[n].kind == ArrayTy
+  let (_, b) = sons2(tree, n)
+  result = tree.lit.numbers[LitId tree[b].operand]
+
+proc returnType*(tree: TypeGraph; n: TypeId): (TypeId, TypeId) =
+  # Returns the positions of the return type + calling convention.
+  var pos = n.int
+  assert tree.nodes[pos].kind == ProcTy
+  let a = n.int+1
+  let b = a + span(tree, a)
+  result = (TypeId b, TypeId a) # not a typo, order is reversed
+
+iterator params*(tree: TypeGraph; n: TypeId): TypeId =
+  var pos = n.int
+  assert tree.nodes[pos].kind == ProcTy
+  let last = pos + tree.nodes[pos].rawSpan
+  inc pos
+  nextChild tree, pos
+  nextChild tree, pos
+  while pos < last:
+    yield TypeId pos
+    nextChild tree, pos
+
+proc openType*(tree: var TypeGraph; kind: NirTypeKind): TypePatchPos =
+  assert kind in {APtrTy, UPtrTy, AArrayPtrTy, UArrayPtrTy,
+    ArrayTy, LastArrayTy, ProcTy, ObjectDecl, UnionDecl,
+    FieldDecl}
+  result = prepare(tree, kind)
+
+template typeInvariant(p: TypePatchPos) =
+  when false:
+    if tree[TypeId(p)].kind == FieldDecl:
+      var k = 0
+      for ch in sons(tree, TypeId(p)):
+        inc k
+      assert k > 2, "damn! " & $k
+
+proc sealType*(tree: var TypeGraph; p: TypePatchPos) =
+  patch tree, p
+  typeInvariant(p)
+
+proc finishType*(tree: var TypeGraph; p: TypePatchPos): TypeId =
+  # Search for an existing instance of this type in
+  # order to reduce memory consumption:
+  patch tree, p
+  typeInvariant(p)
+
+  let s = span(tree, p.int)
+  var i = 0
+  while i < p.int:
+    if tree.nodes[i].x == tree.nodes[p.int].x:
+      var isMatch = true
+      for j in 1..<s:
+        if tree.nodes[j+i].x == tree.nodes[j+p.int].x:
+          discard "still a match"
+        else:
+          isMatch = false
+          break
+      if isMatch:
+        if p.int+s == tree.len:
+          setLen tree.nodes, p.int
+        return TypeId(i)
+    nextChild tree, i
+  result = TypeId(p)
+
+proc nominalType*(tree: var TypeGraph; kind: NirTypeKind; name: string): TypeId =
+  assert kind in {ObjectTy, UnionTy}
+  let content = TypeNode(x: toX(kind, tree.lit.strings.getOrIncl(name)))
+  for i in 0..<tree.len:
+    if tree.nodes[i].x == content.x:
+      return TypeId(i)
+  result = TypeId tree.nodes.len
+  tree.nodes.add content
+
+proc addNominalType*(tree: var TypeGraph; kind: NirTypeKind; name: string) =
+  assert kind in {ObjectTy, UnionTy}
+  tree.nodes.add TypeNode(x: toX(kind, tree.lit.strings.getOrIncl(name)))
+
+proc getTypeTag*(tree: TypeGraph; t: TypeId): string =
+  assert tree[t].kind in {ObjectTy, UnionTy}
+  result = tree.lit.strings[LitId tree[t].operand]
+
+proc addVarargs*(tree: var TypeGraph) =
+  tree.nodes.add TypeNode(x: toX(VarargsTy, 0'u32))
+
+proc getFloat128Type*(tree: var TypeGraph): TypeId =
+  result = TypeId tree.nodes.len
+  tree.nodes.add TypeNode(x: toX(FloatTy, 128'u32))
+
+proc addBuiltinType*(g: var TypeGraph; id: TypeId) =
+  g.nodes.add g[id]
+
+template firstSon*(n: TypeId): TypeId = TypeId(n.int+1)
+
+proc addType*(g: var TypeGraph; t: TypeId) =
+  # We cannot simply copy `*Decl` nodes. We have to introduce `*Ty` nodes instead:
+  if g[t].kind in {ObjectDecl, UnionDecl}:
+    assert g[t.firstSon].kind == NameVal
+    let name = LitId g[t.firstSon].operand
+    if g[t].kind == ObjectDecl:
+      g.nodes.add TypeNode(x: toX(ObjectTy, name))
+    else:
+      g.nodes.add TypeNode(x: toX(UnionTy, name))
+  else:
+    let pos = t.int
+    let L = span(g, pos)
+    let d = g.nodes.len
+    g.nodes.setLen(d + L)
+    assert L > 0
+    for i in 0..<L:
+      g.nodes[d+i] = g.nodes[pos+i]
+
+proc addArrayLen*(g: var TypeGraph; len: int64) =
+  g.nodes.add TypeNode(x: toX(IntVal, g.lit.numbers.getOrIncl(len)))
+
+proc addSize*(g: var TypeGraph; s: int64) =
+  g.nodes.add TypeNode(x: toX(SizeVal, g.lit.numbers.getOrIncl(s)))
+
+proc addOffset*(g: var TypeGraph; offset: int64) =
+  g.nodes.add TypeNode(x: toX(OffsetVal, g.lit.numbers.getOrIncl(offset)))
+
+proc addAlign*(g: var TypeGraph; a: int64) =
+  g.nodes.add TypeNode(x: toX(AlignVal, g.lit.numbers.getOrIncl(a)))
+
+proc addName*(g: var TypeGraph; name: string) =
+  g.nodes.add TypeNode(x: toX(NameVal, g.lit.strings.getOrIncl(name)))
+
+proc addAnnotation*(g: var TypeGraph; name: string) =
+  g.nodes.add TypeNode(x: toX(NameVal, g.lit.strings.getOrIncl(name)))
+
+proc addField*(g: var TypeGraph; name: string; typ: TypeId; offset: int64) =
+  let f = g.openType FieldDecl
+  g.addType typ
+  g.addOffset offset
+  g.addName name
+  sealType(g, f)
+
+proc ptrTypeOf*(g: var TypeGraph; t: TypeId): TypeId =
+  let f = g.openType APtrTy
+  g.addType t
+  result = finishType(g, f)
+
+proc arrayPtrTypeOf*(g: var TypeGraph; t: TypeId): TypeId =
+  let f = g.openType AArrayPtrTy
+  g.addType t
+  result = finishType(g, f)
+
+proc store*(r: var RodFile; g: TypeGraph) =
+  storeSeq r, g.nodes
+
+proc load*(r: var RodFile; g: var TypeGraph) =
+  loadSeq r, g.nodes
+
+proc toString*(dest: var string; g: TypeGraph; i: TypeId) =
+  case g[i].kind
+  of VoidTy: dest.add "void"
+  of IntTy:
+    dest.add "i"
+    dest.addInt g[i].operand
+  of UIntTy:
+    dest.add "u"
+    dest.addInt g[i].operand
+  of FloatTy:
+    dest.add "f"
+    dest.addInt g[i].operand
+  of BoolTy:
+    dest.add "b"
+    dest.addInt g[i].operand
+  of CharTy:
+    dest.add "c"
+    dest.addInt g[i].operand
+  of NameVal, AnnotationVal:
+    dest.add g.lit.strings[LitId g[i].operand]
+  of IntVal, SizeVal, AlignVal, OffsetVal:
+    dest.add $g[i].kind
+    dest.add ' '
+    dest.add $g.lit.numbers[LitId g[i].operand]
+  of VarargsTy:
+    dest.add "..."
+  of APtrTy:
+    dest.add "aptr["
+    toString(dest, g, g.elementType(i))
+    dest.add "]"
+  of UPtrTy:
+    dest.add "uptr["
+    toString(dest, g, g.elementType(i))
+    dest.add "]"
+  of AArrayPtrTy:
+    dest.add "aArrayPtr["
+    toString(dest, g, g.elementType(i))
+    dest.add "]"
+  of UArrayPtrTy:
+    dest.add "uArrayPtr["
+    toString(dest, g, g.elementType(i))
+    dest.add "]"
+  of ArrayTy:
+    dest.add "Array["
+    let (elems, len, name) = g.sons3(i)
+    toString(dest, g, elems)
+    dest.add ", "
+    toString(dest, g, len)
+    dest.add ", "
+    toString(dest, g, name)
+    dest.add "]"
+  of LastArrayTy:
+    # array of unspecified size as a last field inside an object
+    dest.add "LastArrayTy["
+    toString(dest, g, g.elementType(i))
+    dest.add "]"
+  of ObjectTy:
+    dest.add "object "
+    dest.add g.lit.strings[LitId g[i].operand]
+  of UnionTy:
+    dest.add "union "
+    dest.add g.lit.strings[LitId g[i].operand]
+  of ProcTy:
+    dest.add "proc["
+    for t in sons(g, i):
+      dest.add ' '
+      toString(dest, g, t)
+    dest.add "]"
+  of ObjectDecl:
+    dest.add "object["
+    for t in sons(g, i):
+      toString(dest, g, t)
+      dest.add '\n'
+    dest.add "]"
+  of UnionDecl:
+    dest.add "union["
+    for t in sons(g, i):
+      toString(dest, g, t)
+      dest.add '\n'
+    dest.add "]"
+  of FieldDecl:
+    dest.add "field["
+    for t in sons(g, i):
+      toString(dest, g, t)
+      dest.add ' '
+    dest.add "]"
+
+    when false:
+      let (typ, offset, name) = g.sons3(i)
+      toString(dest, g, typ)
+      dest.add ' '
+      toString(dest, g, offset)
+      dest.add ' '
+      toString(dest, g, name)
+
+proc toString*(dest: var string; g: TypeGraph) =
+  var i = 0
+  while i < g.len:
+    dest.add "T<"
+    dest.addInt i
+    dest.add "> "
+    toString(dest, g, TypeId i)
+    dest.add '\n'
+    nextChild g, i
+
+iterator allTypes*(g: TypeGraph; start = 0): TypeId =
+  var i = start
+  while i < g.len:
+    yield TypeId i
+    nextChild g, i
+
+iterator allTypesIncludingInner*(g: TypeGraph; start = 0): TypeId =
+  var i = start
+  while i < g.len:
+    yield TypeId i
+    inc i
+
+proc `$`(g: TypeGraph): string =
+  result = ""
+  toString(result, g)
+
+when isMainModule:
+  var g = initTypeGraph(Literals())
+
+  let a = g.openType ArrayTy
+  g.addBuiltinType Int8Id
+  g.addArrayLen 5
+  g.addName "SomeArray"
+  let finalArrayType = finishType(g, a)
+
+  let obj = g.openType ObjectDecl
+  g.nodes.add TypeNode(x: toX(NameVal, g.lit.strings.getOrIncl("MyType")))
+
+  g.addField "p", finalArrayType, 0
+  sealType(g, obj)
+
+  echo g

compiler/nir/stringcases.nim

@@ -0,0 +1,200 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## included from ast2ir.nim
+
+#[
+
+case s
+of "abc", "abbd":
+  echo 1
+of "hah":
+  echo 2
+of "gah":
+  echo 3
+
+# we produce code like this:
+
+if s[0] <= 'a':
+  if s == "abc: goto L1
+  elif s == "abbd": goto L1
+else:
+  if s[2] <= 'h':
+    if s == "hah": goto L2
+    elif s == "gah": goto L3
+goto afterCase
+
+L1:
+  echo 1
+  goto afterCase
+L2:
+  echo 2
+  goto afterCase
+L3:
+  echo 3
+  goto afterCase
+
+afterCase: ...
+
+]#
+
+# We split the set of strings into 2 sets of roughly the same size.
+# The condition used for splitting is a (position, char) tuple.
+# Every string of length > position for which s[position] <= char is in one
+# set else it is in the other set.
+
+from std/sequtils import addUnique
+
+type
+  Key = (LitId, LabelId)
+
+proc splitValue(strings: BiTable[string]; a: openArray[Key]; position: int): (char, float) =
+  var cand: seq[char] = @[]
+  for t in items a:
+    let s = strings[t[0]]
+    if s.len > position: cand.addUnique s[position]
+
+  result = ('\0', -1.0)
+  for disc in items cand:
+    var hits = 0
+    for t in items a:
+      let s = strings[t[0]]
+      if s.len > position and s[position] <= disc:
+        inc hits
+    # the split is the better, the more `hits` is close to `a.len / 2`:
+    let grade = 100000.0 - abs(hits.float - a.len.float / 2.0)
+    if grade > result[1]:
+      result = (disc, grade)
+
+proc tryAllPositions(strings: BiTable[string]; a: openArray[Key]): (char, int) =
+  var m = 0
+  for t in items a:
+    m = max(m, strings[t[0]].len)
+
+  result = ('\0', -1)
+  var best = -1.0
+  for i in 0 ..< m:
+    let current = splitValue(strings, a, i)
+    if current[1] > best:
+      best = current[1]
+      result = (current[0], i)
+
+type
+  SearchKind = enum
+    LinearSearch, SplitSearch
+  SearchResult* = object
+    case kind: SearchKind
+    of LinearSearch:
+      a: seq[Key]
+    of SplitSearch:
+      span: int
+      best: (char, int)
+
+proc emitLinearSearch(strings: BiTable[string]; a: openArray[Key]; dest: var seq[SearchResult]) =
+  var d = SearchResult(kind: LinearSearch, a: @[])
+  for x in a: d.a.add x
+  dest.add d
+
+proc split(strings: BiTable[string]; a: openArray[Key]; dest: var seq[SearchResult]) =
+  if a.len <= 4:
+    emitLinearSearch strings, a, dest
+  else:
+    let best = tryAllPositions(strings, a)
+    var groupA: seq[Key] = @[]
+    var groupB: seq[Key] = @[]
+    for t in items a:
+      let s = strings[t[0]]
+      if s.len > best[1] and s[best[1]] <= best[0]:
+        groupA.add t
+      else:
+        groupB.add t
+    if groupA.len == 0 or groupB.len == 0:
+      emitLinearSearch strings, a, dest
+    else:
+      let toPatch = dest.len
+      dest.add SearchResult(kind: SplitSearch, span: 1, best: best)
+      split strings, groupA, dest
+      split strings, groupB, dest
+      let dist = dest.len - toPatch
+      assert dist > 0
+      dest[toPatch].span = dist
+
+proc toProblemDescription(c: var ProcCon; n: PNode): (seq[Key], LabelId) =
+  result = (@[], newLabels(c.labelGen, n.len))
+  assert n.kind == nkCaseStmt
+  for i in 1..<n.len:
+    let it = n[i]
+    let thisBranch = LabelId(result[1].int + i - 1)
+    if it.kind == nkOfBranch:
+      for j in 0..<it.len-1:
+        assert it[j].kind in {nkStrLit..nkTripleStrLit}
+        result[0].add (c.lit.strings.getOrIncl(it[j].strVal), thisBranch)
+
+proc decodeSolution(c: var ProcCon; dest: var Tree; s: seq[SearchResult]; i: int;
+                    selector: Value; info: PackedLineInfo) =
+  case s[i].kind
+  of SplitSearch:
+    let thenA = i+1
+    let elseA = thenA + (if s[thenA].kind == LinearSearch: 1 else: s[thenA].span)
+    let best = s[i].best
+
+    let tmp = getTemp(c, Bool8Id, info)
+    buildTyped dest, info, Asgn, Bool8Id:
+      dest.copyTree tmp
+      buildTyped dest, info, Call, Bool8Id:
+        c.addUseCodegenProc dest, "nimStrAtLe", info
+        dest.copyTree selector
+        dest.addIntVal c.lit.numbers, info, c.m.nativeIntId, best[1]
+        dest.addIntVal c.lit.numbers, info, Char8Id, best[0].int
+
+    template then() =
+      c.decodeSolution dest, s, thenA, selector, info
+    template otherwise() =
+      c.decodeSolution dest, s, elseA, selector, info
+    buildIfThenElse tmp, then, otherwise
+    freeTemp c, tmp
+
+  of LinearSearch:
+    let tmp = getTemp(c, Bool8Id, info)
+    for x in s[i].a:
+      buildTyped dest, info, Asgn, Bool8Id:
+        dest.copyTree tmp
+        buildTyped dest, info, Call, Bool8Id:
+          c.addUseCodegenProc dest, "eqStrings", info
+          dest.copyTree selector
+          dest.addStrLit info, x[0]
+      buildIf tmp:
+        c.code.gotoLabel info, Goto, x[1]
+    freeTemp c, tmp
+
+proc genStringCase(c: var ProcCon; n: PNode; d: var Value) =
+  let (problem, firstBranch) = toProblemDescription(c, n)
+  var solution: seq[SearchResult] = @[]
+  split c.lit.strings, problem, solution
+
+  # XXX Todo move complex case selector into a temporary.
+  let selector = c.genx(n[0])
+
+  let info = toLineInfo(c, n.info)
+  decodeSolution c, c.code, solution, 0, selector, info
+
+  let lend = newLabel(c.labelGen)
+  c.code.addLabel info, Goto, lend
+  for i in 1..<n.len:
+    let it = n[i]
+    let thisBranch = LabelId(firstBranch.int + i - 1)
+    c.code.addLabel info, Label, thisBranch
+    if it.kind == nkOfBranch:
+      gen(c, it.lastSon, d)
+      c.code.addLabel info, Goto, lend
+    else:
+      gen(c, it.lastSon, d)
+
+  c.code.addLabel info, Label, lend
+  freeTemp c, selector

compiler/nir/types2ir.nim

@@ -0,0 +1,525 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+import std / [assertions, tables, sets]
+import ".." / [ast, types, options, sighashes, modulegraphs]
+import nirtypes
+
+type
+  TypesCon* = object
+    processed: Table[ItemId, TypeId]
+    processedByName: Table[string, TypeId]
+    recursionCheck: HashSet[ItemId]
+    conf: ConfigRef
+    stringType: TypeId
+
+proc initTypesCon*(conf: ConfigRef): TypesCon =
+  TypesCon(conf: conf, stringType: TypeId(-1))
+
+proc mangle(c: var TypesCon; t: PType): string =
+  result = $sighashes.hashType(t, c.conf)
+
+template cached(c: var TypesCon; t: PType; body: untyped) =
+  result = c.processed.getOrDefault(t.itemId)
+  if result.int == 0:
+    body
+    c.processed[t.itemId] = result
+
+template cachedByName(c: var TypesCon; t: PType; body: untyped) =
+  let key = mangle(c, t)
+  result = c.processedByName.getOrDefault(key)
+  if result.int == 0:
+    body
+    c.processedByName[key] = result
+
+proc typeToIr*(c: var TypesCon; g: var TypeGraph; t: PType): TypeId
+
+proc collectFieldTypes(c: var TypesCon; g: var TypeGraph; n: PNode; dest: var Table[ItemId, TypeId]) =
+  case n.kind
+  of nkRecList:
+    for i in 0..<n.len:
+      collectFieldTypes(c, g, n[i], dest)
+  of nkRecCase:
+    assert(n[0].kind == nkSym)
+    collectFieldTypes(c, g, n[0], dest)
+    for i in 1..<n.len:
+      case n[i].kind
+      of nkOfBranch, nkElse:
+        collectFieldTypes c, g, lastSon(n[i]), dest
+      else: discard
+  of nkSym:
+    dest[n.sym.itemId] = typeToIr(c, g, n.sym.typ)
+  else:
+    assert false, "unknown node kind: " & $n.kind
+
+proc objectToIr(c: var TypesCon; g: var TypeGraph; n: PNode; fieldTypes: Table[ItemId, TypeId]; unionId: var int) =
+  case n.kind
+  of nkRecList:
+    for i in 0..<n.len:
+      objectToIr(c, g, n[i], fieldTypes, unionId)
+  of nkRecCase:
+    assert(n[0].kind == nkSym)
+    objectToIr(c, g, n[0], fieldTypes, unionId)
+    let u = openType(g, UnionDecl)
+    g.addName "u_" & $unionId
+    inc unionId
+    for i in 1..<n.len:
+      case n[i].kind
+      of nkOfBranch, nkElse:
+        let subObj = openType(g, ObjectDecl)
+        g.addName "uo_" & $unionId & "_" & $i
+        objectToIr c, g, lastSon(n[i]), fieldTypes, unionId
+        sealType(g, subObj)
+      else: discard
+    sealType(g, u)
+  of nkSym:
+    g.addField n.sym.name.s & "_" & $n.sym.position, fieldTypes[n.sym.itemId], n.sym.offset
+  else:
+    assert false, "unknown node kind: " & $n.kind
+
+proc objectToIr(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  if t.baseClass != nil:
+    # ensure we emitted the base type:
+    discard typeToIr(c, g, t.baseClass)
+
+  var unionId = 0
+  var fieldTypes = initTable[ItemId, TypeId]()
+  collectFieldTypes c, g, t.n, fieldTypes
+  let obj = openType(g, ObjectDecl)
+  g.addName mangle(c, t)
+  g.addSize c.conf.getSize(t)
+  g.addAlign c.conf.getAlign(t)
+
+  if t.baseClass != nil:
+    g.addNominalType(ObjectTy, mangle(c, t.baseClass))
+  else:
+    g.addBuiltinType VoidId # object does not inherit
+    if not lacksMTypeField(t):
+      let f2 = g.openType FieldDecl
+      let voidPtr = openType(g, APtrTy)
+      g.addBuiltinType(VoidId)
+      sealType(g, voidPtr)
+      g.addOffset 0 # type field is always at offset 0
+      g.addName "m_type"
+      sealType(g, f2) # FieldDecl
+
+  objectToIr c, g, t.n, fieldTypes, unionId
+  result = finishType(g, obj)
+
+proc objectHeaderToIr(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  result = g.nominalType(ObjectTy, mangle(c, t))
+
+proc tupleToIr(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  var fieldTypes = newSeq[TypeId](t.len)
+  for i in 0..<t.len:
+    fieldTypes[i] = typeToIr(c, g, t[i])
+  let obj = openType(g, ObjectDecl)
+  g.addName mangle(c, t)
+  g.addSize c.conf.getSize(t)
+  g.addAlign c.conf.getAlign(t)
+
+  var accum = OffsetAccum(maxAlign: 1)
+  for i in 0..<t.len:
+    let child = t[i]
+    g.addField "f_" & $i, fieldTypes[i], accum.offset
+
+    computeSizeAlign(c.conf, child)
+    accum.align(child.align)
+    accum.inc(int32(child.size))
+  result = finishType(g, obj)
+
+proc procToIr(c: var TypesCon; g: var TypeGraph; t: PType; addEnv = false): TypeId =
+  var fieldTypes = newSeq[TypeId](0)
+  for i in 0..<t.len:
+    if t[i] == nil or not isCompileTimeOnly(t[i]):
+      fieldTypes.add typeToIr(c, g, t[i])
+  let obj = openType(g, ProcTy)
+
+  case t.callConv
+  of ccNimCall, ccFastCall, ccClosure: g.addAnnotation "__fastcall"
+  of ccStdCall: g.addAnnotation "__stdcall"
+  of ccCDecl: g.addAnnotation "__cdecl"
+  of ccSafeCall: g.addAnnotation "__safecall"
+  of ccSysCall: g.addAnnotation "__syscall"
+  of ccInline: g.addAnnotation "__inline"
+  of ccNoInline: g.addAnnotation "__noinline"
+  of ccThisCall: g.addAnnotation "__thiscall"
+  of ccNoConvention, ccMember: g.addAnnotation ""
+
+  for i in 0..<fieldTypes.len:
+    g.addType fieldTypes[i]
+
+  if addEnv:
+    let a = openType(g, APtrTy)
+    g.addBuiltinType(VoidId)
+    sealType(g, a)
+
+  if tfVarargs in t.flags:
+    g.addVarargs()
+  result = finishType(g, obj)
+
+proc nativeInt(c: TypesCon): TypeId =
+  case c.conf.target.intSize
+  of 2: result = Int16Id
+  of 4: result = Int32Id
+  else: result = Int64Id
+
+proc openArrayPayloadType*(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  let e = elementType(t)
+  let elementType = typeToIr(c, g, e)
+  let arr = g.openType AArrayPtrTy
+  g.addType elementType
+  result = finishType(g, arr) # LastArrayTy
+
+proc openArrayToIr(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  # object (a: ArrayPtr[T], len: int)
+  let e = elementType(t)
+  let mangledBase = mangle(c, e)
+  let typeName = "NimOpenArray" & mangledBase
+
+  let elementType = typeToIr(c, g, e)
+  #assert elementType.int >= 0, typeToString(t)
+
+  let p = openType(g, ObjectDecl)
+  g.addName typeName
+  g.addSize c.conf.target.ptrSize*2
+  g.addAlign c.conf.target.ptrSize
+
+  let f = g.openType FieldDecl
+  let arr = g.openType AArrayPtrTy
+  g.addType elementType
+  sealType(g, arr) # LastArrayTy
+  g.addOffset 0
+  g.addName "data"
+  sealType(g, f) # FieldDecl
+
+  g.addField "len", c.nativeInt, c.conf.target.ptrSize
+
+  result = finishType(g, p) # ObjectDecl
+
+proc strPayloadType(c: var TypesCon; g: var TypeGraph): (string, TypeId) =
+  result = ("NimStrPayload", TypeId(-1))
+  let p = openType(g, ObjectDecl)
+  g.addName result[0]
+  g.addSize c.conf.target.ptrSize*2
+  g.addAlign c.conf.target.ptrSize
+
+  g.addField "cap", c.nativeInt, 0
+
+  let f = g.openType FieldDecl
+  let arr = g.openType LastArrayTy
+  g.addBuiltinType Char8Id
+  result[1] = finishType(g, arr) # LastArrayTy
+  g.addOffset c.conf.target.ptrSize # comes after the len field
+  g.addName "data"
+  sealType(g, f) # FieldDecl
+
+  sealType(g, p)
+
+proc strPayloadPtrType*(c: var TypesCon; g: var TypeGraph): (TypeId, TypeId) =
+  let (mangled, arrayType) = strPayloadType(c, g)
+  let ffp = g.openType APtrTy
+  g.addNominalType ObjectTy, mangled
+  result = (finishType(g, ffp), arrayType) # APtrTy
+
+proc stringToIr(c: var TypesCon; g: var TypeGraph): TypeId =
+  #[
+
+    NimStrPayload = object
+      cap: int
+      data: UncheckedArray[char]
+
+    NimStringV2 = object
+      len: int
+      p: ptr NimStrPayload
+
+  ]#
+  let payload = strPayloadType(c, g)
+
+  let str = openType(g, ObjectDecl)
+  g.addName "NimStringV2"
+  g.addSize c.conf.target.ptrSize*2
+  g.addAlign c.conf.target.ptrSize
+
+  g.addField "len", c.nativeInt, 0
+
+  let fp = g.openType FieldDecl
+  let ffp = g.openType APtrTy
+  g.addNominalType ObjectTy, "NimStrPayload"
+  sealType(g, ffp) # APtrTy
+  g.addOffset c.conf.target.ptrSize # comes after 'len' field
+  g.addName "p"
+  sealType(g, fp) # FieldDecl
+
+  result = finishType(g, str) # ObjectDecl
+
+proc seqPayloadType(c: var TypesCon; g: var TypeGraph; t: PType): (string, TypeId) =
+  #[
+    NimSeqPayload[T] = object
+      cap: int
+      data: UncheckedArray[T]
+  ]#
+  let e = elementType(t)
+  result = (mangle(c, e), TypeId(-1))
+  let payloadName = "NimSeqPayload" & result[0]
+
+  let elementType = typeToIr(c, g, e)
+
+  let p = openType(g, ObjectDecl)
+  g.addName payloadName
+  g.addSize c.conf.target.intSize
+  g.addAlign c.conf.target.intSize
+
+  g.addField "cap", c.nativeInt, 0
+
+  let f = g.openType FieldDecl
+  let arr = g.openType LastArrayTy
+  g.addType elementType
+  # DO NOT USE `finishType` here as it is an inner type. This is subtle and we
+  # probably need an even better API here.
+  sealType(g, arr)
+  result[1] = TypeId(arr)
+
+  g.addOffset c.conf.target.ptrSize
+  g.addName "data"
+  sealType(g, f) # FieldDecl
+
+  sealType(g, p)
+
+proc seqPayloadPtrType*(c: var TypesCon; g: var TypeGraph; t: PType): (TypeId, TypeId) =
+  let (mangledBase, arrayType) = seqPayloadType(c, g, t)
+  let ffp = g.openType APtrTy
+  g.addNominalType ObjectTy, "NimSeqPayload" & mangledBase
+  result = (finishType(g, ffp), arrayType) # APtrTy
+
+proc seqToIr(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  #[
+    NimSeqV2*[T] = object
+      len: int
+      p: ptr NimSeqPayload[T]
+  ]#
+  let (mangledBase, _) = seqPayloadType(c, g, t)
+
+  let sq = openType(g, ObjectDecl)
+  g.addName "NimSeqV2" & mangledBase
+  g.addSize c.conf.getSize(t)
+  g.addAlign c.conf.getAlign(t)
+
+  g.addField "len", c.nativeInt, 0
+
+  let fp = g.openType FieldDecl
+  let ffp = g.openType APtrTy
+  g.addNominalType ObjectTy, "NimSeqPayload" & mangledBase
+  sealType(g, ffp) # APtrTy
+  g.addOffset c.conf.target.ptrSize
+  g.addName "p"
+  sealType(g, fp) # FieldDecl
+
+  result = finishType(g, sq) # ObjectDecl
+
+
+proc closureToIr(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  # struct {fn(args, void* env), env}
+  # typedef struct {$n" &
+  #        "N_NIMCALL_PTR($2, ClP_0) $3;$n" &
+  #        "void* ClE_0;$n} $1;$n"
+  let mangledBase = mangle(c, t)
+  let typeName = "NimClosure" & mangledBase
+
+  let procType = procToIr(c, g, t, addEnv=true)
+
+  let p = openType(g, ObjectDecl)
+  g.addName typeName
+  g.addSize c.conf.getSize(t)
+  g.addAlign c.conf.getAlign(t)
+
+  let f = g.openType FieldDecl
+  g.addType procType
+  g.addOffset 0
+  g.addName "ClP_0"
+  sealType(g, f) # FieldDecl
+
+  let f2 = g.openType FieldDecl
+  let voidPtr = openType(g, APtrTy)
+  g.addBuiltinType(VoidId)
+  sealType(g, voidPtr)
+
+  g.addOffset c.conf.target.ptrSize
+  g.addName "ClE_0"
+  sealType(g, f2) # FieldDecl
+
+  result = finishType(g, p) # ObjectDecl
+
+proc bitsetBasetype*(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  let s = int(getSize(c.conf, t))
+  case s
+  of 1: result = UInt8Id
+  of 2: result = UInt16Id
+  of 4: result = UInt32Id
+  of 8: result = UInt64Id
+  else: result = UInt8Id
+
+proc typeToIr*(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  if t == nil: return VoidId
+  case t.kind
+  of tyInt:
+    case int(getSize(c.conf, t))
+    of 2: result = Int16Id
+    of 4: result = Int32Id
+    else: result = Int64Id
+  of tyInt8: result = Int8Id
+  of tyInt16: result = Int16Id
+  of tyInt32: result = Int32Id
+  of tyInt64: result = Int64Id
+  of tyFloat:
+    case int(getSize(c.conf, t))
+    of 4: result = Float32Id
+    else: result = Float64Id
+  of tyFloat32: result = Float32Id
+  of tyFloat64: result = Float64Id
+  of tyFloat128: result = getFloat128Type(g)
+  of tyUInt:
+    case int(getSize(c.conf, t))
+    of 2: result = UInt16Id
+    of 4: result = UInt32Id
+    else: result = UInt64Id
+  of tyUInt8: result = UInt8Id
+  of tyUInt16: result = UInt16Id
+  of tyUInt32: result = UInt32Id
+  of tyUInt64: result = UInt64Id
+  of tyBool: result = Bool8Id
+  of tyChar: result = Char8Id
+  of tyVoid: result = VoidId
+  of tySink, tyGenericInst, tyDistinct, tyAlias, tyOwned, tyRange:
+    result = typeToIr(c, g, t.skipModifier)
+  of tyEnum:
+    if firstOrd(c.conf, t) < 0:
+      result = Int32Id
+    else:
+      case int(getSize(c.conf, t))
+      of 1: result = UInt8Id
+      of 2: result = UInt16Id
+      of 4: result = Int32Id
+      of 8: result = Int64Id
+      else: result = Int32Id
+  of tyOrdinal, tyGenericBody, tyGenericParam, tyInferred, tyStatic:
+    if t.len > 0:
+      result = typeToIr(c, g, t.skipModifier)
+    else:
+      result = TypeId(-1)
+  of tyFromExpr:
+    if t.n != nil and t.n.typ != nil:
+      result = typeToIr(c, g, t.n.typ)
+    else:
+      result = TypeId(-1)
+  of tyArray:
+    cached(c, t):
+      var n = toInt64(lengthOrd(c.conf, t))
+      if n <= 0: n = 1   # make an array of at least one element
+      let elemType = typeToIr(c, g, t.elementType)
+      let a = openType(g, ArrayTy)
+      g.addType(elemType)
+      g.addArrayLen n
+      g.addName mangle(c, t)
+      result = finishType(g, a)
+  of tyPtr, tyRef:
+    cached(c, t):
+      let e = t.elementType
+      if e.kind == tyUncheckedArray:
+        let elemType = typeToIr(c, g, e.elementType)
+        let a = openType(g, AArrayPtrTy)
+        g.addType(elemType)
+        result = finishType(g, a)
+      else:
+        let elemType = typeToIr(c, g, t.elementType)
+        let a = openType(g, APtrTy)
+        g.addType(elemType)
+        result = finishType(g, a)
+  of tyVar, tyLent:
+    cached(c, t):
+      let e = t.elementType
+      if e.skipTypes(abstractInst).kind in {tyOpenArray, tyVarargs}:
+        # skip the modifier, `var openArray` is a (ptr, len) pair too:
+        result = typeToIr(c, g, e)
+      else:
+        let elemType = typeToIr(c, g, e)
+        let a = openType(g, APtrTy)
+        g.addType(elemType)
+        result = finishType(g, a)
+  of tySet:
+    let s = int(getSize(c.conf, t))
+    case s
+    of 1: result = UInt8Id
+    of 2: result = UInt16Id
+    of 4: result = UInt32Id
+    of 8: result = UInt64Id
+    else:
+      # array[U8, s]
+      cached(c, t):
+        let a = openType(g, ArrayTy)
+        g.addType(UInt8Id)
+        g.addArrayLen s
+        g.addName mangle(c, t)
+        result = finishType(g, a)
+  of tyPointer, tyNil:
+    # tyNil can happen for code like: `const CRAP = nil` which we have in posix.nim
+    let a = openType(g, APtrTy)
+    g.addBuiltinType(VoidId)
+    result = finishType(g, a)
+  of tyObject:
+    # Objects are special as they can be recursive in Nim. This is easily solvable.
+    # We check if we are already "processing" t. If so, we produce `ObjectTy`
+    # instead of `ObjectDecl`.
+    cached(c, t):
+      if not c.recursionCheck.containsOrIncl(t.itemId):
+        result = objectToIr(c, g, t)
+      else:
+        result = objectHeaderToIr(c, g, t)
+  of tyTuple:
+    cachedByName(c, t):
+      result = tupleToIr(c, g, t)
+  of tyProc:
+    cached(c, t):
+      if t.callConv == ccClosure:
+        result = closureToIr(c, g, t)
+      else:
+        result = procToIr(c, g, t)
+  of tyVarargs, tyOpenArray:
+    cached(c, t):
+      result = openArrayToIr(c, g, t)
+  of tyString:
+    if c.stringType.int < 0:
+      result = stringToIr(c, g)
+      c.stringType = result
+    else:
+      result = c.stringType
+  of tySequence:
+    cachedByName(c, t):
+      result = seqToIr(c, g, t)
+  of tyCstring:
+    cached(c, t):
+      let a = openType(g, AArrayPtrTy)
+      g.addBuiltinType Char8Id
+      result = finishType(g, a)
+  of tyUncheckedArray:
+    # We already handled the `ptr UncheckedArray` in a special way.
+    cached(c, t):
+      let elemType = typeToIr(c, g, t.elementType)
+      let a = openType(g, LastArrayTy)
+      g.addType(elemType)
+      result = finishType(g, a)
+  of tyUntyped, tyTyped:
+    # this avoids a special case for system.echo which is not a generic but
+    # uses `varargs[typed]`:
+    result = VoidId
+  of tyNone, tyEmpty, tyTypeDesc,
+     tyGenericInvocation, tyProxy, tyBuiltInTypeClass,
+     tyUserTypeClass, tyUserTypeClassInst, tyCompositeTypeClass,
+     tyAnd, tyOr, tyNot, tyAnything, tyConcept, tyIterable, tyForward:
+    result = TypeId(-1)

compiler/options.nim

@@ -139,6 +139,7 @@ type
     backendCpp = "cpp"
     backendJs = "js"
     backendObjc = "objc"
+    backendNir = "nir"
     # backendNimscript = "nimscript" # this could actually work
     # backendLlvm = "llvm" # probably not well supported; was cmdCompileToLLVM
 
@@ -146,6 +147,7 @@ type
     cmdNone # not yet processed command
     cmdUnknown # command unmapped
     cmdCompileToC, cmdCompileToCpp, cmdCompileToOC, cmdCompileToJS,
+    cmdCompileToNir,
     cmdCrun # compile and run in nimache
     cmdTcc # run the project via TCC backend
     cmdCheck # semantic checking for whole project
@@ -174,7 +176,7 @@ type
 
 const
   cmdBackends* = {cmdCompileToC, cmdCompileToCpp, cmdCompileToOC,
-                  cmdCompileToJS, cmdCrun}
+                  cmdCompileToJS, cmdCrun, cmdCompileToNir}
   cmdDocLike* = {cmdDoc0, cmdDoc, cmdDoc2tex, cmdJsondoc0, cmdJsondoc,
                  cmdCtags, cmdBuildindex}
 
@@ -252,7 +254,7 @@ type
 
   TSystemCC* = enum
     ccNone, ccGcc, ccNintendoSwitch, ccLLVM_Gcc, ccCLang, ccBcc, ccVcc,
-    ccTcc, ccEnv, ccIcl, ccIcc, ccClangCl, ccHipcc, ccNvcc
+    ccTcc, ccEnv, ccIcl, ccIcc, ccClangCl
 
   ExceptionSystem* = enum
     excNone,   # no exception system selected yet

compiler/pipelines.nim

@@ -13,6 +13,7 @@ when not defined(leanCompiler):
 import std/[syncio, objectdollar, assertions, tables, strutils, strtabs]
 import renderer
 import ic/replayer
+import nir/nir
 
 proc setPipeLinePass*(graph: ModuleGraph; pass: PipelinePass) =
   graph.pipelinePass = pass
@@ -44,6 +45,10 @@ proc processPipeline(graph: ModuleGraph; semNode: PNode; bModule: PPassContext):
       result = nil
   of EvalPass, InterpreterPass:
     result = interpreterCode(bModule, semNode)
+  of NirReplPass:
+    result = runCode(bModule, semNode)
+  of NirPass:
+    result = nirBackend(bModule, semNode)
   of NonePass:
     raiseAssert "use setPipeLinePass to set a proper PipelinePass"
 
@@ -106,6 +111,8 @@ proc processPipelineModule*(graph: ModuleGraph; module: PSym; idgen: IdGenerator
     case graph.pipelinePass
     of CgenPass:
       setupCgen(graph, module, idgen)
+    of NirPass:
+      openNirBackend(graph, module, idgen)
     of JSgenPass:
       when not defined(leanCompiler):
         setupJSgen(graph, module, idgen)
@@ -113,6 +120,8 @@ proc processPipelineModule*(graph: ModuleGraph; module: PSym; idgen: IdGenerator
         nil
     of EvalPass, InterpreterPass:
       setupEvalGen(graph, module, idgen)
+    of NirReplPass:
+      setupNirReplGen(graph, module, idgen)
     of GenDependPass:
       setupDependPass(graph, module, idgen)
     of Docgen2Pass:
@@ -200,6 +209,10 @@ proc processPipelineModule*(graph: ModuleGraph; module: PSym; idgen: IdGenerator
       discard finalJSCodeGen(graph, bModule, finalNode)
   of EvalPass, InterpreterPass:
     discard interpreterCode(bModule, finalNode)
+  of NirReplPass:
+    discard runCode(bModule, finalNode)
+  of NirPass:
+    closeNirBackend(bModule, finalNode)
   of SemPass, GenDependPass:
     discard
   of Docgen2Pass, Docgen2TexPass:

compiler/pragmas.nim

@@ -81,7 +81,7 @@ const
     wRequiresInit, wNoalias, wAlign, wNoInit} - {wExportNims, wNodecl} # why exclude these?
   varPragmas* = declPragmas + {wVolatile, wRegister, wThreadVar,
     wMagic, wHeader, wCompilerProc, wCore, wDynlib,
-    wNoInit, wCompileTime, wGlobal, wLiftLocals,
+    wNoInit, wCompileTime, wGlobal,
     wGensym, wInject, wCodegenDecl,
     wGuard, wGoto, wCursor, wNoalias, wAlign}
   constPragmas* = declPragmas + {wHeader, wMagic,
@@ -882,7 +882,6 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
 
     # number of pragmas increase/decrease with user pragma expansion
     inc c.instCounter
-    defer: dec c.instCounter
     if c.instCounter > 100:
       globalError(c.config, it.info, "recursive dependency: " & userPragma.name.s)
 
@@ -892,6 +891,7 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
     pragma(c, sym, userPragma.ast, validPragmas, isStatement)
     n.sons[i..i] = userPragma.ast.sons # expand user pragma with its content
     i.inc(userPragma.ast.len - 1) # inc by -1 is ok, user pragmas was empty
+    dec c.instCounter
   else:
     let k = whichKeyword(ident)
     if k in validPragmas:
@@ -1036,7 +1036,7 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
         incl(sym.flags, sfGeneratedOp)
       of wNosinks:
         noVal(c, it)
-        incl(sym.flags, sfNosinks)
+        incl(sym.flags, sfWasForwarded)
       of wDynlib:
         processDynLib(c, it, sym)
       of wCompilerProc, wCore:
@@ -1308,8 +1308,7 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
         noVal(c, it)
         if sym == nil: invalidPragma(c, it)
         else: sym.flags.incl sfUsed
-      of wLiftLocals:
-        sym.flags.incl(sfForceLift)
+      of wLiftLocals: discard
       of wRequires, wInvariant, wAssume, wAssert:
         pragmaProposition(c, it)
       of wEnsures:

compiler/semdata.nim

@@ -331,7 +331,7 @@ proc newContext*(graph: ModuleGraph; module: PSym): PContext =
     graph.packed[id].module = module
     initEncoder graph, module
 
-template packedRepr*(c): untyped = c.graph.packed[c.module.position].fromDisk
+template packedRepr*(c): untyped = c.graph.packed[c.module.position].toDisk
 template encoder*(c): untyped = c.graph.encoders[c.module.position]
 
 proc addIncludeFileDep*(c: PContext; f: FileIndex) =

compiler/semexprs.nim

@@ -562,7 +562,7 @@ proc semIs(c: PContext, n: PNode, flags: TExprFlags): PNode =
   result = isOpImpl(c, n, flags)
 
 proc semOpAux(c: PContext, n: PNode) =
-  const flags = {efDetermineType, efAllowSymChoice}
+  const flags = {efDetermineType}
   for i in 1..<n.len:
     var a = n[i]
     if a.kind == nkExprEqExpr and a.len == 2:

compiler/semfold.nim

@@ -701,7 +701,10 @@ proc getConstExpr(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
     except DivByZeroDefect:
       localError(g.config, n.info, "division by zero")
   of nkAddr:
-    result = nil # don't fold paths containing nkAddr
+    var a = getConstExpr(m, n[0], idgen, g)
+    if a != nil:
+      result = n
+      n[0] = a
   of nkBracket, nkCurly:
     result = copyNode(n)
     for son in n.items:

compiler/seminst.nim

@@ -345,8 +345,7 @@ proc generateInstance(c: PContext, fn: PSym, pt: TypeMapping,
   # generates an instantiated proc
   if c.instCounter > 50:
     globalError(c.config, info, "generic instantiation too nested")
-  inc c.instCounter
-  defer: dec c.instCounter
+  inc(c.instCounter)
   # careful! we copy the whole AST including the possibly nil body!
   var n = copyTree(fn.ast)
   # NOTE: for access of private fields within generics from a different module
@@ -440,6 +439,7 @@ proc generateInstance(c: PContext, fn: PSym, pt: TypeMapping,
   popOwner(c)
   c.currentScope = oldScope
   discard c.friendModules.pop()
+  dec(c.instCounter)
   c.matchedConcept = oldMatchedConcept
   if result.kind == skMethod: finishMethod(c, result)
 

compiler/semstmts.nim

@@ -283,7 +283,6 @@ proc discardCheck(c: PContext, result: PNode, flags: TExprFlags) =
     if implicitlyDiscardable(result):
       var n = newNodeI(nkDiscardStmt, result.info, 1)
       n[0] = result
-      # notes that it doesn't transform nodes into discard statements
     elif result.typ.kind != tyError and c.config.cmd != cmdInteractive:
       if result.typ.kind == tyNone:
         localError(c.config, result.info, "expression has no type: " &
@@ -1775,13 +1774,8 @@ proc typeSectionFinalPass(c: PContext, n: PNode) =
               assignType(s.typ, t)
               s.typ.itemId = t.itemId     # same id
         var hasError = false
-        let baseType = s.typ.safeSkipTypes(abstractPtrs)
-        if baseType.kind in {tyObject, tyTuple} and not baseType.n.isNil and
-          (x.kind in {nkObjectTy, nkTupleTy} or
-           (x.kind in {nkRefTy, nkPtrTy} and x.len == 1 and
-           x[0].kind in {nkObjectTy, nkTupleTy})
-          ):
-          checkForMetaFields(c, baseType.n, hasError)
+        if s.typ.kind in {tyObject, tyTuple} and not s.typ.n.isNil:
+          checkForMetaFields(c, s.typ.n, hasError)
         if not hasError:
           checkConstructedType(c.config, s.info, s.typ)
 

compiler/sigmatch.nim

@@ -1260,14 +1260,13 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
     subtypeCheck()
   of tyArray:
     a = reduceToBase(a)
-    if a.kind == tyArray:
+    case a.kind
+    of tyArray:
       var fRange = f.indexType
       var aRange = a.indexType
       if fRange.kind in {tyGenericParam, tyAnything}:
         var prev = idTableGet(c.bindings, fRange)
         if prev == nil:
-          if typeRel(c, fRange, aRange) == isNone:
-            return isNone
           put(c, fRange, a.indexType)
           fRange = a
         else:
@@ -1280,6 +1279,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
         result = isGeneric
       else:
         result = typeRel(c, ff, aa, flags)
+
       if result < isGeneric:
         if nimEnableCovariance and
            trNoCovariance notin flags and
@@ -1290,8 +1290,6 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
           return isNone
 
       if fRange.rangeHasUnresolvedStatic:
-        if aRange.kind in {tyGenericParam} and aRange.reduceToBase() == aRange:
-          return
         return inferStaticsInRange(c, fRange, a)
       elif c.c.matchedConcept != nil and aRange.rangeHasUnresolvedStatic:
         return inferStaticsInRange(c, aRange, f)
@@ -1300,6 +1298,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
       else:
         if lengthOrd(c.c.config, fRange) != lengthOrd(c.c.config, aRange):
           result = isNone
+    else: discard
   of tyUncheckedArray:
     if a.kind == tyUncheckedArray:
       result = typeRel(c, elementType(f), elementType(a), flags)

compiler/sinkparameter_inference.nim

@@ -28,7 +28,7 @@ proc checkForSink*(config: ConfigRef; idgen: IdGenerator; owner: PSym; arg: PNod
         arg.sym.typ.kind notin {tyVar, tySink, tyOwned}:
       # Watch out: cannot do this inference for procs with forward
       # declarations.
-      if {sfWasForwarded, sfNosinks} * owner.flags == {}:
+      if sfWasForwarded notin owner.flags:
         let argType = arg.sym.typ
 
         let sinkType = newType(tySink, idgen, owner)
@@ -43,9 +43,9 @@ proc checkForSink*(config: ConfigRef; idgen: IdGenerator; owner: PSym; arg: PNod
         #message(config, arg.info, warnUser,
         #  ("turned '$1' to a sink parameter") % [$arg])
         #echo config $ arg.info, " turned into a sink parameter ", arg.sym.name.s
-      elif {sfWasForwarded, sfNosinks} * arg.sym.flags == {}:
+      elif sfWasForwarded notin arg.sym.flags:
         # we only report every potential 'sink' parameter only once:
-        incl arg.sym.flags, sfNosinks
+        incl arg.sym.flags, sfWasForwarded
         message(config, arg.info, hintPerformance,
           "could not turn '$1' to a sink parameter" % [arg.sym.name.s])
       #echo config $ arg.info, " candidate for a sink parameter here"

compiler/transf.nim

@@ -56,7 +56,6 @@ type
     contSyms, breakSyms: seq[PSym]  # to transform 'continue' and 'break'
     deferDetected, tooEarly: bool
     isIntroducingNewLocalVars: bool  # true if we are in `introducingNewLocalVars` (don't transform yields)
-    inAddr: bool
     flags: TransformFlags
     graph: ModuleGraph
     idgen: IdGenerator
@@ -98,7 +97,10 @@ proc newTemp(c: PTransf, typ: PType, info: TLineInfo): PNode =
   r.typ = typ #skipTypes(typ, {tyGenericInst, tyAlias, tySink})
   incl(r.flags, sfFromGeneric)
   let owner = getCurrOwner(c)
-  result = newSymNode(r)
+  if owner.isIterator and not c.tooEarly:
+    result = freshVarForClosureIter(c.graph, r, c.idgen, owner)
+  else:
+    result = newSymNode(r)
 
 proc transform(c: PTransf, n: PNode): PNode
 
@@ -174,10 +176,13 @@ proc transformSym(c: PTransf, n: PNode): PNode =
 
 proc freshVar(c: PTransf; v: PSym): PNode =
   let owner = getCurrOwner(c)
-  var newVar = copySym(v, c.idgen)
-  incl(newVar.flags, sfFromGeneric)
-  newVar.owner = owner
-  result = newSymNode(newVar)
+  if owner.isIterator and not c.tooEarly:
+    result = freshVarForClosureIter(c.graph, v, c.idgen, owner)
+  else:
+    var newVar = copySym(v, c.idgen)
+    incl(newVar.flags, sfFromGeneric)
+    newVar.owner = owner
+    result = newSymNode(newVar)
 
 proc transformVarSection(c: PTransf, v: PNode): PNode =
   result = newTransNode(v)
@@ -1057,10 +1062,7 @@ proc transform(c: PTransf, n: PNode): PNode =
   of nkHiddenAddr:
     result = transformAddrDeref(c, n, {nkHiddenDeref})
   of nkAddr:
-    let oldInAddr = c.inAddr
-    c.inAddr = true
     result = transformAddrDeref(c, n, {nkDerefExpr, nkHiddenDeref})
-    c.inAddr = oldInAddr
   of nkDerefExpr:
     result = transformAddrDeref(c, n, {nkAddr, nkHiddenAddr})
   of nkHiddenDeref:
@@ -1140,7 +1142,7 @@ proc transform(c: PTransf, n: PNode): PNode =
   let exprIsPointerCast = n.kind in {nkCast, nkConv, nkHiddenStdConv} and
                           n.typ != nil and
                           n.typ.kind == tyPointer
-  if not exprIsPointerCast and not c.inAddr:
+  if not exprIsPointerCast:
     var cnst = getConstExpr(c.module, result, c.idgen, c.graph)
     # we inline constants if they are not complex constants:
     if cnst != nil and not dontInlineConstant(n, cnst):

compiler/types.nim

@@ -115,7 +115,7 @@ proc isPureObject*(typ: PType): bool =
 proc isUnsigned*(t: PType): bool =
   t.skipTypes(abstractInst).kind in {tyChar, tyUInt..tyUInt64}
 
-proc getOrdValueAux*(n: PNode, err: var bool): Int128 =
+proc getOrdValue*(n: PNode; onError = high(Int128)): Int128 =
   var k = n.kind
   if n.typ != nil and n.typ.skipTypes(abstractInst).kind in {tyChar, tyUInt..tyUInt64}:
     k = nkUIntLit
@@ -131,22 +131,13 @@ proc getOrdValueAux*(n: PNode, err: var bool): Int128 =
     toInt128(n.intVal)
   of nkNilLit:
     int128.Zero
-  of nkHiddenStdConv:
-    getOrdValueAux(n[1], err)
+  of nkHiddenStdConv: getOrdValue(n[1], onError)
   else:
-    err = true
-    int128.Zero
-
-proc getOrdValue*(n: PNode): Int128 =
-  var err: bool = false
-  result = getOrdValueAux(n, err)
-  #assert err == false
-
-proc getOrdValue*(n: PNode, onError: Int128): Int128 =
-  var err = false
-  result = getOrdValueAux(n, err)
-  if err:
-    result = onError
+    # XXX: The idea behind the introduction of int128 was to finally
+    # have all calculations numerically far away from any
+    # overflows. This command just introduces such overflows and
+    # should therefore really be revisited.
+    onError
 
 proc getFloatValue*(n: PNode): BiggestFloat =
   case n.kind

compiler/vmgen.nim

@@ -1559,8 +1559,7 @@ proc checkCanEval(c: PCtx; n: PNode) =
     elif s.kind == skParam and s.typ.kind == tyTypeDesc: discard
     else: cannotEval(c, n)
   elif s.kind in {skProc, skFunc, skConverter, skMethod,
-                  skIterator} and sfWasForwarded in s.flags and
-                  s.originatingModule == c.module: # forbides recursive calls from the same module
+                  skIterator} and sfForward in s.flags:
     cannotEval(c, n)
 
 template needsAdditionalCopy(n): untyped =

doc/nimc.md

@@ -481,28 +481,6 @@ They are:
 5. nl_types. No headers for this.
 6. As mmap is not supported, the nimAllocPagesViaMalloc option has to be used.
 
-GPU Compilation
-===============
-
-Compiling for GPU computation can be achieved with `--cc:nvcc` for CUDA with nvcc, or with `--cc:hipcc` for AMD GPUs with HIP. Both compilers require building for C++ with `nim cpp`.
-
-Here's a very simple CUDA kernel example using emit, which can be compiled with `nim cpp --cc:nvcc --define:"useMalloc" hello_kernel.nim` assuming you have the CUDA toolkit installed.
-
-```nim
-{.emit: """
-__global__ void add(int a, int b) {
-  int c;
-  c = a + b;
-}
-""".}
-
-proc main() =
-  {.emit: """
-  add<<<1,1>>>(2,7);
-  """.}
-
-main()
-```
 
 DLL generation
 ==============

koch.nim

@@ -11,7 +11,7 @@
 
 const
   # examples of possible values for repos: Head, ea82b54
-  NimbleStableCommit = "3b119f6fa135429a704f9c60f0b8944906398eea" # master
+  NimbleStableCommit = "f8bd7b5fa6ea7a583b411b5959b06e6b5eb23667" # master
   AtlasStableCommit = "5faec3e9a33afe99a7d22377dd1b45a5391f5504"
   ChecksumsStableCommit = "025bcca3915a1b9f19878cea12ad68f9884648fc"
   SatStableCommit = "faf1617f44d7632ee9601ebc13887644925dcc01"

lib/core/macros.nim

@@ -277,7 +277,7 @@ when (NimMajor, NimMinor, NimPatch) >= (1, 3, 5) or defined(nimSymImplTransform)
     ## note that code transformations are implementation dependent and subject to change.
     ## See an example in `tests/macros/tmacros_various.nim`.
 
-proc owner*(sym: NimNode): NimNode {.magic: "SymOwner", noSideEffect, deprecated.}
+proc owner*(sym: NimNode): NimNode {.magic: "SymOwner", noSideEffect.}
   ## Accepts a node of kind `nnkSym` and returns its owner's symbol.
   ## The meaning of 'owner' depends on `sym`'s `NimSymKind` and declaration
   ## context. For top level declarations this is an `nskModule` symbol,

lib/pure/hashes.nim

@@ -518,19 +518,6 @@ proc hashFarm(s: openArray[byte]): uint64 {.inline.} =
   swap z, x
   len16 len16(v[0],w[0],mul) + shiftMix(y)*k0 + z, len16(v[1],w[1],mul) + x, mul
 
-template jsNoInt64: untyped =
-  when defined js:
-    when compiles(compileOption("jsbigint64")):
-      when not compileOption("jsbigint64"): true
-      else: false
-    else: false
-  else: false
-const sHash2 = (when defined(nimStringHash2) or jsNoInt64(): true else: false)
-
-template maybeFailJS_Number =
-  when jsNoInt64() and not defined(nimStringHash2):
-    {.error: "Must use `-d:nimStringHash2` when using `--jsbigint64:off`".}
-
 proc hash*(x: string): Hash =
   ## Efficient hashing of strings.
   ##
@@ -539,13 +526,13 @@ proc hash*(x: string): Hash =
   ## * `hashIgnoreCase <#hashIgnoreCase,string>`_
   runnableExamples:
     doAssert hash("abracadabra") != hash("AbracadabrA")
-  maybeFailJS_Number()
-  when not sHash2:
+
+  when defined nimPreviewHashFarm: # Default switched -> `not nimStringHash2`
     result = cast[Hash](hashFarm(toOpenArrayByte(x, 0, x.high)))
   else:
-    #when nimvm:
-    #  result = hashVmImpl(x, 0, high(x))
-    when true:
+    when nimvm:
+      result = hashVmImpl(x, 0, high(x))
+    else:
       result = murmurHash(toOpenArrayByte(x, 0, high(x)))
 
 proc hash*(x: cstring): Hash =
@@ -555,22 +542,21 @@ proc hash*(x: cstring): Hash =
     doAssert hash(cstring"AbracadabrA") == hash("AbracadabrA")
     doAssert hash(cstring"abracadabra") != hash(cstring"AbracadabrA")
 
-  maybeFailJS_Number()
-  when not sHash2:
+  when defined nimPreviewHashFarm: # Default switched -> `not nimStringHash2`
     when defined js:
       let xx = $x
       result = cast[Hash](hashFarm(toOpenArrayByte(xx, 0, xx.high)))
     else:
       result = cast[Hash](hashFarm(toOpenArrayByte(x, 0, x.high)))
   else:
-    #when nimvm:
-    #  result = hashVmImpl(x, 0, high(x))
-    when true:
+    when nimvm:
+      hashVmImpl(x, 0, high(x))
+    else:
       when not defined(js):
-        result = murmurHash(toOpenArrayByte(x, 0, x.high))
+        murmurHash(toOpenArrayByte(x, 0, x.high))
       else:
         let xx = $x
-        result = murmurHash(toOpenArrayByte(xx, 0, high(xx)))
+        murmurHash(toOpenArrayByte(xx, 0, high(xx)))
 
 proc hash*(sBuf: string, sPos, ePos: int): Hash =
   ## Efficient hashing of a string buffer, from starting
@@ -581,8 +567,7 @@ proc hash*(sBuf: string, sPos, ePos: int): Hash =
     var a = "abracadabra"
     doAssert hash(a, 0, 3) == hash(a, 7, 10)
 
-  maybeFailJS_Number()
-  when not sHash2:
+  when defined nimPreviewHashFarm: # Default switched -> `not nimStringHash2`
     result = cast[Hash](hashFarm(toOpenArrayByte(sBuf, sPos, ePos)))
   else:
     murmurHash(toOpenArrayByte(sBuf, sPos, ePos))
@@ -720,17 +705,17 @@ proc hash*[A](x: openArray[A]): Hash =
   ## Efficient hashing of arrays and sequences.
   ## There must be a `hash` proc defined for the element type `A`.
   when A is byte:
-    when not sHash2:
+    when defined nimPreviewHashFarm: # Default switched -> `not nimStringHash2`
       result = cast[Hash](hashFarm(x))
     else:
       result = murmurHash(x)
   elif A is char:
-    when not sHash2:
+    when defined nimPreviewHashFarm: # Default switched -> `not nimStringHash2`
       result = cast[Hash](hashFarm(toOpenArrayByte(x, 0, x.high)))
     else:
-      #when nimvm:
-      #  result = hashVmImplChar(x, 0, x.high)
-      when true:
+      when nimvm:
+        result = hashVmImplChar(x, 0, x.high)
+      else:
         result = murmurHash(toOpenArrayByte(x, 0, x.high))
   else:
     result = 0
@@ -747,23 +732,22 @@ proc hash*[A](aBuf: openArray[A], sPos, ePos: int): Hash =
   runnableExamples:
     let a = [1, 2, 5, 1, 2, 6]
     doAssert hash(a, 0, 1) == hash(a, 3, 4)
+
   when A is byte:
-    maybeFailJS_Number()
-    when not sHash2:
+    when defined nimPreviewHashFarm: # Default switched -> `not nimStringHash2`
       result = cast[Hash](hashFarm(toOpenArray(aBuf, sPos, ePos)))
     else:
-      #when nimvm:
-      #  result = hashVmImplByte(aBuf, sPos, ePos)
-      when true:
+      when nimvm:
+        result = hashVmImplByte(aBuf, sPos, ePos)
+      else:
         result = murmurHash(toOpenArray(aBuf, sPos, ePos))
   elif A is char:
-    maybeFailJS_Number()
-    when not sHash2:
+    when defined nimPreviewHashFarm: # Default switched -> `not nimStringHash2`
       result = cast[Hash](hashFarm(toOpenArrayByte(aBuf, sPos, ePos)))
     else:
-      #when nimvm:
-      #  result = hashVmImplChar(aBuf, sPos, ePos)
-      when true:
+      when nimvm:
+        result = hashVmImplChar(aBuf, sPos, ePos)
+      else:
         result = murmurHash(toOpenArrayByte(aBuf, sPos, ePos))
   else:
     for i in sPos .. ePos:

lib/pure/lexbase.nim

@@ -104,9 +104,9 @@ proc fillBaseLexer(L: var BaseLexer, pos: int): int =
     result = 0
 
 proc handleCR*(L: var BaseLexer, pos: int): int =
-  ## Call this if you scanned over `'\c'` in the buffer; it returns the
+  ## Call this if you scanned over '\c' in the buffer; it returns the
   ## position to continue the scanning from. `pos` must be the position
-  ## of the `'\c'`.
+  ## of the '\c'.
   assert(L.buf[pos] == '\c')
   inc(L.lineNumber)
   result = fillBaseLexer(L, pos)
@@ -115,9 +115,9 @@ proc handleCR*(L: var BaseLexer, pos: int): int =
   L.lineStart = result
 
 proc handleLF*(L: var BaseLexer, pos: int): int =
-  ## Call this if you scanned over `'\L'` in the buffer; it returns the
+  ## Call this if you scanned over '\L' in the buffer; it returns the
   ## position to continue the scanning from. `pos` must be the position
-  ## of the `'\L'`.
+  ## of the '\L'.
   assert(L.buf[pos] == '\L')
   inc(L.lineNumber)
   result = fillBaseLexer(L, pos) #L.lastNL := result-1; // BUGFIX: was: result;

lib/pure/math.nim

@@ -58,7 +58,6 @@ import std/private/since
                        # of the standard library!
 
 import std/[bitops, fenv]
-import system/countbits_impl
 
 when defined(nimPreviewSlimSystem):
   import std/assertions
@@ -1230,42 +1229,40 @@ func gcd*[T](x, y: T): T =
     swap x, y
   abs x
 
-when useBuiltins:
-  ## this func uses bitwise comparisons from C compilers, which are not always available.
-  func gcd*(x, y: SomeInteger): SomeInteger =
-    ## Computes the greatest common (positive) divisor of `x` and `y`,
-    ## using the binary GCD (aka Stein's) algorithm.
-    ##
-    ## **See also:**
-    ## * `gcd func <#gcd,T,T>`_ for a float version
-    ## * `lcm func <#lcm,T,T>`_
-    runnableExamples:
-      doAssert gcd(12, 8) == 4
-      doAssert gcd(17, 63) == 1
-  
-    when x is SomeSignedInt:
-      var x = abs(x)
-    else:
-      var x = x
-    when y is SomeSignedInt:
-      var y = abs(y)
-    else:
-      var y = y
-  
-    if x == 0:
-      return y
-    if y == 0:
-      return x
-  
-    let shift = countTrailingZeroBits(x or y)
-    y = y shr countTrailingZeroBits(y)
-    while x != 0:
-      x = x shr countTrailingZeroBits(x)
-      if y > x:
-        swap y, x
-      x -= y
-    y shl shift
-  
+func gcd*(x, y: SomeInteger): SomeInteger =
+  ## Computes the greatest common (positive) divisor of `x` and `y`,
+  ## using the binary GCD (aka Stein's) algorithm.
+  ##
+  ## **See also:**
+  ## * `gcd func <#gcd,T,T>`_ for a float version
+  ## * `lcm func <#lcm,T,T>`_
+  runnableExamples:
+    doAssert gcd(12, 8) == 4
+    doAssert gcd(17, 63) == 1
+
+  when x is SomeSignedInt:
+    var x = abs(x)
+  else:
+    var x = x
+  when y is SomeSignedInt:
+    var y = abs(y)
+  else:
+    var y = y
+
+  if x == 0:
+    return y
+  if y == 0:
+    return x
+
+  let shift = countTrailingZeroBits(x or y)
+  y = y shr countTrailingZeroBits(y)
+  while x != 0:
+    x = x shr countTrailingZeroBits(x)
+    if y > x:
+      swap y, x
+    x -= y
+  y shl shift
+
 func gcd*[T](x: openArray[T]): T {.since: (1, 1).} =
   ## Computes the greatest common (positive) divisor of the elements of `x`.
   ##

lib/pure/osproc.nim

@@ -1416,8 +1416,6 @@ elif not defined(useNimRtl):
           tmspec.tv_nsec = (timeout * 1_000_000)
 
         try:
-          if not running(p):
-            return exitStatusLikeShell(p.exitStatus)
           if clock_gettime(CLOCK_REALTIME, stspec) == -1:
             raiseOSError(osLastError())
           while true:

lib/pure/parseopt.nim

@@ -176,7 +176,6 @@
 
 include "system/inclrtl"
 
-import std/strutils
 import std/os
 
 type
@@ -250,20 +249,9 @@ proc initOptParser*(cmdline: seq[string], shortNoVal: set[char] = {},
       result.cmds[i] = cmdline[i]
   else:
     when declared(paramCount):
-      when defined(nimscript):
-        var ctr = 0
-        var firstNimsFound = false
-        for i in countup(0, paramCount()):
-          if firstNimsFound: 
-            result.cmds[ctr] = paramStr(i)
-            inc ctr, 1
-          if paramStr(i).endsWith(".nims") and not firstNimsFound:
-            firstNimsFound = true 
-            result.cmds = newSeq[string](paramCount()-i)
-      else:
-        result.cmds = newSeq[string](paramCount())
-        for i in countup(1, paramCount()):
-          result.cmds[i-1] = paramStr(i)
+      result.cmds = newSeq[string](paramCount())
+      for i in countup(1, paramCount()):
+        result.cmds[i-1] = paramStr(i)
     else:
       # we cannot provide this for NimRtl creation on Posix, because we can't
       # access the command line arguments then!

lib/pure/strmisc.nim

@@ -27,17 +27,20 @@ func expandTabs*(s: string, tabSize: int = 8): string =
     doAssert expandTabs("a\tb\n\txy\t", 3) == "a  b\n   xy "
 
   result = newStringOfCap(s.len + s.len shr 2)
+  var pos = 0
 
   template addSpaces(n) =
-    for _ in 1..n:
+    for j in 0 ..< n:
       result.add(' ')
-    pos += n
+      pos += 1
 
-  var pos = 0
-  let denominator = if tabSize > 0: tabSize else: 1
-  for c in s:
+  for i in 0 ..< len(s):
+    let c = s[i]
     if c == '\t':
-      let numSpaces = tabSize - pos mod denominator
+      let
+        denominator = if tabSize > 0: tabSize else: 1
+        numSpaces = tabSize - pos mod denominator
+
       addSpaces(numSpaces)
     else:
       result.add(c)

lib/pure/strutils.nim

@@ -1307,7 +1307,7 @@ func parseEnum*[T: enum](s: string): T =
   ## type contains multiple fields with the same string value.
   ##
   ## Raises `ValueError` for an invalid value in `s`. The comparison is
-  ## done in a style insensitive way (first letter is still case-sensitive).
+  ## done in a style insensitive way.
   runnableExamples:
     type
       MyEnum = enum
@@ -1327,7 +1327,7 @@ func parseEnum*[T: enum](s: string, default: T): T =
   ## type contains multiple fields with the same string value.
   ##
   ## Uses `default` for an invalid value in `s`. The comparison is done in a
-  ## style insensitive way (first letter is still case-sensitive).
+  ## style insensitive way.
   runnableExamples:
     type
       MyEnum = enum

lib/system.nim

@@ -2102,14 +2102,12 @@ when not defined(js):
     proc cstringArrayToSeq*(a: cstringArray, len: Natural): seq[string] =
       ## Converts a `cstringArray` to a `seq[string]`. `a` is supposed to be
       ## of length `len`.
-      if a == nil: return @[]
       newSeq(result, len)
       for i in 0..len-1: result[i] = $a[i]
 
     proc cstringArrayToSeq*(a: cstringArray): seq[string] =
       ## Converts a `cstringArray` to a `seq[string]`. `a` is supposed to be
       ## terminated by `nil`.
-      if a == nil: return @[]
       var L = 0
       while a[L] != nil: inc(L)
       result = cstringArrayToSeq(a, L)

lib/system/alloc.nim

@@ -789,13 +789,13 @@ when defined(gcDestructors):
     # Well, not for the entire list, but for `max` elements of the list because
     # we split the list in order to achieve bounded response times.
     var it = c.freeList
-    var total = 0
+    var x = 0
     while it != nil:
-      inc total, size
+      inc x, size
       let chunk = cast[PSmallChunk](pageAddr(it))
-      inc(chunk.free, size)
+      inc(chunk.free, x)
       it = it.next
-    dec(a.occ, total)
+    dec(a.occ, x)
 
   proc freeDeferredObjects(a: var MemRegion; root: PBigChunk) =
     var it = root
@@ -865,7 +865,7 @@ proc rawAlloc(a: var MemRegion, requestedSize: int): pointer =
         when not defined(gcDestructors):
           sysAssert(c.freeList.zeroField == 0, "rawAlloc 8")
         c.freeList = c.freeList.next
-      dec(cast[PSmallChunk](pageAddr(result)).free, size)
+      dec(c.free, size)
       sysAssert((cast[int](result) and (MemAlign-1)) == 0, "rawAlloc 9")
       sysAssert(allocInv(a), "rawAlloc: end c != nil")
     sysAssert(allocInv(a), "rawAlloc: before c.free < size")
@@ -904,7 +904,7 @@ proc rawAlloc(a: var MemRegion, requestedSize: int): pointer =
     trackSize(c.size)
   sysAssert(isAccessible(a, result), "rawAlloc 14")
   sysAssert(allocInv(a), "rawAlloc: end")
-  when logAlloc: cprintf("var pointer_%p = alloc(%ld) # %p\n", result, requestedSize, addr a)
+  when logAlloc: cprintf("var pointer_%p = alloc(%ld)\n", result, requestedSize)
 
 proc rawAlloc0(a: var MemRegion, requestedSize: int): pointer =
   result = rawAlloc(a, requestedSize)
@@ -948,13 +948,11 @@ proc rawDealloc(a: var MemRegion, p: pointer) =
         inc(c.free, s)
       else:
         inc(c.free, s)
-        if c.free == SmallChunkSize-smallChunkOverhead() and a.freeSmallChunks[s div MemAlign] == c:
+        if c.free == SmallChunkSize-smallChunkOverhead():
           listRemove(a.freeSmallChunks[s div MemAlign], c)
           c.size = SmallChunkSize
           freeBigChunk(a, cast[PBigChunk](c))
     else:
-      when logAlloc: cprintf("dealloc(pointer_%p) # SMALL FROM %p CALLER %p\n", p, c.owner, addr(a))
-
       when defined(gcDestructors):
         addToSharedFreeList(c, f, s div MemAlign)
     sysAssert(((cast[int](p) and PageMask) - smallChunkOverhead()) %%
@@ -962,7 +960,6 @@ proc rawDealloc(a: var MemRegion, p: pointer) =
   else:
     # set to 0xff to check for usage after free bugs:
     when overwriteFree: nimSetMem(p, -1'i32, c.size -% bigChunkOverhead())
-    when logAlloc: cprintf("dealloc(pointer_%p) # BIG %p\n", p, c.owner)
     when defined(gcDestructors):
       if c.owner == addr(a):
         deallocBigChunk(a, cast[PBigChunk](c))
@@ -970,9 +967,8 @@ proc rawDealloc(a: var MemRegion, p: pointer) =
         addToSharedFreeListBigChunks(c.owner[], cast[PBigChunk](c))
     else:
       deallocBigChunk(a, cast[PBigChunk](c))
-
   sysAssert(allocInv(a), "rawDealloc: end")
-  #when logAlloc: cprintf("dealloc(pointer_%p)\n", p)
+  when logAlloc: cprintf("dealloc(pointer_%p)\n", p)
 
 when not defined(gcDestructors):
   proc isAllocatedPtr(a: MemRegion, p: pointer): bool =

lib/system/sysstr.nim

@@ -220,10 +220,7 @@ proc appendChar(dest: NimString, c: char) {.compilerproc, inline.} =
 proc setLengthStr(s: NimString, newLen: int): NimString {.compilerRtl.} =
   let n = max(newLen, 0)
   if s == nil:
-    if n == 0:
-      return s
-    else:
-      result = mnewString(n)
+    result = mnewString(n)
   elif n <= s.space:
     result = s
   else:
@@ -304,10 +301,7 @@ proc setLengthSeqV2(s: PGenericSeq, typ: PNimType, newLen: int): PGenericSeq {.
     compilerRtl.} =
   sysAssert typ.kind == tySequence, "setLengthSeqV2: type is not a seq"
   if s == nil:
-    if newLen == 0:
-      result = s
-    else:
-      result = cast[PGenericSeq](newSeq(typ, newLen))
+    result = cast[PGenericSeq](newSeq(typ, newLen))
   else:
     let elemSize = typ.base.size
     let elemAlign = typ.base.align

tests/arc/topenarray.nim

@@ -68,19 +68,3 @@ block:
   doAssert foo(noBugConst) == expected
   let noBugSeq = @["0", "c", "a"]
   doAssert foo(noBugSeq) == expected
-
-block: # bug #20865
-  var p: pointer
-  var x: array[0, int]
-  # echo toOpenArray(x, 0, 1)[0] # Raises IndexDefect
-  doAssertRaises(IndexDefect):
-    echo toOpenArray(cast[ptr array[0, int]](p)[], 0, 1)[0] # Does not raise IndexDefect
-
-block: # bug #20987
-  var v: array[1, byte]
-
-  var p = cast[ptr array[0, byte]](addr v)
-
-  doAssertRaises(IndexDefect):
-    echo toOpenArray(p[], 1, 2)
-

tests/ccgbugs/t13062.nim

@@ -24,10 +24,7 @@ type
     fulfilled: Atomic[bool]
 
 var x: Pledge
-when defined(cpp):
-  # TODO: fixme
-  discard "it doesn't work for refc/orc because of contrived `Atomic` in cpp"
-elif defined(gcRefc):
+when defined(gcRefc):
   doAssert x.repr == "[p = nil]"
-else: # fixme # bug #20081
+elif not defined(cpp): # fixme # bug #20081
   doAssert x.repr == "Pledge(p: nil)"

tests/ccgbugs/t23796.nim

@@ -1,25 +0,0 @@
-discard """
-    targets: "c cpp"
-"""
-
-# bug #23796
-
-{.emit: """
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void fooArr(float data[3]) {}
-void fooIntArr(int id, float data[3]) {}
-
-#ifdef __cplusplus
-}
-#endif
-""".}
-
-proc fooArr(data: var array[3, cfloat]) {.importc.}
-proc fooIntArr(id: cint, data: var array[3, cfloat]) {.importc, nodecl.}
-
-var arr = [cfloat 1, 2, 3]
-fooArr(arr)
-fooIntArr(1, arr)

tests/ccgbugs/tcgbug.nim

@@ -4,7 +4,6 @@ success
 M1 M2
 ok
 '''
-matrix: "--mm:refc;--mm:orc"
 """
 
 type
@@ -134,30 +133,3 @@ proc foo = # bug #23280
   doAssert L mod 6 == 0 
 
 foo()
-
-block: # bug #9940
-  {.emit:"""/*TYPESECTION*/
-typedef struct { int base; } S;
-""".}
-
-  type S {.importc: "S", completeStruct.} = object
-    base: cint
-  proc init(x:ptr S) =
-    x.base = 1
-
-  type
-    Foo = object
-      a: seq[float]
-      b: seq[float]
-      c: seq[float]
-      d: seq[float]
-      s: S
-
-  proc newT(): Foo =
-    var t: Foo
-    t.s.addr.init
-    doAssert t.s.base == 1
-    t
-
-  var t = newT()
-  doAssert t.s.base == 1

tests/cpp/tcasts.nim

@@ -1,5 +1,6 @@
 discard """
   cmd: "nim cpp $file"
+  output: '''{"vas": "kas", "123": "123"}'''
   targets: "cpp"
 """
 
@@ -17,4 +18,4 @@ import tables
 var t = initTable[string, string]()
 discard t.hasKeyOrPut("123", "123")
 discard t.mgetOrPut("vas", "kas")
-doAssert t.len == 2
+echo t

tests/destructor/t23748.nim

@@ -1,31 +0,0 @@
-discard """
-  matrix: "--gc:refc; --gc:arc"
-  output: '''
-hello 42
-hello 42
-len = 2
-'''
-"""
-
-# bug #23748
-
-type
-  O = ref object
-    s: string
-    cb: seq[proc()]
-
-proc push1(o: O, i: int) =
-  let o = o
-  echo o.s, " ", i
-  o.cb.add(proc() = echo o.s, " ", i)
-
-proc push2(o: O, i: int) =
-  let o = o
-  echo o.s, " ", i
-  proc p() = echo o.s, " ", i
-  o.cb.add(p)
-
-let o = O(s: "hello", cb: @[])
-o.push1(42)
-o.push2(42)
-echo "len = ", o.cb.len

tests/destructor/tuse_ownedref_after_move.nim

@@ -1,6 +1,6 @@
 discard """
   cmd: '''nim c --newruntime $file'''
-  errormsg: "'=copy' is not available for type <owned Button>; requires a copy because it's not the last read of ':envAlt.b0'; routine: main"
+  errormsg: "'=copy' is not available for type <owned Button>; requires a copy because it's not the last read of ':envAlt.b1'; routine: main"
   line: 48
 """
 

tests/discard/tdiscardable.nim

@@ -140,27 +140,3 @@ block: # issue #14665
         continue
       inc i
   test()
-
-block: # bug #23775
-  proc retInt(): int {.discardable.} =
-    42
-
-  proc retString(): string {.discardable.} =
-    "text"
-
-  type
-    Enum = enum
-      A, B, C, D
-
-  proc doStuff(msg: Enum) =
-    case msg:
-    of A:
-      retString()
-    of B:
-      retInt()
-    of C:
-      discard retString()
-    else:
-      let _ = retString()
-
-  doStuff(C)

tests/errmsgs/tmetaobjectfields.nim

@@ -2,18 +2,16 @@ discard """
   cmd: "nim check --hints:off $file"
   action: "reject"
   nimout: '''
-tmetaobjectfields.nim(26, 5) Error: 'array' is not a concrete type
-tmetaobjectfields.nim(30, 5) Error: 'seq' is not a concrete type
-tmetaobjectfields.nim(34, 5) Error: 'set' is not a concrete type
-tmetaobjectfields.nim(37, 3) Error: 'sink' is not a concrete type
-tmetaobjectfields.nim(39, 3) Error: 'lent' is not a concrete type
-tmetaobjectfields.nim(56, 16) Error: 'seq' is not a concrete type
-tmetaobjectfields.nim(60, 5) Error: 'ptr' is not a concrete type
-tmetaobjectfields.nim(61, 5) Error: 'ref' is not a concrete type
-tmetaobjectfields.nim(62, 5) Error: 'auto' is not a concrete type
-tmetaobjectfields.nim(63, 5) Error: 'UncheckedArray' is not a concrete type
-tmetaobjectfields.nim(68, 5) Error: 'object' is not a concrete type
-tmetaobjectfields.nim(72, 5) Error: 'Type3011:ObjectType' is not a concrete type
+tmetaobjectfields.nim(24, 5) Error: 'array' is not a concrete type
+tmetaobjectfields.nim(28, 5) Error: 'seq' is not a concrete type
+tmetaobjectfields.nim(32, 5) Error: 'set' is not a concrete type
+tmetaobjectfields.nim(35, 3) Error: 'sink' is not a concrete type
+tmetaobjectfields.nim(37, 3) Error: 'lent' is not a concrete type
+tmetaobjectfields.nim(54, 16) Error: 'seq' is not a concrete type
+tmetaobjectfields.nim(58, 5) Error: 'ptr' is not a concrete type
+tmetaobjectfields.nim(59, 5) Error: 'ref' is not a concrete type
+tmetaobjectfields.nim(60, 5) Error: 'auto' is not a concrete type
+tmetaobjectfields.nim(61, 5) Error: 'UncheckedArray' is not a concrete type
 '''
 """
 
@@ -61,15 +59,3 @@ type
     b: ref
     c: auto
     d: UncheckedArray
-
-# bug #3011
-type
-  Type3011 = ref object 
-    context: ref object
-
-type
-  Value3011 = ref object
-    typ: Type3011
-
-proc x3011(): Value3011 =
-  nil

tests/generics/t23790.nim

@@ -1,14 +0,0 @@
-# bug #23790
-
-discard compiles($default(seq[seq[ref int]]))
-discard compiles($default(seq[seq[ref uint]]))
-discard compiles($default(seq[seq[ref int8]]))
-discard compiles($default(seq[seq[ref uint8]]))
-discard compiles($default(seq[seq[ref int16]]))
-discard compiles($default(seq[seq[ref uint16]]))
-discard compiles($default(seq[seq[ref int32]]))
-discard compiles($default(seq[seq[ref uint32]]))
-discard compiles($default(seq[seq[ref int64]]))
-discard compiles($default(seq[seq[ref uint64]]))
-proc s(_: int | string) = discard
-s(0)

tests/generics/twrong_generic_object.nim

@@ -1,6 +1,6 @@
 discard """
-  errormsg: "'Node' is not a concrete type"
-  line: 11
+  errormsg: "cannot instantiate: 'GenericNodeObj[T]'; Maybe generic arguments are missing?"
+  line: 21
 """
 # bug #2509
 type

tests/int/tints.nim

@@ -1,5 +1,5 @@
 discard """
-  matrix: "; --backend:js --jsbigint64:off -d:nimStringHash2; --backend:js --jsbigint64:on"
+  matrix: "; --backend:js --jsbigint64:off; --backend:js --jsbigint64:on"
   output: '''
 0 0
 0 0

tests/iter/tyieldintry.nim

@@ -504,26 +504,3 @@ block: # void iterator
     except:
       discard
   var a = it
-
-block: # Locals present in only 1 state should be on the stack
-  proc checkOnStack(a: pointer, shouldBeOnStack: bool) =
-    # Quick and dirty way to check if a points to stack
-    var dummy = 0
-    let dummyAddr = addr dummy
-    let distance = abs(cast[int](dummyAddr) - cast[int](a))
-    const requiredDistance = 300
-    if shouldBeOnStack:
-      doAssert(distance <= requiredDistance, "a is not on stack, but should")
-    else:
-      doAssert(distance > requiredDistance, "a is on stack, but should not")
-
-  iterator it(): int {.closure.} =
-    var a = 1
-    var b = 2
-    var c {.liftLocals.} = 3
-    checkOnStack(addr a, true)
-    checkOnStack(addr b, false)
-    checkOnStack(addr c, false)
-    yield a
-    yield b
-  test(it, 1, 2)

tests/js/ttypedarray.nim

@@ -1,5 +1,5 @@
 discard """
-  matrix: "--jsbigint64:off -d:nimStringHash2; --jsbigint64:on"
+  matrix: "--jsbigint64:off; --jsbigint64:on"
 """
 
 import std/private/jsutils

tests/lookups/t23749.nim

@@ -1,37 +0,0 @@
-discard """
-  action: compile
-"""
-
-{.pragma: callback, gcsafe, raises: [].}
-
-type
-  DataProc* = proc(val: openArray[byte]) {.callback.}
-  GetProc = proc (db: RootRef, key: openArray[byte], onData: DataProc): bool {.nimcall, callback.}
-  KvStoreRef* = ref object
-    obj: RootRef
-    getProc: GetProc
-
-template get(dbParam: KvStoreRef, key: openArray[byte], onData: untyped): bool =
-  let db = dbParam
-  db.getProc(db.obj, key, onData)
-
-func decode(input: openArray[byte], maxSize = 128): seq[byte] =
-  @[]
-
-proc getSnappySSZ(db: KvStoreRef, key: openArray[byte]): string =
-  var status = "not found"
-  proc decode(data: openArray[byte]) =
-    status =
-      if true: "found"
-      else: "corrupted"
-  discard db.get(key, decode)
-  status
-
-
-var ksr: KvStoreRef
-var k = [byte(1), 2, 3, 4, 5]
-
-proc foo(): string =
-  getSnappySSZ(ksr, toOpenArray(k, 1, 3))
-
-echo foo()

tests/macros/t23784.nim

@@ -1,157 +0,0 @@
-discard """
-  joinable: false
-"""
-
-
-# debug ICE: genCheckedRecordField
-# apparently after https://github.com/nim-lang/Nim/pull/23477
-
-# bug #23784
-
-import std/bitops, std/macros
-
-# --------------------------------------------------------------
-
-type Algebra = enum
-  BN254_Snarks
-
-type SecretWord* = distinct uint64
-const WordBitWidth* = sizeof(SecretWord) * 8
-
-func wordsRequired*(bits: int): int {.inline.} =
-  const divShiftor = fastLog2(WordBitWidth)
-  result = (bits + WordBitWidth - 1) shr divShiftor
-
-type
-  BigInt*[bits: static int] = object
-    limbs*: array[bits.wordsRequired, SecretWord]  # <--- crash points to here
-
-# --------------------------------------------------------------
-
-const CurveBitWidth = [
-  BN254_Snarks: 254
-]
-
-const BN254_Snarks_Modulus = BigInt[254](limbs: [SecretWord 0x1, SecretWord 0x2, SecretWord 0x3, SecretWord 0x4])
-const BN254_Snarks_Order = BigInt[254](limbs: [SecretWord 0x1, SecretWord 0x1, SecretWord 0x2, SecretWord 0x2])
-
-func montyOne*(M: BigInt[254]): BigInt[254] =
-  ## Returns "1 (mod M)" in the Montgomery domain.
-  ## This is equivalent to R (mod M) in the natural domain
-  BigInt[254](limbs: [SecretWord 0x1, SecretWord 0x1, SecretWord 0x1, SecretWord 0x1])
-
-
-{.experimental: "dynamicBindSym".}
-
-type
-  DerivedConstantMode* = enum
-    kModulus
-    kOrder
-
-macro genDerivedConstants*(mode: static DerivedConstantMode): untyped =
-  ## Generate constants derived from the main constants
-  ##
-  ## For example
-  ## - the Montgomery magic constant "R^2 mod N" in ROM
-  ##   For each curve under the private symbol "MyCurve_R2modP"
-  ## - the Montgomery magic constant -1/P mod 2^Wordbitwidth
-  ##   For each curve under the private symbol "MyCurve_NegInvModWord
-  ## - ...
-
-  # Now typedesc are NimNode and there is no way to translate
-  # NimNode -> typedesc easily so we can't
-  # "for curve in low(Curve) .. high(Curve):"
-  # As an ugly workaround, we count
-  # The item at position 0 is a pragma
-  result = newStmtList()
-
-  template used(name: string): NimNode =
-    nnkPragmaExpr.newTree(
-      ident(name),
-      nnkPragma.newTree(ident"used")
-    )
-
-  let ff = if mode == kModulus: "_Fp" else: "_Fr"
-
-  for curveSym in low(Algebra) .. high(Algebra):
-    let curve = $curveSym
-    let M = if mode == kModulus: bindSym(curve & "_Modulus")
-            else: bindSym(curve & "_Order")
-
-    # const MyCurve_montyOne = montyOne(MyCurve_Modulus)
-    result.add newConstStmt(
-      used(curve & ff & "_MontyOne"), newCall(
-        bindSym"montyOne",
-        M
-      )
-    )
-
-# --------------------------------------------------------------
-
-{.experimental: "dynamicBindSym".}
-
-genDerivedConstants(kModulus)
-genDerivedConstants(kOrder)
-
-proc bindConstant(ff: NimNode, property: string): NimNode =
-  # Need to workaround https://github.com/nim-lang/Nim/issues/14021
-  # which prevents checking if a type FF[Name] = Fp[Name] or Fr[Name]
-  # was instantiated with Fp or Fr.
-  # getTypeInst only returns FF and sameType doesn't work.
-  # so quote do + when checks.
-  let T = getTypeInst(ff)
-  T.expectKind(nnkBracketExpr)
-  doAssert T[0].eqIdent("typedesc")
-
-  let curve =
-    if T[1].kind == nnkBracketExpr: # typedesc[Fp[BLS12_381]] as used internally
-      # doAssert T[1][0].eqIdent"Fp" or T[1][0].eqIdent"Fr", "Found ident: '" & $T[1][0] & "' instead of 'Fp' or 'Fr'"
-      T[1][1].expectKind(nnkIntLit) # static enum are ints in the VM
-      $Algebra(T[1][1].intVal)
-    else: # typedesc[bls12381_fp] alias as used for C exports
-      let T1 = getTypeInst(T[1].getImpl()[2])
-      if T1.kind != nnkBracketExpr or
-         T1[1].kind != nnkIntLit:
-        echo T.repr()
-        echo T1.repr()
-        echo getTypeInst(T1).treerepr()
-        error "getTypeInst didn't return the full instantiation." &
-          " Dealing with types in macros is hard, complain at https://github.com/nim-lang/RFCs/issues/44"
-      $Algebra(T1[1].intVal)
-
-  let curve_fp = bindSym(curve & "_Fp_" & property)
-  let curve_fr = bindSym(curve & "_Fr_" & property)
-  result = quote do:
-    when `ff` is Fp:
-      `curve_fp`
-    elif `ff` is Fr:
-      `curve_fr`
-    else:
-      {.error: "Unreachable, received type: " & $`ff`.}
-
-# --------------------------------------------------------------
-
-template matchingBigInt*(Name: static Algebra): untyped =
-  ## BigInt type necessary to store the prime field Fp
-  # Workaround: https://github.com/nim-lang/Nim/issues/16774
-  # as we cannot do array accesses in type section.
-  # Due to generic sandwiches, it must be exported.
-  BigInt[CurveBitWidth[Name]]
-
-type
-  Fp*[Name: static Algebra] = object
-    mres*: matchingBigInt(Name)
-
-macro getMontyOne*(ff: type Fp): untyped =
-  ## Get one in Montgomery representation (i.e. R mod P)
-  result = bindConstant(ff, "MontyOne")
-
-func getOne*(T: type Fp): T {.noInit, inline.} =
-  result = cast[ptr T](unsafeAddr getMontyOne(T))[]
-
-# --------------------------------------------------------------
-proc foo(T: Fp) =
-  discard T
-
-let a = Fp[BN254_Snarks].getOne()
-foo(a) # oops this was a leftover that broke the bisect.

tests/osproc/twaitforexit.nim

@@ -1,18 +0,0 @@
-import std/[osproc, os, times]
-
-block: # bug #5091
-    when defined(linux):
-        const filename = "false"
-        var p = startProcess(filename, options = {poStdErrToStdOut, poUsePath})
-        os.sleep(1000) # make sure process has exited already
-
-        let atStart = getTime()
-        const msWait = 2000
-
-        try:
-            discard waitForExit(p, msWait)
-        except OSError:
-            discard
-
-        # check that we don't have to wait msWait milliseconds
-        doAssert(getTime() <  atStart + milliseconds(msWait))

tests/overload/t23755.nim

@@ -1,62 +0,0 @@
-type
-  BigInt[bits: static int] = object
-    limbs: array[8, uint64]
-
-block:
-  proc view[N](a: array[N, uint64]) =
-    discard
-
-  proc view[N](a: var array[N, uint64]) =
-    discard
-
-  var r: BigInt[64]
-  r.limbs.view()
-
-
-type Limbs[N: static int] = array[N, uint64]
-
-block:
-  proc view(a: Limbs) =
-    discard
-
-  proc view(a: var Limbs) =
-    discard
-
-  var r: BigInt[64]
-  r.limbs.view()
-
-
-block:
-  type IntArray[N: static[int]] = array[N, int]
-
-  proc p[T](a: IntArray[T]): bool= true
-  proc p(a: IntArray[5]): bool= false
-
-  var s: IntArray[5]
-  doAssert s.p == false
-
-block:
-  type IntArray[N: static[int]] = array[N, int]
-
-  proc `$`(a: IntArray): string =
-    return "test"
-
-  var s: IntArray[5] = [1,1,1,1,1]
-  doAssert `$`(s) == "test"
-
-block: 
-  proc p[n:static[int]](a: array[n, char]):bool=true
-  proc p[T, IDX](a: array[IDX, T]):bool=false
-
-  var g: array[32, char]
-  doAssert p(g)
-
-block:  # issue #23823
-  func p[N,T](a, b: array[N,T]) =
-    discard
-
-  func p[N: static int; T](x, y: array[N, T]) =
-    discard
-
-  var a: array[5, int]
-  p(a,a)

tests/overload/t8829.nim

@@ -2,7 +2,7 @@ block:
   let txt = "Hello World"
 
   template `[]`[T](p: ptr T, span: Slice[int]): untyped =
-    toOpenArray(cast[ptr UncheckedArray[T]](p), span.a, span.b)
+    toOpenArray(cast[ptr array[0, T]](p)[], span.a, span.b)
 
   doAssert $cast[ptr uint8](txt[0].addr)[0 ..< txt.len] == 
                 "[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]"
@@ -12,7 +12,7 @@ block:
   let txt = "Hello World"
 
   template `[]`[T](p: ptr T, span: Slice[int]): untyped =
-    toOpenArray(cast[ptr UncheckedArray[T]](p), span.a, span.b)
+    toOpenArray(cast[ptr array[0, T]](p)[], span.a, span.b)
 
   doAssert $cast[ptr uint8](txt[0].addr)[0 ..< txt.len] == 
                 "[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]"

tests/parallel/tsendtwice.nim

@@ -1,10 +1,18 @@
 discard """
+  output: '''ob2 @[]
+ob @[]
+ob3 @[]
+3
+ob2 @[]
+ob @[]
+ob3 @[]
+'''
   matrix: "--mm:refc"
 """
 
 # bug #4776
 
-import tables, algorithm
+import tables
 
 type
   Base* = ref object of RootObj
@@ -27,21 +35,20 @@ globalTable.add("ob", d)
 globalTable.add("ob2", d)
 globalTable.add("ob3", d)
 
-proc `<`(x, y: seq[int]): bool = x.len < y.len
-proc kvs(t: TableRef[string, Base]): seq[(string, seq[int])] =
-  for k, v in t.pairs: result.add (k, v.someSeq)
-  result.sort
-
 proc testThread(channel: ptr TableChannel) {.thread.} =
   globalTable = channel[].recv()
+  for k, v in pairs globaltable:
+    echo k, " ", v.someSeq
   var myObj: Base
   deepCopy(myObj, globalTable["ob"])
   myObj.someSeq = newSeq[int](100)
   let table = channel[].recv() # same table
+  echo table.len
+  for k, v in mpairs table:
+    echo k, " ", v.someSeq
   assert(table.contains("ob")) # fails!
   assert(table.contains("ob2")) # fails!
   assert(table.contains("ob3")) # fails!
-  assert table.kvs == globalTable.kvs # Last to see above spot checks first
 
 var channel: TableChannel
 

tests/refc/tsinkbug.nim

@@ -15,12 +15,3 @@ var obj = AnObject(value: 42)
 echo "Value is: ", obj.value
 mutate(obj)
 echo "Value is: ", obj.value
-
-proc p(x: sink string) = 
-  var y = move(x)
-  doAssert x.len == 0
-  doAssert y.len == 4
-
-p("1234")
-var s = "oooo"
-p(s)

tests/stdlib/thashes.nim

@@ -1,5 +1,5 @@
 discard """
-  matrix: "--mm:refc; --mm:orc; --backend:cpp; --backend:js --jsbigint64:on; --backend:c -d:nimStringHash2; --backend:cpp -d:nimStringHash2; --backend:js -d:nimStringHash2"
+  matrix: "--mm:refc; --mm:orc; --backend:cpp; --backend:js --jsbigint64:on; --backend:js --jsbigint64:off"
 """
 
 import std/hashes
@@ -46,18 +46,10 @@ block hashes:
     else:
       doAssert hashWangYi1(456) == -6421749900419628582
 
-template jsNoInt64: untyped =
-  when defined js:
-    when compiles(compileOption("jsbigint64")):
-      when not compileOption("jsbigint64"): true
-      else: false
-    else: false
-  else: false
-const sHash2 = (when defined(nimStringHash2) or jsNoInt64(): true else: false)
-
 block empty:
   const emptyStrHash = # Hash=int=4B on js even w/--jsbigint64:on => cast[Hash]
-    when sHash2: 0 else: cast[Hash](-7286425919675154353i64)
+    when defined nimPreviewHashFarm: cast[Hash](-7286425919675154353i64)
+    else: 0
   var
     a = ""
     b = newSeq[char]()
@@ -104,7 +96,8 @@ block largeSize: # longer than 4 characters
 proc main() =
   doAssert hash(0.0) == hash(0)
   # bug #16061
-  when not sHash2: # Hash=int=4B on js even w/--jsbigint64:on => cast[Hash]
+  when defined nimPreviewHashFarm: # Default switched -> `not nimStringHash2`
+    # Hash=int=4B on js even w/--jsbigint64:on => cast[Hash]
     doAssert hash(cstring"abracadabra") == cast[Hash](-1119910118870047694i64)
   else:
     doAssert hash(cstring"abracadabra") == 97309975

tests/stdlib/thttpclient.nim

@@ -53,9 +53,9 @@ proc asyncTest() {.async.} =
   doAssert("<title>Example Domain</title>" in body)
 
   resp = await client.request("http://example.com/404")
-  doAssert(resp.code.is4xx or resp.code.is5xx)
-  doAssert(resp.code == Http404 or resp.code == Http500)
-  doAssert(resp.status == $Http404 or resp.status == $Http500)
+  doAssert(resp.code.is4xx)
+  doAssert(resp.code == Http404)
+  doAssert(resp.status == $Http404)
 
   when false: # occasionally does not give success code 
     resp = await client.request("https://google.com/")
@@ -115,9 +115,9 @@ proc syncTest() =
   doAssert("<title>Example Domain</title>" in resp.body)
 
   resp = client.request("http://example.com/404")
-  doAssert(resp.code.is4xx or resp.code.is5xx)
-  doAssert(resp.code == Http404 or resp.code == Http500)
-  doAssert(resp.status == $Http404 or resp.status == $Http500)
+  doAssert(resp.code.is4xx)
+  doAssert(resp.code == Http404)
+  doAssert(resp.status == $Http404)
 
   when false: # occasionally does not give success code
     resp = client.request("https://google.com/")

tests/stdlib/tjson.nim

@@ -1,5 +1,5 @@
 discard """
-  matrix: "; --backend:cpp; --backend:js --jsbigint64:off -d:nimStringHash2; --backend:js --jsbigint64:on"
+  matrix: "; --backend:cpp; --backend:js --jsbigint64:off; --backend:js --jsbigint64:on"
 """
 
 

tests/stdlib/trandom.nim

@@ -1,6 +1,6 @@
 discard """
   joinable: false # to avoid messing with global rand state
-  matrix: "--mm:refc; --mm:orc; --backend:js --jsbigint64:off -d:nimStringHash2; --backend:js --jsbigint64:on"
+  matrix: "--mm:refc; --mm:orc; --backend:js --jsbigint64:off; --backend:js --jsbigint64:on"
 """
 import std/[assertions, formatfloat]
 import std/[random, math, stats, sets, tables]

tests/stdlib/tstrutils.nim

@@ -1,5 +1,5 @@
 discard """
-  matrix: "--mm:refc; --mm:orc; --backend:cpp; --backend:js --jsbigint64:off -d:nimStringHash2; --backend:js --jsbigint64:on"
+  matrix: "--mm:refc; --mm:orc; --backend:cpp; --backend:js --jsbigint64:off; --backend:js --jsbigint64:on"
 """
 
 import std/strutils

tests/stdlib/ttimes.nim

@@ -1,5 +1,5 @@
 discard """
-  matrix: "--mm:refc; --mm:orc; --backend:js --jsbigint64:on; --backend:js --jsbigint64:off -d:nimStringHash2"
+  matrix: "--mm:refc; --mm:orc; --backend:js --jsbigint64:on; --backend:js --jsbigint64:off"
 """
 
 import times, strutils, unittest

tests/system/tdollars.nim

@@ -1,5 +1,5 @@
 discard """
-  matrix: "--mm:refc; --mm:orc; --backend:cpp; --backend:js --jsbigint64:off -d:nimStringHash2; --backend:js --jsbigint64:on"
+  matrix: "--mm:refc; --mm:orc; --backend:cpp; --backend:js --jsbigint64:off; --backend:js --jsbigint64:on"
 """
 
 #[

tests/vm/tconsttable.nim

@@ -17,18 +17,3 @@ x = "ah"
 echo foo[x]
 x = "possible."
 echo foo[x]
-
-block: # bug #19840
-  const testBytes = [byte 0xD8, 0x08, 0xDF, 0x45, 0x00, 0x3D, 0x00, 0x52, 0x00, 0x61]
-  var tempStr = "__________________"
-
-  tempStr.prepareMutation
-  copyMem(addr tempStr[0], addr testBytes[0], testBytes.len)
-
-block: # bug #22389
-  func foo(): ptr UncheckedArray[byte] =
-    const bar = [77.byte]
-    cast[ptr UncheckedArray[byte]](addr bar[0])
-
-  doAssert foo()[0] == 77
-

tests/vm/tcyclic.nim

@@ -1,18 +0,0 @@
-discard """
-  errormsg: "cannot evaluate at compile time: error"
-"""
-
-static: # bug #23827
-  # Forward-declaring procedure (let's call this proc "A")
-  proc error() {.raises: [].}
-
-  # called in another function (let's call this proc "B")
-  proc env(key: string, default: string = ""): string {.raises: [].} =
-    error()
-
-  # A used before its implmentation
-  # removing this line fixes the issue
-  let DESTDIR = env("", "")
-
-  # later, A's implementation uses B
-  proc error() = discard env("", "")

tests/vm/topenarrays.nim

@@ -67,23 +67,3 @@ template fn=
   doAssert test([0,1,2,3,4,5]).id == 0
 fn() # ok
 static: fn()
-
-
-block: # bug #22095
-  type
-    StUint = object
-      limbs: array[4, uint64]
-
-  func shlAddMod(a: var openArray[uint64]) =  
-    a[0] = 10
-
-  func divRem(r: var openArray[uint64]) =
-    shlAddMod(r.toOpenArray(0, 3))
-
-  func fn(): StUint =
-    divRem(result.limbs)
-
-  const
-    z = fn()
-
-  doAssert z.limbs[0] == 10