NIR: Nim intermediate representation (#22777)

Theoretical Benefits / Plans: - Typed assembler-like language. - Allows for a CPS transformation. - Can replace the existing C backend by a new C backend. - Can replace the VM. - Can do more effective "not nil" checking and static array bounds checking. - Can be used instead of the DFA. - Easily translatable to LLVM. - Reasonably easy to produce native code from. - Tiny memory consumption. No pointers, no cry. **In very early stages of development.** Todo: - [x] Map Nim types to IR types. - [ ] Map Nim AST to IR instructions: - [x] Map bitsets to bitops. - [ ] Implement string cases. - [ ] Implement range and index checks. - [x] Implement `default(T)` builtin. - [x] Implement multi string concat. - [ ] Write some analysis passes. - [ ] Write a backend. - [x] Integrate into the compilation pipeline.
2026-05-01 03:24:41 +00:00 · 2023-10-11 17:44:14 +02:00
parent ecaccafa6c
commit 816589b667
35 changed files with 4009 additions and 122 deletions
--- a/compiler/ast.nim
+++ b/compiler/ast.nim
@@ -936,7 +936,7 @@ type
                              # it won't cause problems
                              # for skModule the string literal to output for
                              # deprecated modules.
-    instantiatedFrom*: PSym   # for instances, the generic symbol where it came from.                
+    instantiatedFrom*: PSym   # for instances, the generic symbol where it came from.
    when defined(nimsuggest):
      allUsages*: seq[TLineInfo]

@@ -2173,3 +2173,7 @@ const
    nkFuncDef, nkConstSection, nkConstDef, nkIncludeStmt, nkImportStmt,
    nkExportStmt, nkPragma, nkCommentStmt, nkBreakState,
    nkTypeOfExpr, nkMixinStmt, nkBindStmt}
+
+proc isTrue*(n: PNode): bool =
+  n.kind == nkSym and n.sym.kind == skEnumField and n.sym.position != 0 or
+    n.kind == nkIntLit and n.intVal != 0
--- a/compiler/bitsets.nim
+++ b/compiler/bitsets.nim
@@ -90,3 +90,8 @@ proc bitSetCard*(x: TBitSet): BiggestInt =
  result = 0
  for it in x:
    result.inc int(populationCount[it])
+
+proc bitSetToWord*(s: TBitSet; size: int): BiggestUInt =
+  result = 0
+  for j in 0..<size:
+    if j < s.len: result = result or (BiggestUInt(s[j]) shl (j * 8))
--- a/compiler/ccgexprs.nim
+++ b/compiler/ccgexprs.nim
@@ -112,11 +112,6 @@ proc genLiteral(p: BProc, n: PNode, ty: PType; result: var Rope) =
 proc genLiteral(p: BProc, n: PNode; result: var Rope) =
  genLiteral(p, n, n.typ, result)

-proc bitSetToWord(s: TBitSet, size: int): BiggestUInt =
-  result = 0
-  for j in 0..<size:
-    if j < s.len: result = result or (BiggestUInt(s[j]) shl (j * 8))
-
 proc genRawSetData(cs: TBitSet, size: int; result: var Rope) =
  if size > 8:
    var res = "{\n"
@@ -1561,7 +1556,7 @@ proc genObjConstr(p: BProc, e: PNode, d: var TLoc) =
    if e[i].len == 3 and optFieldCheck in p.options:
      check = e[i][2]
    genFieldObjConstr(p, ty, useTemp, isRef, e[i][0], e[i][1], check, d, r, e.info)
-  
+
  if useTemp:
    if d.k == locNone:
      d = tmp
