From 22f56af72be42ef05f26e27f586f4004fb498d94 Mon Sep 17 00:00:00 2001
From: Saem Ghani <saemghani+github@gmail.com>
Date: Thu, 30 Dec 2021 16:31:58 -0800
Subject: [PATCH] first pass of dod ast

Breaks/Issues:
- no more nil means have to use a sentinel value
- lots of effects because of access to `ast_types.state`
- tcan_compile_nim, tcompilerapi, and tresults fail
- the ic test category takes forever/doesn't come back

Next steps:
- test fixes
- it's pretty slow right now
- clean-up type and report storage, tables are super slow

signature change for transition procs mean we're creating new node
this could well break assumptions that pervade the compiler. Worst case
will need to supprot the mutability for now to get the first port, then
figure out how to start changing up the compiler based on
fork/join/mutation observations.
---
 compiler/ast/ast.nim               | 226 ++++++++++++++++++----
 compiler/ast/ast_types.nim         | 295 +++++++++++++++++++++++++++--
 compiler/ast/astalgo.nim           |   4 +-
 compiler/ast/enumtostr.nim         |   2 +-
 compiler/ast/errorhandling.nim     |  13 +-
 compiler/ast/filters.nim           |   2 +-
 compiler/ast/nimsets.nim           |   2 +-
 compiler/ast/parser.nim            |   7 +-
 compiler/ast/renderer.nim          |   7 +-
 compiler/ast/reports.nim           |   8 +-
 compiler/ast/types.nim             |   2 +-
 compiler/backend/ccgcalls.nim      |   2 +-
 compiler/backend/ccgexprs.nim      |   4 +-
 compiler/backend/ccgstmts.nim      |  10 +-
 compiler/backend/cgmeth.nim        |   2 +-
 compiler/backend/jsgen.nim         |   8 +-
 compiler/front/commands.nim        |  26 ++-
 compiler/front/msgs.nim            |   2 +-
 compiler/front/options.nim         |   2 +-
 compiler/ic/dce.nim                |   2 +-
 compiler/ic/ic.nim                 |   6 +-
 compiler/modules/magicsys.nim      |   2 +-
 compiler/modules/modules.nim       |   2 +-
 compiler/sem/closureiters.nim      |   8 +-
 compiler/sem/guards.nim            |  12 +-
 compiler/sem/injectdestructors.nim |   6 +-
 compiler/sem/lookups.nim           |  16 +-
 compiler/sem/lowerings.nim         |   2 +-
 compiler/sem/nilcheck.nim          |   4 +-
 compiler/sem/passes.nim            |   4 +-
 compiler/sem/patterns.nim          |   8 +-
 compiler/sem/pragmas.nim           |  38 ++--
 compiler/sem/sem.nim               |   4 +-
 compiler/sem/semcall.nim           |  10 +-
 compiler/sem/semexprs.nim          |  39 ++--
 compiler/sem/semfold.nim           |  24 +--
 compiler/sem/semgnrc.nim           |   8 +-
 compiler/sem/semobjconstr.nim      |   4 +-
 compiler/sem/semparallel.nim       |   6 +-
 compiler/sem/sempass2.nim          |   8 +-
 compiler/sem/semstmts.nim          |   5 +-
 compiler/sem/semtypes.nim          |  26 ++-
 compiler/sem/semtypinst.nim        |   6 +-
 compiler/sem/sigmatch.nim          |  67 ++++---
 compiler/sem/spawn.nim             |  20 +-
 compiler/sem/transf.nim            |  10 +-
 compiler/sem/varpartitions.nim     |   2 +-
 compiler/tools/suggest.nim         |  16 +-
 compiler/utils/astrepr.nim         |  14 +-
 compiler/vm/vm.nim                 |  36 ++--
 compiler/vm/vmcompilerserdes.nim   |  16 +-
 compiler/vm/vmdef.nim              |   7 +-
 compiler/vm/vmgen.nim              |  16 +-
 tests/vm/tnimnode.nim              |   1 -
 54 files changed, 758 insertions(+), 321 deletions(-)

diff --git a/compiler/ast/ast.nim b/compiler/ast/ast.nim
index 0f03fa848f4..e6f37cb39b1 100644
--- a/compiler/ast/ast.nim
+++ b/compiler/ast/ast.nim
@@ -34,7 +34,7 @@ type Gconfig = object
   ## we put comments in a side channel to avoid increasing `sizeof(TNode)`,
   ## which reduces memory usage given that `PNode` is the most allocated
   ## type by far.
-  comments: Table[int, string] # nodeId => comment
+  comments: Table[NodeId, string] # nodeId => comment
   useIc*: bool
 
 var gconfig {.threadvar.}: Gconfig
@@ -319,6 +319,7 @@ proc discardSons*(father: PNode)
 type Indexable = PNode | PType
 
 proc len*(n: Indexable): int {.inline.} =
+  ## number of children, unsafe if called on leaf nodes, see `safeLen`
   result = n.sons.len
 
 proc safeLen*(n: PNode): int {.inline.} =
@@ -326,15 +327,22 @@ proc safeLen*(n: PNode): int {.inline.} =
   if n.kind in {nkNone..nkNilLit}: result = 0
   else: result = n.len
 
-proc add*(father, son: Indexable) =
-  assert son != nil
-  father.sons.add(son)
+proc safeArrLen*(n: PNode): int {.inline.} =
+  ## works for array-like objects (strings passed as openArray in VM).
+  if n.kind in {nkStrLit..nkTripleStrLit}: result = n.strVal.len
+  elif n.kind in {nkNone..nkFloat128Lit}: result = 0
+  else: result = n.len
 
 proc addAllowNil*(father, son: Indexable) {.inline.} =
   father.sons.add(son)
 
+proc add*(father, son: Indexable) {.inline.} =
+  assert son != nil
+  addAllowNil(father, son)
+
 template `[]`*(n: Indexable, i: int): Indexable = n.sons[i]
-template `[]=`*(n: Indexable, i: int; x: Indexable) = n.sons[i] = x
+template `[]=`*(n: Indexable, i: int; x: Indexable) =
+  n.sons[i] = x
 
 template `[]`*(n: Indexable, i: BackwardsIndex): Indexable = n[n.len - i.int]
 template `[]=`*(n: Indexable, i: BackwardsIndex; x: Indexable) = n[n.len - i.int] = x
@@ -366,19 +374,46 @@ proc getDeclPragma*(n: PNode): PNode =
       result = n[0][1]
   else:
     # support as needed for `nkIdentDefs` etc.
-    result = nil
+    result = nilPNode
   if result != nil:
     assert result.kind == nkPragma, $(result.kind, n.kind)
 
-const invalidNodeId* = 0
-var gNodeId: int
-
 when defined(useNodeIds):
-  const nodeIdToDebug* = -1 # 2322968
+  const nodeIdToDebug* = NodeId -1 # 2322968
 
-template setNodeId() =
-  inc gNodeId
-  result.id = gNodeId
+template newNodeImpl(kind: TNodeKind, info2: TLineInfo) =
+  # result = PNode(kind: kind, info: info2)
+  {.cast(noSideEffect).}:
+    let
+      nodeId = state.nextNodeId()
+      nodeIdx = nodeId.idx
+    state.nodeList.add NodeData(kind: kind)
+    state.nodeInf.add info2
+    state.nodeFlag.add {}
+    case extraDataKind(kind):
+    of ExtraDataInt:
+      state.nodeInt.add 0
+      state.nodeList[nodeIdx].extra = ExtraDataId state.nodeInt.len
+    of ExtraDataFloat:
+      state.nodeFlt.add 0
+      state.nodeList[nodeIdx].extra = ExtraDataId state.nodeFlt.len
+    of ExtraDataString:
+      state.nodeStr.add ""
+      state.nodeList[nodeIdx].extra = ExtraDataId state.nodeStr.len
+    of ExtraDataSymbol:
+      state.nodeSym.add nil
+      state.nodeList[nodeIdx].extra = ExtraDataId state.nodeSym.len
+    of ExtraDataIdentifier:
+      state.nodeIdt.add nil
+      state.nodeList[nodeIdx].extra = ExtraDataId state.nodeIdt.len
+    of ExtraDataAst, ExtraDataNone:
+      state.astData.add @[]
+      state.nodeList[nodeIdx].extra = ExtraDataId state.astData.len
+      discard
+
+    result = PNode(id: nodeId)
+
+template checkNodeIdForDebug() =
   when defined(useNodeIds):
     if result.id == nodeIdToDebug:
       echo "KIND ", result.kind
@@ -386,16 +421,17 @@ template setNodeId() =
 
 func newNodeI*(kind: TNodeKind, info: TLineInfo): PNode =
   ## new node with line info, no type, and no children
-  result = PNode(kind: kind, info: info, reportId: emptyReportId)
+  newNodeImpl(kind, info)
   {.cast(noSideEffect).}:
-    setNodeId()
-  when false:
-    # this would add overhead, so we skip it; it results in a small amount of leaked entries
-    # for old PNode that gets re-allocated at the same address as a PNode that
-    # has `nfHasComment` set (and an entry in that table). Only `nfHasComment`
-    # should be used to test whether a PNode has a comment; gconfig.comments
-    # can contain extra entries for deleted PNode's with comments.
-    gconfig.comments.del(result.id)
+    checkNodeIdForDebug()
+    when defined(nimsuggest):
+      # this would add overhead, so we skip it; it results in a small amount of
+      # leaked entries for old PNode that gets re-allocated at the same address
+      # as a PNode that has `nfHasComment` set (and an entry in that table).
+      # Only `nfHasComment` should be used to test whether a PNode has a
+      # comment; gconfig.comments can contain extra entries for deleted PNode's
+      # with comments.
+      gconfig.comments.del(result.id)
 
 proc newNode*(kind: TNodeKind): PNode =
   ## new node with unknown line info, no type, and no children
@@ -418,6 +454,11 @@ proc newNodeIT*(kind: TNodeKind, info: TLineInfo, typ: PType, children: int): PN
   if children > 0:
     newSeq(result.sons, children)
 
+proc newErrorNodeIT*(rep: ReportId, info: TLineInfo, typ: PType): PNode =
+  ## new node with line info, type, report, and no children
+  result = newNodeIT(nkError, info, typ)
+  result.reportId = rep
+
 proc newTree*(kind: TNodeKind; children: varargs[PNode]): PNode =
   result = newNode(kind)
   if children.len > 0:
@@ -802,14 +843,43 @@ proc delSon*(father: PNode, idx: int) =
   for i in idx..<father.len - 1: father[i] = father[i + 1]
   father.sons.setLen(father.len - 1)
 
+proc applyToNode*(src, dest: PNode) =
+  ## used for the VM when we pass nodes "by value"
+  # assert not dest.isNil
+  # assert not src.isNil
+  # assert dest.id != src.id, "applying to self, id: " & $src.id
+  state.nodeList[dest.idx] = state.nodeList[src.idx]
+  state.nodeFlag[dest.idx] = state.nodeFlag[src.idx]
+  state.nodeInf[dest.idx] = state.nodeInf[src.idx]
+  if state.nodeTyp.hasKey(src.id):
+    state.nodeTyp[dest.id] = state.nodeTyp[src.id]
+  if state.nodeRpt.hasKey(src.id):
+    state.nodeRpt[dest.id] = state.nodeRpt[src.id]
+  case src.kind.extraDataKind
+  of ExtraDataInt:
+    dest.intVal = src.intVal
+  of ExtraDataFloat:
+    dest.floatVal = src.floatVal
+  of ExtraDataString:
+    dest.strVal = src.strVal
+  of ExtraDataSymbol:
+    dest.sym = src.sym
+  of ExtraDataIdentifier:
+    dest.ident = src.ident
+  of ExtraDataAst, ExtraDataNone:
+    dest.sons = src.sons
+
 template copyNodeImpl(dst, src, processSonsStmt) =
-  if src == nil: return
+  # does not copy src's sons to dst
+  if src == nil:
+    return nilPNode
   dst = newNode(src.kind)
   dst.info = src.info
   dst.typ = src.typ
   dst.flags = src.flags * PersistentNodeFlags
   dst.comment = src.comment
-  dst.reportId = src.reportId
+  if src.kind == nkError:
+    dst.reportId = src.reportId
   when defined(useNodeIds):
     if dst.id == nodeIdToDebug:
       echo "COMES FROM ", src.id
@@ -826,22 +896,108 @@ proc copyNode*(src: PNode): PNode =
   copyNodeImpl(result, src):
     discard
 
-template transitionNodeKindCommon(k: TNodeKind) =
-  let obj {.inject.} = n[]
-  n[] = TNode(id: obj.id, kind: k, typ: obj.typ, info: obj.info,
-              flags: obj.flags)
-  # n.comment = obj.comment # shouldn't be needed, the address doesnt' change
+type
+  NodeDataToClear = enum
+    nodeClearAst,
+    nodeClearFlg,
+    nodeClearInf,
+    nodeClearSym,
+    nodeClearIdt,
+    nodeClearTyp,
+    nodeClearInt,
+    nodeClearFlt,
+    nodeClearStr,
+    nodeClearRpt,
+    nodeClearCmt
+
+func determineNodeDataToClear(k: TNodeKind): set[NodeDataToClear] {.inline.} =
+  case k
+  of nkCharLit..nkUInt64Lit:
+    {nodeClearAst, nodeClearSym, nodeClearIdt, nodeClearFlt, nodeClearStr, nodeClearRpt}
+  of nkFloatLit..nkFloat128Lit:
+    {nodeClearAst, nodeClearSym, nodeClearIdt, nodeClearInt, nodeClearStr, nodeClearRpt}
+  of nkStrLit..nkTripleStrLit:
+    {nodeClearAst, nodeClearSym, nodeClearIdt, nodeClearInt, nodeClearFlt, nodeClearRpt}
+  of nkSym:
+    {nodeClearAst, nodeClearIdt, nodeClearInt, nodeClearFlt, nodeClearStr, nodeClearRpt}
+  of nkIdent:
+    {nodeClearAst, nodeClearSym, nodeClearInt, nodeClearFlt, nodeClearStr, nodeClearRpt}
+  of nkError:
+    {nodeClearIdt, nodeClearSym, nodeClearInt, nodeClearFlt, nodeClearStr}
+  else:
+    {nodeClearIdt, nodeClearSym, nodeClearInt, nodeClearFlt, nodeClearStr, nodeClearRpt}
+    # xxx: this should handle empty and other special cases
+
+template transitionNodeKindCommon(k, old: TNodeKind) =
+  # xxx: this used to be a memory copy, but now we just change the kind
+  # xxx: trace the transition for lineage information
+
+  # clear old data: this was added as part of the data oriented design
+  #                 refactor; might be a source of bugs wrt to how legacy code
+  #                 expects things to work, try to favour fixing legacy code
+  let
+    kExtraDataKind = extraDataKind(k)
+    oldExtraDataKind = extraDataKind(old)
+    sameNodeVariety = kExtraDataKind == oldExtraDataKind ## kinds need equivalent storage
+    clears =
+      if sameNodeVariety: {}            # don't clear if the same
+      else: determineNodeDataToClear(k)
+    resetExtraDataId = clears != {} and oldExtraDataKind != ExtraDataNone
+
+  for clear in clears.items:
+    case clear
+    of nodeClearAst:
+      if oldExtraDataKind == ExtraDataAst:
+        state.astData[n.extraIdx].setLen(0)
+    of nodeClearFlg: state.nodeFlag[n.idx] = {}
+    of nodeClearInf: state.nodeInf[n.idx] = unknownLineInfo
+    of nodeClearTyp: state.nodeTyp.del(n.id)
+    of nodeClearRpt: state.nodeRpt.del(n.id)
+    of nodeClearSym:
+      if oldExtraDataKind == ExtraDataSymbol:
+        state.nodeSym[n.extraId.idx] = nil
+    of nodeClearIdt:
+      if oldExtraDataKind == ExtraDataIdentifier:
+        state.nodeIdt[n.extraId.idx] = nil
+    of nodeClearInt:
+      if oldExtraDataKind == ExtraDataInt:
+        state.nodeInt[n.extraId.idx] = 0
+    of nodeClearFlt:
+      if oldExtraDataKind == ExtraDataFloat:
+        state.nodeFlt[n.extraId.idx] = 0.0
+    of nodeClearStr:
+      if oldExtraDataKind == ExtraDataString:
+        state.nodeStr[n.extraId.idx] = ""
+    of nodeClearCmt: gconfig.comments.del(n.id)
+  
+  state.nodeList[n.idx].kind = k
+
+  # xxx: setup storage if we reset it
+  if resetExtraDataId:
+    state.nodeList[n.idx].extra = nilExtraDataId
+  
+  when defined(useNodeIds):
+    if n.id == nodeIdToDebug:
+      echo "KIND ", n.kind
+      writeStackTrace()
 
 proc transitionSonsKind*(n: PNode, kind: range[nkDotCall..nkTupleConstr]) =
-  transitionNodeKindCommon(kind)
-  n.sons = obj.sons
+  # xxx: just change the kind now, might need clearing/validation here
+  transitionNodeKindCommon(kind, n.kind)
+  # xxx: this used to copy sons, not sure if that's still needed.
 
 proc transitionIntKind*(n: PNode, kind: range[nkCharLit..nkUInt64Lit]) =
-  transitionNodeKindCommon(kind)
-  n.intVal = obj.intVal
+  # xxx: just change the kind now, might need clearing/validation here
+  transitionNodeKindCommon(kind, n.kind)
+
+proc transitionToNilLit*(n: PNode) =
+  ## used to reset a node to a nil literal
+  transitionNodeKindCommon(nkNilLit, n.kind)
 
 proc transitionNoneToSym*(n: PNode) =
-  transitionNodeKindCommon(nkSym)
+  # xxx: just change the kind now, might need clearing/validation here
+  #      see the hack in `semtypes.semTypeIdent`
+  transitionNodeKindCommon(nkSym, n.kind)
 
 template transitionSymKindCommon*(k: TSymKind) =
   let obj {.inject.} = s[]
@@ -1175,7 +1331,7 @@ proc findUnresolvedStatic*(n: PNode): PNode =
     let n = son.findUnresolvedStatic
     if n != nil: return n
 
-  return nil
+  return nilPNode
 
 when false:
   proc containsNil*(n: PNode): bool =
diff --git a/compiler/ast/ast_types.nim b/compiler/ast/ast_types.nim
index 7432e27d9ee..006ce008be9 100644
--- a/compiler/ast/ast_types.nim
+++ b/compiler/ast/ast_types.nim
@@ -768,13 +768,81 @@ proc hash*(x: ItemId): Hash =
   h = h !& hash(x.item)
   result = !$h
 
+import std/tables # for DOD ast
 
 type
   TIdObj* {.acyclic.} = object of RootObj
     itemId*: ItemId
   PIdObj* = ref TIdObj
 
-  PNode* = ref TNode
+  #----------------------------------------------------------------------------
+  # DOD AST Draft - Start
+  #----------------------------------------------------------------------------
+
+  # Actually implementing, would go something like:
+  # 1. repeat this pattern for P/TSym and P/TType
+  # 2. drop old P/TNode, P/TSym, and P/TType
+  # 3. implement inline accessors to replace fields
+  #    a. bash compiler until it compiles
+  # 5. discover zany uses of the P/TNode and friends...
+  #    a. bash compiler until it compiles
+  # 6. run all the tests
+  #    a. bash compiler until tests pass
+
+  PNode* = object
+    ## initial conversion point of AST to a data oriented design; rename to
+    ## `PNode` and swap out the old `PNode` for this
+    id*: NodeId
+
+  NodeData* = object
+    ## bare minimum data we need to know about every node
+    kind*: TNodeKind    ## presently the same as the nim node
+    extra*: ExtraDataId ## id into extra data about this node, depends on
+                        ## `kind`, for lookup of literal, sym, ident, etc
+
+  State* = ref object
+    nodeList*: NodeList        ## each node, NodeId is their sequence index
+    nodeFlag*: seq[TNodeFlags] ## flags for each node, rarely accessed bloat
+
+    nodeInf*: seq[TLineInfo]   ## info on a per node basis
+
+    # astData*: AstTree          ## actual tree structure for the various AST
+
+    # sparse data, not all nodes have these
+    nodeTyp*: OrderedTable[NodeId, PType]    ## types
+    nodeRpt*: OrderedTable[NodeId, ReportId] ## report id
+
+    # all indexed by the extra data field
+    nodeSym*: seq[PSym]         ## symbols
+    nodeIdt*: seq[PIdent]       ## identifiers
+    nodeInt*: seq[BiggestInt]   ## int literals
+    nodeFlt*: seq[BiggestFloat] ## float literals
+    nodeStr*: seq[string]       ## string literals
+    astData*: seq[TNodeSeq]     ## the sons for ast nodes
+
+  ExtraDataKind* {.pure.} = enum
+    ExtraDataNone,
+    ExtraDataInt,
+    ExtraDataFloat,
+    ExtraDataString,
+    ExtraDataSymbol,
+    ExtraDataIdentifier,
+    ExtraDataAst
+
+  # IDs
+  # xxx: disabled distincts until the basics work
+  NodeId* = distinct int      ## the minimum amount of data identifying a node
+  ExtraDataId* = distinct int ## id to extra information for some nodes
+  InfoId* = #[distinct]# int       ## used by Nodes & Symbols for line info
+                              ## an index into the info sequence
+
+  NodeList* = seq[NodeData]
+
+  #----------------------------------------------------------------------------
+  # DOD AST Draft - End
+  #----------------------------------------------------------------------------
+
+  # PNode* = ref TNode
   TNodeSeq* = seq[PNode]
   PType* = ref TType
   PSym* = ref TSym
@@ -889,8 +957,6 @@ type
 
   PScope* = ref TScope
 
-
-
   PLib* = ref TLib
   TSym* {.acyclic.} = object of TIdObj # Keep in sync with PackedSym
     ## proc and type instantiations are cached in the generic symbol
@@ -1030,7 +1096,215 @@ type
   TImplication* = enum
     impUnknown, impNo, impYes
 
+const emptyReportId* = ReportId(0)
+
+func `==`*(id1, id2: ReportId): bool = uint32(id1) == uint32(id2)
+func `<`*(id1, id2: ReportId): bool = uint32(id1) < uint32(id2)
+
+func isEmpty*(id: ReportId): bool = id == emptyReportId
+
+func `$`*(id: ReportId): string =
+  if id.isEmpty:
+    "<empty report id>"
+
+  else:
+    "<report-id-" & $uint32(id) & ">"
 
+#------------------------------------------------------------------------------
+# DOD AST Draft - Start
+#------------------------------------------------------------------------------
+
+# xxx: need this stuff for distincts
+proc hash*(n: NodeId): Hash {.borrow.}
+proc `==`*(a, b: NodeId): bool {.borrow.}
+proc cmp*(a, b: NodeId): int = cmp(a.int, b.int)
+proc `$`*(n: NodeId): string {.inline.} = $(int(n))
+# proc hash*(n: InfoId): Hash {.borrow.}
+# proc `==`*(a, b: InfoId): bool {.borrow.}
+# proc cmp*(a, b: InfoId): int = cmp(a.int, b.int)
+proc cmp*(a, b: PSym): int = cmp(cast[int](a), cast[int](b))
+proc `==`*(a, b: ExtraDataId): bool {.borrow.}
+
+func extraDataKind*(k: TNodeKind): ExtraDataKind {.inline.} =
+  case k
+  of nkCharLit..nkUInt64Lit:    ExtraDataInt
+  of nkFloatLit..nkFloat128Lit: ExtraDataFloat
+  of nkStrLit..nkTripleStrLit:  ExtraDataString
+  of nkSym:                     ExtraDataSymbol
+  of nkIdent:                   ExtraDataIdentifier
+  else:                         ExtraDataAst
+
+const
+  # unknownLineInfoId = InfoId 0
+  nilNodeId* = NodeId 0
+  nilExtraDataId* = ExtraDataId 0
+
+const nilPNode* = PNode(id: nilNodeId)
+
+func `==`*(a, b: PNode): bool {.inline.} =
+  a.id == b.id
+func `==`*(a: PNode, b: typeof(nil)): bool {.inline.} =
+  a.id == nilNodeId
+func `==`*(a: typeof(nil), b: PNode): bool {.inline.} =
+  b.id == nilNodeId
+func isNil*(a: PNode): bool {.inline.} =
+  a.id == nilNodeId
+
+var state* = State(
+    # xxx: set good default capacity based on the system lib alone
+  )
+
+func isBad*(n: PNode): bool {.inline, deprecated: "for debugging".} =
+  return n.id != nilNodeId
+func isNilOrBad*(n: PNode): bool {.inline, deprecated: "for debugging".} =
+  return n.id != nilNodeId
+
+proc nextNodeId*(s: State): NodeId {.inline.} =
+  NodeId state.nodeList.len + 1
+
+func idx*(n: NodeId): int {.inline.} =
+  ## internal NodeId to node index
+  # assert n != nilNodeId, "attempting to get an idx of a nil node"
+  n.int - 1
+func idx*(n: PNode): int {.inline.} = n.id.idx
+  ## internal PNode to node index
+
+proc extraId*(n: PNode): ExtraDataId {.inline.} =
+  ## quick access to the ExtraDataId for a node
+  state.nodeList[n.idx].extra
+func idx*(e: ExtraDataId): int {.inline.} =
+  ## internal ExtraDataId to node extra data index
+  # assert e != nilExtraDataId, "attempting to get an idx of a nil extra data id"
+  e.int - 1
+proc extraIdx*(n: PNode): int {.inline.} = n.extraId.idx
+  ## quick access to the extra data index for a node
+
+func id*(n: PNode): NodeId {.inline.} = n.id
+
+proc kind*(n: PNode): TNodeKind =
+  {.cast(noSideEffect).}:
+    result = state.nodeList[n.idx].kind
+
+proc typ*(n: PNode): PType {.inline.} =
+  {.cast(noSideEffect).}:
+    result = state.nodeTyp.getOrDefault(n.id, nil)
+proc `typ=`*(n: PNode, t: PType) {.inline.} =
+  state.nodeTyp[n.id] = t
+
+proc info*(n: PNode): var TLineInfo {.inline.} =
+  {.cast(noSideEffect).}:
+    result = state.nodeInf[n.idx]
+proc `info=`*(n: PNode, info: TLineInfo) {.inline.} =
+  state.nodeInf[n.idx] = info
+
+proc flags*(n: PNode): var TNodeFlags {.inline.} =
+  state.nodeFlag[n.idx]
+proc `flags=`*(n: PNode, flags: TNodeFlags) {.inline.} =
+  state.nodeFlag[n.idx] = flags
+
+proc intVal*(n: PNode): var BiggestInt {.inline.} =
+  # assert n.kind in {nkCharLit..nkUInt64Lit}, "not an integer, id: " & $n.id
+  {.cast(noSideEffect).}:
+    result = state.nodeInt[n.extraIdx]
+proc `intVal=`*(n: PNode, v: BiggestInt) {.inline.} =
+  # assert n.kind in {nkCharLit..nkUInt64Lit}, "not an integer, id: " & $n.id
+  if n.extraId == nilExtraDataId:
+    state.nodeInt.add v
+    state.nodeList[n.idx].extra = ExtraDataId state.nodeInt.len
+  else:
+    state.nodeInt[n.extraId.idx] = v
+
+proc floatVal*(n: PNode): var BiggestFloat {.inline.} =
+  # assert n.kind in {nkFloatLit..nkFloat128Lit}, "not a float, id: " & $n.id
+  {.cast(noSideEffect).}:
+    result = state.nodeFlt[n.extraId.idx]
+proc `floatVal=`*(n: PNode, v: BiggestFloat) {.inline.} =
+  # assert n.kind in {nkFloatLit..nkFloat128Lit}, "not a float, id: " & $n.id
+  if n.extraId == nilExtraDataId:
+    state.nodeFlt.add v
+    state.nodeList[n.idx].extra = ExtraDataId state.nodeFlt.len
+  else:
+    state.nodeFlt[n.extraId.idx] = v
+
+proc strVal*(n: PNode): var string {.inline.} =
+  # assert n.kind in {nkStrLit..nkTripleStrLit}, "not a string, id: " & $n.id
+  {.cast(noSideEffect).}:
+    result = state.nodeStr[n.extraId.idx]
+proc `strVal=`*(n: PNode, v: string) {.inline.} =
+  # assert n.kind in {nkStrLit..nkTripleStrLit}, "not a string, id: " & $n.id
+  if n.extraId == nilExtraDataId:
+    state.nodeStr.add v
+    state.nodeList[n.idx].extra = ExtraDataId state.nodeStr.len
+  else:
+    state.nodeStr[n.extraId.idx] = v
+
+proc sym*(n: PNode): PSym {.inline.} =
+  # assert n.kind == nkSym, "not a symbol, id: " & $n.id & " and kind: " & $n.kind
+  {.cast(noSideEffect).}:
+    result = state.nodeSym[n.extraId.idx]
+proc `sym=`*(n: PNode, sym: PSym) {.inline.} =
+  # assert n.kind == nkSym, "not a symbol, id: " & $n.id
+  {.cast(noSideEffect).}:
+    if n.extraId == nilExtraDataId:
+      state.nodeSym.add sym
+      state.nodeList[n.idx].extra = ExtraDataId state.nodeSym.len
+    else:
+      state.nodeSym[n.extraId.idx] = sym
+
+proc ident*(n: PNode): PIdent {.inline.} =
+  assert n.kind == nkIdent, "not an ident, id: " & $n.id
+  {.cast(noSideEffect).}:
+    result = state.nodeIdt[n.extraId.idx]
+proc `ident=`*(n: PNode, ident: PIdent) {.inline.} =
+  assert n.kind == nkIdent, "not an ident, id: " & $n.id
+  {.cast(noSideEffect).}:
+    if n.extraId == nilExtraDataId:
+      state.nodeIdt.add ident
+      state.nodeList[n.idx].extra = ExtraDataId state.nodeIdt.len
+    else:
+      state.nodeIdt[n.extraId.idx] = ident
+
+const haveNoSons = {
+    nkCharLit..nkUInt64Lit,
+    nkFloatLit..nkFloat128Lit,
+    nkStrLit..nkTripleStrLit,
+    nkSym,
+    nkIdent
+  }
+
+proc initSons*(n: PNode) {.inline.} =
+  ## reset sons storage, this shouldn't be needed if lifetimes were clarified
+  ## and the VM didn't abuse nodes as it does.
+  if n.extraId == nilExtraDataId:
+      state.astData.add @[]
+      state.nodeList[n.idx].extra = ExtraDataId state.astData.len
+
+proc sons*(n: PNode): var TNodeSeq {.inline.} =
+  # assert n.kind notin haveNoSons, "not a parent, id: " & $n.id
+  {.cast(noSideEffect).}:
+    # assert n.id.int <= state.nodeList.len, "invalid node id: " & $n.id.int
+    initSons(n)
+    result = state.astData[n.extraId.idx]
+proc `sons=`*(n: PNode, sons: TNodeSeq) =
+  # assert n.kind notin haveNoSons, "not a parent, id: " & $n.id
+  # assert n.id.int <= state.nodeList.len, "invalid node id: " & $n.id.int
+  {.cast(noSideEffect).}:
+    state.astData[n.extraIdx] = sons
+
+proc reportId*(n: PNode): ReportId {.inline.} =
+  state.nodeRpt.getOrDefault(n.id, emptyReportId)
+proc `reportId=`*(n: PNode, id: ReportId) {.inline.} =
+  state.nodeRpt[n.id] = id
+
+proc idToNode*(id: NodeId): PNode {.inline.} =
+  # assert id.int <= state.nodeList.len, "invalid node id: " & $id.int
+  case id
+  of nilNodeId: nilPNode
+  else: PNode(id: id)
+
+#------------------------------------------------------------------------------
+# DOD AST Draft - End
+#------------------------------------------------------------------------------
 
 type
   EffectsCompat* = enum
@@ -1113,18 +1387,3 @@ type
       # overload resolution.
 
   TExprFlags* = set[TExprFlag]
-
-
-const emptyReportId* = ReportId(0)
-
-func `==`*(id1, id2: ReportId): bool = uint32(id1) == uint32(id2)
-func `<`*(id1, id2: ReportId): bool = uint32(id1) < uint32(id2)
-
-func isEmpty*(id: ReportId): bool = id == emptyReportId
-
-func `$`*(id: ReportId): string =
-  if id.isEmpty:
-    "<empty report id>"
-
-  else:
-    "<report-id-" & $uint32(id) & ">"
diff --git a/compiler/ast/astalgo.nim b/compiler/ast/astalgo.nim
index 9376a6cb1bf..0dd0483d923 100644
--- a/compiler/ast/astalgo.nim
+++ b/compiler/ast/astalgo.nim
@@ -89,7 +89,7 @@ proc sameValue*(a, b: PNode): bool =
     #InternalError(a.info, "SameValue")
     discard
 
-proc leValue*(a, b: PNode): bool =
+func leValue*(a, b: PNode): bool =
   # a <= b?
   result = false
   case a.kind
@@ -501,7 +501,7 @@ proc idNodeTableGet(t: TIdNodeTable, key: PIdObj): PNode =
   var index: int
   index = idNodeTableRawGet(t, key)
   if index >= 0: result = t.data[index].val
-  else: result = nil
+  else: result = nilPNode
 
 proc idNodeTableRawInsert(data: var TIdNodePairSeq, key: PIdObj, val: PNode) =
   var h: Hash