@@ -1868,8 +1863,8 @@ proc genArrayLen(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
          else:
            unaryExpr(p, e, d, "$1.Field1")
  of tyCstring:
-    if op == mHigh: unaryExpr(p, e, d, "($1 ? (#nimCStrLen($1)-1) : -1)")
-    else: unaryExpr(p, e, d, "($1 ? #nimCStrLen($1) : 0)")
+    if op == mHigh: unaryExpr(p, e, d, "(#nimCStrLen($1)-1)")
+    else: unaryExpr(p, e, d, "#nimCStrLen($1)")
  of tyString:
    var a: TLoc = initLocExpr(p, e[1])
    var x = lenExpr(p, a)
@@ -1889,13 +1884,6 @@ proc genArrayLen(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
    else: putIntoDest(p, d, e, rope(lengthOrd(p.config, typ)))
  else: internalError(p.config, e.info, "genArrayLen()")

-proc makeAddr(n: PNode; idgen: IdGenerator): PNode =
-  if n.kind == nkHiddenAddr:
-    result = n
-  else:
-    result = newTree(nkHiddenAddr, n)
-    result.typ = makePtrType(n.typ, idgen)
-
 proc genSetLengthSeq(p: BProc, e: PNode, d: var TLoc) =
  if optSeqDestructors in p.config.globalOptions:
    e[1] = makeAddr(e[1], p.module.idgen)
@@ -2521,8 +2509,12 @@ proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
  of mOrd: genOrd(p, e, d)
  of mLengthArray, mHigh, mLengthStr, mLengthSeq, mLengthOpenArray:
    genArrayLen(p, e, d, op)
-  of mGCref: unaryStmt(p, e, d, "if ($1) { #nimGCref($1); }$n")
-  of mGCunref: unaryStmt(p, e, d, "if ($1) { #nimGCunref($1); }$n")
+  of mGCref:
+    # only a magic for the old GCs
+    unaryStmt(p, e, d, "if ($1) { #nimGCref($1); }$n")
+  of mGCunref:
+    # only a magic for the old GCs
+    unaryStmt(p, e, d, "if ($1) { #nimGCunref($1); }$n")
  of mSetLengthStr: genSetLengthStr(p, e, d)
  of mSetLengthSeq: genSetLengthSeq(p, e, d)
  of mIncl, mExcl, mCard, mLtSet, mLeSet, mEqSet, mMulSet, mPlusSet, mMinusSet,
@@ -3217,22 +3209,6 @@ proc getDefaultValue(p: BProc; typ: PType; info: TLineInfo; result: var Rope) =
  else:
    globalError(p.config, info, "cannot create null element for: " & $t.kind)

-proc caseObjDefaultBranch(obj: PNode; branch: Int128): int =
-  result = 0
-  for i in 1 ..< obj.len:
-    for j in 0 .. obj[i].len - 2:
-      if obj[i][j].kind == nkRange:
-        let x = getOrdValue(obj[i][j][0])
-        let y = getOrdValue(obj[i][j][1])
-        if branch >= x and branch <= y:
-          return i
-      elif getOrdValue(obj[i][j]) == branch:
-        return i
-    if obj[i].len == 1:
-      # else branch
-      return i
-  assert(false, "unreachable")
-
 proc isEmptyCaseObjectBranch(n: PNode): bool =
  for it in n:
    if it.kind == nkSym and not isEmptyType(it.sym.typ): return false
--- a/compiler/ccgreset.nim
+++ b/compiler/ccgreset.nim
@@ -95,11 +95,11 @@ proc specializeResetT(p: BProc, accessor: Rope, typ: PType) =
      lineCg(p, cpsStmts, "$1 = 0;$n", [accessor])
    else:
      raiseAssert "unexpected set type kind"
-  of {tyNone, tyEmpty, tyNil, tyUntyped, tyTyped, tyGenericInvocation,
+  of tyNone, tyEmpty, tyNil, tyUntyped, tyTyped, tyGenericInvocation,
      tyGenericParam, tyOrdinal, tyRange, tyOpenArray, tyForward, tyVarargs,
      tyUncheckedArray, tyProxy, tyBuiltInTypeClass, tyUserTypeClass,
      tyUserTypeClassInst, tyCompositeTypeClass, tyAnd, tyOr, tyNot,
-      tyAnything, tyStatic, tyFromExpr, tyConcept, tyVoid, tyIterable}:
+      tyAnything, tyStatic, tyFromExpr, tyConcept, tyVoid, tyIterable:
    discard

 proc specializeReset(p: BProc, a: TLoc) =
--- a/compiler/ccgstmts.nim
+++ b/compiler/ccgstmts.nim
@@ -1457,7 +1457,8 @@ proc genTrySetjmp(p: BProc, t: PNode, d: var TLoc) =
        let memberName = if p.module.compileToCpp: "m_type" else: "Sup.m_type"
        if optTinyRtti in p.config.globalOptions:
          let checkFor = $getObjDepth(t[i][j].typ)
-          appcg(p.module, orExpr, "#isObjDisplayCheck(#nimBorrowCurrentException()->$1, $2, $3)", [memberName, checkFor,  $genDisplayElem(MD5Digest(hashType(t[i][j].typ, p.config)))])
+          appcg(p.module, orExpr, "#isObjDisplayCheck(#nimBorrowCurrentException()->$1, $2, $3)",
+              [memberName, checkFor, $genDisplayElem(MD5Digest(hashType(t[i][j].typ, p.config)))])
        else:
          let checkFor = genTypeInfoV1(p.module, t[i][j].typ, t[i][j].info)
          appcg(p.module, orExpr, "#isObj(#nimBorrowCurrentException()->$1, $2)", [memberName, checkFor])
--- a/compiler/ccgtypes.nim
+++ b/compiler/ccgtypes.nim
@@ -24,7 +24,7 @@ type
    dkResult #skResult
    dkConst #skConst
    dkOther #skType, skTemp, skLet and skForVar so far
-   
+
 proc descKindFromSymKind(kind: TSymKind): TypeDescKind =
  case kind
  of skParam: dkParam
@@ -33,7 +33,7 @@ proc descKindFromSymKind(kind: TSymKind): TypeDescKind =
  of skResult: dkResult
  of skConst: dkConst
  else: dkOther
- 
+
 proc isKeyword(w: PIdent): bool =
  # Nim and C++ share some keywords
  # it's more efficient to test the whole Nim keywords range
@@ -464,7 +464,7 @@ proc multiFormat*(frmt: var string, chars : static openArray[char], args: openAr
    var num = 0
    while i < frmt.len:
      if frmt[i] == c:
-        inc(i)                  
+        inc(i)
        case frmt[i]
        of c:
          res.add(c)
@@ -521,7 +521,7 @@ proc genMemberProcParams(m: BModule; prc: PSym, superCall, rettype, name, params
    types.add getTypeDescWeak(m, this.typ, check, dkParam)

  let firstParam = if isCtor: 1 else: 2
-  for i in firstParam..<t.n.len: 
+  for i in firstParam..<t.n.len:
    if t.n[i].kind != nkSym: internalError(m.config, t.n.info, "genMemberProcParams")
    var param = t.n[i].sym
    var descKind = dkParam
@@ -649,7 +649,7 @@ proc mangleRecFieldName(m: BModule; field: PSym): Rope =
    result = rope(mangleField(m, field.name))
  if result == "": internalError(m.config, field.info, "mangleRecFieldName")

-proc hasCppCtor(m: BModule; typ: PType): bool = 
+proc hasCppCtor(m: BModule; typ: PType): bool =
  result = false
  if m.compileToCpp and typ != nil and typ.itemId in m.g.graph.memberProcsPerType:
    for prc in m.g.graph.memberProcsPerType[typ.itemId]:
@@ -763,7 +763,7 @@ proc getRecordFields(m: BModule; typ: PType, check: var IntSet): Rope =
    if isCtorGen and not isDefaultCtorGen:
      var ch: IntSet
      result.addf "$1() = default;$n", [getTypeDescAux(m, typ, ch, dkOther)]
-    
+
 proc fillObjectFields*(m: BModule; typ: PType) =
  # sometimes generic objects are not consistently merged. We patch over
  # this fact here.
@@ -771,7 +771,7 @@ proc fillObjectFields*(m: BModule; typ: PType) =
  discard getRecordFields(m, typ, check)

 proc mangleDynLibProc(sym: PSym): Rope
-  
+
 proc getRecordDescAux(m: BModule; typ: PType, name, baseType: Rope,
                   check: var IntSet, hasField:var bool): Rope =
  result = ""
@@ -816,7 +816,7 @@ proc getRecordDesc(m: BModule; typ: PType, name: Rope,
  else:
    structOrUnion = structOrUnion(typ)
  var baseType: string = ""
-  if typ[0] != nil: 
+  if typ[0] != nil:
    baseType = getTypeDescAux(m, typ[0].skipTypes(skipPtrs), check, dkField)
  if typ.sym == nil or sfCodegenDecl notin typ.sym.flags:
    result = structOrUnion & " " & name
@@ -1128,8 +1128,8 @@ proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDes
    result = ""
  # fixes bug #145:
  excl(check, t.id)
-  
-  
+
+
 proc getTypeDesc(m: BModule; typ: PType; kind = dkParam): Rope =
  var check = initIntSet()
  result = getTypeDescAux(m, typ, check, kind)
@@ -1214,7 +1214,7 @@ proc genMemberProcHeader(m: BModule; prc: PSym; result: var Rope; asPtr: bool =
  var name, params, rettype, superCall: string = ""
  var isFnConst, isOverride, isMemberVirtual: bool = false
  parseVFunctionDecl(prc.constraint.strVal, name, params, rettype, superCall, isFnConst, isOverride, isMemberVirtual, isCtor)
-  genMemberProcParams(m, prc, superCall, rettype, name, params, check, true, false) 
+  genMemberProcParams(m, prc, superCall, rettype, name, params, check, true, false)
  let isVirtual = sfVirtual in prc.flags or isMemberVirtual
  var fnConst, override: string = ""
  if isCtor:
@@ -1224,7 +1224,7 @@ proc genMemberProcHeader(m: BModule; prc: PSym; result: var Rope; asPtr: bool =
  if isFwdDecl:
    if isVirtual:
      rettype = "virtual " & rettype
-      if isOverride: 
+      if isOverride:
        override = " override"
    superCall = ""
  else:
@@ -1232,14 +1232,14 @@ proc genMemberProcHeader(m: BModule; prc: PSym; result: var Rope; asPtr: bool =
      prc.loc.r = "$1$2(@)" % [memberOp, name]
    elif superCall != "":
      superCall = " : " & superCall
-    
+
    name = "$1::$2" % [typDesc, name]

  result.add "N_LIB_PRIVATE "
  result.addf("$1$2($3, $4)$5$6$7$8",
        [rope(CallingConvToStr[prc.typ.callConv]), asPtrStr, rettype, name,
        params, fnConst, override, superCall])
-  
+
 proc genProcHeader(m: BModule; prc: PSym; result: var Rope; asPtr: bool = false) =
  # using static is needed for inline procs
  var check = initIntSet()
@@ -1575,10 +1575,6 @@ proc genTypeInfo2Name(m: BModule; t: PType): Rope =

 proc isTrivialProc(g: ModuleGraph; s: PSym): bool {.inline.} = getBody(g, s).len == 0

-proc makePtrType(baseType: PType; idgen: IdGenerator): PType =
-  result = newType(tyPtr, nextTypeId idgen, baseType.owner)
-  addSonSkipIntLit(result, baseType, idgen)
-
 proc generateRttiDestructor(g: ModuleGraph; typ: PType; owner: PSym; kind: TTypeAttachedOp;
              info: TLineInfo; idgen: IdGenerator; theProc: PSym): PSym =
  # the wrapper is roughly like:
@@ -1946,14 +1942,14 @@ proc genTypeInfo*(config: ConfigRef, m: BModule; t: PType; info: TLineInfo): Rop
  else:
    result = genTypeInfoV1(m, t, info)

-proc genTypeSection(m: BModule, n: PNode) = 
+proc genTypeSection(m: BModule, n: PNode) =
  var intSet = initIntSet()
  for i in 0..<n.len:
    if len(n[i]) == 0: continue
    if n[i][0].kind != nkPragmaExpr: continue
    for p in 0..<n[i][0].len:
      if (n[i][0][p].kind != nkSym): continue
-      if sfExportc in n[i][0][p].sym.flags:        
+      if sfExportc in n[i][0][p].sym.flags:
        discard getTypeDescAux(m, n[i][0][p].typ, intSet, descKindFromSymKind(n[i][0][p].sym.kind))
        if m.g.generatedHeader != nil:
          discard getTypeDescAux(m.g.generatedHeader, n[i][0][p].typ, intSet, descKindFromSymKind(n[i][0][p].sym.kind))
--- a/compiler/cgen.nim
+++ b/compiler/cgen.nim
@@ -17,6 +17,8 @@ import
  lowerings, tables, sets, ndi, lineinfos, pathutils, transf,
  injectdestructors, astmsgs, modulepaths, backendpragmas

+from expanddefaults import caseObjDefaultBranch
+
 import pipelineutils

 when defined(nimPreviewSlimSystem):
@@ -499,8 +501,8 @@ proc resetLoc(p: BProc, loc: var TLoc) =
      # array passed as argument decayed into pointer, bug #7332
      # so we use getTypeDesc here rather than rdLoc(loc)
      let tyDesc = getTypeDesc(p.module, loc.t, descKindFromSymKind mapTypeChooser(loc))
-      if p.module.compileToCpp and isOrHasImportedCppType(typ): 
-        if lfIndirect in loc.flags: 
+      if p.module.compileToCpp and isOrHasImportedCppType(typ):
+        if lfIndirect in loc.flags:
          #C++ cant be just zeroed. We need to call the ctors
          var tmp = getTemp(p, loc.t)
          linefmt(p, cpsStmts,"#nimCopyMem((void*)$1, (NIM_CONST void*)$2, sizeof($3));$n",
@@ -508,7 +510,7 @@ proc resetLoc(p: BProc, loc: var TLoc) =
      else:
        linefmt(p, cpsStmts, "#nimZeroMem((void*)$1, sizeof($2));$n",
                [addrLoc(p.config, loc), tyDesc])
-      
+
      # XXX: We can be extra clever here and call memset only
      # on the bytes following the m_type field?
      genObjectInit(p, cpsStmts, loc.t, loc, constructObj)
@@ -551,7 +553,7 @@ proc getTemp(p: BProc, t: PType, needsInit=false): TLoc =
  result = TLoc(r: "T" & rope(p.labels) & "_", k: locTemp, lode: lodeTyp t,
                storage: OnStack, flags: {})
  if p.module.compileToCpp and isOrHasImportedCppType(t):
-    linefmt(p, cpsLocals, "$1 $2$3;$n", [getTypeDesc(p.module, t, dkVar), result.r, 
+    linefmt(p, cpsLocals, "$1 $2$3;$n", [getTypeDesc(p.module, t, dkVar), result.r,
      genCppInitializer(p.module, p, t)])
  else:
    linefmt(p, cpsLocals, "$1 $2;$n", [getTypeDesc(p.module, t, dkVar), result.r])
@@ -607,8 +609,8 @@ proc assignLocalVar(p: BProc, n: PNode) =
  # this need not be fulfilled for inline procs; they are regenerated
  # for each module that uses them!
  let nl = if optLineDir in p.config.options: "" else: "\n"
-  var decl = localVarDecl(p, n) 
-  if p.module.compileToCpp and isOrHasImportedCppType(n.typ): 
+  var decl = localVarDecl(p, n)
+  if p.module.compileToCpp and isOrHasImportedCppType(n.typ):
    decl.add genCppInitializer(p.module, p, n.typ)
  decl.add ";" & nl
  line(p, cpsLocals, decl)
--- a/compiler/dfa.nim
+++ b/compiler/dfa.nim
@@ -129,10 +129,6 @@ template withBlock(labl: PSym; body: untyped) =
  body
  popBlock(c, oldLen)

-proc isTrue(n: PNode): bool =
-  n.kind == nkSym and n.sym.kind == skEnumField and n.sym.position != 0 or
-    n.kind == nkIntLit and n.intVal != 0
-
 template forkT(body) =
  let lab1 = c.forkI()
  body
--- a/compiler/expanddefaults.nim
+++ b/compiler/expanddefaults.nim
@@ -0,0 +1,131 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+import lineinfos, ast, types
+
+proc caseObjDefaultBranch*(obj: PNode; branch: Int128): int =
+  result = 0
+  for i in 1 ..< obj.len:
+    for j in 0 .. obj[i].len - 2:
+      if obj[i][j].kind == nkRange:
+        let x = getOrdValue(obj[i][j][0])
+        let y = getOrdValue(obj[i][j][1])
+        if branch >= x and branch <= y:
+          return i
+      elif getOrdValue(obj[i][j]) == branch:
+        return i
+    if obj[i].len == 1:
+      # else branch
+      return i
+  return 1
+
+template newZero(t: PType; info: TLineInfo; k = nkIntLit): PNode = newNodeIT(k, info, t)
+
+proc expandDefault*(t: PType; info: TLineInfo): PNode
+
+proc expandField(s: PSym; info: TLineInfo): PNode =
+  result = newNodeIT(nkExprColonExpr, info, s.typ)
+  result.add newSymNode(s)
+  result.add expandDefault(s.typ, info)
+
+proc expandDefaultN(n: PNode; info: TLineInfo; res: PNode) =
+  case n.kind
+  of nkRecList:
+    for i in 0..<n.len:
+      expandDefaultN(n[i], info, res)
+  of nkRecCase:
+    res.add expandField(n[0].sym, info)
+    var branch = Zero
+    let constOrNil = n[0].sym.astdef
+    if constOrNil != nil:
+      branch = getOrdValue(constOrNil)
+
+    let selectedBranch = caseObjDefaultBranch(n, branch)
+    let b = lastSon(n[selectedBranch])
+    expandDefaultN b, info, res
+  of nkSym:
+    res.add expandField(n.sym, info)
+  else:
+    discard
+
+proc expandDefaultObj(t: PType; info: TLineInfo; res: PNode) =
+  if t[0] != nil:
+    expandDefaultObj(t[0], info, res)
+  expandDefaultN(t.n, info, res)
+
+proc expandDefault(t: PType; info: TLineInfo): PNode =
+  case t.kind
+  of tyInt:     result = newZero(t, info, nkIntLit)
+  of tyInt8:    result = newZero(t, info, nkInt8Lit)
+  of tyInt16:   result = newZero(t, info, nkInt16Lit)
+  of tyInt32:   result = newZero(t, info, nkInt32Lit)
+  of tyInt64:   result = newZero(t, info, nkInt64Lit)
+  of tyUInt:    result = newZero(t, info, nkUIntLit)
+  of tyUInt8:   result = newZero(t, info, nkUInt8Lit)
+  of tyUInt16:  result = newZero(t, info, nkUInt16Lit)
+  of tyUInt32:  result = newZero(t, info, nkUInt32Lit)
+  of tyUInt64:  result = newZero(t, info, nkUInt64Lit)
+  of tyFloat:   result = newZero(t, info, nkFloatLit)
+  of tyFloat32: result = newZero(t, info, nkFloat32Lit)
+  of tyFloat64: result = newZero(t, info, nkFloat64Lit)
+  of tyFloat128: result = newZero(t, info, nkFloat64Lit)
+  of tyChar:    result = newZero(t, info, nkCharLit)
+  of tyBool:    result = newZero(t, info, nkIntLit)
+  of tyEnum:
+    # Could use low(T) here to finally fix old language quirks
+    result = newZero(t, info, nkIntLit)
+  of tyRange:
+    # Could use low(T) here to finally fix old language quirks
+    result = expandDefault(t[0], info)
+  of tyVoid: result = newZero(t, info, nkEmpty)
+  of tySink, tyGenericInst, tyDistinct, tyAlias, tyOwned:
+    result = expandDefault(t.lastSon, info)
+  of tyOrdinal, tyGenericBody, tyGenericParam, tyInferred, tyStatic:
+    if t.len > 0:
+      result = expandDefault(t.lastSon, info)
+    else:
+      result = newZero(t, info, nkEmpty)
+  of tyFromExpr:
+    if t.n != nil and t.n.typ != nil:
+      result = expandDefault(t.n.typ, info)
+    else:
+      result = newZero(t, info, nkEmpty)
+  of tyArray:
+    result = newZero(t, info, nkBracket)
+    let n = toInt64(lengthOrd(nil, t))
+    for i in 0..<n:
+      result.add expandDefault(t[1], info)
+  of tyPtr, tyRef, tyProc, tyPointer, tyCstring:
+    result = newZero(t, info, nkNilLit)
+  of tyVar, tyLent:
+    let e = t.lastSon
+    if e.skipTypes(abstractInst).kind in {tyOpenArray, tyVarargs}:
+      # skip the modifier, `var openArray` is a (ptr, len) pair too:
+      result = expandDefault(e, info)
+    else:
+      result = newZero(t.lastSon, info, nkNilLit)
+  of tySet:
+    result = newZero(t, info, nkCurly)
+  of tyObject:
+    result = newNodeIT(nkObjConstr, info, t)
+    result.add newNodeIT(nkType, info, t)
+    expandDefaultObj(t, info, result)
+  of tyTuple:
+    result = newZero(t, info, nkTupleConstr)
+    for it in t:
+      result.add expandDefault(it, info)
+  of tyVarargs, tyOpenArray, tySequence, tyUncheckedArray:
+    result = newZero(t, info, nkBracket)
+  of tyString:
+    result = newZero(t, info, nkStrLit)
+  of tyNone, tyEmpty, tyUntyped, tyTyped, tyTypeDesc,
+     tyNil, tyGenericInvocation, tyProxy, tyBuiltInTypeClass,
+     tyUserTypeClass, tyUserTypeClassInst, tyCompositeTypeClass,
+     tyAnd, tyOr, tyNot, tyAnything, tyConcept, tyIterable, tyForward:
+    result = newZero(t, info, nkEmpty) # bug indicator
--- a/compiler/ic/bitabs.nim
+++ b/compiler/ic/bitabs.nim
@@ -13,6 +13,8 @@ type
    vals: seq[T] # indexed by LitId
    keys: seq[LitId]  # indexed by hash(val)

+proc initBiTable*[T](): BiTable[T] = BiTable[T](vals: @[], keys: @[])
+
 proc nextTry(h, maxHash: Hash): Hash {.inline.} =
  result = (h + 1) and maxHash

--- a/compiler/magicsys.nim
+++ b/compiler/magicsys.nim
@@ -150,4 +150,13 @@ proc getMagicEqSymForType*(g: ModuleGraph; t: PType; info: TLineInfo): PSym =
    globalError(g.config, info,
      "can't find magic equals operator for type kind " & $t.kind)

+proc makePtrType*(baseType: PType; idgen: IdGenerator): PType =
+  result = newType(tyPtr, nextTypeId idgen, baseType.owner)
+  addSonSkipIntLit(result, baseType, idgen)

+proc makeAddr*(n: PNode; idgen: IdGenerator): PNode =
+  if n.kind == nkHiddenAddr:
+    result = n
+  else:
+    result = newTree(nkHiddenAddr, n)
+    result.typ = makePtrType(n.typ, idgen)
--- a/compiler/main.nim
+++ b/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]
@@ -173,13 +175,14 @@ 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 not useNir:
+    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), {})
@@ -407,7 +410,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):
--- a/compiler/modulegraphs.nim
+++ b/compiler/modulegraphs.nim
@@ -65,6 +65,7 @@ type
    CgenPass
    EvalPass
    InterpreterPass
+    NirReplPass
    GenDependPass
    Docgen2TexPass
    Docgen2JsonPass
@@ -99,6 +100,7 @@ type
    cache*: IdentCache
    vm*: RootRef # unfortunately the 'vm' state is shared project-wise, this will
                 # be clarified in later compiler implementations.
+    repl*: RootRef # REPL state is shared project-wise.
    doStopCompile*: proc(): bool {.closure.}
    usageSym*: PSym # for nimsuggest
    owners*: seq[PSym]
--- a/compiler/nim.nim
+++ 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}:
+    if conf.backend in {backendC, backendCpp, backendObjc} or
+        (conf.cmd == cmdInteractive and isDefined(conf, "nir")):
      initOrcDefines(conf)

  mainCommand(graph)
--- a/compiler/nir/ast2ir.nim
+++ b/compiler/nir/ast2ir.nim
--- a/compiler/nir/cir.nim
+++ b/compiler/nir/cir.nim
@@ -0,0 +1,78 @@
+#
+#
+#           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
+import .. / ic / bitabs
+
+type
+  Token = LitId # indexing into the tokens BiTable[string]
+
+  PredefinedToken = enum
+    IgnoreMe = "<unused>"
+    EmptyToken = ""
+    DeclPrefix = "" # the next token is the name of a definition
+    CurlyLe = "{"
+    CurlyRi = "}"
+    ParLe = "("
+    ParRi = ")"
+    BracketLe = "["
+    BracketRi = "]"
+    NewLine = "\n"
+    Semicolon = ";"
+    Comma = ", "
+    Space = " "
+    Colon = ":"
+    Dot = "."
+    Arrow = "->"
+    Star = "*"
+    Amp = "&"
+    AsgnOpr = " = "
+    ScopeOpr = "::"
+    ConstKeyword = "const "
+    StaticKeyword = "static "
+    NimString = "NimString"
+    StrLitPrefix = "(NimChar*)"
+    StrLitNamePrefix = "Qstr"
+    LoopKeyword = "while (true) "
+    WhileKeyword = "while ("
+    IfKeyword = "if ("
+    ElseKeyword = "else "
+    SwitchKeyword = "switch ("
+    CaseKeyword = "case "
+    DefaultKeyword = "default:"
+    BreakKeyword = "break"
+    NullPtr = "nullptr"
+    IfNot = "if (!("
+    ReturnKeyword = "return "
+
+const
+  ModulePrefix = Token(int(ReturnKeyword)+1)
+
+proc fillTokenTable(tab: var BiTable[string]) =
+  for e in EmptyToken..high(PredefinedToken):
+    let id = tab.getOrIncl $e
+    assert id == LitId(e)
+
+type
+  GeneratedCode* = object
+    code: seq[LitId]
+    tokens: BiTable[string]
+
+proc initGeneratedCode*(): GeneratedCode =
+  result = GeneratedCode(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)
+
--- a/compiler/nir/nir.nim
+++ b/compiler/nir/nir.nim
@@ -0,0 +1,71 @@
+#
+#
+#           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.
+
+import ".." / [ast, modulegraphs, renderer, transf]
+import nirtypes, nirinsts, ast2ir
+
+type
+  PCtx* = ref object of TPassContext
+    m: ModuleCon
+    c: ProcCon
+    oldErrorCount: int
+
+proc newCtx*(module: PSym; g: ModuleGraph; idgen: IdGenerator): PCtx =
+  let m = initModuleCon(g, g.config, idgen, module)
+  PCtx(m: m, c: initProcCon(m, nil, g.config), idgen: idgen)
+
+proc refresh*(c: PCtx; module: PSym; idgen: IdGenerator) =
+  c.m = initModuleCon(c.m.graph, c.m.graph.config, idgen, module)
+  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 = ""
+  if pc < c.c.code.len:
+    toString c.c.code, NodePos(pc), c.m.strings, c.m.integers, res
+  #res.add "\n"
+  #toString res, c.m.types.g
+  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
+
+when false:
+  type
+    Module* = object
+      types: TypeGraph
+      data: seq[Tree]
+      init: seq[Tree]
+      procs: seq[Tree]
+
--- a/compiler/nir/nirinsts.nim
+++ b/compiler/nir/nirinsts.nim
@@ -0,0 +1,418 @@
+#
+#
+#           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
+import nirlineinfos, nirtypes
+
+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)
+    SummonGlobal,
+    SummonThreadLocal,
+    Summon, # x = Summon Typed <Type ID>; x begins to live
+    SummonParam,
+    SummonConst,
+    Kill, # `Kill x`: scope end for `x`
+
+    AddrOf,
+    ArrayAt, # addr(a[i])
+    FieldAt, # addr(obj.field)
+
+    Load, # a[]
+    Store, # a[] = b
+    Asgn,  # a = b
+    SetExc,
+    TestExc,
+
+    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,
+    PragmaPair
+
+type
+  PragmaKey* = enum
+    FastCall, StdCall, CDeclCall, SafeCall, SysCall, InlineCall, NoinlineCall, ThisCall, NoCall,
+    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,
+    FieldAt,
+    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 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
+
+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
+
+template `[]`*(t: Tree; n: NodePos): Instr = t.nodes[n.int]
+
+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]
+
+type
+  LabelId* = distinct int
+
+proc newLabel*(labelGen: var int): LabelId {.inline.} =
+  result = LabelId labelGen
+  inc labelGen
+
+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 boolVal*(t: var Tree; info: PackedLineInfo; b: bool) =
+  t.nodes.add Instr(x: toX(ImmediateVal, uint32(b)), info: info)
+
+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 addTyped*(t: var Tree; info: PackedLineInfo; typ: TypeId) {.inline.} =
+  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 opc in {Summon, SummonConst, SummonGlobal, SummonThreadLocal, SummonParam}
+  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 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 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 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 '"'
+
+proc toString*(t: Tree; pos: NodePos; strings: BiTable[string]; integers: BiTable[int64];
+               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 $t[pos].operand
+  of SymUse:
+    r.add "SymUse "
+    r.add $t[pos].operand
+  of PragmaId:
+    r.add $cast[PragmaKey](t[pos].operand)
+  of Typed:
+    r.add "Typed "
+    r.add $t[pos].operand
+  of NilVal:
+    r.add "NilVal"
+  of Label:
+    r.add "L"
+    r.add $t[pos].operand
+  of Goto, CheckedGoto, LoopLabel, GotoLoop:
+    r.add $t[pos].kind
+    r.add ' '
+    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, r, nesting+1
+    r.add "\n"
+    for i in 0..<nesting*2: r.add ' '
+    r.add "}"
+
+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
--- a/compiler/nir/nirlineinfos.nim
+++ b/compiler/nir/nirlineinfos.nim
@@ -0,0 +1,78 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+# For the line information we use 32 bits. They are used as follows:
+# Bit 0 (AsideBit): If we have inline line information or not. If not, the
+# remaining 31 bits are used as an index into a seq[(LitId, int, int)].
+#
+# We use 10 bits for the "file ID", this means a program can consist of as much
+# as 1024 different files. (If it uses more files than that, the overflow bit
+# would be set.)
+# This means we have 21 bits left to encode the (line, col) pair. We use 7 bits for the column
+# so 128 is the limit and 14 bits for the line number.
+# The packed representation supports files with up to 16384 lines.
+# Keep in mind that whenever any limit is reached the AsideBit is set and the real line
+# information is kept in a side channel.
+
+import std / assertions
+
+const
+  AsideBit = 1
+  FileBits = 10
+  LineBits = 14
+  ColBits = 7
+  FileMax = (1 shl FileBits) - 1
+  LineMax = (1 shl LineBits) - 1
+  ColMax = (1 shl ColBits) - 1
+
+static:
+  assert AsideBit + FileBits + LineBits + ColBits == 32
+
+import .. / ic / bitabs # for LitId
+
+type
+  PackedLineInfo* = distinct uint32
+
+  LineInfoManager* = object
+    aside*: seq[(LitId, int32, int32)]
+
+proc pack*(m: var LineInfoManager; file: LitId; line, col: int32): PackedLineInfo =
+  if file.uint32 <= FileMax.uint32 and line <= LineMax and col <= ColMax:
+    let col = if col < 0'i32: 0'u32 else: col.uint32
+    let line = if line < 0'i32: 0'u32 else: line.uint32
+    # use inline representation:
+    result = PackedLineInfo((file.uint32 shl 1'u32) or (line shl uint32(AsideBit + FileBits)) or
+      (col shl uint32(AsideBit + FileBits + LineBits)))
+  else:
+    result = PackedLineInfo((m.aside.len shl 1) or AsideBit)
+    m.aside.add (file, line, col)
+
+proc unpack*(m: LineInfoManager; i: PackedLineInfo): (LitId, int32, int32) =
+  let i = i.uint32
+  if (i and 1'u32) == 0'u32:
+    # inline representation:
+    result = (LitId((i shr 1'u32) and FileMax.uint32),
+      int32((i shr uint32(AsideBit + FileBits)) and LineMax.uint32),
+      int32((i shr uint32(AsideBit + FileBits + LineBits)) and ColMax.uint32))
+  else:
+    result = m.aside[int(i shr 1'u32)]
+
+proc getFileId*(m: LineInfoManager; i: PackedLineInfo): LitId =
+  result = unpack(m, i)[0]
+
+when isMainModule:
+  var m = LineInfoManager(aside: @[])
+  for i in 0'i32..<16388'i32:
+    for col in 0'i32..<100'i32:
+      let packed = pack(m, LitId(1023), i, col)
+      let u = unpack(m, packed)
+      assert u[0] == LitId(1023)
+      assert u[1] == i
+      assert u[2] == col
+  echo m.aside.len
--- a/compiler/nir/nirslots.nim
+++ b/compiler/nir/nirslots.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.
+#
+
+## 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]
+    locGen: ref int
+
+proc initSlotManager*(flags: set[SlotManagerFlag]; generator: ref int): SlotManager {.inline.} =
+  SlotManager(flags: flags, locGen: generator)
+
+proc allocRaw(m: var SlotManager; t: TypeId; f: SlotManagerFlag; k: SlotKind): SymId {.inline.} =
+  if f in m.flags and m.dead.hasKey(t) and m.dead[t].len > 0:
+    result = m.dead[t].pop()
+  else:
+    result = SymId(m.locGen[])
+    inc m.locGen[]
+    m.inScope.add result
+  m.live[result] = (k, t)
+
+proc allocTemp*(m: var SlotManager; t: TypeId): SymId {.inline.} =
+  result = allocRaw(m, t, ReuseTemps, Temp)
+
+proc allocVar*(m: var SlotManager; t: TypeId): SymId {.inline.} =
+  result = allocRaw(m, t, ReuseVars, Perm)
+
+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 m = initSlotManager({ReuseTemps}, new(int))
+
+  var g = initTypeGraph()
+
+  let a = g.openType ArrayTy
+  g.addBuiltinType Int8Id
+  g.addArrayLen 5'u64
+  let finalArrayType = sealType(g, a)
+
+  let obj = g.openType ObjectDecl
+  g.addName "MyType"
+
+  g.addField "p", finalArrayType
+  let objB = sealType(g, obj)
+
+  let x = m.allocTemp(objB)
+  assert x.int == 0
+
+  let y = m.allocTemp(objB)
+  assert y.int == 1
+
+  let z = m.allocTemp(Int8Id)
+  assert z.int == 2
+
+  m.freeLoc y
+  let y2 = m.allocTemp(objB)
+  assert y2.int == 1
+
+
--- a/compiler/nir/nirtypes.nim
+++ b/compiler/nir/nirtypes.nim
@@ -0,0 +1,347 @@
+#
+#
+#           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
+
+type
+  NirTypeKind* = enum
+    VoidTy, IntTy, UIntTy, FloatTy, BoolTy, CharTy, NameVal, IntVal,
+    AnnotationVal,
+    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
+    ObjectTy,
+    UnionTy,
+    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)
+
+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
+  TypeGraph* = object
+    nodes: seq[TypeNode]
+    names: BiTable[string]
+    numbers: BiTable[uint64]
+
+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*(): 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))
+  ])
+  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 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 arrayLen*(tree: TypeGraph; n: TypeId): BiggestUInt =
+  assert tree[n].kind == ArrayTy
+  result = tree.numbers[LitId tree[n].operand]
+
+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)
+
+proc sealType*(tree: var TypeGraph; p: TypePatchPos): TypeId =
+  # TODO: Search for an existing instance of this type in
+  # order to reduce memory consumption.
+  result = TypeId(p)
+  patch tree, p
+
+proc nominalType*(tree: var TypeGraph; kind: NirTypeKind; name: string): TypeId =
+  assert kind in {ObjectTy, UnionTy}
+  result = TypeId tree.nodes.len
+  tree.nodes.add TypeNode(x: toX(kind, tree.names.getOrIncl(name)))
+
+proc addNominalType*(tree: var TypeGraph; kind: NirTypeKind; name: string) =
+  assert kind in {ObjectTy, UnionTy}
+  tree.nodes.add TypeNode(x: toX(kind, tree.names.getOrIncl(name)))
+
+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: uint64) =
+  g.nodes.add TypeNode(x: toX(IntVal, g.numbers.getOrIncl(len)))
+
+proc addName*(g: var TypeGraph; name: string) =
+  g.nodes.add TypeNode(x: toX(NameVal, g.names.getOrIncl(name)))
+
+proc addAnnotation*(g: var TypeGraph; name: string) =
+  g.nodes.add TypeNode(x: toX(NameVal, g.names.getOrIncl(name)))
+
+proc addField*(g: var TypeGraph; name: string; typ: TypeId) =
+  let f = g.openType FieldDecl
+  g.addType typ
+  g.addName name
+  discard sealType(g, f)
+
+proc ptrTypeOf*(g: var TypeGraph; t: TypeId): TypeId =
+  let f = g.openType APtrTy
+  g.addType t
+  result = sealType(g, f)
+
+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.names[LitId g[i].operand]
+  of IntVal:
+    dest.add $g.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) = g.sons2(i)
+    toString(dest, g, elems)
+    dest.add ", "
+    toString(dest, g, len)
+    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.names[LitId g[i].operand]
+  of UnionTy:
+    dest.add "union "
+    dest.add g.names[LitId g[i].operand]
+  of ProcTy:
+    dest.add "proc["
+    for t in sons(g, i): 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:
+    let (typ, name) = g.sons2(i)
+    toString(dest, g, typ)
+    dest.add ' '
+    toString(dest, g, name)
+
+proc toString*(dest: var string; g: TypeGraph) =
+  var i = 0
+  while i < g.len:
+    toString(dest, g, TypeId i)
+    dest.add '\n'
+    nextChild g, i
+
+proc `$`(g: TypeGraph): string =
+  result = ""
+  toString(result, g)
+
+when isMainModule:
+  var g = initTypeGraph()
+
+  let a = g.openType ArrayTy
+  g.addBuiltinType Int8Id
+  g.addArrayLen 5'u64
+  let finalArrayType = sealType(g, a)
+
+  let obj = g.openType ObjectDecl
+  g.nodes.add TypeNode(x: toX(NameVal, g.names.getOrIncl("MyType")))
+
+  g.addField "p", finalArrayType
+  discard sealType(g, obj)
+
+  echo g
--- a/compiler/nir/types2ir.nim
+++ b/compiler/nir/types2ir.nim
@@ -0,0 +1,466 @@
+#
+#
+#           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]
+    recursionCheck: HashSet[ItemId]
+    g*: TypeGraph
+    conf: ConfigRef
+
+proc initTypesCon*(conf: ConfigRef): TypesCon =
+  TypesCon(g: initTypeGraph(), conf: conf)
+
+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
+
+proc typeToIr*(c: var TypesCon; t: PType): TypeId
+
+proc collectFieldTypes(c: var TypesCon; n: PNode; dest: var Table[ItemId, TypeId]) =
+  case n.kind
+  of nkRecList:
+    for i in 0..<n.len:
+      collectFieldTypes(c, n[i], dest)
+  of nkRecCase:
+    assert(n[0].kind == nkSym)
+    collectFieldTypes(c, n[0], dest)
+    for i in 1..<n.len:
+      case n[i].kind
+      of nkOfBranch, nkElse:
+        collectFieldTypes c, lastSon(n[i]), dest
+      else: discard
+  of nkSym:
+    dest[n.sym.itemId] = typeToIr(c, n.sym.typ)
+  else:
+    assert false, "unknown node kind: " & $n.kind
+
+proc objectToIr(c: var TypesCon; n: PNode; fieldTypes: Table[ItemId, TypeId]; unionId: var int) =
+  case n.kind
+  of nkRecList:
+    for i in 0..<n.len:
+      objectToIr(c, n[i], fieldTypes, unionId)
+  of nkRecCase:
+    assert(n[0].kind == nkSym)
+    objectToIr(c, n[0], fieldTypes, unionId)
+    let u = openType(c.g, UnionDecl)
+    c.g.addName "u_" & $unionId
+    inc unionId
+    for i in 1..<n.len:
+      case n[i].kind
+      of nkOfBranch, nkElse:
+        let subObj = openType(c.g, ObjectDecl)
+        c.g.addName "uo_" & $unionId & "_" & $i
+        objectToIr c, lastSon(n[i]), fieldTypes, unionId
+        discard sealType(c.g, subObj)
+      else: discard
+    discard sealType(c.g, u)
+  of nkSym:
+    c.g.addField n.sym.name.s & "_" & $n.sym.position, fieldTypes[n.sym.itemId]
+  else:
+    assert false, "unknown node kind: " & $n.kind
+
+proc objectToIr(c: var TypesCon; t: PType): TypeId =
+  if t[0] != nil:
+    # ensure we emitted the base type:
+    discard typeToIr(c, t[0])
+
+  var unionId = 0
+  var fieldTypes = initTable[ItemId, TypeId]()
+  collectFieldTypes c, t.n, fieldTypes
+  let obj = openType(c.g, ObjectDecl)
+  c.g.addName mangle(c, t)
+  if t[0] != nil:
+    c.g.addNominalType(ObjectTy, mangle(c, t[0]))
+  else:
+    c.g.addBuiltinType VoidId # object does not inherit
+    if not lacksMTypeField(t):
+      let f2 = c.g.openType FieldDecl
+      let voidPtr = openType(c.g, APtrTy)
+      c.g.addBuiltinType(VoidId)
+      discard sealType(c.g, voidPtr)
+      c.g.addName "m_type"
+      discard sealType(c.g, f2) # FieldDecl
+
+  objectToIr c, t.n, fieldTypes, unionId
+  result = sealType(c.g, obj)
+
+proc objectHeaderToIr(c: var TypesCon; t: PType): TypeId =
+  result = c.g.nominalType(ObjectTy, mangle(c, t))
+
+proc tupleToIr(c: var TypesCon; t: PType): TypeId =
+  var fieldTypes = newSeq[TypeId](t.len)
+  for i in 0..<t.len:
+    fieldTypes[i] = typeToIr(c, t[i])
+  let obj = openType(c.g, ObjectDecl)
+  c.g.addName mangle(c, t)
+  for i in 0..<t.len:
+    c.g.addField "f_" & $i, fieldTypes[i]
+  result = sealType(c.g, obj)
+
+proc procToIr(c: var TypesCon; 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, t[i])
+  let obj = openType(c.g, ProcTy)
+
+  case t.callConv
+  of ccNimCall, ccFastCall, ccClosure: c.g.addAnnotation "__fastcall"
+  of ccStdCall: c.g.addAnnotation "__stdcall"
+  of ccCDecl: c.g.addAnnotation "__cdecl"
+  of ccSafeCall: c.g.addAnnotation "__safecall"
+  of ccSysCall: c.g.addAnnotation "__syscall"
+  of ccInline: c.g.addAnnotation "__inline"
+  of ccNoInline: c.g.addAnnotation "__noinline"
+  of ccThisCall: c.g.addAnnotation "__thiscall"
+  of ccNoConvention: c.g.addAnnotation ""
+
+  for i in 0..<fieldTypes.len:
+    c.g.addType fieldTypes[i]
+
+  if addEnv:
+    let a = openType(c.g, APtrTy)
+    c.g.addBuiltinType(VoidId)
+    discard sealType(c.g, a)
+
+  if tfVarargs in t.flags:
+    c.g.addVarargs()
+  result = sealType(c.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; t: PType): TypeId =
+  let e = lastSon(t)
+  let elementType = typeToIr(c, e)
+  let arr = c.g.openType AArrayPtrTy
+  c.g.addType elementType
+  result = sealType(c.g, arr) # LastArrayTy
+
+proc openArrayToIr(c: var TypesCon; t: PType): TypeId =
+  # object (a: ArrayPtr[T], len: int)
+  let e = lastSon(t)
+  let mangledBase = mangle(c, e)
+  let typeName = "NimOpenArray" & mangledBase
+
+  let elementType = typeToIr(c, e)
+  #assert elementType.int >= 0, typeToString(t)
+
+  let p = openType(c.g, ObjectDecl)
+  c.g.addName typeName
+
+  let f = c.g.openType FieldDecl
+  let arr = c.g.openType AArrayPtrTy
+  c.g.addType elementType
+  discard sealType(c.g, arr) # LastArrayTy
+  c.g.addName "data"
+  discard sealType(c.g, f) # FieldDecl
+
+  c.g.addField "len", c.nativeInt
+
+  result = sealType(c.g, p) # ObjectDecl
+
+proc strPayloadType(c: var TypesCon): string =
+  result = "NimStrPayload"
+  let p = openType(c.g, ObjectDecl)
+  c.g.addName result
+  c.g.addField "cap", c.nativeInt
+
+  let f = c.g.openType FieldDecl
+  let arr = c.g.openType LastArrayTy
+  c.g.addBuiltinType Char8Id
+  discard sealType(c.g, arr) # LastArrayTy
+  c.g.addName "data"
+  discard sealType(c.g, f) # FieldDecl
+
+  discard sealType(c.g, p)
+
+proc strPayloadPtrType*(c: var TypesCon): TypeId =
+  let mangled = strPayloadType(c)
+  let ffp = c.g.openType APtrTy
+  c.g.addNominalType ObjectTy, mangled
+  result = sealType(c.g, ffp) # APtrTy
+
+proc stringToIr(c: var TypesCon): TypeId =
+  #[
+
+    NimStrPayload = object
+      cap: int
+      data: UncheckedArray[char]
+
+    NimStringV2 = object
+      len: int
+      p: ptr NimStrPayload
+
+  ]#
+  let payload = strPayloadType(c)
+
+  let str = openType(c.g, ObjectDecl)
+  c.g.addName "NimStringV2"
+  c.g.addField "len", c.nativeInt
+
+  let fp = c.g.openType FieldDecl
+  let ffp = c.g.openType APtrTy
+  c.g.addNominalType ObjectTy, "NimStrPayload"
+  discard sealType(c.g, ffp) # APtrTy
+  c.g.addName "p"
+  discard sealType(c.g, fp) # FieldDecl
+
+  result = sealType(c.g, str) # ObjectDecl
+
+proc seqPayloadType(c: var TypesCon; t: PType): string =
+  #[
+    NimSeqPayload[T] = object
+      cap: int
+      data: UncheckedArray[T]
+  ]#
+  let e = lastSon(t)
+  result = mangle(c, e)
+  let payloadName = "NimSeqPayload" & result
+
+  let elementType = typeToIr(c, e)
+
+  let p = openType(c.g, ObjectDecl)
+  c.g.addName payloadName
+  c.g.addField "cap", c.nativeInt
+
+  let f = c.g.openType FieldDecl
+  let arr = c.g.openType LastArrayTy
+  c.g.addType elementType
+  discard sealType(c.g, arr) # LastArrayTy
+  c.g.addName "data"
+  discard sealType(c.g, f) # FieldDecl
+  discard sealType(c.g, p)
+
+proc seqPayloadPtrType*(c: var TypesCon; t: PType): TypeId =
+  let mangledBase = seqPayloadType(c, t)
+  let ffp = c.g.openType APtrTy
+  c.g.addNominalType ObjectTy, "NimSeqPayload" & mangledBase
+  result = sealType(c.g, ffp) # APtrTy
+
+proc seqToIr(c: var TypesCon; t: PType): TypeId =
+  #[
+    NimSeqV2*[T] = object
+      len: int
+      p: ptr NimSeqPayload[T]
+  ]#
+  let mangledBase = seqPayloadType(c, t)
+
+  let sq = openType(c.g, ObjectDecl)
+  c.g.addName "NimSeqV2" & mangledBase
+  c.g.addField "len", c.nativeInt
+
+  let fp = c.g.openType FieldDecl
+  let ffp = c.g.openType APtrTy
+  c.g.addNominalType ObjectTy, "NimSeqPayload" & mangledBase
+  discard sealType(c.g, ffp) # APtrTy
+  c.g.addName "p"
+  discard sealType(c.g, fp) # FieldDecl
+
+  result = sealType(c.g, sq) # ObjectDecl
+
+
+proc closureToIr(c: var TypesCon; 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, t, addEnv=true)
+
+  let p = openType(c.g, ObjectDecl)
+  c.g.addName typeName
+
+  let f = c.g.openType FieldDecl
+  c.g.addType procType
+  c.g.addName "ClP_0"
+  discard sealType(c.g, f) # FieldDecl
+
+  let f2 = c.g.openType FieldDecl
+  let voidPtr = openType(c.g, APtrTy)
+  c.g.addBuiltinType(VoidId)
+  discard sealType(c.g, voidPtr)
+
+  c.g.addName "ClE_0"
+  discard sealType(c.g, f2) # FieldDecl
+
+  result = sealType(c.g, p) # ObjectDecl
+
+proc bitsetBasetype*(c: var TypesCon; 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; 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(c.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, t.lastSon)
+  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, t.lastSon)
+    else:
+      result = TypeId(-1)
+  of tyFromExpr:
+    if t.n != nil and t.n.typ != nil:
+      result = typeToIr(c, 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, t[1])
+      let a = openType(c.g, ArrayTy)
+      c.g.addType(elemType)
+      c.g.addArrayLen uint64(n)
+      result = sealType(c.g, a)
+  of tyPtr, tyRef:
+    cached(c, t):
+      let e = t.lastSon
+      if e.kind == tyUncheckedArray:
+        let elemType = typeToIr(c, e.lastSon)
+        let a = openType(c.g, AArrayPtrTy)
+        c.g.addType(elemType)
+        result = sealType(c.g, a)
+      else:
+        let elemType = typeToIr(c, t.lastSon)
+        let a = openType(c.g, APtrTy)
+        c.g.addType(elemType)
+        result = sealType(c.g, a)
+  of tyVar, tyLent:
+    cached(c, t):
+      let e = t.lastSon
+      if e.skipTypes(abstractInst).kind in {tyOpenArray, tyVarargs}:
+        # skip the modifier, `var openArray` is a (ptr, len) pair too:
+        result = typeToIr(c, e)
+      else:
+        let elemType = typeToIr(c, e)
+        let a = openType(c.g, APtrTy)
+        c.g.addType(elemType)
+        result = sealType(c.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(c.g, ArrayTy)
+        c.g.addType(UInt8Id)
+        c.g.addArrayLen uint64(s)
+        result = sealType(c.g, a)
+  of tyPointer:
+    let a = openType(c.g, APtrTy)
+    c.g.addBuiltinType(VoidId)
+    result = sealType(c.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, t)
+      else:
+        result = objectHeaderToIr(c, t)
+  of tyTuple:
+    cached(c, t):
+      result = tupleToIr(c, t)
+  of tyProc:
+    cached(c, t):
+      if t.callConv == ccClosure:
+        result = closureToIr(c, t)
+      else:
+        result = procToIr(c, t)
+  of tyVarargs, tyOpenArray:
+    cached(c, t):
+      result = openArrayToIr(c, t)
+  of tyString:
+    cached(c, t):
+      result = stringToIr(c)
+  of tySequence:
+    cached(c, t):
+      result = seqToIr(c, t)
+  of tyCstring:
+    cached(c, t):
+      let a = openType(c.g, AArrayPtrTy)
+      c.g.addBuiltinType Char8Id
+      result = sealType(c.g, a)
+  of tyUncheckedArray:
+    # We already handled the `ptr UncheckedArray` in a special way.
+    cached(c, t):
+      let elemType = typeToIr(c, t.lastSon)
+      let a = openType(c.g, LastArrayTy)
+      c.g.addType(elemType)
+      result = sealType(c.g, a)
+  of tyNone, tyEmpty, tyUntyped, tyTyped, tyTypeDesc,
+     tyNil, tyGenericInvocation, tyProxy, tyBuiltInTypeClass,
+     tyUserTypeClass, tyUserTypeClassInst, tyCompositeTypeClass,
+     tyAnd, tyOr, tyNot, tyAnything, tyConcept, tyIterable, tyForward:
+    result = TypeId(-1)
--- a/compiler/pipelines.nim
+++ b/compiler/pipelines.nim
@@ -11,7 +11,7 @@ when not defined(leanCompiler):
 import std/[syncio, objectdollar, assertions, tables, strutils]
 import renderer
 import ic/replayer
-
+import nir/nir

 proc setPipeLinePass*(graph: ModuleGraph; pass: PipelinePass) =
  graph.pipelinePass = pass
@@ -43,6 +43,8 @@ proc processPipeline(graph: ModuleGraph; semNode: PNode; bModule: PPassContext):
      result = nil
  of EvalPass, InterpreterPass:
    result = interpreterCode(bModule, semNode)
+  of NirReplPass:
+    result = runCode(bModule, semNode)
  of NonePass:
    raiseAssert "use setPipeLinePass to set a proper PipelinePass"

@@ -112,6 +114,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:
@@ -197,6 +201,8 @@ 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 SemPass, GenDependPass:
    discard
  of Docgen2Pass, Docgen2TexPass:
--- a/compiler/semobjconstr.nim
+++ b/compiler/semobjconstr.nim
@@ -68,9 +68,7 @@ proc locateFieldInInitExpr(c: PContext, field: PSym, initExpr: PNode): PNode =
    let assignment = initExpr[i]
    if assignment.kind != nkExprColonExpr:
      invalidObjConstr(c, assignment)
-      continue
-
-    if fieldId == considerQuotedIdent(c, assignment[0]).id:
+    elif fieldId == considerQuotedIdent(c, assignment[0]).id:
      return assignment

 proc semConstrField(c: PContext, flags: TExprFlags,
@@ -125,7 +123,7 @@ proc pickCaseBranch(caseExpr, matched: PNode): PNode =
      return caseExpr[i]

  if endsWithElse:
-    return caseExpr[^1]
+    result = caseExpr[^1]
  else:
    result = nil

@@ -138,8 +136,8 @@ iterator directFieldsInRecList(recList: PNode): PNode =
  else:
    doAssert recList.kind == nkRecList
    for field in recList:
-      if field.kind != nkSym: continue
-      yield field
+      if field.kind == nkSym:
+        yield field

 template quoteStr(s: string): string = "'" & s & "'"

@@ -416,8 +414,8 @@ proc semConstructTypeAux(c: PContext,
    if status in {initPartial, initNone, initUnknown}:
      discard collectMissingFields(c, t.n, constrCtx, result.defaults)
    let base = t[0]
-    if base == nil or base.id == t.id or 
-      base.kind in { tyRef, tyPtr } and base[0].id == t.id: 
+    if base == nil or base.id == t.id or
+      base.kind in {tyRef, tyPtr} and base[0].id == t.id:
        break
    t = skipTypes(base, skipPtrs)
    if t.kind != tyObject:
@@ -463,7 +461,7 @@ proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType

  if t == nil:
    return localErrorNode(c, result, "object constructor needs an object type")
-  
+
  if t.skipTypes({tyGenericInst,
      tyAlias, tySink, tyOwned, tyRef}).kind != tyObject and
      expectedType != nil and expectedType.skipTypes({tyGenericInst,
--- a/compiler/semparallel.nim
+++ b/compiler/semparallel.nim
@@ -25,7 +25,7 @@ import
  ast, astalgo, idents, lowerings, magicsys, guards, msgs,
  renderer, types, modulegraphs, options, spawn, lineinfos

-from trees import getMagic, isTrue, getRoot
+from trees import getMagic, getRoot
 from strutils import `%`

 discard """
--- a/compiler/trees.nim
+++ b/compiler/trees.nim
@@ -198,10 +198,6 @@ proc extractRange*(k: TNodeKind, n: PNode, a, b: int): PNode =
  result = newNodeI(k, n.info, b-a+1)
  for i in 0..b-a: result[i] = n[i+a]

-proc isTrue*(n: PNode): bool =
-  n.kind == nkSym and n.sym.kind == skEnumField and n.sym.position != 0 or
-    n.kind == nkIntLit and n.intVal != 0
-
 proc getRoot*(n: PNode): PSym =
  ## ``getRoot`` takes a *path* ``n``. A path is an lvalue expression
  ## like ``obj.x[i].y``. The *root* of a path is the symbol that can be
--- a/compiler/vm.nim
+++ b/compiler/vm.nim
@@ -1521,7 +1521,7 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
        frame = frame.next
        jumpTo = findExceptionHandler(c, frame, raised)

-      case jumpTo.why:
+      case jumpTo.why
      of ExceptionGotoHandler:
        # Jump to the handler, do nothing when the `finally` block ends.
        savedPC = -1
--- a/compiler/vmgen.nim
+++ b/compiler/vmgen.nim
@@ -321,10 +321,6 @@ proc isNotOpr(n: PNode): bool =
  n.kind in nkCallKinds and n[0].kind == nkSym and
    n[0].sym.magic == mNot

-proc isTrue(n: PNode): bool =
-  n.kind == nkSym and n.sym.kind == skEnumField and n.sym.position != 0 or
-    n.kind == nkIntLit and n.intVal != 0
-
 proc genWhile(c: PCtx; n: PNode) =
  # lab1:
  #   cond, tmp
--- a/lib/std/formatfloat.nim
+++ b/lib/std/formatfloat.nim
@@ -100,22 +100,23 @@ proc addFloatSprintf*(result: var string; x: float) =
    let n = writeFloatToBufferSprintf(buffer, x)
    result.addCstringN(cast[cstring](buffer[0].addr), n)

-proc nimFloatToString(a: float): cstring =
-  ## ensures the result doesn't print like an integer, i.e. return 2.0, not 2
-  # print `-0.0` properly
-  asm """
-    function nimOnlyDigitsOrMinus(n) {
-      return n.toString().match(/^-?\d+$/);
-    }
-    if (Number.isSafeInteger(`a`))
-      `result` = `a` === 0 && 1 / `a` < 0 ? "-0.0" : `a`+".0"
-    else {
-      `result` = `a`+""
-      if(nimOnlyDigitsOrMinus(`result`)){
-        `result` = `a`+".0"
+when defined(js):
+  proc nimFloatToString(a: float): cstring =
+    ## ensures the result doesn't print like an integer, i.e. return 2.0, not 2
+    # print `-0.0` properly
+    asm """
+      function nimOnlyDigitsOrMinus(n) {
+        return n.toString().match(/^-?\d+$/);
      }
-    }
-  """
+      if (Number.isSafeInteger(`a`))
+        `result` = `a` === 0 && 1 / `a` < 0 ? "-0.0" : `a`+".0"
+      else {
+        `result` = `a`+""
+        if(nimOnlyDigitsOrMinus(`result`)){
+          `result` = `a`+".0"
+        }
+      }
+    """

 proc addFloat*(result: var string; x: float | float32) {.inline.} =
  ## Converts float to its string representation and appends it to `result`.
--- a/lib/system.nim
+++ b/lib/system.nim
@@ -1117,8 +1117,6 @@ template sysAssert(cond: bool, msg: string) =

 const hasAlloc = (hostOS != "standalone" or not defined(nogc)) and not defined(nimscript)

-when notJSnotNims and hostOS != "standalone" and hostOS != "any":
-  include "system/cgprocs"
 when notJSnotNims and hasAlloc and not defined(nimSeqsV2):
  proc addChar(s: NimString, c: char): NimString {.compilerproc, benign.}

@@ -1431,7 +1429,6 @@ proc isNil*[T: proc | iterator {.closure.}](x: T): bool {.noSideEffect, magic: "
  ## Fast check whether `x` is nil. This is sometimes more efficient than
  ## `== nil`.

-
 when defined(nimHasTopDownInference):
  # magic used for seq type inference
  proc `@`*[T](a: openArray[T]): seq[T] {.magic: "OpenArrayToSeq".} =
@@ -2200,6 +2197,16 @@ when not defined(js):

 when notJSnotNims:
  when hostOS != "standalone" and hostOS != "any":
+    type
+      LibHandle = pointer       # private type
+      ProcAddr = pointer        # library loading and loading of procs:
+
+    proc nimLoadLibrary(path: string): LibHandle {.compilerproc, hcrInline, nonReloadable.}
+    proc nimUnloadLibrary(lib: LibHandle) {.compilerproc, hcrInline, nonReloadable.}
+    proc nimGetProcAddr(lib: LibHandle, name: cstring): ProcAddr {.compilerproc, hcrInline, nonReloadable.}
+
+    proc nimLoadLibraryError(path: string) {.compilerproc, hcrInline, nonReloadable.}
+
    include "system/dyncalls"

  import system/countbits_impl
@@ -2673,7 +2680,7 @@ proc `==`*(x, y: cstring): bool {.magic: "EqCString", noSideEffect,
  proc strcmp(a, b: cstring): cint {.noSideEffect,
    importc, header: "<string.h>".}
  if pointer(x) == pointer(y): result = true
-  elif x.isNil or y.isNil: result = false
+  elif pointer(x) == nil or pointer(y) == nil: result = false
  else: result = strcmp(x, y) == 0

 template closureScope*(body: untyped): untyped =
--- a/lib/system/ansi_c.nim
+++ b/lib/system/ansi_c.nim
@@ -224,7 +224,7 @@ proc rawWriteString*(f: CFilePtr, s: cstring, length: int) {.compilerproc, nonRe

 proc rawWrite*(f: CFilePtr, s: cstring) {.compilerproc, nonReloadable, inline.} =
  # we cannot throw an exception here!
-  discard c_fwrite(s, 1, cast[csize_t](s.len), f)
+  discard c_fwrite(s, 1, c_strlen(s), f)
  discard c_fflush(f)

 {.pop.}
--- a/lib/system/cgprocs.nim
+++ b/lib/system/cgprocs.nim
@@ -8,13 +8,3 @@
 #

 # Headers for procs that the code generator depends on ("compilerprocs")
-
-type
-  LibHandle = pointer       # private type
-  ProcAddr = pointer        # library loading and loading of procs:
-
-proc nimLoadLibrary(path: string): LibHandle {.compilerproc, hcrInline, nonReloadable.}
-proc nimUnloadLibrary(lib: LibHandle) {.compilerproc, hcrInline, nonReloadable.}
-proc nimGetProcAddr(lib: LibHandle, name: cstring): ProcAddr {.compilerproc, hcrInline, nonReloadable.}
-
-proc nimLoadLibraryError(path: string) {.compilerproc, hcrInline, nonReloadable.}
--- a/lib/system/memory.nim
+++ b/lib/system/memory.nim
@@ -43,6 +43,7 @@ proc nimCmpMem*(a, b: pointer, size: Natural): cint {.compilerproc, nonReloadabl
      inc i

 proc nimCStrLen*(a: cstring): int {.compilerproc, nonReloadable, inline.} =
+  if a.isNil: return 0
  when useLibC:
    cast[int](c_strlen(a))
  else:
--- a/lib/system/strmantle.nim
+++ b/lib/system/strmantle.nim
@@ -23,6 +23,14 @@ proc cmpStrings(a, b: string): int {.inline, compilerproc.} =
  else:
    result = alen - blen

+proc leStrings(a, b: string): bool {.inline, compilerproc.} =
+  # required by upcoming backends (NIR).
+  cmpStrings(a, b) <= 0
+
+proc ltStrings(a, b: string): bool {.inline, compilerproc.} =
+  # required by upcoming backends (NIR).
+  cmpStrings(a, b) < 0
+
 proc eqStrings(a, b: string): bool {.inline, compilerproc.} =
  let alen = a.len
  let blen = b.len
--- a/lib/system/strs_v2.nim
+++ b/lib/system/strs_v2.nim
@@ -201,6 +201,10 @@ proc prepareMutation*(s: var string) {.inline.} =
    let s = unsafeAddr s
    nimPrepareStrMutationV2(cast[ptr NimStringV2](s)[])

+proc nimAddStrV1(s: var NimStringV2; src: NimStringV2) {.compilerRtl, inl.} =
+  #if (s.p == nil) or (s.len+1 > s.p.cap and not strlitFlag):
+  prepareAdd(s, src.len)
+  appendString s, src

 func capacity*(self: string): int {.inline.} =
  ## Returns the current capacity of the string.