diff --git a/compiler/ast/enumtostr.nim b/compiler/ast/enumtostr.nim
index 12b206321e6..72dc87c483c 100644
--- a/compiler/ast/enumtostr.nim
+++ b/compiler/ast/enumtostr.nim
@@ -52,7 +52,7 @@ proc genEnumToStrProc*(t: PType; info: TLineInfo; g: ModuleGraph; idgen: IdGener
 proc searchObjCaseImpl(obj: PNode; field: PSym): PNode =
   case obj.kind
   of nkSym:
-    result = nil
+    result = nilPNode
   of nkElse, nkOfBranch:
     result = searchObjCaseImpl(obj.lastSon, field)
   else:
diff --git a/compiler/ast/errorhandling.nim b/compiler/ast/errorhandling.nim
index a1b23adf964..e26bdef5ff0 100644
--- a/compiler/ast/errorhandling.nim
+++ b/compiler/ast/errorhandling.nim
@@ -49,11 +49,11 @@ proc errorSubNode*(n: PNode): PNode =
   ## find the first error node, or nil, under `n` using a depth first traversal
   case n.kind
   of nkEmpty..nkNilLit:
-    result = nil
+    result = nilPNode
   of nkError:
     result = n
   else:
-    result = nil
+    result = nilPNode
     for s in n.items:
       if s.isNil: continue
       result = errorSubNode(s)
@@ -85,11 +85,10 @@ proc newError*(
   assert wrongNode != nil, "can't have a nil node for `wrongNode`"
   assert not report.isEmpty(), $report
 
-  result = PNode(
-    kind: nkError,
-    info: wrongNode.info,
-    typ: newType(tyError, ItemId(module: -2, item: -1), nil),
-    reportId: report
+  result = newErrorNodeIT(
+    report,
+    wrongNode.info,
+    newType(tyError, ItemId(module: -2, item: -1), nil)
   )
 
   addInNimDebugUtilsError(conf, wrongNode, result)
diff --git a/compiler/ast/filters.nim b/compiler/ast/filters.nim
index 62c0a36978c..ae8e72f3d06 100644
--- a/compiler/ast/filters.nim
+++ b/compiler/ast/filters.nim
@@ -32,7 +32,7 @@ proc invalidPragma(conf: ConfigRef; n: PNode) =
   conf.localReport(n.info, reportAst(rsemNodeNotAllowed, n))
 
 proc getArg(conf: ConfigRef; n: PNode, name: string, pos: int): PNode =
-  result = nil
+  result = nilPNode
   if n.kind in {nkEmpty..nkNilLit}: return
   for i in 1..<n.len:
     if n[i].kind == nkExprEqExpr:
diff --git a/compiler/ast/nimsets.nim b/compiler/ast/nimsets.nim
index f3a9cb187a4..640956835b4 100644
--- a/compiler/ast/nimsets.nim
+++ b/compiler/ast/nimsets.nim
@@ -33,7 +33,7 @@ proc inSet*(s: PNode, elem: PNode): bool =
         return true
   result = false
 
-proc overlap*(a, b: PNode): bool =
+func overlap*(a, b: PNode): bool =
   if a.kind == nkRange:
     if b.kind == nkRange:
       # X..Y and C..D overlap iff (X <= D and C <= Y)
diff --git a/compiler/ast/parser.nim b/compiler/ast/parser.nim
index f90cd06820c..233bd16820f 100644
--- a/compiler/ast/parser.nim
+++ b/compiler/ast/parser.nim
@@ -448,7 +448,7 @@ proc exprList(p: var Parser, endTok: TokType, result: PNode) =
   when defined(nimpretty):
     dec p.em.doIndentMore
 
-proc exprColonEqExprListAux(p: var Parser, endTok: TokType, result: PNode) =
+proc exprColonEqExprListAux(p: var Parser, endTok: TokType, result: var PNode) =
   assert(endTok in {tkCurlyRi, tkCurlyDotRi, tkBracketRi, tkParRi})
   getTok(p)
   flexComment(p, result)
@@ -518,7 +518,8 @@ proc setOrTableConstr(p: var Parser): PNode =
     # progress guaranteed
     while p.tok.tokType notin {tkCurlyRi, tkEof}:
       var a = exprColonEqExpr(p)
-      if a.kind == nkExprColonExpr: result.transitionSonsKind(nkTableConstr)
+      if a.kind == nkExprColonExpr:
+        result.transitionSonsKind(nkTableConstr)
       result.add(a)
       if p.tok.tokType != tkComma: break
       getTok(p)
@@ -1709,7 +1710,7 @@ proc parseTry(p: var Parser; isExpr: bool): PNode =
   getTok(p)
   colcom(p, result)
   result.add(parseStmt(p))
-  var b: PNode = nil
+  var b: PNode = nilPNode
   while sameOrNoInd(p) or isExpr:
     case p.tok.tokType
     of tkExcept:
diff --git a/compiler/ast/renderer.nim b/compiler/ast/renderer.nim
index 49be60b144b..9b9ca71e383 100644
--- a/compiler/ast/renderer.nim
+++ b/compiler/ast/renderer.nim
@@ -408,7 +408,9 @@ proc atom(g: TSrcGen; n: PNode): string =
   of nkUInt64Lit: result = ulitAux(g, n, n.intVal, 8) & "\'u64"
   of nkFloatLit:
     if n.flags * {nfBase2, nfBase8, nfBase16} == {}: result = $(n.floatVal)
-    else: result = litAux(g, n, (cast[PInt64](addr(n.floatVal)))[] , 8)
+    else:
+      f = n.floatVal
+      result = litAux(g, n, (cast[PInt64](addr(f)))[] , 8)
   of nkFloat32Lit:
     if n.flags * {nfBase2, nfBase8, nfBase16} == {}:
       result = $n.floatVal & "\'f32"
@@ -419,7 +421,8 @@ proc atom(g: TSrcGen; n: PNode): string =
     if n.flags * {nfBase2, nfBase8, nfBase16} == {}:
       result = $n.floatVal & "\'f64"
     else:
-      result = litAux(g, n, (cast[PInt64](addr(n.floatVal)))[], 8) & "\'f64"
+      f = n.floatVal
+      result = litAux(g, n, (cast[PInt64](addr(f)))[], 8) & "\'f64"
   of nkNilLit: result = "nil"
   of nkType:
     if (n.typ != nil) and (n.typ.sym != nil): result = n.typ.sym.name.s
diff --git a/compiler/ast/reports.nim b/compiler/ast/reports.nim
index be3c6107c1f..e2868fbb2eb 100644
--- a/compiler/ast/reports.nim
+++ b/compiler/ast/reports.nim
@@ -369,7 +369,7 @@ proc reportSymbols*(
     kind: ReportKind,
     symbols: seq[PSym],
     typ: PType = nil,
-    ast: PNode = nil
+    ast: PNode = nilPNode
   ): SemReport =
   case kind:
     of rsemReportTwoSym: assert symbols.len == 2
@@ -392,20 +392,20 @@ func reportAst*(
 
 func reportTyp*(
     kind: ReportKind,
-    typ: PType, ast: PNode = nil, sym: PSym = nil, str: string = ""
+    typ: PType, ast: PNode = nilPNode, sym: PSym = nil, str: string = ""
   ): SemReport =
   SemReport(kind: kind, typ: typ, ast: ast, sym: sym, str: str)
 
 func reportStr*(
     kind: ReportKind,
-    str: string, ast: PNode = nil, typ: PType = nil, sym: PSym = nil
+    str: string, ast: PNode = nilPNode, typ: PType = nil, sym: PSym = nil
   ): SemReport =
 
   SemReport(kind: kind, ast: ast, str: str, typ: typ, sym: sym)
 
 func reportSym*(
     kind: ReportKind,
-    sym: PSym, ast: PNode = nil, str: string = "", typ: PType = nil,
+    sym: PSym, ast: PNode = nilPNode, str: string = "", typ: PType = nil,
   ): SemReport =
 
   SemReport(kind: kind, ast: ast, str: str, typ: typ, sym: sym)
diff --git a/compiler/ast/types.nim b/compiler/ast/types.nim
index 8d430674a86..5befc21b789 100644
--- a/compiler/ast/types.nim
+++ b/compiler/ast/types.nim
@@ -372,7 +372,7 @@ proc mutateTypeAux(marker: var IntSet, t: PType, iter: TTypeMutator,
                    closure: RootRef): PType
 proc mutateNode(marker: var IntSet, n: PNode, iter: TTypeMutator,
                 closure: RootRef): PNode =
-  result = nil
+  result = nilPNode
   if n != nil:
     result = copyNode(n)
     result.typ = mutateTypeAux(marker, n.typ, iter, closure)
diff --git a/compiler/backend/ccgcalls.nim b/compiler/backend/ccgcalls.nim
index c0951978af4..c733301a2ae 100644
--- a/compiler/backend/ccgcalls.nim
+++ b/compiler/backend/ccgcalls.nim
@@ -829,4 +829,4 @@ proc genAsgnCall(p: BProc, le, ri: PNode, d: var TLoc) =
   else:
     genPrefixCall(p, le, ri, d)
 
-proc genCall(p: BProc, e: PNode, d: var TLoc) = genAsgnCall(p, nil, e, d)
+proc genCall(p: BProc, e: PNode, d: var TLoc) = genAsgnCall(p, nilPNode, e, d)
diff --git a/compiler/backend/ccgexprs.nim b/compiler/backend/ccgexprs.nim
index f5a45392816..2354898c2e1 100644
--- a/compiler/backend/ccgexprs.nim
+++ b/compiler/backend/ccgexprs.nim
@@ -2593,7 +2593,7 @@ proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
       p.config.quitOrRaise "compiler built without support for the 'spawn' statement"
     else:
       let n = spawn.wrapProcForSpawn(
-        p.module.g.graph, p.module.idgen, p.module.module, e, e.typ, nil, nil)
+        p.module.g.graph, p.module.idgen, p.module.module, e, e.typ, nilPNode, nilPNode)
       expr(p, n, d)
   of mParallel:
     when defined(leanCompiler):
@@ -3129,7 +3129,7 @@ proc getDefaultValue(p: BProc; typ: PType; info: TLineInfo): Rope =
   of tyObject:
     var count = 0
     result.add "{"
-    getNullValueAuxT(p, t, t, t.n, nil, result, count, true, info)
+    getNullValueAuxT(p, t, t, t.n, nilPNode, result, count, true, info)
     result.add "}"
   of tyTuple:
     result = rope"{"
diff --git a/compiler/backend/ccgstmts.nim b/compiler/backend/ccgstmts.nim
index 5e7c3703c91..47b7c6df0cb 100644
--- a/compiler/backend/ccgstmts.nim
+++ b/compiler/backend/ccgstmts.nim
@@ -1007,7 +1007,7 @@ proc genTryCpp(p: BProc, t: PNode, d: var TLoc) =
 
   p.procSec(cpsInit).add(ropecg(p.module, "\tstd::exception_ptr T$1_ = nullptr;", [etmp]))
 
-  let fin = if t[^1].kind == nkFinally: t[^1] else: nil
+  let fin = if t[^1].kind == nkFinally: t[^1] else: nilPNode
   p.nestedTryStmts.add((fin, false, 0.Natural))
 
   if t.kind == nkHiddenTryStmt:
@@ -1045,7 +1045,7 @@ proc genTryCpp(p: BProc, t: PNode, d: var TLoc) =
       endBlock(p)
     else:
       var orExpr = Rope(nil)
-      var exvar = PNode(nil)
+      var exvar = nilPNode
       for j in 0..<t[i].len - 1:
         var typeNode = t[i][j]
         if t[i][j].isInfixAs():
@@ -1165,7 +1165,7 @@ proc genTryCppOld(p: BProc, t: PNode, d: var TLoc) =
     getTemp(p, t.typ, d)
   genLineDir(p, t)
   discard cgsym(p.module, "popCurrentExceptionEx")
-  let fin = if t[^1].kind == nkFinally: t[^1] else: nil
+  let fin = if t[^1].kind == nkFinally: t[^1] else: nilPNode
   p.nestedTryStmts.add((fin, false, 0.Natural))
   startBlock(p, "try {$n")
   expr(p, t[0], d)
@@ -1229,7 +1229,7 @@ proc bodyCanRaise(p: BProc; n: PNode): bool =
     result = false
 
 proc genTryGoto(p: BProc; t: PNode; d: var TLoc) =
-  let fin = if t[^1].kind == nkFinally: t[^1] else: nil
+  let fin = if t[^1].kind == nkFinally: t[^1] else: nilPNode
   inc p.labels
   let lab = p.labels
   let hasExcept = t[1].kind == nkExceptBranch
@@ -1378,7 +1378,7 @@ proc genTrySetjmp(p: BProc, t: PNode, d: var TLoc) =
     else:
       linefmt(p, cpsStmts, "$1.status = setjmp($1.context);$n", [safePoint])
     lineCg(p, cpsStmts, "if ($1.status == 0) {$n", [safePoint])
-  let fin = if t[^1].kind == nkFinally: t[^1] else: nil
+  let fin = if t[^1].kind == nkFinally: t[^1] else: nilPNode
   p.nestedTryStmts.add((fin, quirkyExceptions, 0.Natural))
   expr(p, t[0], d)
   if not quirkyExceptions:
diff --git a/compiler/backend/cgmeth.nim b/compiler/backend/cgmeth.nim
index 7f78dc7a0a5..d444d72c648 100644
--- a/compiler/backend/cgmeth.nim
+++ b/compiler/backend/cgmeth.nim
@@ -268,7 +268,7 @@ proc genDispatcher(g: ModuleGraph; methods: seq[PSym], relevantCols: IntSet): PS
             newSymNode(getCompilerProc(g, "chckNilDisp")), newSymNode(param))
   for meth in 0..high(methods):
     var curr = methods[meth]      # generate condition:
-    var cond: PNode = nil
+    var cond: PNode = nilPNode
     for col in 1..<paramLen:
       if contains(relevantCols, col):
         var isn = newNodeIT(nkCall, base.info, boolType)
diff --git a/compiler/backend/jsgen.nim b/compiler/backend/jsgen.nim
index 7efcb73fcbb..3a2f660d7b8 100644
--- a/compiler/backend/jsgen.nim
+++ b/compiler/backend/jsgen.nim
@@ -206,7 +206,7 @@ proc initProcOptions(module: BModule): TOptions =
     result.excl(optStackTrace)
 
 proc newInitProc(globals: PGlobals, module: BModule): PProc =
-  result = newProc(globals, module, nil, initProcOptions(module))
+  result = newProc(globals, module, nilPNode, initProcOptions(module))
 
 proc declareGlobal(p: PProc; id: int; r: Rope) =
   if p.prc != nil and not p.declaredGlobals.containsOrIncl(id):
@@ -835,7 +835,7 @@ proc genTry(p: PProc, n: PNode, r: var TCompRes) =
       if i > 1: lineF(p, "}$n", [])
     else:
       var orExpr: Rope = nil
-      var excAlias: PNode = nil
+      var excAlias: PNode = nilPNode
 
       useMagic(p, "isObj")
       for j in 0..<n[i].len - 1:
@@ -1574,7 +1574,7 @@ proc genArgs(p: PProc, n: PNode, r: var TCompRes; start=1) =
 
   for i in start..<n.len:
     let it = n[i]
-    var paramType: PNode = nil
+    var paramType: PNode = nilPNode
     if i < typ.len:
       assert(typ.n[i].kind == nkSym)
       paramType = typ.n[i]
@@ -1606,7 +1606,7 @@ proc genOtherArg(p: PProc; n: PNode; i: int; typ: PType;
       node = n))
 
   let it = n[i]
-  var paramType: PNode = nil
+  var paramType: PNode = nilPNode
   if i < typ.len:
     assert(typ.n[i].kind == nkSym)
     paramType = typ.n[i]
diff --git a/compiler/front/commands.nim b/compiler/front/commands.nim
index 81e54d399d4..1abae0addad 100644
--- a/compiler/front/commands.nim
+++ b/compiler/front/commands.nim
@@ -341,13 +341,13 @@ proc processCompile(conf: ConfigRef; filename: string) =
   if found.isEmpty: found = AbsoluteFile filename
   extccomp.addExternalFileToCompile(conf, found)
 
-template warningOptionNoop(switch: string) =
+template warningOptionNoop(switch: string, info: TLineInfo) =
   conf.localReport(info,
     ExternalReport(
       kind: rextDeprecated,
       msg: "'$#' is deprecated, now a noop" % switch))
 
-template deprecatedAlias(oldName, newName: string) =
+template deprecatedAlias(oldName, newName: string, info: TLineInfo) =
   conf.localReport(
     info,
     ExternalReport(
@@ -384,7 +384,7 @@ proc testCompileOptionArg*(conf: ConfigRef; switch, arg: string, info: TLineInfo
     of "go": result = conf.selectedGC == gcGo
     of "none": result = conf.selectedGC == gcNone
     of "stack", "regions": result = conf.selectedGC == gcRegions
-    of "v2", "generational": warningOptionNoop(arg)
+    of "v2", "generational": warningOptionNoop(arg, info)
     else:
       conf.localReport(info, ExternalReport(
         kind: rextUnexpectedValue,
@@ -478,10 +478,10 @@ proc testCompileOption*(conf: ConfigRef; switch: string, info: TLineInfo): bool
   of "tlsemulation": result = contains(conf.globalOptions, optTlsEmulation)
   of "implicitstatic": result = contains(conf.options, optImplicitStatic)
   of "patterns", "trmacros":
-    if switch.normalize == "patterns": deprecatedAlias(switch, "trmacros")
+    if switch.normalize == "patterns": deprecatedAlias(switch, "trmacros", info)
     result = contains(conf.options, optTrMacros)
   of "excessivestacktrace": result = contains(conf.globalOptions, optExcessiveStackTrace)
-  of "nilseqs", "nilchecks", "taintmode": warningOptionNoop(switch)
+  of "nilseqs", "nilchecks", "taintmode": warningOptionNoop(switch, info)
   else: invalidCmdLineOption(conf, passCmd1, switch, info)
 
 proc processPath(conf: ConfigRef; path: string, info: TLineInfo, switch: string,
@@ -683,7 +683,7 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
       addPath(conf, if pass == passPP: processCfgPath(conf, path, info, switch)
                     else: processPath(conf, path, info, switch), info)
   of "nimblepath", "babelpath":
-    if switch.normalize == "babelpath": deprecatedAlias(switch, "nimblepath")
+    if switch.normalize == "babelpath": deprecatedAlias(switch, "nimblepath", info)
     if pass in {passCmd2, passPP} and optNoNimblePath notin conf.globalOptions:
       expectArg(conf, switch, arg, pass, info)
       var path = processPath(conf, arg, info, switch, notRelativeToProj=true)
@@ -692,7 +692,7 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
         path = nimbleDir / RelativeDir"pkgs"
       nimblePath(conf, path, info)
   of "nonimblepath", "nobabelpath":
-    if switch.normalize == "nobabelpath": deprecatedAlias(switch, "nonimblepath")
+    if switch.normalize == "nobabelpath": deprecatedAlias(switch, "nonimblepath", info)
     expectNoArg(conf, switch, arg, pass, info)
     disableNimblePath(conf)
   of "clearnimblepath":
@@ -819,7 +819,7 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
       of "stack", "regions":
         conf.selectedGC = gcRegions
         defineSymbol(conf, "gcregions")
-      of "v2": warningOptionNoop(arg)
+      of "v2": warningOptionNoop(arg, info)
       else:
         conf.localReport(
           info, invalidSwitchValue gcNames)
@@ -928,8 +928,7 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
   of "implicitstatic":
     processOnOffSwitch(conf, {optImplicitStatic}, arg, pass, info, switch)
   of "patterns", "trmacros":
-    if switch.normalize == "patterns":
-      deprecatedAlias(switch, "trmacros")
+    if switch.normalize == "patterns": deprecatedAlias(switch, "trmacros", info)
     processOnOffSwitch(conf, {optTrMacros}, arg, pass, info, switch)
   of "opt":
     expectArg(conf, switch, arg, pass, info)
@@ -1074,7 +1073,7 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
     expectNoArg(conf, switch, arg, pass, info)
     helpOnError(conf, pass)
   of "symbolfiles", "incremental", "ic":
-    if switch.normalize == "symbolfiles": deprecatedAlias(switch, "incremental")
+    if switch.normalize == "symbolfiles": deprecatedAlias(switch, "incremental", info)
       # xxx maybe also ic, since not in help?
     if pass in {passCmd2, passPP}:
       case arg.normalize
@@ -1097,7 +1096,7 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
   of "skipparentcfg":
     processOnOffSwitchG(conf, {optSkipParentConfigFiles}, arg, pass, info, switch)
   of "genscript", "gendeps":
-    if switch.normalize == "gendeps": deprecatedAlias(switch, "genscript")
+    if switch.normalize == "gendeps": deprecatedAlias(switch, "genscript", info)
     processOnOffSwitchG(conf, {optGenScript}, arg, pass, info, switch)
     processOnOffSwitchG(conf, {optCompileOnly}, arg, pass, info, switch)
   of "colors": processOnOffSwitchG(conf, {optUseColors}, arg, pass, info, switch)
@@ -1305,8 +1304,7 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
     handleStdinInput(conf)
   of "nilseqs", "nilchecks", "mainmodule", "m", "symbol", "taintmode",
      "cs", "deadcodeelim":
-    warningOptionNoop(switch)
-
+    warningOptionNoop(switch, info)
   else:
     if strutils.find(switch, '.') >= 0: options.setConfigVar(conf, switch, arg)
     else: invalidCmdLineOption(conf, pass, switch, info)
diff --git a/compiler/front/msgs.nim b/compiler/front/msgs.nim
index 39327287ab8..93b2f59a11d 100644
--- a/compiler/front/msgs.nim
+++ b/compiler/front/msgs.nim
@@ -567,7 +567,7 @@ template localReport*(conf: ConfigRef, report: Report) =
 proc semReportCountMismatch*(
     kind: ReportKind,
     expected, got: distinct SomeInteger,
-    node: PNode = nil,
+    node: PNode = nilPNode,
   ): SemReport =
   result = SemReport(kind: kind, ast: node)
   result.countMismatch = (toInt128(expected), toInt128(got))
diff --git a/compiler/front/options.nim b/compiler/front/options.nim
index 98f98feb067..0ee1c14b12d 100644
--- a/compiler/front/options.nim
+++ b/compiler/front/options.nim
@@ -499,7 +499,7 @@ proc canReport*(conf: ConfigRef, id: ReportId): bool =
   ## Check whether report with given ID can actually be written out, or it
   ## has already been seen. This check is used to prevent multiple reports
   ## from the `nkError` node.
-  id notin conf.m.writtenSemReports
+  true or id notin conf.m.writtenSemReports
 
 proc canReport*(conf: ConfigRef, node: PNode): bool =
   ## Check whether `nkError` node can be reported
diff --git a/compiler/ic/dce.nim b/compiler/ic/dce.nim
index b40c21abb26..4566209e443 100644
--- a/compiler/ic/dce.nim
+++ b/compiler/ic/dce.nim
@@ -61,7 +61,7 @@ proc followLater(c: var AliveContext; g: PackedModuleGraph; module: int; item: i
     if body != emptyNodeId:
       let opt = g[module].fromDisk.syms[item].options
       if g[module].fromDisk.syms[item].kind in routineKinds:
-        body = NodeId ithSon(g[module].fromDisk.bodies, NodePos body, bodyPos)
+        body = packed_ast.NodeId ithSon(g[module].fromDisk.bodies, NodePos body, bodyPos)
       c.stack.add((module, opt, NodePos(body)))
 
     when false:
diff --git a/compiler/ic/ic.nim b/compiler/ic/ic.nim
index 58f7202cc2d..3eac7a79799 100644
--- a/compiler/ic/ic.nim
+++ b/compiler/ic/ic.nim
@@ -758,7 +758,7 @@ proc loadNodes*(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: int;
                 tree: PackedTree; n: NodePos): PNode =
   let k = n.kind
   if k == nkNilRodNode:
-    return nil
+    return nilPNode
   when false:
     echo "loading node ", c.config $ translateLineInfo(c, g, thisModule, n.info)
   result = newNodeIT(k, translateLineInfo(c, g, thisModule, n.info),
@@ -784,7 +784,7 @@ proc loadNodes*(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: int;
     let (n1, n2) = sons2(tree, n)
     assert n1.kind == nkInt32Lit
     assert n2.kind == nkInt32Lit
-    transitionNoneToSym(result)
+    result.transitionNoneToSym()
     result.sym = loadSym(c, g, thisModule, PackedItemId(module: n1.litId, item: tree.nodes[n2.int].operand))
   else:
     for n0 in sonsReadonly(tree, n):
@@ -812,7 +812,7 @@ proc loadProcHeader(c: var PackedDecoder; g: var PackedModuleGraph; thisModule:
     if i != bodyPos:
       result.add loadNodes(c, g, thisModule, tree, n0)
     else:
-      result.addAllowNil nil
+      result.addAllowNil nilPNode
     inc i
 
 proc loadProcBody(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: int;
diff --git a/compiler/modules/magicsys.nim b/compiler/modules/magicsys.nim
index 503bfd5b6df..e373c63bfbc 100644
--- a/compiler/modules/magicsys.nim
+++ b/compiler/modules/magicsys.nim
@@ -122,7 +122,7 @@ proc getFloatLitType*(g: ModuleGraph; literal: PNode): PType =
 proc skipIntLit*(t: PType; id: IdGenerator): PType {.inline.} =
   if t.n != nil and t.kind in {tyInt, tyFloat}:
     result = copyType(t, nextTypeId(id), t.owner)
-    result.n = nil
+    result.n = nilPNode
   else:
     result = t
 
diff --git a/compiler/modules/modules.nim b/compiler/modules/modules.nim
index 447f4e2f761..ad5fd6d37f3 100644
--- a/compiler/modules/modules.nim
+++ b/compiler/modules/modules.nim
@@ -147,7 +147,7 @@ proc compileModule*(graph: ModuleGraph; fileIdx: FileIndex; flags: TSymFlags, fr
     result.flags.excl sfDirty
     # reset module fields:
     initStrTables(graph, result)
-    result.ast = nil
+    result.ast = nilPNode
     processModuleAux("import(dirty)")
     graph.markClientsDirty(fileIdx)
 
diff --git a/compiler/sem/closureiters.nim b/compiler/sem/closureiters.nim
index 73487cc4808..74e32855f16 100644
--- a/compiler/sem/closureiters.nim
+++ b/compiler/sem/closureiters.nim
@@ -473,7 +473,7 @@ proc newNotCall(g: ModuleGraph; e: PNode): PNode =
   result = newTree(nkCall, newSymNode(g.getSysMagic(e.info, "not", mNot), e.info), e)
   result.typ = g.getSysType(e.info, tyBool)
 
-proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
+proc lowerStmtListExprs(ctx: var Ctx, n: var PNode, needsSplit: var bool): PNode =
   result = n
   case n.kind
   of nkSkip:
@@ -995,7 +995,7 @@ proc transformClosureIteratorBody(ctx: var Ctx, n: PNode, gotoOut: PNode): PNode
 
       if exceptBody.kind != nkEmpty:
         ctx.curExcHandlingState = finallyIdx
-        let realExceptIdx = ctx.newState(exceptBody, nil)
+        let realExceptIdx = ctx.newState(exceptBody, nilPNode)
         assert(realExceptIdx == -exceptIdx)
 
       ctx.curExcHandlingState = oldExcHandlingState
@@ -1279,7 +1279,7 @@ proc wrapIntoStateLoop(ctx: var Ctx, n: PNode): PNode =
 
 proc deleteEmptyStates(ctx: var Ctx) =
   let goOut = newTree(nkGotoState, ctx.g.newIntLit(TLineInfo(), -1))
-  ctx.exitStateIdx = ctx.newState(goOut, nil)
+  ctx.exitStateIdx = ctx.newState(goOut, nilPNode)
 
   # Apply new state indexes and mark unused states with -1
   var iValid = 0
@@ -1429,7 +1429,7 @@ proc transformClosureIterator*(g: ModuleGraph; idgen: IdGenerator; fn: PSym, n:
   #echo "transformed into ", n
   #var n = n.toStmtList
 
-  discard ctx.newState(n, nil)
+  discard ctx.newState(n, nilPNode)
   let gotoOut = newTree(nkGotoState, g.newIntLit(n.info, -1))
 
   var ns = false
diff --git a/compiler/sem/guards.nim b/compiler/sem/guards.nim
index 6530c4efbc6..725e609acb8 100644
--- a/compiler/sem/guards.nim
+++ b/compiler/sem/guards.nim
@@ -113,7 +113,7 @@ proc swapArgs(fact: PNode, newOp: PSym): PNode =
   result[2] = fact[1]
 
 proc neg(n: PNode; o: Operators): PNode =
-  if n == nil: return nil
+  if n == nil: return nilPNode
   case n.getMagic
   of mNot:
     result = n[1]
@@ -123,7 +123,7 @@ proc neg(n: PNode; o: Operators): PNode =
   of someLe:
     result = swapArgs(n, o.opLt)
   of mInSet:
-    if n[1].kind != nkCurly: return nil
+    if n[1].kind != nkCurly: return nilPNode
     let t = n[2].typ.skipTypes(abstractInst)
     result = newNodeI(nkCall, n.info, 3)
     result[0] = n[0]
@@ -139,7 +139,7 @@ proc neg(n: PNode; o: Operators): PNode =
     else:
       # not ({2, 3, 4}.contains(x))   x != 2 and x != 3 and x != 4
       # XXX todo
-      result = nil
+      result = nilPNode
   of mOr:
     # not (a or b) --> not a and not b
     let
@@ -304,7 +304,7 @@ proc canon*(n: PNode; o: Operators): PNode =
                            reassociation(o.opAdd.buildCall(y, x[2]), o))
       of someAdd:
         # Rule A:
-        let plus = negate(y, x[2], nil, o).reassociation(o)
+        let plus = negate(y, x[2], nilPNode, o).reassociation(o)
         if plus != nil: result = buildCall(result[0].sym, x[1], plus)
       else: discard
     elif y.kind in nkCallKinds and y.len == 3 and y[2].isValue and
@@ -315,7 +315,7 @@ proc canon*(n: PNode; o: Operators): PNode =
         result = buildCall(result[0].sym, y[1],
                            reassociation(o.opAdd.buildCall(x, y[2]), o))
       of someAdd:
-        let plus = negate(x, y[2], nil, o).reassociation(o)
+        let plus = negate(x, y[2], nilPNode, o).reassociation(o)
         # ensure that Rule A will not trigger afterwards with the
         # additional 'not isLetLocation' constraint:
         if plus != nil and not isLetLocation(x, true):
@@ -898,7 +898,7 @@ proc pleViaModelRec(m: var TModel; a, b: PNode): TImplication =
     let fact = m.s[i]
     if fact != nil and fact.getMagic in someLe:
       # mark as used:
-      m.s[i] = nil
+      m.s[i] = nilPNode
       # i <= len-100
       # i <=? len-1
       # --> true  if  (len-100) <= (len-1)
diff --git a/compiler/sem/injectdestructors.nim b/compiler/sem/injectdestructors.nim
index 7ae0c8eb392..62a2ce6b1a3 100644
--- a/compiler/sem/injectdestructors.nim
+++ b/compiler/sem/injectdestructors.nim
@@ -104,7 +104,7 @@ proc moveOrCopy(dest, ri: PNode; c: var Con; s: var Scope; isDecl = false): PNod
 
 import sets, hashes
 
-proc hash(n: PNode): Hash = hash(cast[pointer](n))
+proc hash(n: PNode): Hash = hash(n.id)
 
 proc aliasesCached(cache: var Table[(PNode, PNode), AliasKind], obj, field: PNode): AliasKind =
   let key = (obj, field)
@@ -327,7 +327,7 @@ proc genOp(c: var Con; t: PType; kind: TTypeAttachedOp; dest, ri: PNode): PNode
 
 proc genDestroy(c: var Con; dest: PNode): PNode =
   let t = dest.typ.skipTypes({tyGenericInst, tyAlias, tySink})
-  result = c.genOp(t, attachedDestructor, dest, nil)
+  result = c.genOp(t, attachedDestructor, dest, nilPNode)
 
 proc canBeMoved(c: Con; t: PType): bool {.inline.} =
   let t = t.skipTypes({tyGenericInst, tyAlias, tySink})
@@ -545,7 +545,7 @@ proc cycleCheck(n: PNode; c: var Con) =
     return
 
   var x = n[0]
-  var field: PNode = nil
+  var field: PNode = nilPNode
   while true:
     if x.kind == nkDotExpr:
       field = x[1]
diff --git a/compiler/sem/lookups.nim b/compiler/sem/lookups.nim
index 3f9505de3eb..00d3edd7cce 100644
--- a/compiler/sem/lookups.nim
+++ b/compiler/sem/lookups.nim
@@ -68,8 +68,8 @@ proc considerQuotedIdent2*(c: PContext; n: PNode): PIdentResult =
 
   result =
     case n.kind
-    of nkIdent: (ident: n.ident, errNode: nil)
-    of nkSym: (ident: n.sym.name, errNode: nil)
+    of nkIdent: (ident: n.ident, errNode: nilPNode)
+    of nkSym: (ident: n.sym.name, errNode: nilPNode)
     of nkAccQuoted:
       case n.len
       of 0: (ident: ic.getNotFoundIdent(), errNode: n)
@@ -90,10 +90,10 @@ proc considerQuotedIdent2*(c: PContext; n: PNode): PIdentResult =
         if error:
           (ident: ic.getNotFoundIdent(), errNode: n)
         else:
-          (ident: getIdent(c.cache, id), errNode: nil)
+          (ident: getIdent(c.cache, id), errNode: nilPNode)
     of nkOpenSymChoice, nkClosedSymChoice:
       if n[0].kind == nkSym:
-        (ident: n[0].sym.name, errNode: nil)
+        (ident: n[0].sym.name, errNode: nilPNode)
       else:
         (ident: ic.getNotFoundIdent(), errNode: n)
     else:
@@ -110,7 +110,7 @@ proc noidentError(conf: ConfigRef; n, origin: PNode) =
     wrongNode: origin
   ))
 
-proc considerQuotedIdent*(c: PContext; n: PNode, origin: PNode = nil): PIdent =
+proc considerQuotedIdent*(c: PContext; n: PNode, origin: PNode = nilPNode): PIdent =
   ## Retrieve a PIdent from a PNode, taking into account accent nodes.
   ## ``origin`` can be nil. If it is not nil, it is used for a better
   ## error message.
@@ -642,7 +642,7 @@ proc newQualifiedLookUpError(c: PContext, ident: PIdent, info: TLineInfo, err: P
   result.ast = err
 
 proc errorExpectedIdentifier(
-    c: PContext, ident: PIdent, n: PNode, exp: PNode = nil
+    c: PContext, ident: PIdent, n: PNode, exp: PNode = nilPNode
   ): PSym {.inline.} =
   ## create an error symbol for non-identifier in identifier position within an
   ## expression (`exp`). non-nil `exp` leads to better error messages.
@@ -748,7 +748,7 @@ proc qualifiedLookUp*(c: PContext, n: PNode, flags: set[TLookupFlag]): PSym =
       amb = false
       (ident, errNode) = considerQuotedIdent2(c, n)
     if isNotFound(c.cache, ident):
-      let errExprCtx = if errNode != n: n else: nil
+      let errExprCtx = if errNode != n: n else: nilPNode
         ## expression within which the error occurred
       result = errorExpectedIdentifier(c, ident, errNode, errExprCtx)
     elif checkModule in flags:
@@ -816,7 +816,7 @@ proc qualifiedLookUp*(c: PContext, n: PNode, flags: set[TLookupFlag]): PSym =
     if m != nil and m.kind == skModule:
       var
         ident: PIdent = nil
-        errNode: PNode = nil
+        errNode: PNode = nilPNode
       if n[1].kind == nkIdent:
         ident = n[1].ident
       elif n[1].kind == nkAccQuoted:
diff --git a/compiler/sem/lowerings.nim b/compiler/sem/lowerings.nim
index 3cd62475d6f..bbfddf2e395 100644
--- a/compiler/sem/lowerings.nim
+++ b/compiler/sem/lowerings.nim
@@ -300,7 +300,7 @@ proc genDeref*(n: PNode; k = nkHiddenDeref): PNode =
 
 proc callCodegenProc*(g: ModuleGraph; name: string;
                       info: TLineInfo = unknownLineInfo;
-                      arg1, arg2, arg3, optionalArgs: PNode = nil): PNode =
+                      arg1, arg2, arg3, optionalArgs: PNode = nilPNode): PNode =
   result = newNodeI(nkCall, info)
   let sym = magicsys.getCompilerProc(g, name)
   if sym == nil:
diff --git a/compiler/sem/nilcheck.nim b/compiler/sem/nilcheck.nim
index 553788a15a9..4238f33e550 100644
--- a/compiler/sem/nilcheck.nim
+++ b/compiler/sem/nilcheck.nim
@@ -392,7 +392,6 @@ proc aliasSet(ctx: NilCheckerContext, map: NilMap, index: ExprIndex): IntSet =
   result = map.sets[map.setIndices[index]]
 
 
-
 proc store(
     map: NilMap,
     ctx: NilCheckerContext,
@@ -400,9 +399,8 @@ proc store(
     value: Nilability,
     kind: NilTransition,
     info: TLineInfo,
-    node: PNode = nil
+    node: PNode = nilPNode
   ) =
-
   if index == noExprIndex:
     return
   map.expressions[index] = value
diff --git a/compiler/sem/passes.nim b/compiler/sem/passes.nim
index 46039cea953..a944c747d8d 100644
--- a/compiler/sem/passes.nim
+++ b/compiler/sem/passes.nim
@@ -78,7 +78,7 @@ proc openPasses(g: ModuleGraph; a: var TPassContextArray;
     else: a[i] = nil
 
 proc closePasses(graph: ModuleGraph; a: var TPassContextArray) =
-  var m: PNode = nil
+  var m: PNode = nilPNode
   for i in 0..<graph.passes.len:
     if not isNil(graph.passes[i].close):
       m = graph.passes[i].close(graph, a[i], m)
@@ -188,7 +188,7 @@ proc processModule*(graph: ModuleGraph; module: PSym; idgen: IdGenerator;
         # read everything until the next proc declaration etc.
         var sl = newNodeI(nkStmtList, n.info)
         sl.add n
-        var rest: PNode = nil
+        var rest: PNode = nilPNode
         while true:
           var n = parseTopLevelStmt(p)
           if n.kind == nkEmpty or n.kind notin imperativeCode:
diff --git a/compiler/sem/patterns.nim b/compiler/sem/patterns.nim
index c45a879420f..4cfed98bdfe 100644
--- a/compiler/sem/patterns.nim
+++ b/compiler/sem/patterns.nim
@@ -258,7 +258,7 @@ proc applyRule*(c: PContext, s: PSym, n: PNode): PNode =
   ctx.c = c
   ctx.formals = s.typ.len-1
   var m = matchStmtList(ctx, s.ast[patternPos], n)
-  if isNil(m): return nil
+  if isNil(m): return nilPNode
   # each parameter should have been bound; we simply setup a call and
   # let semantic checking deal with the rest :-)
   result = newNodeI(nkCall, n.info)
@@ -272,7 +272,7 @@ proc applyRule*(c: PContext, s: PSym, n: PNode): PNode =
     let param = params[i].sym
     let x = getLazy(ctx, param)
     # couldn't bind parameter:
-    if isNil(x): return nil
+    if isNil(x): return nilPNode
     result.add(x)
     if requiresAA: addToArgList(args, x)
   # perform alias analysis here:
@@ -290,7 +290,7 @@ proc applyRule*(c: PContext, s: PSym, n: PNode): PNode =
             ok = true
             break
         # constraint not fulfilled:
-        if not ok: return nil
+        if not ok: return nilPNode
       of aqNoAlias:
         # it MUST not alias with any other param:
         var ok = true
@@ -299,7 +299,7 @@ proc applyRule*(c: PContext, s: PSym, n: PNode): PNode =
             ok = false
             break
         # constraint not fulfilled:
-        if not ok: return nil
+        if not ok: return nilPNode
 
   markUsed(c, n.info, s)
   if ctx.subMatch:
diff --git a/compiler/sem/pragmas.nim b/compiler/sem/pragmas.nim
index 15fbff9997e..955217ae953 100644
--- a/compiler/sem/pragmas.nim
+++ b/compiler/sem/pragmas.nim
@@ -121,7 +121,7 @@ const
 
 proc getPragmaVal*(procAst: PNode; name: TSpecialWord): PNode =
   let p = procAst[pragmasPos]
-  if p.kind == nkEmpty: return nil
+  if p.kind == nkEmpty: return nilPNode
   for it in p:
     if it.kind in nkPragmaCallKinds and it.len == 2 and it[0].kind == nkIdent and
         it[0].ident.id == ord(name):
@@ -272,7 +272,7 @@ proc strLitToStrOrErr(c: PContext, n: PNode): (string, PNode) =
   let r = getStrLitNode(c, n)
   case r.kind
   of nkStrLit, nkRStrLit, nkTripleStrLit:
-    (r.strVal, nil)
+    (r.strVal, nilPNode)
   of nkError:
     ("", r)
   else:
@@ -287,7 +287,7 @@ proc intLitToIntOrErr(c: PContext, n: PNode): (int, PNode) =
     n[1] = c.semConstExpr(c, n[1])
     case n[1].kind
     of nkIntLit..nkInt64Lit:
-      (int(n[1].intVal), nil)
+      (int(n[1].intVal), nilPNode)
     else:
       (-1, c.config.newError(n, SemReport(kind: rsemIntLiteralExpected)))
 
@@ -339,7 +339,7 @@ proc isTurnedOn(c: PContext, n: PNode): (bool, PNode) =
     let x = c.semConstBoolExpr(c, n[1])
     n[1] = x
     if x.kind == nkIntLit:
-      (x.intVal != 0, nil)
+      (x.intVal != 0, nilPNode)
     else:
       (false, c.config.newError(n, SemReport(kind: rsemOnOrOffExpected)))
   else:
@@ -530,32 +530,32 @@ proc tryProcessOption(c: PContext, n: PNode, resOptions: var TOptions): (bool, P
   ## (mutate) `n` with it's children analysed, and using the values update
   ## `resOptions` appropriately. Upon error, instead of the `n` production, an
   ## error node wrapping n is produced.
-  result = (true, nil)
+  result = (true, nilPNode)
   if n.kind notin nkPragmaCallKinds or n.len != 2:
-    result = (false, nil)
+    result = (false, nilPNode)
   elif n[0].kind == nkBracketExpr:
     let err = processNote(c, n)
-    result = (true, if err.kind == nkError: err else: nil)
+    result = (true, if err.kind == nkError: err else: nilPNode)
   elif n[0].kind != nkIdent:
-    result = (false, nil)
+    result = (false, nilPNode)
   else:
     let sw = whichKeyword(n[0].ident)
     if sw == wExperimental:
       let e = processExperimental(c, n)
-      result = (true, if e.kind == nkError: e else: nil)
+      result = (true, if e.kind == nkError: e else: nilPNode)
       return
     let opts = pragmaToOptions(sw)
     if opts != {}:
       let e = onOff(c, n, opts, resOptions)
-      result = (true, if e.kind == nkError: e else: nil)
+      result = (true, if e.kind == nkError: e else: nilPNode)
     else:
       case sw
       of wCallconv:
         let e = processCallConv(c, n)
-        result = (true, if e.kind == nkError: e else: nil)
+        result = (true, if e.kind == nkError: e else: nilPNode)
       of wDynlib:
         let e = processDynLib(c, n, nil)
-        result = (true, if e.kind == nkError: e else: nil)
+        result = (true, if e.kind == nkError: e else: nilPNode)
       of wOptimization:
         # debug n
         if n[1].kind != nkIdent:
@@ -576,7 +576,7 @@ proc tryProcessOption(c: PContext, n: PNode, resOptions: var TOptions): (bool, P
               kind: rsemWrongIdent,
               expectedIdents: @["none", "speed", "size"])))
       else:
-        result = (false, nil)
+        result = (false, nilPNode)
 
 proc processOption(c: PContext, n: PNode, resOptions: var TOptions): PNode =
   ## wraps `tryProcessOption`, the difference that the return is either an
@@ -696,7 +696,7 @@ proc processCompile(c: PContext, n: PNode): PNode =
     case n[i].kind
     of nkStrLit, nkRStrLit, nkTripleStrLit:
       shallowCopy(result[0], n[i].strVal)
-      result[1] = nil
+      result[1] = nilPNode
     else:
       result = ("", c.config.newError(
         n, SemReport(kind: rsemStringLiteralExpected)))
@@ -934,7 +934,7 @@ proc pragmaLocks(c: PContext, it: PNode): (TLockLevel, PNode) =
     case it[1].kind
     of nkStrLit, nkRStrLit, nkTripleStrLit:
       if it[1].strVal == "unknown":
-        result = (UnknownLockLevel, nil)
+        result = (UnknownLockLevel, nilPNode)
       else:
         it[1] = c.config.newError(it[1], reportStr(
           rsemLocksPragmaBadLevel,
@@ -949,7 +949,7 @@ proc pragmaLocks(c: PContext, it: PNode): (TLockLevel, PNode) =
             "integer must be within 0.." & $MaxLockLevel))
           result = (UnknownLockLevel, wrapErrorInSubTree(c.config, it))
         else:
-          result = (TLockLevel(x), nil)
+          result = (TLockLevel(x), nilPNode)
 
 proc typeBorrow(c: PContext; sym: PSym, n: PNode): PNode =
   result = n
@@ -961,7 +961,7 @@ proc typeBorrow(c: PContext; sym: PSym, n: PNode): PNode =
   incl(sym.typ.flags, tfBorrowDot)
 
 proc markCompilerProc(c: PContext; s: PSym): PNode =
-  result = nil
+  result = nilPNode
   # minor hack ahead: FlowVar is the only generic .compilerproc type which
   # should not have an external name set.
   # xxx: like all hacks, they incur penalties and now the error handling is
@@ -1128,9 +1128,9 @@ proc prepareSinglePragma(
   of nkCast:
     result =
       if comesFromPush:
-        c.config.newError(n, reportAst(rsemCannotPushCast, nil))
+        c.config.newError(n, reportAst(rsemCannotPushCast, nilPNode))
       elif not isStatement:
-        c.config.newError(n, reportAst(rsemCastRequiresStatement, nil))
+        c.config.newError(n, reportAst(rsemCastRequiresStatement, nilPNode))
       elif whichPragma(key[1]) in {wRaises, wTags}:
         pragmaRaisesOrTags(c, key[1])
       else:
diff --git a/compiler/sem/sem.nim b/compiler/sem/sem.nim
index b6673805bdb..17e4dd9dd39 100644
--- a/compiler/sem/sem.nim
+++ b/compiler/sem/sem.nim
@@ -447,7 +447,7 @@ proc tryConstExpr(c: PContext, n: PNode): PNode =
 
   result = evalConstExpr(c.module, c.idgen, c.graph, e)
   if result == nil or result.kind in {nkEmpty, nkError}:
-    result = nil
+    result = nilPNode
   else:
     result = fixupTypeAfterEval(c, result, e)
 
@@ -781,7 +781,7 @@ proc myProcess(context: PPassContext, n: PNode): PNode {.nosinks.} =
       msgs.setInfoContextLen(c.config, oldContextLen)
       if getCurrentException() of ESuggestDone:
         c.suggestionsMade = true
-        result = nil
+        result = nilPNode
       else:
         result = newNodeI(nkEmpty, n.info)
   storeRodNode(c, result)
diff --git a/compiler/sem/semcall.nim b/compiler/sem/semcall.nim
index ce1bbb7fdc9..1ca2080e0ef 100644
--- a/compiler/sem/semcall.nim
+++ b/compiler/sem/semcall.nim
@@ -280,7 +280,7 @@ proc resolveOverloads(c: PContext, n: PNode,
     else:
       f = f[0]
   else:
-    initialBinding = nil
+    initialBinding = nilPNode
 
   if f.isError:
     n[0] = f
@@ -319,7 +319,7 @@ proc resolveOverloads(c: PContext, n: PNode,
       if f.ident.s notin [".", ".()"]: # a dot call on a dot call is invalid
         # leave the op head symbol empty,
         # we are going to try multiple variants
-        n.sons[0..1] = [nil, n[1], f]
+        n.sons[0..1] = [nilPNode, n[1], f]
 
         if nfExplicitCall in n.flags:
           tryOp ".()"
@@ -330,7 +330,7 @@ proc resolveOverloads(c: PContext, n: PNode,
     elif nfDotSetter in n.flags and f.kind == nkIdent and n.len == 3:
       # we need to strip away the trailing '=' here:
       let calleeName = newIdentNode(getIdent(c.cache, f.ident.s[0..^2]), f.info)
-      n.sons[0..1] = [nil, n[1], calleeName]
+      n.sons[0..1] = [nilPNode, n[1], calleeName]
       tryOp ".="
 
     if overloadsState == csEmpty and result.state == csEmpty:
@@ -552,7 +552,7 @@ proc explicitGenericInstError(c: PContext; n: PNode): PNode =
 
 proc explicitGenericSym(c: PContext, n: PNode, s: PSym): PNode =
   # binding has to stay 'nil' for this to work!
-  var m = newCandidate(c, s, nil)
+  var m = newCandidate(c, s, nilPNode)
 
   for i in 1..<n.len:
     let formal = s.ast[genericParamsPos][i-1].typ
@@ -566,7 +566,7 @@ proc explicitGenericSym(c: PContext, n: PNode, s: PSym): PNode =
         arg.sons = @[evaluated.typ]
         arg.n = evaluated
     let tm = typeRel(m, formal, arg)
-    if tm in {isNone, isConvertible}: return nil
+    if tm in {isNone, isConvertible}: return nilPNode
   var newInst = generateInstance(c, s, m.bindings, n.info)
   newInst.typ.flags.excl tfUnresolved
   let info = getCallLineInfo(n)
diff --git a/compiler/sem/semexprs.nim b/compiler/sem/semexprs.nim
index 8c060d7db24..b1f1b7029b1 100644
--- a/compiler/sem/semexprs.nim
+++ b/compiler/sem/semexprs.nim
@@ -561,7 +561,7 @@ proc overloadedCallOpr(c: PContext, n: PNode): PNode =
   var par = getIdent(c.cache, "()")
   var amb = false
   if searchInScopes(c, par, amb) == nil:
-    result = nil
+    result = nilPNode
   else:
     result = newNodeI(nkCall, n.info)
     result.add newIdentNode(par, n.info)
@@ -1038,7 +1038,7 @@ proc afterCallActions(c: PContext; n: PNode, flags: TExprFlags): PNode =
 
 proc semIndirectOp(c: PContext, n: PNode, flags: TExprFlags): PNode =
   addInNimDebugUtils(c.config, "semIndirectOp", n, result, flags)
-  result = nil
+  result = nilPNode
   checkMinSonsLen(n, 1, c.config)
   if n.kind == nkError: return n
   var prc = n[0]
@@ -1102,7 +1102,7 @@ proc semIndirectOp(c: PContext, n: PNode, flags: TExprFlags): PNode =
 
         return
 
-      result = nil
+      result = nilPNode
 
     else:
       result = m.call
@@ -1293,7 +1293,7 @@ proc readTypeParameter(c: PContext, typ: PType,
           let foundTyp = makeTypeDesc(c, rawTyp)
           return newSymNode(copySym(tParam.sym, nextSymId c.idgen).linkTo(foundTyp), info)
 
-  return nil
+  return nilPNode
 
 proc semSym(c: PContext, n: PNode, sym: PSym, flags: TExprFlags): PNode =
   let s = getGenSym(c, sym)
@@ -1395,10 +1395,10 @@ proc semSym(c: PContext, n: PNode, sym: PSym, flags: TExprFlags): PNode =
       var ty = skipTypes(p.selfSym.typ, {tyGenericInst, tyVar, tyLent, tyPtr, tyRef,
                                          tyAlias, tySink, tyOwned})
       while tfBorrowDot in ty.flags: ty = ty.skipTypes({tyDistinct, tyGenericInst, tyAlias})
-      var check: PNode = nil
+      var check: PNode = nilPNode
       if ty.kind == tyObject:
         while true:
-          check = nil
+          check = nilPNode
           let f = lookupInRecordAndBuildCheck(c, n, ty.n, s.name, check)
           if f != nil and fieldVisible(c, f):
             # is the access to a public field or in the same module or in a friend?
@@ -1509,7 +1509,7 @@ proc builtinFieldAccess(c: PContext, n: PNode, flags: TExprFlags): PNode =
   var i = considerQuotedIdent(c, n[1], n)
   var ty = n[0].typ
   var f: PSym = nil
-  result = nil
+  result = nilPNode
 
   if ty.kind == tyTypeDesc:
     if ty.base.kind == tyNone:
@@ -1521,23 +1521,23 @@ proc builtinFieldAccess(c: PContext, n: PNode, flags: TExprFlags): PNode =
         n.typ = makeTypeFromExpr(c, n.copyTree)
         return n
       else:
-        return nil
+        return nilPNode
     else:
       return tryReadingTypeField(c, n, i, ty.base)
   elif isTypeExpr(n.sons[0]):
     return tryReadingTypeField(c, n, i, ty)
   elif ty.kind == tyError:
     # a type error doesn't have any builtin fields
-    return nil
+    return nilPNode
 
   if ty.kind in tyUserTypeClasses and ty.isResolvedUserTypeClass:
     ty = ty.lastSon
   ty = skipTypes(ty, {tyGenericInst, tyVar, tyLent, tyPtr, tyRef, tyOwned, tyAlias, tySink, tyStatic})
   while tfBorrowDot in ty.flags: ty = ty.skipTypes({tyDistinct, tyGenericInst, tyAlias})
-  var check: PNode = nil
+  var check: PNode = nilPNode
   if ty.kind == tyObject:
     while true:
-      check = nil
+      check = nilPNode
       f = lookupInRecordAndBuildCheck(c, n, ty.n, i, check)
       if f != nil: break
       if ty[0] == nil: break
@@ -1612,9 +1612,8 @@ proc semDeref(c: PContext, n: PNode): PNode =
   case t.kind:
     of tyRef, tyPtr:
       n.typ = t.lastSon
-
     else:
-      result = nil
+      result = nilPNode
 
   #GlobalError(n[0].info, errCircumNeedsPointer)
 
@@ -1647,7 +1646,7 @@ proc semSubscript(c: PContext, n: PNode, flags: TExprFlags): PNode =
   ## checking of assignments
   if n.len == 1:
     let x = semDeref(c, n)
-    if x == nil: return nil
+    if x == nil: return nilPNode
     result = newNodeIT(nkDerefExpr, x.info, x.typ)
     result.add(x[0])
     return
@@ -1670,7 +1669,7 @@ proc semSubscript(c: PContext, n: PNode, flags: TExprFlags): PNode =
   case arr.kind
   of tyArray, tyOpenArray, tyVarargs, tySequence, tyString, tyCstring,
     tyUncheckedArray:
-    if n.len != 2: return nil
+    if n.len != 2: return nilPNode
     n[0] = makeDeref(n[0])
     for i in 1..<n.len:
       n[i] = semExprWithType(c, n[i],
@@ -1696,7 +1695,7 @@ proc semSubscript(c: PContext, n: PNode, flags: TExprFlags): PNode =
     result.typ = makeTypeDesc(c, semTypeNode(c, n, nil))
     #result = symNodeFromType(c, semTypeNode(c, n, nil), n.info)
   of tyTuple:
-    if n.len != 2: return nil
+    if n.len != 2: return nilPNode
     n[0] = makeDeref(n[0])
     # [] operator for tuples requires constant expression:
     n[1] = semConstExpr(c, n[1])
@@ -1713,7 +1712,7 @@ proc semSubscript(c: PContext, n: PNode, flags: TExprFlags): PNode =
 
       result = n
     else:
-      result = nil
+      result = nilPNode
   else:
     let s = if n[0].kind == nkSym: n[0].sym
             elif n[0].kind in nkSymChoices: n[0][0].sym
@@ -2306,7 +2305,7 @@ proc tryExpr(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
       trackStmt(c, c.module, result, isTopLevel = false)
     if c.config.errorCounter != oldErrorCount and
        result != nil and result.kind != nkError:
-      result = nil
+      result = nilPNode
   except ERecoverableError:
     discard
   # undo symbol table changes (as far as it's possible):
@@ -2519,7 +2518,7 @@ proc semMagic(c: PContext, n: PNode, s: PSym, flags: TExprFlags): PNode =
 proc semWhen(c: PContext, n: PNode, semCheck = true): PNode =
   # If semCheck is set to false, ``when`` will return the verbatim AST of
   # the correct branch. Otherwise the AST will be passed through semStmt.
-  result = nil
+  result = nilPNode
 
   template setResult(e: untyped) =
     if semCheck: result = semExpr(c, e) # do not open a new scope!
@@ -2852,7 +2851,7 @@ proc asBracketExpr(c: PContext; n: PNode): PNode =
           result = newNodeI(nkBracketExpr, n.info)
           for i in 1..<n.len: result.add(n[i])
           return result
-  return nil
+  return nilPNode
 
 proc hoistParamsUsedInDefault(c: PContext, call, letSection, defExpr: var PNode) =
   # This takes care of complicated signatures such as:
diff --git a/compiler/sem/semfold.nim b/compiler/sem/semfold.nim
index a693479ea5c..2766178c292 100644
--- a/compiler/sem/semfold.nim
+++ b/compiler/sem/semfold.nim
@@ -145,7 +145,7 @@ proc isIntRangeOrLit(t: PType): bool =
 
 proc evalOp(m: TMagic, n, a, b, c: PNode; idgen: IdGenerator; g: ModuleGraph): PNode =
   # b and c may be nil
-  result = nil
+  result = nilPNode
   case m
   of mOrd: result = newIntNodeT(getOrdValue(a), n, idgen, g)
   of mChr: result = newIntNodeT(getInt(a), n, idgen, g)
@@ -333,12 +333,12 @@ proc evalOp(m: TMagic, n, a, b, c: PNode; idgen: IdGenerator; g: ModuleGraph): P
   else: discard
 
 proc getConstIfExpr(c: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode =
-  result = nil
+  result = nilPNode
   for i in 0..<n.len:
     var it = n[i]
     if it.len == 2:
       var e = getConstExpr(c, it[0], idgen, g)
-      if e == nil: return nil
+      if e == nil: return nilPNode
       if getOrdValue(e) != 0:
         if result == nil:
           result = getConstExpr(c, it[1], idgen, g)
@@ -519,7 +519,7 @@ proc foldConStrStr(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
   result.strVal = ""
   for i in 1..<n.len:
     let a = getConstExpr(m, n[i], idgen, g)
-    if a == nil: return nil
+    if a == nil: return nilPNode
     result.strVal.add(getStrOrChar(a))
 
 proc newSymNodeTypeDesc*(s: PSym; idgen: IdGenerator; info: TLineInfo): PNode =
@@ -531,7 +531,7 @@ proc newSymNodeTypeDesc*(s: PSym; idgen: IdGenerator; info: TLineInfo): PNode =
     result.typ = s.typ
 
 proc getConstExpr(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode =
-  result = nil
+  result = nilPNode
   case n.kind
   of nkSym:
     var s = n.sym
@@ -638,11 +638,11 @@ proc getConstExpr(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
         # This fixes bug #544.
         result = newIntNodeT(lengthOrd(g.config, n[1].typ), n, idgen, g)
       of mSizeOf:
-        result = foldSizeOf(g.config, n, nil)
+        result = foldSizeOf(g.config, n, nilPNode)
       of mAlignOf:
-        result = foldAlignOf(g.config, n, nil)
+        result = foldAlignOf(g.config, n, nilPNode)
       of mOffsetOf:
-        result = foldOffsetOf(g.config, n, nil)
+        result = foldOffsetOf(g.config, n, nilPNode)
       of mAstToStr:
         result = newStrNodeT(renderTree(n[1], {renderNoComments}), n, g)
       of mConStrStr:
@@ -666,7 +666,7 @@ proc getConstExpr(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
     result = copyNode(n)
     for i, son in n.pairs:
       var a = getConstExpr(m, son, idgen, g)
-      if a == nil: return nil
+      if a == nil: return nilPNode
       result.add a
     incl(result.flags, nfAllConst)
   of nkRange:
@@ -692,13 +692,13 @@ proc getConstExpr(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
         let exprNew = copyNode(expr) # nkExprColonExpr
         exprNew.add expr[0]
         let a = getConstExpr(m, expr[1], idgen, g)
-        if a == nil: return nil
+        if a == nil: return nilPNode
         exprNew.add a
         result.add exprNew
     else:
       for i, expr in n.pairs:
         let a = getConstExpr(m, expr, idgen, g)
-        if a == nil: return nil
+        if a == nil: return nilPNode
         result.add a
     incl(result.flags, nfAllConst)
   of nkChckRangeF, nkChckRange64, nkChckRange:
@@ -724,7 +724,7 @@ proc getConstExpr(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
   of nkDerefExpr, nkHiddenDeref:
     let a = getConstExpr(m, n[0], idgen, g)
     if a != nil and a.kind == nkNilLit:
-      result = nil
+      result = nilPNode
       #localReport(g.config, n.info, "nil dereference is not allowed")
   of nkCast:
     var a = getConstExpr(m, n[1], idgen, g)
diff --git a/compiler/sem/semgnrc.nim b/compiler/sem/semgnrc.nim
index ea5d5698f00..f2c6818a1e1 100644
--- a/compiler/sem/semgnrc.nim
+++ b/compiler/sem/semgnrc.nim
@@ -59,7 +59,7 @@ template macroToExpandSym(s): untyped =
   sfCustomPragma notin s.flags and s.kind in {skMacro, skTemplate} and
     (s.typ.len == 1) and not fromDotExpr
 
-template isMixedIn(sym): bool =
+template isMixedIn(sym: PSym, flags: TSemGenericFlags): bool =
   let s = sym
   s.name.id in ctx.toMixin or (withinConcept in flags and
                                s.magic == mNone and
@@ -135,7 +135,7 @@ proc lookup(c: PContext, n: PNode, flags: TSemGenericFlags,
   else:
     if withinBind in flags or s.id in ctx.toBind:
       result = symChoice(c, n, s, scClosed)
-    elif s.isMixedIn:
+    elif s.isMixedIn(flags):
       result = symChoice(c, n, s, scForceOpen)
     else:
       result = semGenericStmtSymbol(c, n, s, ctx, flags)
@@ -171,7 +171,7 @@ proc fuzzyLookup(c: PContext, n: PNode, flags: TSemGenericFlags,
       isMacro = s.kind in {skTemplate, skMacro}
       if withinBind in flags or s.id in ctx.toBind:
         result = newDot(result, symChoice(c, n, s, scClosed))
-      elif s.isMixedIn:
+      elif s.isMixedIn(flags):
         result = newDot(result, symChoice(c, n, s, scForceOpen))
       else:
         let syms = semGenericStmtSymbol(c, n, s, ctx, flags, fromDotExpr=true)
@@ -246,7 +246,7 @@ proc semGenericStmt(c: PContext, n: PNode,
       incl(s.flags, sfUsed)
       mixinContext = s.magic in {mDefined, mDeclared, mDeclaredInScope, mCompiles, mAstToStr}
       let whichChoice = if s.id in ctx.toBind: scClosed
-                        elif s.isMixedIn: scForceOpen
+                        elif s.isMixedIn(flags): scForceOpen
                         else: scOpen
       let sc = symChoice(c, fn, s, whichChoice)
       case s.kind
diff --git a/compiler/sem/semobjconstr.nim b/compiler/sem/semobjconstr.nim
index 8d93cb4e2ed..f72fd31484c 100644
--- a/compiler/sem/semobjconstr.nim
+++ b/compiler/sem/semobjconstr.nim
@@ -286,7 +286,7 @@ proc semConstructFields(c: PContext, n: PNode,
       if discrimAssign != nil and discrimAssign.kind == nkError:
         mergeInitStatus(result, initError)
         return
-      var discriminatorVal = if discrimAssign.isNil: nil else: discrimAssign[1]
+      var discriminatorVal = if discrimAssign.isNil: nilPNode else: discrimAssign[1]
 
       if discriminatorVal != nil:
         discriminatorVal = discriminatorVal.skipHidden
@@ -362,7 +362,7 @@ proc semConstructFields(c: PContext, n: PNode,
         mergeInitStatus(result, initError)
         return
 
-      let discriminatorVal = if discrimAssign.isNil: nil else: discrimAssign[1]
+      let discriminatorVal = if discrimAssign.isNil: nilPNode else: discrimAssign[1]
       if discriminatorVal == nil:
         # None of the branches were explicitly selected by the user and no
         # value was given to the discrimator. We can assume that it will be
diff --git a/compiler/sem/semparallel.nim b/compiler/sem/semparallel.nim
index 1db4c94e98a..d523b8dc9c7 100644
--- a/compiler/sem/semparallel.nim
+++ b/compiler/sem/semparallel.nim
@@ -468,7 +468,7 @@ proc transformSpawnSons(g: ModuleGraph; idgen: IdGenerator; owner: PSym; n, barr
 proc transformSpawn(g: ModuleGraph; idgen: IdGenerator; owner: PSym; n, barrier: PNode): PNode =
   case n.kind
   of nkVarSection, nkLetSection:
-    result = nil
+    result = nilPNode
     for it in n:
       let b = it.lastSon
       if getMagic(b) == mSpawn:
@@ -484,7 +484,7 @@ proc transformSpawn(g: ModuleGraph; idgen: IdGenerator; owner: PSym; n, barrier:
           result.add wrapProcForSpawn(g, idgen, owner, m, b.typ, barrier, it[0])
           it[^1] = newNodeI(nkEmpty, it.info)
         else:
-          it[^1] = wrapProcForSpawn(g, idgen, owner, m, b.typ, barrier, nil)
+          it[^1] = wrapProcForSpawn(g, idgen, owner, m, b.typ, barrier, nilPNode)
     if result.isNil: result = n
   of nkAsgn, nkFastAsgn:
     let b = n[1]
@@ -496,7 +496,7 @@ proc transformSpawn(g: ModuleGraph; idgen: IdGenerator; owner: PSym; n, barrier:
   of nkCallKinds:
     if getMagic(n) == mSpawn:
       result = transformSlices(g, idgen, n)
-      return wrapProcForSpawn(g, idgen, owner, result, n.typ, barrier, nil)
+      return wrapProcForSpawn(g, idgen, owner, result, n.typ, barrier, nilPNode)
     result = transformSpawnSons(g, idgen, owner, n, barrier)
   elif n.safeLen > 0:
     result = transformSpawnSons(g, idgen, owner, n, barrier)
diff --git a/compiler/sem/sempass2.nim b/compiler/sem/sempass2.nim
index ac356607c19..2d59e319157 100644
--- a/compiler/sem/sempass2.nim
+++ b/compiler/sem/sempass2.nim
@@ -671,8 +671,8 @@ proc notNilCheck(tracked: PEffects, n: PNode, paramType: PType) =
         discard
 
 proc assumeTheWorst(tracked: PEffects; n: PNode; op: PType) =
-  addRaiseEffect(tracked, createRaise(tracked.graph, n), nil)
-  addTag(tracked, createTag(tracked.graph, n), nil)
+  addRaiseEffect(tracked, createRaise(tracked.graph, n), nilPNode)
+  addTag(tracked, createTag(tracked.graph, n), nilPNode)
   let lockLevel = if op.lockLevel == UnspecifiedLockLevel: UnknownLockLevel
                   else: op.lockLevel
   #if lockLevel == UnknownLockLevel:
@@ -1092,7 +1092,7 @@ proc track(tracked: PEffects, n: PNode) =
       # A `raise` with no arguments means we're going to re-raise the exception
       # being handled or, if outside of an `except` block, a `ReraiseDefect`.
       # Here we add a `Exception` tag in order to cover both the cases.
-      addRaiseEffect(tracked, createRaise(tracked.graph, n), nil)
+      addRaiseEffect(tracked, createRaise(tracked.graph, n), nilPNode)
   of nkCallKinds:
     trackCall(tracked, n)
   of nkDotExpr:
@@ -1339,7 +1339,7 @@ proc checkRaisesSpec(
     spec, real: PNode,
     hints: bool,
     effectPredicate: proc (g: ModuleGraph; a, b: PNode): bool {.nimcall.},
-    hintsArg: PNode = nil
+    hintsArg: PNode = nilPNode
   ) =
   # check that any real exception is listed in 'spec'; mark those as used;
   # report any unused exception
diff --git a/compiler/sem/semstmts.nim b/compiler/sem/semstmts.nim
index 045d948f99f..f916c6fa39c 100644
--- a/compiler/sem/semstmts.nim
+++ b/compiler/sem/semstmts.nim
@@ -897,7 +897,7 @@ proc handleStmtMacro(c: PContext; n, selector: PNode; magicType: string;
     case match.kind
     of skMacro: result = semMacroExpr(c, callExpr, match, flags)
     of skTemplate: result = semTemplateExpr(c, callExpr, match, flags)
-    else: result = nil
+    else: result = nilPNode
 
 proc handleForLoopMacro(c: PContext; n: PNode; flags: TExprFlags): PNode =
   result = handleStmtMacro(c, n, n[^2], "ForLoopStmt", flags)
@@ -923,7 +923,7 @@ proc handleCaseStmtMacro(c: PContext; n: PNode; flags: TExprFlags): PNode =
     case match.kind
     of skMacro: result = semMacroExpr(c, toExpand, match, flags)
     of skTemplate: result = semTemplateExpr(c, toExpand, match, flags)
-    else: result = nil
+    else: result = nilPNode
   else:
     assert r.call.kind == nkError
     result = r.call # xxx: hope this is nkError
@@ -2136,6 +2136,7 @@ proc semProcAux(c: PContext, n: PNode, kind: TSymKind,
         maybeAddResult(c, s, n)
         # semantic checking also needed with importc in case used in VM
         s.ast[bodyPos] = hloBody(c, semProcBody(c, n[bodyPos]))
+
         # unfortunately we cannot skip this step when in 'system.compiles'
         # context as it may even be evaluated in 'system.compiles':
         trackProc(c, s, s.ast[bodyPos])
diff --git a/compiler/sem/semtypes.nim b/compiler/sem/semtypes.nim
index 91ad9d32b31..42e0771e9f6 100644
--- a/compiler/sem/semtypes.nim
+++ b/compiler/sem/semtypes.nim
@@ -66,7 +66,7 @@ proc semEnum(c: PContext, n: PNode, prev: PType): PType =
         identToReplace = addr n[i][0]
 
       var v = semConstExpr(c, n[i][1])
-      var strVal: PNode = nil
+      var strVal: PNode = nilPNode
       case skipTypes(v.typ, abstractInst-{tyTypeDesc}).kind
       of tyTuple:
         if v.len == 2:
@@ -482,9 +482,7 @@ proc semTypeIdent(c: PContext, n: PNode): PSym =
       if result.typ.kind != tyGenericParam:
         # XXX get rid of this hack!
         var oldInfo = n.info
-        let oldId = n.id
-        reset(n[])
-        n.id = oldId
+        n.flags = {}
         n.transitionNoneToSym()
         n.sym = result
         n.info = oldInfo
@@ -539,7 +537,7 @@ proc semTuple(c: PContext, n: PNode, prev: PType): PType =
       styleCheckDef(c.config, a[j].info, field)
       onDef(field.info, field)
 
-  if result.n.len == 0: result.n = nil
+  if result.n.len == 0: result.n = nilPNode
   if isTupleRecursive(result):
     localReport(c.config, n.info, reportTyp(
       rsemIllegalRecursion, result))
@@ -835,7 +833,7 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var IntSet, pos: var int,
   if n == nil: return
   case n.kind
   of nkRecWhen:
-    var branch: PNode = nil   # the branch to take
+    var branch: PNode = nilPNode   # the branch to take
     for i in 0..<n.len:
       var it = n[i]
       if it == nil:
@@ -1370,8 +1368,8 @@ proc semProcTypeNode(c: PContext, n, genericParams: PNode,
     checkMinSonsLen(a, 3, c.config)
     var
       typ: PType = nil
-      def: PNode = nil
-      constraint: PNode = nil
+      def: PNode = nilPNode
+      constraint: PNode = nilPNode
       hasType = a[^2].kind != nkEmpty
       hasDefault = a[^1].kind != nkEmpty
 
@@ -1530,13 +1528,13 @@ proc semProcTypeNode(c: PContext, n, genericParams: PNode,
       result.n.typ = r
 
   if genericParams.isGenericParams:
-    for n in genericParams:
-      if {sfUsed, sfAnon} * n.sym.flags == {}:
+    for gp in genericParams:
+      if {sfUsed, sfAnon} * gp.sym.flags == {}:
         result.flags.incl tfUnresolved
 
-      if tfWildcard in n.sym.typ.flags:
-        n.sym.transitionGenericParamToType()
-        n.sym.typ.flags.excl tfWildcard
+      if tfWildcard in gp.sym.typ.flags:
+        gp.sym.transitionGenericParamToType()
+        gp.sym.typ.flags.excl tfWildcard
 
 proc semStmtListType(c: PContext, n: PNode, prev: PType): PType =
   checkMinSonsLen(n, 1, c.config)
@@ -1832,7 +1830,7 @@ proc semProcTypeWithScope(c: PContext, n: PNode,
       return semTypeNode(c, macroEval, prev)
 
   openScope(c)
-  result = semProcTypeNode(c, n[0], nil, prev, kind, isType=true)
+  result = semProcTypeNode(c, n[0], nilPNode, prev, kind, isType=true)
   # start with 'ccClosure', but of course pragmas can overwrite this:
   result.callConv = ccClosure
   # dummy symbol for `pragma`:
diff --git a/compiler/sem/semtypinst.nim b/compiler/sem/semtypinst.nim
index 35cd01cf9d4..433c70d6dc3 100644
--- a/compiler/sem/semtypinst.nim
+++ b/compiler/sem/semtypinst.nim
@@ -194,8 +194,8 @@ proc replaceObjBranches(cl: TReplTypeVars, n: PNode): PNode =
   of nkNone..nkNilLit:
     discard
   of nkRecWhen:
-    var branch: PNode = nil              # the branch to take
-    for i in 0 ..< n.len:
+    var branch: PNode = nilPNode         # the branch to take
+    for i in 0..<n.len:
       var it = n[i]
       if it == nil:
         cl.c.config.globalReport(reportAst(
@@ -243,7 +243,7 @@ proc replaceTypeVarsN(cl: var TReplTypeVars, n: PNode; start=0): PNode =
       # don't add the 'void' field
       result = newNodeI(nkRecList, n.info)
   of nkRecWhen:
-    var branch: PNode = nil              # the branch to take
+    var branch: PNode = nilPNode         # the branch to take
     for i in 0..<n.len:
       var it = n[i]
       if it == nil:
diff --git a/compiler/sem/sigmatch.nim b/compiler/sem/sigmatch.nim
index 4395e336b14..a2175abe174 100644
--- a/compiler/sem/sigmatch.nim
+++ b/compiler/sem/sigmatch.nim
@@ -99,21 +99,8 @@ proc markOwnerModuleAsUsed*(c: PContext; s: PSym)
 
 template hasFauxMatch*(c: TCandidate): bool = c.fauxMatch != tyNone
 
-proc put(c: var TCandidate, key, val: PType) {.inline.} =
-  ## Given: proc foo[T](x: T); foo(4)
-  ## key: 'T'
-  ## val: 'int' (typeof(4))
-  when false:
-    let old = PType(idTableGet(c.bindings, key))
-    if old != nil:
-      echo "Putting ", typeToString(key), " ", typeToString(val), " and old is ", typeToString(old)
-      if typeToString(old) == "float32":
-        writeStackTrace()
-    if c.c.module.name.s == "temp3":
-      echo "binding ", key, " -> ", val
-  idTablePut(c.bindings, key, val.skipIntLit(c.c.idgen))
-
-proc initCandidate*(ctx: PContext, c: var TCandidate, callee: PType) =
+proc initCandidateAux(ctx: PContext,
+                      c: var TCandidate, callee: PType) {.inline.} =
   c.c = ctx
   c.exactMatches = 0
   c.subtypeMatches = 0
@@ -122,14 +109,31 @@ proc initCandidate*(ctx: PContext, c: var TCandidate, callee: PType) =
   c.genericMatches = 0
   c.state = csEmpty
   c.callee = callee
-  c.calleeSym = nil
-  c.call = nil
+  c.call = nilPNode
   c.baseTypeMatch = false
   c.genericConverter = false
   c.inheritancePenalty = 0
   c.error = SemCallMismatch()
+
+proc initCandidate*(ctx: PContext, c: var TCandidate, callee: PType) =
+  initCandidateAux(ctx, c, callee)
+  c.calleeSym = nil
   initIdTable(c.bindings)
 
+proc put(c: var TCandidate, key, val: PType) {.inline.} =
+  ## Given: proc foo[T](x: T); foo(4)
+  ## key: 'T'
+  ## val: 'int' (typeof(4))
+  when false:
+    let old = PType(idTableGet(c.bindings, key))
+    if old != nil:
+      echo "Putting ", typeToString(key), " ", typeToString(val), " and old is ", typeToString(old)
+      if typeToString(old) == "float32":
+        writeStackTrace()
+    if c.c.module.name.s == "temp3":
+      echo "binding ", key, " -> ", val
+  idTablePut(c.bindings, key, val.skipIntLit(c.c.idgen))
+
 proc initCandidate*(ctx: PContext, c: var TCandidate, callee: PSym,
                     binding: PNode, calleeScope = -1) =
   initCandidate(ctx, c, callee.typ)
@@ -1899,7 +1903,7 @@ proc isLValue(c: PContext; n: PNode): bool {.inline.} =
 
 proc userConvMatch(c: PContext, m: var TCandidate, f, a: PType,
                    arg: PNode): PNode =
-  result = nil
+  result = nilPNode
   for i in 0..<c.converters.len:
     var src = c.converters[i].typ[1]
     var dest = c.converters[i].typ[0]
@@ -1930,7 +1934,7 @@ proc userConvMatch(c: PContext, m: var TCandidate, f, a: PType,
       # We build the call expression by ourselves in order to avoid passing this
       # expression trough the semantic check phase once again so let's make sure
       # it is correct
-      var param: PNode = nil
+      var param: PNode = nilPNode
       if srca == isSubtype:
         param = implicitConv(nkHiddenSubConv, src, copyTree(arg), m, c)
       elif src.kind in {tyVar}:
@@ -1953,7 +1957,7 @@ proc userConvMatch(c: PContext, m: var TCandidate, f, a: PType,
 proc localConvMatch(c: PContext, m: var TCandidate, f, a: PType,
                     arg: PNode): PNode =
   # arg.typ can be nil in 'suggest':
-  if isNil(arg.typ): return nil
+  if isNil(arg.typ): return nilPNode
 
   # sem'checking for 'echo' needs to be re-entrant:
   # XXX we will revisit this issue after 0.10.2 is released
@@ -1967,13 +1971,14 @@ proc localConvMatch(c: PContext, m: var TCandidate, f, a: PType,
   result = c.semTryExpr(c, call, {efNoSem2Check})
 
   if result != nil:
-    if result.typ == nil: return nil
+    if result.typ == nil: return nilPNode
     # bug #13378, ensure we produce a real generic instantiation:
     result = c.semExpr(c, call)
     # resulting type must be consistent with the other arguments:
     var r = typeRel(m, f[0], result.typ)
-    if r < isGeneric: return nil
-    if result.kind == nkCall: result.transitionSonsKind(nkHiddenCallConv)
+    if r < isGeneric: return nilPNode
+    if result.kind == nkCall:
+      result.transitionSonsKind(nkHiddenCallConv)
     inc(m.convMatches)
     if r == isGeneric:
       result.typ = getInstantiatedType(c, arg, m, base(f))
@@ -2079,7 +2084,7 @@ proc paramTypesMatchAux(m: var TCandidate, f, a: PType,
     if arg.kind in {nkProcDef, nkFuncDef, nkIteratorDef} + nkLambdaKinds:
       result = c.semInferredLambda(c, m.bindings, arg)
     elif arg.kind != nkSym:
-      result = nil
+      result = nilPNode
       return
     else:
       let inferred = c.semGenerateInstance(c, arg.sym, m.bindings, arg.info)
@@ -2113,7 +2118,7 @@ proc paramTypesMatchAux(m: var TCandidate, f, a: PType,
     if arg.kind in {nkProcDef, nkFuncDef, nkIteratorDef} + nkLambdaKinds:
       result = c.semInferredLambda(c, m.bindings, arg)
     elif arg.kind != nkSym:
-      result = nil
+      result = nilPNode
       return
     else:
       let inferred = c.semGenerateInstance(c, arg.sym, m.bindings, arg.info)
@@ -2137,7 +2142,7 @@ proc paramTypesMatchAux(m: var TCandidate, f, a: PType,
       result = arg
   of isBothMetaConvertible:
     # This is the result for the 101th time.
-    result = nil
+    result = nilPNode
   of isFromIntLit:
     # too lazy to introduce another ``*matches`` field, so we conflate
     # ``isIntConv`` and ``isIntLit`` here:
@@ -2247,14 +2252,14 @@ proc paramTypesMatch*(m: var TCandidate, f, a: PType,
               y = z           # z is as good as x
 
     if x.state == csEmpty:
-      result = nil
+      result = nilPNode
     elif y.state == csMatch and cmpCandidates(x, y) == 0:
       m.c.graph.config.internalAssert(x.state == csMatch, arg.info, "x.state is not csMatch")
       # ambiguous: more than one symbol fits!
       # See tsymchoice_for_expr as an example. 'f.kind == tyUntyped' should match
       # anyway:
       if f.kind in {tyUntyped, tyTyped}: result = arg
-      else: result = nil
+      else: result = nilPNode
     else:
       # only one valid interpretation found:
       markUsed(m.c, arg.info, arg[best].sym)
@@ -2400,7 +2405,7 @@ proc matchesAux(c: PContext, n: PNode, m: var TCandidate, marker: var IntSet) =
     arg: PNode # current prepared argument
     formalLen = m.callee.n.len
     formal = if formalLen > 1: m.callee.n[1].sym else: nil # current routine parameter
-    container: PNode = nil # constructed container
+    container: PNode = nilPNode # constructed container
   let firstArgBlock = findFirstArgBlock(m, n)
   while a < n.len:
     c.openShadowScope
@@ -2461,7 +2466,7 @@ proc matchesAux(c: PContext, n: PNode, m: var TCandidate, marker: var IntSet) =
         container = newNodeIT(nkBracket, n[a].info, arrayConstr(c, arg))
         container.add arg
         setSon(m.call, formal.position + 1, container)
-        if f != formalLen - 1: container = nil
+        if f != formalLen - 1: container = nilPNode
       else:
         setSon(m.call, formal.position + 1, arg)
       inc f
@@ -2547,7 +2552,7 @@ proc matchesAux(c: PContext, n: PNode, m: var TCandidate, marker: var IntSet) =
           elif formal.typ.kind != tyVarargs or container == nil:
             setSon(m.call, formal.position + 1, arg)
             inc f
-            container = nil
+            container = nilPNode
           else:
             # we end up here if the argument can be converted into the varargs
             # formal (e.g. seq[T] -> varargs[T]) but we have already instantiated
diff --git a/compiler/sem/spawn.nim b/compiler/sem/spawn.nim
index 4a225a94d7c..48920a28b64 100644
--- a/compiler/sem/spawn.nim
+++ b/compiler/sem/spawn.nim
@@ -134,21 +134,21 @@ proc createWrapperProc(g: ModuleGraph; f: PNode; threadParam, argsParam: PSym;
   var threadLocalBarrier: PSym
   if barrier != nil:
     var varSection2 = newNodeI(nkVarSection, barrier.info)
-    threadLocalBarrier = addLocalVar(g, varSection2, nil, idgen, result,
+    threadLocalBarrier = addLocalVar(g, varSection2, nilPNode, idgen, result,
                                      barrier.typ, barrier)
     body.add varSection2
     body.add callCodegenProc(g, "barrierEnter", threadLocalBarrier.info,
       threadLocalBarrier.newSymNode)
   var threadLocalProm: PSym
   if spawnKind == srByVar:
-    threadLocalProm = addLocalVar(g, varSection, nil, idgen, result, fv.typ, fv)
+    threadLocalProm = addLocalVar(g, varSection, nilPNode, idgen, result, fv.typ, fv)
   elif fv != nil:
     internalAssert(
       g.config,
       fv.typ.kind == tyGenericInst,
       "Expected generic inst type kind, but found " & $fv.typ.kind)
 
-    threadLocalProm = addLocalVar(g, varSection, nil, idgen, result, fv.typ, fv)
+    threadLocalProm = addLocalVar(g, varSection, nilPNode, idgen, result, fv.typ, fv)
   body.add varSection
   body.add varInit
   if fv != nil and spawnKind != srByVar:
@@ -298,7 +298,7 @@ proc setupArgsForParallelism(g: ModuleGraph; n: PNode; objType: PType;
         result.add newFastAsgnStmt(newDotExpr(scratchObj, fieldA), n[2])
         result.add newFastAsgnStmt(newDotExpr(scratchObj, fieldB), n[3])
 
-        let threadLocal = addLocalVar(g, varSection, nil, idgen, owner, fieldA.typ,
+        let threadLocal = addLocalVar(g, varSection, nilPNode, idgen, owner, fieldA.typ,
                                       indirectAccess(castExpr, fieldA, n.info),
                                       useShallowCopy=true)
         slice[2] = threadLocal.newSymNode
@@ -313,7 +313,7 @@ proc setupArgsForParallelism(g: ModuleGraph; n: PNode; objType: PType;
       # the array itself does not need to go through a thread local variable:
       slice[1] = genDeref(indirectAccess(castExpr, field, n.info))
 
-      let threadLocal = addLocalVar(g, varSection, nil, idgen, owner, fieldB.typ,
+      let threadLocal = addLocalVar(g, varSection, nilPNode, idgen, owner, fieldB.typ,
                                     indirectAccess(castExpr, fieldB, n.info),
                                     useShallowCopy=true)
       slice[3] = threadLocal.newSymNode
@@ -325,7 +325,7 @@ proc setupArgsForParallelism(g: ModuleGraph; n: PNode; objType: PType;
       field.typ = a.typ
       objType.addField(field, g.cache, idgen)
       result.add newFastAsgnStmt(newDotExpr(scratchObj, field), a)
-      let threadLocal = addLocalVar(g, varSection, nil, idgen, owner, field.typ,
+      let threadLocal = addLocalVar(g, varSection, nilPNode, idgen, owner, field.typ,
                                     indirectAccess(castExpr, field, n.info),
                                     useShallowCopy=true)
       call.add(genDeref(threadLocal.newSymNode))
@@ -341,7 +341,7 @@ proc setupArgsForParallelism(g: ModuleGraph; n: PNode; objType: PType;
       call.add(threadLocal.newSymNode)
 
 proc wrapProcForSpawn*(g: ModuleGraph; idgen: IdGenerator; owner: PSym; spawnExpr: PNode; retType: PType;
-                       barrier, dest: PNode = nil): PNode =
+                       barrier, dest: PNode = nilPNode): PNode =
   # if 'barrier' != nil, then it is in a 'parallel' section and we
   # generate quite different code
   let n = spawnExpr[^2]
@@ -424,7 +424,7 @@ proc wrapProcForSpawn*(g: ModuleGraph; idgen: IdGenerator; owner: PSym; spawnExp
     setupArgsForParallelism(g, n, objType, idgen, wrapperProc, scratchObj, castExpr, call,
                             varSection, varInit, result)
 
-  var barrierAsExpr: PNode = nil
+  var barrierAsExpr: PNode = nilPNode
   if barrier != nil:
     let typ = newType(tyPtr, nextTypeId idgen, owner)
     typ.rawAddSon(magicsys.getCompilerProc(g, "Barrier").typ)
@@ -436,7 +436,7 @@ proc wrapProcForSpawn*(g: ModuleGraph; idgen: IdGenerator; owner: PSym; spawnExp
     result.add newFastAsgnStmt(newDotExpr(scratchObj, field), barrier)
     barrierAsExpr = indirectAccess(castExpr, field, n.info)
 
-  var fvField, fvAsExpr: PNode = nil
+  var fvField, fvAsExpr: PNode = nilPNode
   if spawnKind == srFlowVar:
     var field = newSym(skField, getIdent(g.cache, "fv"), nextSymId idgen, owner, n.info, g.config.options)
     field.typ = retType
@@ -461,6 +461,6 @@ proc wrapProcForSpawn*(g: ModuleGraph; idgen: IdGenerator; owner: PSym; spawnExp
                       varSection, varInit, call,
                       barrierAsExpr, fvAsExpr, idgen, spawnKind, wrapperProc)
   result.add callCodegenProc(g, "nimSpawn" & $spawnExpr.len, wrapperProc.info,
-    wrapperProc.newSymNode, genAddrOf(scratchObj.newSymNode, idgen), nil, spawnExpr)
+    wrapperProc.newSymNode, genAddrOf(scratchObj.newSymNode, idgen), nilPNode, spawnExpr)
 
   if spawnKind == srFlowVar: result.add fvField
diff --git a/compiler/sem/transf.nim b/compiler/sem/transf.nim
index b4268a5a9a8..15cd3d96cc7 100644
--- a/compiler/sem/transf.nim
+++ b/compiler/sem/transf.nim
@@ -114,7 +114,7 @@ proc transformSymAux(c: PTransf, n: PNode): PNode =
       else: return liftIterSym(c.graph, n, c.idgen, getCurrOwner(c))
     elif s.kind in {skProc, skFunc, skConverter, skMethod} and not c.tooEarly:
       # top level .closure procs are still somewhat supported for 'Nake':
-      return makeClosure(c.graph, c.idgen, s, nil, n.info)
+      return makeClosure(c.graph, c.idgen, s, nilPNode, n.info)
   #elif n.sym.kind in {skVar, skLet} and n.sym.typ.callConv == ccClosure:
   #  echo n.info, " come heer for ", c.tooEarly
   #  if not c.tooEarly:
@@ -748,7 +748,7 @@ proc transformCase(c: PTransf, n: PNode): PNode =
   # removes `elif` branches of a case stmt
   # adds ``else: nil`` if needed for the code generator
   result = newNodeIT(nkCaseStmt, n.info, n.typ)
-  var ifs: PNode = nil
+  var ifs: PNode = nilPNode
   for it in n:
     var e = transform(c, it)
     case it.kind
@@ -823,7 +823,7 @@ proc transformCall(c: PTransf, n: PNode): PNode =
         while (j < n.len):
           let b = transform(c, n[j])
           if not isConstExpr(b): break
-          a = evalOp(op.magic, n, a, b, nil, c.idgen, c.graph)
+          a = evalOp(op.magic, n, a, b, nilPNode, c.idgen, c.graph)
           inc(j)
       result.add(a)
     if result.len == 2: result = result[1]
@@ -893,7 +893,7 @@ proc commonOptimizations*(g: ModuleGraph; idgen: IdGenerator; c: PSym, n: PNode)
         while j < args.len:
           let b = args[j]
           if not isConstExpr(b): break
-          a = evalOp(op.magic, result, a, b, nil, idgen, g)
+          a = evalOp(op.magic, result, a, b, nilPNode, idgen, g)
           inc(j)
       result.add(a)
     if result.len == 2: result = result[1]
@@ -1132,7 +1132,7 @@ proc transformBody*(g: ModuleGraph; idgen: IdGenerator; prc: PSym; cache: bool):
       # it is important to transform exactly once to get sym ids and locations right
       prc.transformedBody = result
     else:
-      prc.transformedBody = nil
+      prc.transformedBody = nilPNode
     # XXX Rodfile support for transformedBody!
 
 proc transformStmt*(g: ModuleGraph; idgen: IdGenerator; module: PSym, n: PNode): PNode =
diff --git a/compiler/sem/varpartitions.nim b/compiler/sem/varpartitions.nim
index c87e5f2079e..7b9f55199c6 100644
--- a/compiler/sem/varpartitions.nim
+++ b/compiler/sem/varpartitions.nim
@@ -324,7 +324,7 @@ proc pathExpr(node: PNode; owner: PSym): PNode =
   if it is not a valid path expression.
   ]#
   var n = node
-  result = nil
+  result = nilPNode
   while true:
     case n.kind
     of nkSym:
diff --git a/compiler/tools/suggest.nim b/compiler/tools/suggest.nim
index 478b98bef80..47f2e2d886d 100644
--- a/compiler/tools/suggest.nim
+++ b/compiler/tools/suggest.nim
@@ -59,7 +59,7 @@ const
 template origModuleName(m: PSym): string = m.name.s
 
 proc findDocComment(n: PNode): PNode =
-  if n == nil: return nil
+  if n == nil: return nilPNode
   if n.comment.len > 0: return n
   if n.kind in {nkStmtList, nkStmtListExpr, nkObjectTy, nkRecList} and n.len > 0:
     result = findDocComment(n[0])
@@ -334,7 +334,7 @@ proc nameFits(c: PContext, s: PSym, n: PNode): bool =
 proc argsFit(c: PContext, candidate: PSym, n: PNode): bool =
   case candidate.kind
   of OverloadableSyms:
-    var m = newCandidate(c, candidate, nil)
+    var m = newCandidate(c, candidate, nilPNode)
     sigmatch.partialMatch(c, n, m)
     result = m.state != csNoMatch
   else:
@@ -342,7 +342,7 @@ proc argsFit(c: PContext, candidate: PSym, n: PNode): bool =
 
 proc suggestCall(c: PContext, n: PNode, outputs: var Suggestions) =
   let info = n.info
-  wholeSymTab(filterSym(it, nil, pm) and nameFits(c, it, n) and argsFit(c, it, n),
+  wholeSymTab(filterSym(it, nilPNode, pm) and nameFits(c, it, n) and argsFit(c, it, n),
               ideCon)
 
 proc suggestVar(c: PContext, n: PNode, outputs: var Suggestions) =
@@ -625,7 +625,7 @@ proc sugExpr(c: PContext, n: PNode, outputs: var Suggestions) =
     # of the next line, so we check the 'field' is actually on the same
     # line as the object to prevent this from happening:
     let prefix = if n.len == 2 and n[1].info.line == n[0].info.line and
-       not c.config.m.trackPosAttached: n[1] else: nil
+       not c.config.m.trackPosAttached: n[1] else: nilPNode
     suggestFieldAccess(c, obj, prefix, outputs)
 
     #if optIdeDebug in gGlobalOptions:
@@ -633,11 +633,11 @@ proc sugExpr(c: PContext, n: PNode, outputs: var Suggestions) =
     #writeStackTrace()
   elif n.kind == nkIdent:
     let
-      prefix = if c.config.m.trackPosAttached: nil else: n
+      prefix = if c.config.m.trackPosAttached: nilPNode else: n
       info = n.info
     wholeSymTab(filterSym(it, prefix, pm), ideSug)
   else:
-    let prefix = if c.config.m.trackPosAttached: nil else: n
+    let prefix = if c.config.m.trackPosAttached: nilPNode else: n
     suggestEverything(c, n, prefix, outputs)
 
 proc suggestExprNoCheck*(c: PContext, n: PNode) =
@@ -684,7 +684,7 @@ proc suggestStmt*(c: PContext, n: PNode) =
 
 proc suggestEnum*(c: PContext; n: PNode; t: PType) =
   var outputs: Suggestions = @[]
-  suggestSymList(c, t.n, nil, n.info, outputs)
+  suggestSymList(c, t.n, nilPNode, n.info, outputs)
   produceOutput(outputs, c.config)
   if outputs.len > 0: suggestQuit()
 
@@ -696,7 +696,7 @@ proc suggestSentinel*(c: PContext) =
   # suggest everything:
   for (it, scopeN, isLocal) in allSyms(c):
     var pm: PrefixMatch
-    if filterSymNoOpr(it, nil, pm):
+    if filterSymNoOpr(it, nilPNode, pm):
       outputs.add(symToSuggest(c.graph, it, isLocal = isLocal, ideSug,
           newLineInfo(c.config.m.trackPos.fileIndex, 0, -1), it.getQuality,
           PrefixMatch.None, false, scopeN))
diff --git a/compiler/utils/astrepr.nim b/compiler/utils/astrepr.nim
index c3ca2ebd3c5..347bedb7c28 100644
--- a/compiler/utils/astrepr.nim
+++ b/compiler/utils/astrepr.nim
@@ -140,6 +140,19 @@ const treeReprAllFields* = { trfShowSymFlags .. trfShowNodeTypes } ## Set
                            ## of flags to print all fields in all tree
                            ## reprs
 
+const defaultTreeReprFlags* = {
+  trfShowNodeIds,
+  trfShowNodeFlags,
+  trfReportInfo,
+  trfSkipAuxError
+} + treeReprAllFields - {
+  trfShowNodeLineInfo,
+  trfShowSymLineInfo,
+  trfShowSymOptions,
+}
+
+const treeReprCompact* = defaultTreeReprFlags + {trfPackedFields}
+
 const style = (
   kind: fgBlue,
   nilIt: fgRed,
@@ -212,7 +225,6 @@ var implicitTReprConf*: TReprConf = defaultTReprConf ## global
   ## debugging functions that could later be called from `gdb` environment
   ## (`debugAst`, `debugType`, `debugSym`), or sem execution tracer
 
-
 const IntTypes = {
   tyInt, tyInt8, tyInt16,
   tyInt32, tyInt64, tyFloat, tyFloat32, tyFloat64, tyUInt, tyUInt8,
diff --git a/compiler/vm/vm.nim b/compiler/vm/vm.nim
index 13b05c85818..b19aa3d6781 100644
--- a/compiler/vm/vm.nim
+++ b/compiler/vm/vm.nim
@@ -45,7 +45,8 @@ import
     debugutils,
     int128,
     btrees,
-    bitsets
+    bitsets,
+    astrepr
   ],
   compiler/sem/[
     sighashes,
@@ -81,6 +82,7 @@ from std/math import round
 
 const
   traceCode = defined(nimVMDebugExecute)
+  debugEchoCode* = defined(nimVMDebugGenerate)
 
 const
   errIllegalConvFromXtoY = "illegal conversion from '$1' to '$2'"
@@ -101,8 +103,8 @@ proc createStackTrace(
 
   result = SemReport(kind: rsemVmStackTrace)
   # Just leave the exceptions empty, they aren't used anyways
-  result.currentExceptionA = nil
-  result.currentExceptionB = nil
+  result.currentExceptionA = nilPNode
+  result.currentExceptionB = nilPNode
 
   block:
     var i = sframe
@@ -419,7 +421,6 @@ proc writeLoc(h: LocHandle, x: TFullReg, mm: var VmMemoryManager) =
   of rkNimNode:
     assert h.typ.kind == akPNode
     setNodeValue(h, x.nimNode)
-
   of rkRegAddr:
     # The following code won't work in the vm (until rkRegAddr replaced)
     # .. code-block:: nim
@@ -730,7 +731,7 @@ proc compile(c: var TCtx, s: PSym): int =
   result = r.start
 
   when debugEchoCode:
-    c.codeListing(s, nil, start = result)
+    c.codeListing(s, nilPNode, start = result)
 
 template handleJmpBack() {.dirty.} =
   if c.loopIterations <= 0:
@@ -973,8 +974,9 @@ proc rawExecute(c: var TCtx, pc: var int, tos: var StackFrameIndex): RegisterInd
   #echo "NEW RUN ------------------------"
   while true:
     #{.computedGoto.}
-    let instr = c.code[pc]
-    let ra = instr.regA
+    let
+      instr = c.code[pc]
+      ra = instr.regA
 
     when traceCode:
       template regDescr(r): TRegisterKind =
@@ -2588,7 +2590,9 @@ proc rawExecute(c: var TCtx, pc: var int, tos: var StackFrameIndex): RegisterInd
         rc = instr.regC
         idx = int(regs[rb+rc-1].intVal)
         callback = c.callbacks[idx].value
-        args = VmArgs(ra: ra, rb: rb, rc: rc, slots: cast[ptr UncheckedArray[TFullReg]](addr regs[0]),
+        args = VmArgs(
+                ra: ra, rb: rb, rc: rc,
+                slots: cast[ptr UncheckedArray[TFullReg]](addr regs[0]),
                 currentException: c.currentExceptionA,
                 currentLineInfo: c.debug[pc],
                 typeCache: addr c.typeInfoCache,
@@ -2679,7 +2683,7 @@ proc rawExecute(c: var TCtx, pc: var int, tos: var StackFrameIndex): RegisterInd
       else: raiseVmError(reportStr(rsemVmFieldNotFound, "floatVal"))
     of opcNodeId:
       decodeB(rkInt)
-      regs[ra].intVal = regs[rb].nimNode.id
+      regs[ra].intVal = regs[rb].nimNode.id.int
     of opcNGetType:
       let rb = instr.regB
       let rc = instr.regC
@@ -3350,7 +3354,7 @@ proc unpackResult(r: sink VmGenResult, conf: ConfigRef, node: PNode, start: var
   ## new `nkError` wrapping `node`. Otherwise, sets `start` to the instruction
   ## offset given by the result and returns `nil`
   if r.success:
-    result = nil
+    result = nilPNode
     start = r.start
   else:
     let kind = r.report.kind
@@ -3374,10 +3378,10 @@ proc execProc*(c: var TCtx; sym: PSym; args: openArray[PNode]): PNode =
 
     else:
       var start: int
-      result = genProc(c, sym).unpackResult(c.config, nil, start)
+      result = genProc(c, sym).unpackResult(c.config, nilPNode, start)
       if unlikely(result != nil):
         localReport(c.config, result)
-        return nil
+        return nilPNode
 
       var tos = TStackFrame(prc: sym, comesFrom: 0, next: -1)
       let maxSlots = sym.offset
@@ -3402,7 +3406,7 @@ proc execProc*(c: var TCtx; sym: PSym; args: openArray[PNode]): PNode =
           mkCallback(c, r): newNodeI(nkEmpty, sym.info)
 
       let r = execute(c, start, tos, cb)
-      result = r.unpackResult(c.config, nil, wrap = false)
+      result = r.unpackResult(c.config, nilPNode, wrap = false)
   else:
     localReport(c.config, sym.info, reportSym(rsemVmCallingNonRoutine, sym))
 
@@ -3417,7 +3421,7 @@ proc evalStmt(c: var TCtx, n: PNode) =
   # execute new instructions; this redundant opcEof check saves us lots
   # of allocations in 'execute':
   if c.code[start].opcode != opcEof:
-    discard execute(c, start).unpackResult(c.config, nil, wrap = false)
+    discard execute(c, start).unpackResult(c.config, nilPNode, wrap = false)
 
 proc evalExpr*(c: var TCtx, n: PNode): PNode =
   # deadcode
@@ -3630,7 +3634,7 @@ proc evalMacroCall*(module: PSym; idgen: IdGenerator; g: ModuleGraph; templInstC
       # TODO: the decrement here is wrong, but the else branch is likely
       #       currently not reached anyway
       dec(g.config.evalMacroCounter)
-      c.callsite = nil
+      c.callsite = nilPNode
       localReport(c.config, n.info, SemReport(
         kind: rsemWrongNumberOfGenericParams,
         countMismatch: (
@@ -3649,5 +3653,5 @@ proc evalMacroCall*(module: PSym; idgen: IdGenerator; g: ModuleGraph; templInstC
     globalReport(c.config, n.info, reportAst(rsemCyclicTree, n, sym = sym))
 
   dec(g.config.evalMacroCounter)
-  c.callsite = nil
+  c.callsite = nilPNode
   c.mode = oldMode
diff --git a/compiler/vm/vmcompilerserdes.nim b/compiler/vm/vmcompilerserdes.nim
index 4b19d6bd385..5de3a5e5bd6 100644
--- a/compiler/vm/vmcompilerserdes.nim
+++ b/compiler/vm/vmcompilerserdes.nim
@@ -51,8 +51,7 @@ template toReport(c: DerefFailureCode): SemReport =
 #      separate parameters would make the function signature unreasonably
 #      large however.
 
-template wrongNode(t: PType): PNode =
-  mixin info
+template wrongNode(t: PType, info: TLineInfo): PNode =
   newNodeIT(nkEmpty, info, t)
 
 proc deserialize(c: TCtx, m: VmMemoryRegion, vt: PVmType, formal, t: PType, info: TLineInfo): PNode
@@ -80,7 +79,7 @@ proc deserializeRef*(c: TCtx, slot: HeapSlotHandle, vt: PVmType; f, con: PType,
       result = c.deserializeObject(src.byteView(), vt.targetType, f, conBase, info)
     else:
       result = c.config.newError(
-        wrongNode(base),
+        wrongNode(base, info),
         SemReport(kind: rsemVmUnsupportedNonNil, typ: con))
 
   else:
@@ -89,7 +88,7 @@ proc deserializeRef*(c: TCtx, slot: HeapSlotHandle, vt: PVmType; f, con: PType,
       if e == dfcNil:
         newNodeIT(nkNilLit, info, f)
       else:
-        c.config.newError(wrongNode(f), e.toReport())
+        c.config.newError(wrongNode(f, info), e.toReport())
 
 proc deserialize(c: TCtx, m: VmMemoryRegion, vt: PVmType, formal: PType, info: TLineInfo): PNode {.inline.} =
   deserialize(c, m, vt, formal, formal.skipTypes(SkipSet), info)
@@ -151,7 +150,7 @@ proc deserializeObjectPart(c: TCtx,
   m: VmMemoryRegion,
   vt: PVmType,
   ty: PType, info: TLineInfo,
-  dest: var TNode): tuple[cIdx: int, hasError: bool] =
+  dest: PNode): tuple[cIdx: int, hasError: bool] =
   var start = 0
   if vt.relFieldStart == 0:
     discard "nothing to do"
@@ -212,7 +211,7 @@ proc deserializeObject(c: TCtx, m: VmMemoryRegion, vt: PVmType; f, con: PType; i
   result.sons[0] = newNode(nkEmpty)
   result.sons[0].typ = f
 
-  let (len, hasError) = deserializeObjectPart(c, m, vt, con, info, result[])
+  let (len, hasError) = deserializeObjectPart(c, m, vt, con, info, result)
   result.sons.setLen(len) # XXX: this should ideally also shrink the capacity
 
   if hasError:
@@ -404,8 +403,9 @@ func findInConstr(n: PNode, pos: FieldPosition): PNode =
   for i in 1..<n.len:
     if n[i][0].sym.position == pos.int:
       return n[i]
-
-  return nil
+  
+  {.cast(noSideEffect).}:
+    return nilPNode
 
 proc serialize*(c: var TCtx, n: PNode, dest: LocHandle, t: PType = nil)
 
diff --git a/compiler/vm/vmdef.nim b/compiler/vm/vmdef.nim
index ce12dc4384b..aba89abb278 100644
--- a/compiler/vm/vmdef.nim
+++ b/compiler/vm/vmdef.nim
@@ -130,6 +130,8 @@ type
     akObject # currently also includes tuple types
     akArray
 
+  # NodeAddr* = distinct int    ## index/identifier into `TCtx.nodeAddrs`
+  NodeAddr* = distinct PNode ## a PNode, but used an address in the VM
 
   # XXX: will be replaced with integer IDs
   PVmType* = ref VmType
@@ -512,6 +514,8 @@ type
     templInstCounter*: ref int # gives every template instantiation a unique ID, needed here for getAst
     vmstateDiff*: seq[(PSym, PNode)] # we remember the "diff" to global state here (feature for IC)
     procToCodePos*: Table[int, int]
+    # nodeAddrs*: seq[NodeId] ## maintain "references" to PNodes, so we can alter
+    #                          ## which PNode we're referring to
 
   StackFrameIndex* = int
 
@@ -695,6 +699,7 @@ const realAtomKinds* = {low(AtomKind)..high(AtomKind)} - pseudoAtomKinds
 
 const
   slotSomeTemp* = slotTempUnknown
+  # nilNodeAddr* = NodeAddr 0
 
 # flag is used to signal opcSeqLen if node is NimNode.
 const nimNodeFlag* = 16
@@ -817,4 +822,4 @@ template unreachable*() =
   raise AssertionDefect.newException("unreachable")
 
 template unreachable*(msg: string) =
-  raise AssertionDefect.newException("unreachable: " & msg)
\ No newline at end of file
+  raise AssertionDefect.newException("unreachable: " & msg)
diff --git a/compiler/vm/vmgen.nim b/compiler/vm/vmgen.nim
index cb95851952d..1cd77368b4f 100644
--- a/compiler/vm/vmgen.nim
+++ b/compiler/vm/vmgen.nim
@@ -99,7 +99,7 @@ func raiseVmGenError(
 func fail(
   info: TLineInfo,
   kind: ReportKind,
-  ast:  PNode = nil,
+  ast:  PNode = nilPNode,
   sym:  PSym = nil,
   str:  string = "",
   loc:  InstantiationInfo = instLoc()
@@ -1817,7 +1817,7 @@ proc canElimAddr(n: PNode): PNode =
     # XXX: for simplicity always take the address of objects values.
     #      While not producing wrong behaviour, in some cases (e.g. var
     #      params) the handle should be passed instead
-    return nil#n[0]
+    return nilPNode#n[0]
   case n[0].kind
   of nkObjUpConv, nkObjDownConv, nkChckRange, nkChckRangeF, nkChckRange64:
     var m = n[0][0]
@@ -1831,7 +1831,7 @@ proc canElimAddr(n: PNode): PNode =
       # addr ( nkConv ( deref ( x ) ) ) --> nkConv(x)
       result = copyNode(n[0])
       result.add m[0]
-  of nkError: result = nil
+  of nkError: result = nilPNode
   else:
     if n[0].kind in {nkDerefExpr, nkHiddenDeref}:
       # addr ( deref ( x )) --> x
@@ -2178,7 +2178,7 @@ proc genRdVar(c: var TCtx; n: PNode; dest: var TDest; flags: TGenFlags) =
       # see tests/t99bott for an example that triggers it:
       cannotEval(c, n)
 
-template needsRegLoad(): untyped =
+template needsRegLoad(flags: TGenFlags): untyped =
   {gfNode, gfNodeAddr} * flags == {} and
     fitsRegister(n.typ.skipTypes({tyVar, tyLent, tyStatic}))
 
@@ -2195,7 +2195,7 @@ proc genArrAccessOpcode(c: var TCtx; n: PNode; dest: var TDest; opc: TOpcode;
     c.gABC(n, opc, dest, a, b)
   elif opc == opcLdStrIdx:
     c.gABC(n, opc, dest, a, b)
-  elif needsRegLoad():
+  elif needsRegLoad(flags):
     var cc = c.getTemp(n.typ)
     c.gABC(n, opc, cc, a, b)
     c.genRegLoad(n, dest, cc)
@@ -2215,7 +2215,7 @@ proc genObjAccess(c: var TCtx; n: PNode; dest: var TDest; flags: TGenFlags) =
   if dest.isUnset: dest = c.getTemp(n.typ)
   if {gfNodeAddr} * flags != {}:
     c.gABC(n, opcLdObjAddr, dest, a, b)
-  elif needsRegLoad():
+  elif needsRegLoad(flags):
     var cc = c.getTemp(n.typ)
     c.gABC(n, opcLdObj, cc, a, b)
     c.genRegLoad(n, dest, cc)
@@ -2297,7 +2297,7 @@ proc genCheckedObjAccess(c: var TCtx; n: PNode; dest: var TDest; flags: TGenFlag
 
   if {gfNodeAddr} * flags != {}:
     c.gABC(n, opcLdObjAddr, dest, objR, fieldPos)
-  elif needsRegLoad():
+  elif needsRegLoad(flags):
     var cc = c.getTemp(accessExpr.typ)
     c.gABC(n, opcLdObj, cc, objR, fieldPos)
     c.genRegLoad(n, dest, cc)
@@ -2321,7 +2321,7 @@ proc genArrAccess(c: var TCtx; n: PNode; dest: var TDest; flags: TGenFlags) =
     if dest.isUnset: dest = c.getTemp(n.typ)
     if gfNodeAddr in flags:
       c.gABC(n, opcLdObjAddr, dest, a, b)
-    elif needsRegLoad():
+    elif needsRegLoad(flags):
       let temp = c.getTemp(n.typ)
       c.gABC(n, opcLdObj, temp, a, b)
       c.genRegLoad(n, dest, temp)
diff --git a/tests/vm/tnimnode.nim b/tests/vm/tnimnode.nim
index f1c4d5e5a5f..dba6d008068 100644
--- a/tests/vm/tnimnode.nim
+++ b/tests/vm/tnimnode.nim
@@ -3,7 +3,6 @@ import macros
 proc assertEq(arg0,arg1: string): void =
   if arg0 != arg1:
     raiseAssert("strings not equal:\n" & arg0 & "\n" & arg1)
-
 # a simple assignment of stmtList to another variable
 var node {.compileTime.}: NimNode
 # an assignment of stmtList into an array